ASCL.net

Astrophysics Source Code Library

Making codes discoverable since 1999

Browsing Codes

Results 1-2402 of 3437 (3348 ASCL, 89 submitted)

Previous
12Next
Order
Title Date
 
Mode
Abstract Compact
Per Page
50100250All
[ascl:2306.019] realfast: Real-time interferometric data analysis for the VLA

The transient search pipeline realfast integrates with the real-time environment at the Very Large Array (VLA) to look for fast radio bursts, pulsars, and other rare astrophysical transients. The software monitors multicast messages, catches visibility data, and defines a fast transient search pipeline with rfpipe (ascl:1710.002). It indexes candidate transients and other metadata for the search interface, and writes and archives new visibility files for candidate transients. realfast provides support for GPU algorithms, manages distributed futures, and performs blind injection and management of mock transients, among other tasks, and rapidly distributes data products and transient alerts to the public.

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

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

[ascl:2103.001] 21cmDeepLearning: Matter density map extractor

21cmDeepLearning extracts the underlying matter density map from a 21 cm intensity field by making use of a convolutional neural network (CNN) with the U-Net architecture; the software is implemented in Pytorch. The astrophysical parameters of the simulations can be predicted with a secondary CNN. The simulations of matter density and 21 cm maps are performed with the code 21cmFAST (ascl:1102.023).

[ascl:2312.013] 21cmEMU: 21cmFAST summaries emulator

21cmEMU emulates 21cmFAST (ascl:1102.023) summary statistics, among them the 21-cm power spectrum, 21-cm global brightness temperature, IGM spin temperature, and neutral fraction. It also emulates the Thomson scattering optical depth and UV luminosity functions. With 21cmFAST installed, parameters can be supplied direction to 21cmEMU, and 21cmEMU can be used for, for example, analytic calculations of taue and UV luminosity functions. The code is included as an alternative simulator in 21cmMC (ascl:1608.017).

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

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

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

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

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

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

[ascl:2307.008] 21cmvFAST: Adding dark matter-baryon relative velocities to 21cmFAST

21cmvFAST demonstrates that including dark matter (DM)-baryon relative velocities produces velocity-induced acoustic oscillations (VAOs) in the 21-cm power spectrum. Based on 21cmFAST (ascl:1102.023) and 21CMMC (ascl:1608.017), 21cmvFAST accounts for molecular-cooling haloes, which are expected to drive star formation during cosmic dawn, as both relative velocities and Lyman-Werner feedback suppress halo formation. This yields accurate 21-cm predictions all the way to reionization (z>~10).

[ascl:2402.010] 2cosmos: Monte Python modification for two independent instances of CLASS

2cosmos is a modification of Monte Python (ascl:1307.002) and allows the user to write likelihood modules that can request two independent instances of CLASS (ascl:1106.020) and separate dictionaries and structures for all cosmological and nuisance parameters. The intention is to be able to evaluate two independent cosmological calculations and their respective parameters within the same likelihood. This is useful for evaluating a likelihood using correlated datasets (e.g. mutually exclusive subsets of the same dataset for which one wants to take into account all correlations between the subsets).

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

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

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

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

[ascl:1505.015] 2dfdr: Data reduction software

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

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

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

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

[ascl:2211.013] 2DFFTUtils: 2DFFT Utilities implementation

The Python module 2DFFTUtils implements tasks associated with measuring spiral galaxy pitch angle with 2DFFT (ascl:1608.015). Since most of the 2DFFT utilities are implemented in one place, it makes preparing images for 2DFFT and dealing with 2DFFT data interactively or in scripts event easier.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[ascl:1708.020] 4DAO: DAOSPEC interface

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

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

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

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

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

[submitted] A pseudo GUI with pyplot

Working with a GUI, or adding interaction in plotting, will help a lot in data analysis. However, the common GUI of Python is OS-dependent, while manually adding interactive codes is too complex. A pseudo-GUI tool is introduced in this work. It will help to add buttons/checkers in the graph and assign callback functions to them. The remaining problem is that the documents in this package are in Chinese and will be in English in the next version. This program is published to the PyPI, and can be installed by 'pip install pltgui'.

[ascl:1312.011] A_phot: Photon Asymmetry

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

[ascl:2209.001] A-SLOTH: Semi-analytical model to connect first stars and galaxies to observables

A-SLOTH (Ancient Stars and Local Observables by Tracing Halos) connects the formation of the first stars and galaxies to observables. The model is based on dark matter merger trees, on which A-SLOTH applies analytical recipes for baryonic physics to model the formation of both metal-free and metal-poor stars and the transition between them. The software samples individual stars and includes radiative, chemical, and mechanical feedback. A-SLOTH has versatile applications with moderate computational requirements. It can be used to constrain the properties of the first stars and high-z galaxies based on local observables, predicts properties of the oldest and most metal-poor stars in the Milky Way, can serve as a subgrid model for larger cosmological simulations, and predicts next-generation observables of the early Universe, such as supernova rates or gravitational wave events.

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

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

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

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

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

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

[ascl:2302.023] AART: Adaptive Analytical Ray Tracing

AART (Adaptive Analytical Ray Tracing) exploits the integrability properties of the Kerr spacetime to compute high-resolution black hole images and their visibility amplitude on long interferometric baselines. It implements a non-uniform adaptive grid on the image plane suitable to study black hole photon rings (narrow ring-shaped features, predicted by general relativity but not yet observed). The code implements all the relevant equations required to compute the appearance of equatorial sources on the (far) observer's screen.

[ascl:2305.013] aartfaac2ms: Aartfaac datasets converter

aartfaac2ms converts raw Aartfaac correlator files to the casacore (ascl:1912.002) measurement set format. It phase rotates the data to a common phase center, and (optionally) flags, averages, and compresses the data. The code includes a tool, afedit, to splice a raw Aartfaac set based on LST.

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

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

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

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

[ascl:1401.007] abundance: High Redshift Cluster Abundance

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

[ascl:2212.016] AbundanceMatching: Subhalo abundance matching with scatter

The AbundanceMatching Python module creates (interpolates and extrapolates) abundance functions and also provides fiducial deconvolution and abundance matching.

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

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

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

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

[ascl:1302.003] ACS: ALMA Common Software

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

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

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

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

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

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

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

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

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

[ascl:1305.004] AdaptaHOP: Subclump finder

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

[ascl:1609.024] AdaptiveBin: Adaptive Binning

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

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

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

[ascl:2204.015] ADBSat: Aerodynamic Database for Satellites

ADBSat computes aerodynamic coefficient databases for satellite geometries in free-molecular flow (FMF) conditions. Written in MATLAB, ADBSat imports body geometry from .stl or .obj mesh files, calculates aerodynamic force and moment coefficient for different gas-surface interaction models, and calculates solar radiation pressure force and moment coefficient. It also takes multiple surface and material characteristics into consideration. ADBSat is a panel-method tool that is able to calculate aerodynamic or solar force and moment coefficient sets for satellite geometries by applying analytical (closed-form) expressions for the interactions to discrete flat-plate mesh elements. The panel method of ADBSat assumes FMF conditions. The code analyzes basic shadowing to identify panels that are shielded from the flow by other parts of the body and will therefore not experience any surface interactions. However, this method is dependent on the refinement of the input mesh and can be sensitive to the orientation and arrangement of the mesh elements with respect to the oncoming flow direction.

[ascl:2307.039] adiabatic-tides: Tidal stripping of dark matter (sub)haloes

adiabatic-tides evaluates the tidal stripping of dark matter (sub)haloes in the adiabatic limit. It exactly reproduces the remnant of an NFW halo that is exposed to a slowly increasing isotropic tidal field and approximately reproduces the remnant for an anisotropic tidal field. adiabatic-tides also predicts the asymptotic mass loss limit for orbiting subhaloes and differently concentrated host-haloes with and without baryonic components, and can be used to improve predictions of dark matter annihilation.

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

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

[ascl:1203.001] AE: ACIS Extract

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

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

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

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

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

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

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

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

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

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

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

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

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

[ascl:2203.019] agnpy: Modeling jetted Active Galactic Nuclei radiative processes with Python

agnpy focuses on the numerical computation of the photon spectra produced by leptonic radiative processes in jetted Active Galactic Nuclei (AGN). It includes classes describing the galaxy components responsible for line and thermal emission and calculates the absorption due to gamma-gamma pair production on soft (IR-UV) photon fields.

[ascl:2307.007] AGNvar: Model spectral timing properties in active galactic nuclei

AGNvar calculates the expected reverberation signal in any given energy band, for a given spectral energy distribution (SED), assuming variable X-ray emission. The code predicts the shape of the re-processed continuum by modeling the time-averaged SED according to input parameters, which include geometry, mass, and mass accretion rate; generally the input parameters are based off typical XSPEC (ascl:9910.005) models. It evaluates the SED response to an input driving light-curve (assumed to originate in the X-ray corona) and creates a set of time-dependent SEDs. It then takes the results from the set of time-dependent SEDs and extracts the light-curve in a given band pass.

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

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

[ascl:2310.011] AI-Feynman: Symbolic regression algorithm

AI-Feynman fits analytical expressions to data sets via symbolic regression, mapping the target variable to different features supplied in the data array. Using a neural network with constraints in the number of parameters utilized, the code provides the ability to obtain analytical expressions for normalized features that are used to predict a Pareto-optimal target. AI-Feynman is robust in handling noisy data, recursively generating multidimensional symbolic expressions that match data from an unknown functions.

[ascl:1310.003] AIDA: Adaptive Image Deconvolution Algorithm

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

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

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

[ascl:2306.014] AIOLOS: Planetary atmosphere accretion and escape simulations

AIOLOS solves differential equations for hydrodynamics, friction, (thermal) radiation transport and (photo)chemistry for simulating accretion onto, and hydrodynamic escape from, planetary atmospheres. The 1-D multispecies, multiphysics hydrodynamics code, written in C++, compiles in a flexible mode that runs problems with any number of input species, and can be sped up by setting the number of species at compile time, and allows the user to provide initial conditions or boundary conditions if desired. AIOLOS provides output and diagnostic files that give snapshots in time of the state of the simulation. Output files are specific to each species, and diagnostic files contain summary as well as detailed information for, for example, the radiation transport, opacities for all species, and optical cell depths per band, in addition to other information.

[ascl:9911.003] AIPS: Astronomical Image Processing System

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

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

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

[ascl:1609.012] AIPY: Astronomical Interferometry in PYthon

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

[ascl:1107.006] AIRES: AIRshower Extended Simulations

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

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

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

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

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

[ascl:1112.019] Aladin: Interactive Sky Atlas

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

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

[ascl:2306.009] Albatross: Stellar stream parameter inference with neural ratio estimation

Albatross analyzes Milky Way stellar streams. This Simulation-Based Inference (SBI) library is built on top of swyft (ascl:2302.016), which implements neural ratio estimation to efficiently access marginal posteriors for all parameters of interest. Using swyft for its internal Truncated Marginal Neural Ratio Estimation (TMNRE) algorithm and sstrax (ascl:2306.008) for fast simulation and modeling, Albatross provides a modular inference pipeline to support parameter inference on all relevant parts of stellar stream models.

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

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

[ascl:2307.004] ALF: Absorption line fitter

alf fits the absorption line optical—NIR spectrum. Initially written to constrain the stellar IMF in old massive galaxies, the code now also offers theoretical age and metallicity-dependent response functions covering 19 elements, nuisance parameters to capture uncertainties in stellar evolution, and parameters to capture uncertainties in the data, including modeling telluric absorption and sky line residuals. alf can fit stellar populations with metallicities from approximately -2.0 to +0.3 and performs well when fitting stellar populations ranging from metal-poor globular clusters to brightest cluster galaxies. The software works in continuum-normalized space and so does not make any use of the shape of the continuum (nor of corresponding photometry). Fitting is handled with emcee (ascl:1303.002); the code is MPI parallelized and runs efficiently on many processors, though fitting data with alf is time intensive.

[ascl:1512.005] ALFA: Automated Line Fitting Algorithm

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

[ascl:2107.011] AlignBandColors: Inter-color-band image alignment tool

AlignBandColors (ABC) aligns inter-color-band astronomical images to a 100th of a pixel accuracy using surrounding stars as guiding points. It has currently been tested with Sloan Digital Sky Survey (SDSS) Data Release 12 images, but is designed to be survey-independent. The code is part of the SpArcFiRe (ascl:2107.010) method.

[ascl:1804.021] allantools: Allan deviation calculation

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

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

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

[ascl:2201.005] AllStarFit: R package for source detection, PSF and multi-component galaxy fitting

AllStarFit analyzes optical and infrared images and includes functions for:
- object detection and image segmentation using the ProFound package (ascl:1804.006);
- PSF determination using the ProFit package (ascl:1612.004) to fit multiple stars in the field simultaneously; and
- galaxy modelling with ProFit, using the previously determined PSF and user-specified models.

AllStarFit supports a variety of optimization methods (provided by external packages), including maximum-likelihood and Markov chain Monte Carlo (MCMC).

[ascl:2301.029] ALMA3: plAnetary Love nuMbers cAlculator

ALMA3 computes loading and tidal Love numbers for a spherically symmetric, radially stratified planet. Both real (time-domain) and complex (frequency-domain) Love numbers can be computed. The planetary structure can include an arbitrary number of layers, and each layer can have a different rheological law. ALMA3 can model numerous linear rheologies, including Elastic, Maxwell visco-elastic, Newtonian viscous fluid, Kelvin-Voigt solid, Burgers and Andrade transient rheologies.

[ascl:2306.025] ALminer: ALMA archive mining and visualization toolkit

ALminer queries, analyzes, and visualizes the ALMA Science Archive. Users can programmatically query the archive for positions, target names, or other keywords in the archive metadata (such as proposal title, abstract, or scientific category). ALminer's plotting routines allow the query results to be visualized, and its analysis functions allow users to filter the results and check whether certain frequencies of interest are covered in the queried observations. The code also allows users to directly download ALMA data products in FITS format and/or the raw data that can be used for manual image processing. ALminer has been designed to make mining the ALMA archive as simple as possible, while being flexible to be customized according to the user's scientific interests. The code is released with a detailed tutorial Jupyter notebook, introducing ALminer's common functions as well as some of its more advanced options.

[ascl:2109.002] alpconv: Calculating alp-photon conversion

alpconv calculates the alp-photon conversion by calculating the degree of irregularity of the spectrum, in contract to some other methods that fit the source's spectrum with both null and ALP models and then compare the goodness of fit between the two.

[ascl:2201.009] AltaiPony: Flare finder for Kepler, K2, and TESS light curves

AltaiPony de-trend light curves from Kepler, K2, and TESS missions, and searches them for flares. The code also injects and recovers synthetic flares to account for de-trending and noise loss in flare energy and determines energy-dependent recovery probability for every flare candidate. AltaiPony uses K2SC (ascl:1605.012), AstroPy (ascl:1304.002) and lightkurve (ascl:1812.013) in addition to other common codes, and extensive documentation and tutorials are provided for the software.

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

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

[ascl:2205.002] am: Microwave through submillimeter-wave propagation tool for the terrestrial atmosphere

am performs optical depth, radiative transfer, and refraction computations involving propagation through the terrestrial atmosphere and other media at microwave through submillimeter wavelengths. The program is used in radio astronomy, atmospheric radiometry, and radio spectrum management.

[ascl:2312.031] AM3: Astrophysical Multi-Messenger Modeling

AM3 simulates lepto-hadronic interactions in astrophysical environments. It solves the time-dependent partial differential equations for the energy spectra of electrons, positrons, protons, neutrons, photons, neutrinos as well as charged secondaries (pions and muons), immersed in an isotropic magnetic field. The code accounts for the emission of photons and charged secondaries in electromagnetic and hadronic interactions feed back into the interaction rates in a time-dependent manner, therefore grasping non-linear effects including electromagnetic cascades. AM3 is computationally efficient, making it possible to scan vast source parameter scans and fit the observational data, and has been deployed to explain multi-wavelength observations from blazars, gamma-ray bursts and tidal disruption events.

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

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

[submitted] amber_meta

amber_meta integrates a few routines to launch AMBER (ascl:2209.007) in a systematic manner. To avoid typing a string in the command line manually with all parameters required to launch AMBER, amber_meta generates the command from configuration files, and can directly launch AMBER instances.

[ascl:2211.003] AMBER: Abundance Matching Box for the Epoch of Reionization

AMBER (Abundance Matching Box for the Epoch of Reionization) models the cosmic dawn. The semi-numerical code allows users to directly specify the reionization history through the redshift midpoint, duration, and asymmetry input parameters. The reionization process is further controlled through the minimum halo mass for galaxy formation and the radiation mean free path for radiative transfer. The parallelized code is over four orders of magnitude faster than radiative transfer simulations and will efficiently enable large-volume models, full-sky mock observations, and parameter-space studies.

[ascl:1010.003] AMBER: Data Reduction Software

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

[ascl:2209.007] AMBER: Fast pipeline for detecting single-pulse radio transients

AMBER (Apertif Monitor for Bursts Encountered in Real-time) detects single-pulse radio phenomena, such as pulsars and fast radio bursts, in real time. It is a fully auto-tuned pipeline that offloads compute-intensive kernels to many-core accelerators; the software automatically tunes these kernels to achieve high performance on different platforms.

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

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

[ascl:2302.021] AMICAL: Aperture Masking Interferometry Calibration and Analysis Library

AMICAL (Aperture Masking Interferometry Calibration and Analysis Library) processes Aperture Masking Interferometry (AMI) data from major existing facilities, such as NIRISS on the JWST, SPHERE and VISIR from the European Very Large Telescope (VLT) and VAMPIRES from SUBARU telescope. The library cleans the reduced datacube from the standard instrument pipelines, extracts the interferometrical quantities (visibilities and closure phases) using a Fourier sampling approach, and calibrates those quantities to remove the instrumental biases. In addition, two external packages (CANDID and Pymask) are included to analyze the final outputs obtained from a binary-like sources (star-star or star-planet); these stand-alone packages are interfaced with AMICAL to quickly estimate scientific results (e.g., separation, position angle, contrast ratio, and contrast limits) using different approaches.

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

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

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

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

[ascl:2108.013] AMOEBA: Automated Gaussian decomposition

AMOEBA (Automated Molecular Excitation Bayesian line-fitting Algorithm) employs a Bayesian approach to Gaussian decomposition, resulting in an objective and statistically robust identification of individual clouds along the line-of-sight. It uses the Python implementation of Goodman & Weare's Affine Invariant Markov chain Monte Carlo (MCMC) Ensemble sampler emcee (ascl:1303.002) to sample the posterior probability distribution and numerically evaluate the integrals required to compute the Bayes Factor. Amoeba takes as input a set of OH optical depth spectra and a set of expected brightness temperature spectra that are obtained by measuring the brightness temperature towards the bright background continuum source (the "on-source" observations), and in a pattern surrounding the continuum source (the "off-source" observations). Amoeba can also take as input a set of OH optical depth spectra only, and also allows input of an arbitrary number of spectra to be fit simultaneously.

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

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

[ascl:2307.032] AmpF: Amplification factor for solar lensing

AmpF numerically calculates the amplification factor for solar lensing. The import parameters are the gravitational-wave frequency and the source angular position with respect to the solar center; the code outputs are the amplification factor and its geometrical-optics limit. AmpF accepts variables for several attributes and the overall amplitude of the lensing potential can be changed as needed. The method has been implemented in both C and Python.

[ascl:1107.007] AMUSE: Astrophysical Multipurpose Software Environment

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

[ascl:1708.028] ANA: Astrophysical Neutrino Anisotropy

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

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

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

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

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

[ascl:2207.030] Analysis of dipole alignment in large-scale distribution of galaxy spin directions

This code analyzes a dipole axis in the distribution of galaxy spin directions. The code takes as input a list of galaxies, their equatorial coordinates, and their spin directions. It then determines the statistical significance of possible dipole axis at any point in the sky by comparing the cosine dependence of the spin directions to the mean and standard deviation of the cosine dependence after 2000 runs with random spin directions. A code to analyze the binomial distribution of the spin directions using Monte Carlo simulation is also available.

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

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

[ascl:2302.007] AnalyticLC: Dynamical modeling of planetary systems

AnalyticLC generates an analytic light-curve, and optionally RV and astrometry data, from a set of initial (free) orbital elements and simultaneously fits these data. Written in MATLAB, the code is fast and efficient, and provides insight into the motion of the orbital elements, which is difficult to obtain from numerical integration. A Python wrapper for AnalyticLC is available separately.

[ascl:1912.007] anesthetic: Nested sampling visualization

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

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

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

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

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

[submitted] AnisoCADO

A python package created around Eric Gendron’s code for analytically (and quickly) generating field-varying SCAO PSFs for the ELT.

[ascl:1411.019] Anmap: Image and data analysis

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

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

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

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

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

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

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

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

[ascl:1010.017] AOFlagger: RFI Software

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

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

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

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

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

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

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

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

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

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

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

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

[ascl:2211.019] APERO: A PipelinE to Reduce Observations

APERO (A PipelinE to Reduce Observations) performs data reduction for the Canada-France-Hawaii Telescope's near-infrared spectropolarimeter SPIRou and offers different recipes or modules for performing specific tasks. APERO can individually run recipes or process a set of files, such as cleaning a data file of detector effects, collecting all dark files and creating a master dark image to use for correction, and creating a bad pixel mask for identifying and dealing with bad pixels. It can extract out flat images to measure the blaze and produced blaze correction and flat correction images, extract dark frames to provide correction for the thermal background after extraction of science or calibration frames, and correct extracted files for leakage coming from a FP (for OBJ_FP files only). It can also take a hot star and calculate telluric transmission, and then use the telluric transmission to calculate principle components (PCA) for correcting input images of atmospheric absorption, among many other tasks.

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

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

[ascl:2101.010] apogee: Tools for APOGEE data

The apogee package works with SDSS-III APOGEE and SDSS-IV APOGEE-2 data. It reads various data products and applies cuts, works with APOGEE bitmasks, and plots APOGEE spectra. It can generate model spectra for APOGEE spectra, and APOGEE model grids can be used to fit spectra. apogee includes some simple stacking functions and implements the effective selection function for APOGEE.

[ascl:2306.022] apollinaire: Helioseismic and asteroseismic peakbagging frameworks

apollinaire provides functions and a framework for helioseismic and asteroseismic instruments data managing and analysis, and includes all the tools necessary to analyze the acoustic oscillations of solar-like stars. The core of the package is the peakbagging library, which provides a full framework to extract oscillation modes parameters from solar and stellar power spectra.

[ascl:2307.058] APOLLO: Radiative transfer and atmosphere spectroscopic retrieval for exoplanets

APOLLO forward models the radiative transfer of light through a planetary (or brown dwarf) atmosphere; it also forward models transit and emission spectra and retrieves atmospheric properties of extrasolar planets. The code has two operational modes: one to compute a planetary spectrum given a set of parameters, and one to retrieve those parameters based on an observed spectrum. The package uses emcee (ascl:1303.002) to find the best fit to a spectrum for a given parameter set. APOLLO is modular and offers many options that may be turned on and off, including the type of observations, a flexible molecular composition, multiple cloud prescriptions, multiple temperature-pressure profile prescriptions, multiple priors, and continuum normalization.

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

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

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

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

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

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

[ascl:2304.002] Applefy: Robust detection limits for high-contrast imaging

Applefy calculates detection limits for exoplanet high contrast imaging (HCI) datasets. The package provides features and functionalities to improve the accuracy and robustness of contrast curve calculations. Applefy implements the classical approach based on the t-test, as well as the parametric boostrap test for non-Gaussian residual noise. Applefy enables the comparison of imaging results across instruments with different noise characteristics.

[ascl:1308.005] APPSPACK: Asynchronous Parallel Pattern Search

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

[ascl:1408.021] APS: Active Parameter Searching

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

[ascl:1208.003] APT: Aperture Photometry Tool

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

[ascl:1007.005] Arcetri Spectral Code for Thin Plasmas

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

[ascl:1107.011] ARCHANGEL: Galaxy Photometry System

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

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

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

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

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

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

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

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

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

[ascl:2011.010] ARES: Accelerated Reionization Era Simulations

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

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

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

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

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

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

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

[ascl:2306.049] ARPACK-NG: Large scale eigenvalue problem solver

ARPACK-NG provides a common repository with maintained versions and a test suite for the ARPACK (ascl:1311.010) code, which is no longer updated; it is a collection of Fortran77 subroutines designed to solve large scale eigenvalue problems. ARPACK-NG offers routines for banded matrices, singular value decomposition, single and double precision real arithmetic versions for symmetric, non-symmetric standard or generalized problems, and a reverse communication interface (RCI). It also provides example driver routines that may be used as templates to implement numerous shift-invert strategies for all problem types, data types and precision, in addition to other tools. The ARPACK-NG project, started by Debian, Octave, and Scilab, is now a community project maintained by volunteers.

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

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

A common community-maintained repository for this software, ARPACK-NG (ascl:2306.049), is available.

[ascl:2107.018] ART: A Reconstruction Tool

ART reconstructs log-probability distributions using Gaussian processes. It requires an existing MCMC chain or similar set of samples from a probability distribution, including the log-probabilities. Gaussian process regression is used for interpolating the log-probability for the rescontruction, allowing for easy resampling, importance sampling, marginalization, testing different samplers, investigating chain convergence, and other operations.

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

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

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

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

[ascl:2103.020] ARTIS: 3D Monte Carlo radiative transfer code for supernovae

ARTIS is a 3D radiative transfer code for Type Ia supernovae using the Monte Carlo method with indivisible energy packets. It incorporates polarization and virtual packets and non-LTE physics appropriate for the nebular phase of Type Ia supernovae.

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

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

[ascl:2110.006] ArtPop: Artificial Stellar Populations generator

ArtPop (Artificial Stellar Populations) synthesizes stellar populations and simulates realistic images of stellar systems. The code is modular, making it possible to use each of its functionalities independently or together. ArtPop can build stellar populations independently from generating mock images, as one might want to do when interested only in calculating integrated photometric properties of the population. The code can also generate stellar magnitudes and artificial galaxies, which can be inject into real imaging data.

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

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

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

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

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

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

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

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

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

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

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

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

[ascl:2205.018] ASOHF: Adaptive Spherical Overdensity Halo Finder

ASOHF (Adaptive Spherical Overdensity Halo Finder) identifies bound dark matter structures (dark matter haloes) in the outputs of cosmological simulations, and works directly on an input particle list. The computational cost of running ASOHF in simulations with a large number of particles can be reduced by using a domain decomposition to split the simulation box into smaller boxes, or subdomains, which are then processed independently. The basic output of ASOHF is a halo catalog. The package includes a python code to build a merger tree from ASOHF outputs.

[ascl:1807.030] ASP: Ames Stereo Pipeline

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

[ascl:1112.017] ASpec: Astronomical Spectrum Analysis Package

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

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

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

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

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

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

[ascl:1510.006] ASPIC: STARLINK image processing package

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

[ascl:2202.022] ASPIRED: Automated SpectroPhotometric Image REDuction

ASPIRED reduces 2D spectral data from raw image to wavelength and flux calibrated 1D spectrum automatically without any user input (quicklook quality), and provides a set of easily configurable routines to build pipelines for long slit spectrographs on different telescopes (science quality). It delivers near real-time data reduction, which can facilitate automated or interactive decision making, allowing "on-the-fly" modification of observing strategies and rapid triggering of other facilities.

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

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

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

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

[ascl:2304.001] ASSIST: Solar system test particles trajectories integrator

ASSIST integrates test particle trajectories in the field of the Sun, Moon, planets, and massive asteroids, with the positions of the masses obtained from the JPL DE441 ephemeris and its associated asteroid perturber file. Using REBOUND's (ascl:1110.016) IAS15 integrator, ASSIST incorporates the most significant gravitational harmonics and general relativistic corrections and accounts for position- and velocity-dependent non-gravitational effects. The first-order variational equations are included for all terms to support orbit fitting and covariance mapping.

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

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

[ascl:1505.002] ASteCA: Automated Stellar Cluster Analysis

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

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

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

[ascl:2112.009] AsteroGaP: Asteroid Gaussian Processes

The Bayesian-based Gaussian Process model AsteroGaP (Asteroid Gaussian Processes) fits sparsely-sampled asteroid light curves. By utilizing a more flexible Gaussian Process framework for modeling asteroid light curves, it is able to represent light curves in a periodic but non-sinusoidal manner.

[ascl:1607.016] astLib: Tools for research astronomers

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

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

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

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

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

[ascl:2103.028] Astro-Fix: Correcting astronomical bad pixels in Python

astrofix is an astronomical image correction algorithm based on Gaussian Process Regression. It trains itself to apply the optimal interpolation kernel for each image, performing multiple times better than median replacement and interpolation with a fixed kernel.

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

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

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

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

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

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

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

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

[ascl:1311.003] AstroAsciiData: ASCII table Python module

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

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

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

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

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

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

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

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

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

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

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

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

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

[ascl:1804.004] AstroCV: Astronomy computer vision library

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

[ascl:2111.001] astroDDPM: Realistic galaxy simulation via score-based generative models

astroDDPM uses a denoising diffusion probabilistic model (DDPM) to synthesize galaxies that are qualitatively and physically indistinguishable from the real thing. The similarity of the synthesized images to real galaxies from the Photometry and Rotation curve OBservations from Extragalactic Surveys (PROBES) sample and from the Sloan Digital Sky Survey is quantified using the Fréchet Inception Distance to test for subjective and morphological similarity. The emergent physical properties (such as total magnitude, color, and half light radius) of a ground truth parent and synthesized child dataset are also compared to generate a Synthetic Galaxy Distance metric. The DDPM approach produces sharper and more realistic images than other generative methods such as Adversarial Networks (with the downside of more costly inference), and could be used to produce large samples of synthetic observations tailored to a specific imaging survey. Potential uses of the DDPM include accurate in-painting of occluded data, such as satellite trails, and domain transfer, where new input images can be processed to mimic the properties of the DDPM training set.

[ascl:1907.016] astrodendro: Astronomical data dendrogram creator

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

[ascl:1010.013] AstroGK: Astrophysical Gyrokinetics Code

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

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

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

[ascl:1309.001] AstroImageJ: ImageJ for Astronomy

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

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

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

[ascl:1406.008] ASTROM: Basic astrometry program

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

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

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

[ascl:2205.020] ASTROMER: Building light curves embeddings using transfomers

ASTROMER is a Transformer-based model trained on millions of stars for the representation of light curves. Pretrained models can be directly used or finetuned on specific datasets. ASTROMER is useful in downstream tasks in which data are limited to train deep learning models.

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

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

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

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

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

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

[ascl:2103.012] AstroNet-Triage: Neural network for TESS light curve triage

AstroNet-Triage contains TensorFlow models and data processing code for identifying exoplanets in astrophysical light curves; this is the triage version of two TESS neural networks. For the vetting version, see AstroNet-Vetting (ascl:2103.011). The TensorFlow code downloads and pre-processes TESS data, builds different types of neural network classification models, trains and evaluates new models, and generates new predictions using a trained model. Utilities that operate on light curves are provided; these reading TESS data from .h5 files, and perform phase folding, splitting, binning, and other tasks. C++ implementations of some light curve utilities are also included.

[ascl:2103.011] AstroNet-Vetting: Neural network for TESS light curve vetting

AstroNet-Vetting identifies exoplanets in astrophysical light curves. This is the vetting version of two TESS neural networks; for the triage version, see AstroNet-Triage (ascl:2103.012). The package contains TensorFlow code that downloads and pre-processes TESS data, builds different types of neural network classification models, trains and evaluates a new model, and uses a trained model to generate new predictions. It includes utilities for operating on light curves, such as for reading TESS data from .h5 files, phase folding, splitting, and binning. In addition, C++ implementations of light curve utilities are also provided.

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

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

[ascl:2308.004] AstroPhot: Fitting everything everywhere all at once in astronomical images

AstroPhot quickly extracts detailed information from complex astronomical data for individual images or large survey programs. It fits models for sky, stars, galaxies, PSFs, and more in a principled chi^2 forward optimization, recovering Bayesian posterior information and covariance of all parameters. The code optimizes forward models on CPU or GPU, across images that are large, multi-band, multi-epoch, rotated, dithered, and more. Models are optimized together, thus handling overlapping objects and including the covariance between parameters (including PSF and galaxy parameters). AstroPhot includes several optimization algorithms, including Levenberg-Marquardt, Gradient descent, and No-U-Turn MCMC sampling.

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

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

[ascl:1402.003] astroplotlib: Astronomical library of plots

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

[ascl:2204.002] Astroplotlib: Python scripts to handle astronomical images

Astroplotlib builds images with any scale, overlay contours, physical bars, and orientation arrows (N and E axes) automatically. The package contains scripts to overlay pseudo-slits and obtain statistics from apertures, estimate the background sky, and overlay the fitted isophotes and their respective contours on an image. Astroplotlib can work with the output table from the Ellipse task of IRAF and overlay fitted isophotes and their respective contours. It includes a GUI for masking areas in the images by using different polygons, and can also obtain statistical information (e.g., total flux and mean, among others) from the masked areas. There is also a GUI to overlay star catalogs on an image and an option to download them directly from the Vizier server.

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

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

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

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

[ascl:1207.007] Astropysics: Astrophysics utilities for python

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

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

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

[ascl:2111.013] Astrosat: Satellite transit calculator

Astrosat calculates which satellites can be seen by a given observer in a given field of view at a given observation time and observation duration. This includes the geometry of the satellite and observer but also estimates the expected apparent brightness of the satellite to aid astronomers in assessing the impact on their observations.

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

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

[ascl:1507.019] AstroStat: Statistical analysis tool

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

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

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

[ascl:2201.002] AstroToolBox: Java tools for identifying and classifying astronomical objects

AstroToolBox identifies and classifies astronomical objects with a focus on low-mass stars and ultra-cool dwarfs. It can search numerous catalogs, including SIMBAD (measurements & references), AllWISE, Gaia, SDSS, among others, evaluates spectral type for main sequence stars including brown dwarfs, and provides SED fitting for ultra-cool and white dwarfs. AstroToolBox draws Gaia color-magnitude diagrams (CMD) with overplotted M0-M9 spectral types, and can draw Montreal Cooling Sequences on the white dwarf branch of the Gaia CMD. The tool can also blink images from different epochs in an image viewer, thus allowing visual identification of the motion or variability of objects. The software displays time series (static or animated) using infrared and optical images of various surveys and contains a photometric classifier. It also includes astrometric calculators and converters, an ADQL query interface (IRSA, VizieR, NOAO) and a batch spectral type lookup feature that uses a CSV file with object coordinates as input. The ToolBox also has a file browser linked to the image viewer, which makes it possible to check a large list of objects in a convenient way, and can save interesting finds in an object collection for later use.

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

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

[ascl:1608.005] AstroVis: Visualizing astronomical data cubes

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

[ascl:1406.001] ASURV: Astronomical SURVival Statistics

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

[ascl:2208.005] Asymmetric Uncertainty: Handling nonstandard numerical uncertainties

Asymmetric Uncertainty implements and provides an object class for dealing with uncertainties for physical quantities that are not symmetric. Instances of the class behave appropriately with other numeric objects under most mathematical operations, and the associated errors propagate accordingly. The class also provides utilities such as methods for evaluating and plotting probability density functions, as well as capabilities for handling arrays of such objects. Standard and symmetric uncertainties are also supported.

[ascl:2105.003] ATARRI: A TESS Archive RR Lyrae Classifier

ATARRI is a graphical user interface for downloading TESS Full Frame Images (FFIs) and displaying properties of the lightcurves of selected objects. Preliminary analysis is performed assuming the object is an RR Lyrae variable. The raw lightcurve, a Lomb-Scargle analysis (both full and pre-whitened), and a folded lightcurve are presented to the user along with options to select the type of RR Lyrae and data quality flags for output.

[ascl:2106.015] ATES: ATmospheric EScape

The ATES hydrodynamics code computes the temperature, density, velocity and ionization fraction profiles of highly irradiated planetary atmospheres, along with the current, steady-state mass loss rate. ATES solves the one-dimensional Euler, mass and energy conservation equations in
radial coordinates through a finite-volume scheme. The hydrodynamics module is paired with a photoionization equilibrium solver that includes cooling via bremsstrahlung, recombination and collisional excitation/ionization for the case of an atmosphere of primordial composition (i.e., pure atomic hydrogen-helium), while also accounting for advection of the different ion species.

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

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

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

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

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

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

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

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

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

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

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

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

[submitted] atlas-fit

atlas-fit is a python tool to amend the results of [spectroflat] with calibration against a solar atlas. I.e., data for wavelength calibration and continuum-correction is genereted from flat field information and selected solar atlantes

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

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

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

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

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

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

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

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

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

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

[ascl:2106.039] atmos: Coupled climate–photochemistry model

Atmos contains two atmospheric models and scripts to couple them together. One atmospheric model calculates the profiles of chemical species, including both gaseous and aerosol phases, and the second model calculates the temperature profile. Because these profiles depend on each other - kinetic reaction rates are temperature-dependent and radiative transfer is subject to radiatively active gases - atmos alternates the running of these two models until both models have solutions consistent with the other one. While either of these models can be run with time-dependence, most applications of these models are to find steady-state solutions for the atmosphere that would be stable over long (geological/astronomical) time periods, given constant inputs to the atmosphere.

[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:2206.017] atoMEC: Average-Atom code for Matter under Extreme Conditions

atoMEC simulates high energy density phenomena such as in warm dense matter. It uses Kohn-Sham density functional theory, in combination with an average-atom approximation, to solve the electronic structure problem for single-element materials at finite temperature.

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

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

[ascl:1405.009] ATV: Image display tool

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

[ascl:2108.002] AUM: A Unified Modeling scheme for galaxy abundance, galaxy clustering and galaxy-galaxy lensing

AUM predicts galaxy abundances, their clustering, and the galaxy-galaxy lensing signal, given the halo occupation distribution of galaxies and the underlying cosmological model. In combination with the measurements of the clustering, abundance, and lensing of galaxies, these routines can be used to perform cosmological parameter inference.

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

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

[ascl:1406.004] Autoastrom: Autoastrometry for Mosaics

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

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

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

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

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

[ascl:2108.017] AutoProf: Automatic Isophotal solutions for galaxy images

AutoProf performs basic and advanced non-parametric galaxy image analysis. The pipeline's design allows for fast startup and easy implementation; the package offers a suite of robust default and optional tools for surface brightness profile extractions and related methods. AUTOPROF is highly extensible and can be adapted for a variety of applications, providing flexibility for exploring new ideas and supporting advanced users.

[ascl:2203.014] AutoSourceID-Light: Source localization in optical images

AutoSourceID-Light (ASID-L) analyzes optical imaging data using computer vision techniques that can naturally deal with large amounts of data. The framework rapidly and reliably localizes sources in optical images.

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

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

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

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

[ascl:2101.005] Avocado: Photometric classification of astronomical transients and variables with biased spectroscopic samples

Avocado produces classifications of arbitrary astronomical transients and variable objects. It addresses the problem of biased spectroscopic samples by generating many lightcurves from each object in the original spectroscopic sample at a variety of redshifts and with many different observing conditions. The "augmented" samples of lightcurves that are generated are much more representative of the full datasets than the original spectroscopic samples.

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

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

[ascl:2203.026] axionCAMB: Modification of the CAMB Boltzmann code

axionCAMB is a modified version of the publicly available code CAMB (ascl:1102.026). axionCAMB computes cosmological observables for comparison with data. This is normally the CMB power spectra (T,E,B,\phi in auto and cross power), but also includes the matter power spectrum.

[ascl:2307.005] axionHMcode: Non-linear power spectrum calculator

axionHMcode computes the non-linear matter power spectrum in a mixed dark matter cosmology with ultra-light axion (ULA) component of the dark matter. This model uses some of the fitting parameters and is inspired by HMcode (ascl:1508.001). axionHMcode uses the full expanded power spectrum to calculate the non-linear power spectrum; it splits the axion overdensity into a clustered and linear component to take the non clustering of axions on small scales due to free-streaming into account.

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

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

[ascl:2106.021] aztekas: GRHD numerical code

aztekas solves hyperbolic partial differential equations in conservative form using High Resolution Shock-Capturing (HRSC) schemes. The code can solve the non-relativistic and relativistic hydrodynamic equations of motion (Euler equations) for a perfect fluid. The relativistic part can solve these equations on a background fixed metric, such as for Schwarzschild, Minkowski, Kerr-Schild, and others.

[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:2307.010] baccoemu: Cosmological emulators for large-scale structure statistics

baccoemu provides a collection of emulators for large-scale structure statistics over a wide range of cosmologies. The emulators provide fast predictions for the linear cold- and total-matter power spectrum, the nonlinear cold-matter power spectrum, and the modifications to the cold-matter power spectrum caused by baryonic physics in a wide cosmological parameter space, including dynamical dark energy and massive neutrinos.

[submitted] backtrack: fit relative motion of candidate direct imaging sources with background proper motion and parallax

Directly imaged planet candidates (high contrast point sources near bright stars) are often validated, among other supporting lines of evidence, by comparing their observed motion against the projected motion of a background source due to the proper motion of the bright star and the parallax motion due to the Earth's orbit. Often, the "background track" is constructed assuming an interloping point source is at infinity and has no proper motion itself, but this assumption can fail, producing false positive results, for crowded fields or insufficient observing time-baselines (e.g. Nielsen et al. 2017). `backtrack` is a tool for constructing background proper motion and parallax tracks for validation of high contrast candidates. It can produce classical infinite distance, stationary background tracks, but was constructed in order to fit finite distance, non-stationary tracks using nested sampling (and can be used on clusters). The code sets priors on parallax based on the relations in Bailer-Jones et al. 2021 that are fit to Gaia eDR3 data, and are therefore representative of the galactic stellar density. The public example currently reproduces the results of Nielsen et al. 2017 and Wagner et al. 2022, demonstrating that the motion of HD 131399A "b" is fit by a finite distance, non-stationary background star, but the code has been tested and validated on proprietary datasets. The code is open source, available on github, and additional contributions are welcome.

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

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

[ascl:2104.017] Bagpipes: Bayesian Analysis of Galaxies for Physical Inference and Parameter EStimation

Bagpipes generates realistic model galaxy spectra and fits these to spectroscopic and photometric observations.

[ascl:2303.017] bajes: Bayesian Jenaer software

bajes [baɪɛs] provides a user-friendly interface for setting up a Bayesian analysis for an arbitrary model, and is specialized for the analysis of gravitational-wave and multi-messenger transients. The code runs a parameter estimation job, inferring the properties of the input model. bajes is designed to be simple-to-use and light-weighted with minimal dependencies on external libraries. The user can set up a pipeline for parameters estimation of multi-messenger transients by writing a configuration file containing the information to be passed to the executables. The package also includes tools and methods for data analysis of multi-messenger signals. The pipeline incorporates an interface with reduced-order-quadratude (ROQ) interpolants. In particular, the ROQ pipeline relies on the output provided by PyROQ-refactored.

[ascl:2107.009] Balrog: Astronomical image simulation

The Balrog package of Python simulation code is for use with real astronomical imaging data. Objects are simulated into a survey's images and measurement software is run over the simulated objects' images. Balrog allows the user to derive the mapping between what is actually measured and the input truth. The package uses GalSim (ascl:1402.009) for all object simulations; source extraction and measurement is performed by SExtractor (ascl:1010.064). Balrog facilitates the ease of running these codes en masse over many images, automating useful GalSim and SExtractor functionality, as well as filling in many bookkeeping steps along the way.

[ascl:2102.029] BALRoGO: Bayesian Astrometric Likelihood Recovery of Galactic Objects

BALRoGO (Bayesian Astrometric Likelihood Recovery of Galactic Objects) handles data from the Gaia space mission. It extracts galactic objects such as globular clusters and dwarf galaxies from data contaminated by interlopers using a combination of Bayesian and non-Bayesian approaches. It fits proper motion space, surface density, and the object center. It also provides confidence regions for the color-magnitude diagram and parallaxes.

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

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

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

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

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

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

[ascl:2205.022] BANG: BAyesian decomposiotioN of Galaxies

BANG (BAyesian decomposiotioN of Galaxies) models both the photometry and kinematics of galaxies. The underlying model is the superposition of different components with three possible combinations: 1.) Bulge + inner disc + outer disc + Halo; 2.) Bulge + disc + Halo; and 3.) inner disc + outer disc + Halo. As CPU parameter estimation can take days, running BANG on GPU is recommended.

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

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

[ascl:2212.012] BANZAI-NRES: BANZAI data reduction pipeline for NRES

The BANZAI-NRES pipeline processes data from the Network of Robotic Echelle Spectrographs (NRES) on the Las Cumbres Observatory network and provides extracted, wavelength calibrated spectra. If the target is a star, it provides stellar classification parameters (e.g., effective temperature and surface gravity) and a radial velocity measurement. The automated radial velocity measurements from this pipeline have a precision of ~ 10 m/s for high signal-to-noise observations. The data flow and infrastructure of this code relies heavily on BANZAI (ascl:2207.031), enabling BANZAI-NRES to focus on analysis that is specific to spectrographs. The wavelength calibration is primarily done using xwavecal (ascl:2212.011). The pipeline propagates an estimate of the formal uncertainties from all of the data processing stages and includes these in the output data products. These are used as weights in the cross correlation function to measure the radial velocity.

[ascl:2207.031] BANZAI: Beautiful Algorithms to Normalize Zillions of Astronomical Images

BANZAI (Beautiful Algorithms to Normalize Zillions of Astronomical Images) processes raw data taken from Las Cumbres Observatory and produces science quality data products. It is capable of reducing single or multi-extension fits files. For historical data, BANZAI can also reduce the data cubes that were produced by the Sinistro cameras.

[ascl:2211.006] baobab: Training data generator for hierarchically modeling strong lenses with Bayesian neural networks

baobab generates images of strongly-lensed systems, given some configurable prior distributions over the parameters of the lens and light profiles as well as configurable assumptions about the instrument and observation conditions. Wrapped around lenstronomy (ascl:1804.012), baobab supports prior distributions ranging from artificially simple to empirical. A major use case for baobab is the generation of training and test sets for hierarchical inference using Bayesian neural networks (BNNs); the code can generate the training and test sets using different priors.

[ascl:2106.009] baofit: Fit cosmological data to measure baryon acoustic oscillations

baofit analyzes cosmological correlation functions to estimate parameters related to baryon acoustic oscillations and redshift-space distortions. It has primarily been used to analyze Lyman-alpha forest autocorrelations and cross correlations with the quasar number density in BOSS data. Fit models are fully three-dimensional and include flexible treatments of redshift-space distortions, anisotropic non-linear broadening, and broadband distortions.

[ascl:1402.025] BAOlab: Baryon Acoustic Oscillations software

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

[ascl:1403.013] BAOlab: Image processing program

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

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

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

[ascl:2008.008] Barry: Modular BAO fitting code

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

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

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

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

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

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

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

[ascl:2401.012] baryon-sweep: Outlier rejection algorithm for JWST/NIRSpec IFS data

baryon-sweep produces a robust outlier rejection while simultaneously preserving the signal of the science target. The code works as a standalone solution or as a supplement to the current pipeline software. baryon-sweep creates the 2D pixel mask and mask layers, processes the sky (non-science target) spaxels, and creates a post-processed cube ready for use.

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

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

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

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

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

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

[ascl:1308.006] BASIN: Beowulf Analysis Symbolic INterface

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

[ascl:2110.010] BASTA: BAyesian STellar Algorithm

BASTA determines properties of stars using a pre-computed grid of stellar models. It calculates the probability density function of a given stellar property based on a set of observational constraints defined by the user. BASTA is very versatile and has been used in a large variety of studies requiring robust determination of fundamental stellar properties.

[ascl:2304.003] BatAnalysis: HEASOFT wrapper for processing Swift-BAT data

BatAnalysis processes and analyzes Swift Burst Alert Telescope (BAT) survey data in a comprehensive computational pipeline. The code downloads BAT survey data, batch processes the survey observations, and extracts light curves and spectra for each survey observation for a given source. BatAnalysis allows for the use of BAT survey data in advanced analyses of astrophysical sources including pulsars, pulsar wind nebula, active galactic nuclei, and other known/unknown transient events that may be detected in the hard X-ray band. BatAnalysis can also create mosaicked images at different time bins and extract light curves and spectra from the mosaicked images for a given source.

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

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

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

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:2101.002] BAYES-LOSVD: Bayesian framework for non-parametric extraction of the LOSVD

BAYES-LOSVD performs non-parametric extraction of the Line-Of-Sight Velocity Distributions in galaxies. Written in Python, it uses Stan (ascl:1801.003) to perform all the computations and provides reliable uncertainties for all the parameters of the model chosen for the fit. The code comes with a large number of features, including read-in routines for some of the most popular IFU spectrographs and surveys, such as ATLAS3D, CALIFA, MaNGA, MUSE-WFM, SAMI, and SAURON.

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

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

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

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

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

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

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

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

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

[ascl:2204.004] Bayesian SZNet: Bayesian deep learning to predict redshift with uncertainty

Bayesian SZNet predicts spectroscopic redshift through use of a Bayesian convolutional network. It uses Monte Carlo dropout to associate predictions with predictive uncertainties, allowing the user to determine unusual or problematic spectra for visual inspection and thresholding to balance between the number of incorrect redshift predictions and coverage.

[ascl:2112.020] BayesicFitting: Model fitting and Bayesian evidence calculation package

BayesicFitting fits models to data. Data in this context means a set of (measured) points x and y. The model provides some (mathematical) relation between the x and y. Fitting adapts the model such that certain criteria are optimized. The BayesicFitting toolbox also determines whether one model fits the data better than another, making the toolbox particularly powerful. The package consists of more than 100 Python classes, of which one third are model classes. Another third are fitters in one guise or another along with additional tools, and the remaining third is used for Nested Sampling.

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

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

[ascl:2207.021] BAYGAUD: BAYesian GAUssian Decomposer

BAYGAUD (BAYesian GAUssian Decomposer) implements the decomposition of velocity profiles in a data cube and subsequent classification. It uses MultiNest (ascl:1109.006) for calculating the posterior distribution and the evidence for a given likelihood function. The code models a given line profile with an optimal number of Gaussians based on the Bayesian Markov Chain Monte Carlo (MCMC) techniques. BAYGAUD is parallelized using the Message-Passing Interface (MPI) standard, which reduces the time needed to calculate the evidence using MCMC techniques.

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

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

[ascl:2308.010] BCemu: Model baryonic effects in cosmological simulations

BCMemu provides emulators to model the suppression in the power spectrum due to baryonic feedback processes. These emulators are based on the baryonification model, where gravity-only N-body simulation results are manipulated to include the impact of baryonic feedback processes. The package also has a three parameter barynification model; the first assumes all the three parameters to be independent of redshift while the second assumes the parameters to be redshift dependent.

[ascl:2110.020] BCES: Linear regression for data with measurement errors and intrinsic scatter

BCES performs robust linear regression on (X,Y) data points where both X and Y have measurement errors. The fitting method is the bivariate correlated errors and intrinsic scatter (BCES). Some of the advantages of BCES regression compared to ordinary least squares fitting are that it allows for measurement errors on both variables and permits the measurement errors for the two variables to be dependent. Further it permits the magnitudes of the measurement errors to depend on the measurements and other lines such as the bisector and the orthogonal regression can be constructed.

[ascl:2307.002] BE-HaPPY: Bias emulator for halo power spectrum

BE-HaPPY (Bias Emulator for Halo Power spectrum Python) facilitates future large scale surveys analysis by providing an accurate, easy to use and computationally inexpensive method to compute the halo bias in the presence of massive neutrinos. Provided with a linear power spectrum, the package will compute a new power spectrum according to the chosen configuration. BE-HaPPY handles linear, polynomial, and perturbation theory bias models. The code also handles Kaiser and Scoccimarro redshifts; other available options include real or redshift space, the total neutrino mass, and a choice of mass bin or scale array, among others.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[ascl:1402.015] BF_dist: Busy Function fitting

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

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

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

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

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

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

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

[ascl:2109.024] BHJet: Semi-analytical black hole jet model

BHJet models steady-state SEDs of jets launched from accreting black holes. This semi-analytical, multi-zone jet model is applicable across the entire black hole mass scale, from black hole X-ray binaries (both low and high mass) to active galactic nuclei of any class (from low-luminosity AGN to flat spectrum radio quasars). It is designed to be more comparable than other codes to GRMHD simulations and/or RMHD semi-analytical solutions.

[ascl:1802.013] BHMcalc: Binary Habitability Mechanism Calculator

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

[ascl:2105.001] BHPToolkit: Black Hole Perturbation Toolkit

The Black Hole Perturbation Toolkit models gravitational radiation from small mass-ratio binaries as well as from the ringdown of black holes. The former are key sources for the future space-based gravitational wave detector LISA. BHPToolkit brings together core elements of multiple scattered black hole perturbation theory codes into a Toolkit that can be used by all; different tools can be installed individually by users depending on need and interest.

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

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

[ascl:1501.009] BIANCHI: Bianchi VIIh Simulations

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

[ascl:1908.021] bias_emulator: Halo bias emulator

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

[ascl:1312.004] BIE: Bayesian Inference Engine

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

[ascl:2106.036] BiFFT: Fast estimation of the bispectrum

BiFFT uses Fourier transforms to implement the Dirac-Delta function that enforces a closed triangle of three k-vectors; this allows very fast calculations of the bispectrum. Once the C code associated with the package is compiled and the source folder directed to the location of the C code, the user can run the code using the python wrapper.The binning in each function has been tested over the course of many years and the user can use it out of the box without ever touching the underlying C code. However, the cylindrical bispectrum calculation is much more sensitive to sample variance; its default binning is quite coarse and might need adjusting (and testing) for some datasets.

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

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

[ascl:1208.007] Big MACS: Accurate photometric calibration

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

[ascl:2211.017] BiGONLight: Bi-local Geodesic Operators framework for Numerical Light propagation

BiGONLight (Bi-local geodesic operators framework for numerical light propagation) encodes the Bi-local Geodesic Operators formalism (BGO) to study light propagation in the geometric optics regime in General Relativity. The parallel transport equations, the optical tidal matrix, and the geodesic deviation equations for the bilocal operators are expressed in 3+1 form and encoded in BiGONLight as Mathematica functions. The bilocal operators are used to obtain all possible optical observables by combining them with the observer and emitter four-velocities and four-accelerations. The user can choose the position of the source and the observer anywhere along the null geodesic with any four-velocities and four-accelerations.

[ascl:2106.031] BiHalofit: Fitting formula of non-linear matter bispectrum

BiHalofit fits the matter bispectrum in the nonlinear regime calibrated by high-resolution cosmological N-body simulations of 41 cold dark matter models around the Planck 2015 best-fit parameters. The parameterization is similar to that in Halofit (ascl:1402.032). The simulation volume is sufficiently large to cover almost all measurable triangle bispectrum configurations in the universe, and the function is calibrated using one-loop perturbation theory at large scales. BiHaloFit predicts the weak-lensing bispectrum and will assist current and future weak-lensing surveys and cosmic microwave background lensing experiments.

[ascl:1901.011] Bilby: Bayesian inference library

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

[ascl:2307.036] binary_c-python: Stellar population synthesis tool and interface to binary_c

binary_c-python provides a manager for and interface to the binary_c framework (ascl:2307.035), and rapidly evolves individual systems and populations of stars. It provides functions such as data processing tools and initial distribution functions for stellar properties. binary_c-python also includes tools to run large grids of (binary) stellar systems on servers or distributed systems.

[ascl:2307.035] binary_c: Stellar population synthesis software framework

The binary_c software framework models the evolution of single, binary and multiple stars, including stellar evolution and nucleosynthesis. Stellar evolution includes wind mass loss, rotation, thermal pulses, magnetic braking, pre-main sequence evolution, supernovae and kicks, and neutron stars; binary-star evolution includes mass transfer, gravitational-wave losses, tides, novae, circumbinary discs, and merging stars. binary_c natively includes nucleosynthesis, and, as it is designed for stellar population calculations, it is lightweight and versatile. binary_c works in standalone, virtual and HPC environments, and its support software contains tools for development and data analysis. A version in Python, binary_c-python (ascl:2307.036), is also available.

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

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

[ascl:1710.008] Binary: Accretion disk evolution

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

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

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

[ascl:2102.025] binaryoffset: Detecting and correcting the binary offset effect in CCDs

binaryoffset identifies the binary offset effect in images from any detector. The easiest input to work with is a dark or bias image that is spatially flat. The code can also be run on images that are not spatially flat, assuming that there is some model of the signal on the CCD that can be used to produce a residual image.

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

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

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

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

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

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

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

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

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

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

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

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

[ascl:2109.029] BiPoS1: Dynamical processing of the initial binary star population

BiPoS1 (Binary Population Synthesizer) efficiently calculates binary distribution functions after the dynamical processing of a realistic population of binary stars during the first few Myr in the hosting embedded star cluster. It is particularly useful for generating a realistic birth binary population as an input for N-body simulations of globular clusters. Instead of time-consuming N-body simulations, BiPoS1 uses the stellar dynamical operator, which determines the fraction of surviving binaries depending on the binding energy of the binaries. The stellar dynamical operator depends on the initial star cluster density, as well as the time until the residual gas of the star cluster is expelled. At the time of gas expulsion, the dynamical processing of the binary population is assumed to effectively end due to the expansion of the star cluster related to that event. BiPoS1 has also a galactic-field mode, in order to synthesize the stellar population of a whole galaxy.

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

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

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

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

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

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

[ascl:2105.011] BlackBOX: BlackGEM and MeerLICHT image reduction software

BlackBOX performs standard CCD image reduction tasks on multiple images from the BlackGEM and MeerLICHT telescopes. It uses the satdet module of ASCtools (ascl:2011.024) and Astro-SCRAPPY (ascl:1907.032). BlackBOX simultaneously uses multi-processing and multi-threading and feeds the reduced images to ZOGY (ascl:2105.010) to ultimately perform optimal image subtraction and detect transient sources.

[ascl:2012.020] BlackHawk: Black hole evaporation calculator

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

[ascl:2211.010] BlackJAX: Library of samplers for JAX

BlackJAX is a sampling library designed for ease of use, speed, and modularity and works on CPU as well as GPU. It is not a probabilistic programming library (PLL), though it integrates well with PPLs as long as they can provide a (potentially unnormalized) log-probability density function compatible with JAX. BlackJAX is written in pure Python and depends on XLA via JAX (ascl:2111.002). It can be used by those who have a logpdf and need a sampler or need more than a general-purpose sampler. It is also useful for building a sample on GPU and for users who want to learn how sampling algorithms work.

[ascl:2210.014] Blacklight: GR ray tracing code for post-processing Athena++ simulations

Blacklight postprocesses general-relativistic magnetohydrodynamic simulation data and produces outputs for analyzing data sets, including maps of auxiliary quantities and false-color renderings. The code can use Athena++ (ascl:1912.005) outputs directly, and also supports files in HARM (ascl:1209.005) and iHARM3d (ascl:2210.013) format. Written in C++, Blacklight offers support for adaptive mesh refinement input, slow-light calculations, and adaptive ray tracing.

[ascl:2208.001] BlaST: Synchrotron peak estimator for blazars

BlaST (Blazar Synchrotron Tool) estimates the synchrotron peak of blazars given their spectral energy distribution. It uses a machine-learning algorithm that simplifies the estimation and also provides a reliable uncertainty estimation. The package naturally accounts for additional SED components from the host galaxy and the disk emission. BlaST also supports bulk estimation, e.g. estimating a whole catalog, by providing a directory or zip file containing the seds as well as an output file in which to write the results.

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

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

[ascl:2303.005] Blobby3D: Bayesian inference for gas kinematics

Blobby3D performs Bayesian inference for gas kinematics on emission line observations of galaxies using Integral Field Spectroscopy. The code robustly infers gas kinematics for regularly rotating galaxies even if the gas profiles have significant substructure. Blobby3D also infers gas kinematic properties free from the effects of beam smearing (where beam smearing is the effect of the observational seeing spatially blurring the gas profiles), which has significant effects on the observed gas kinematic properties, particularly the observed velocity dispersion.

[ascl:1208.009] BLOBCAT: Software to Catalog Blobs

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

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

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

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

[ascl:2201.003] BLOSMapping: Determine line-of-sight magnetic fields of molecular clouds

BLOSMapping determines the line-of-sight component of magnetic fields associated with molecular clouds. The code uses Faraday rotation measure catalogs along with an on-off approach based on relative measurements to estimate the rotation measure caused by molecular clouds. It then uses the outputs from a chemical evolution code along with extinction maps to determine the line-of-sight magnetic field strength and direction.

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

[submitted] BMarXiv

BMarXiv scans new (i.e., since the last time checked) submissions from arXiv, ranks submissions based on keyword matches, and produces an HTML page as an output.

The keywords are looked for (with regex capabilities) in the title, abstract, but also the author list, so it is possible to look for people too. The score is calculated for each specific entry but additional (and optional) scoring is performed using the first author recent submissions and/or the other authors' recent submissions.

It is possible to include/exclude any arXiv categories (within astro-ph or not). New astronomical conferences (from CADC by default) and new codes (from ASCL.net) are also checked and can also be scanned for keywords.

A local bibliography file can be scanned to find frequent words/groups of words that could become scanned keywords.

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

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

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

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

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

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

[ascl:2203.029] Bootsik: Potential field calculator

The Bootsik software generates and visualizes potential magnetic fields. bootsik.f90 generates a potential magnetic field on a 3D mesh, staggered relative to the magnetic potential, by extrapolating the magnetic field normal to the photospheric surface. The code first calculates a magnetic potential using a modified Green’s function method and then uses a finite differencing scheme to calculate the magnetic field from the potential. The IDL script boobox.pro can then be used to visualize the magnetic field.

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

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

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

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

[ascl:2210.023] BornRaytrace: Weak gravitational lensing effects simulator

BornRaytrace uses neural data compression of weak lensing map summary statistics to simulate weak gravitational lensing effects. It can raytrace through overdensity Healpix maps to return a convergence map, include shear-kappa transformation on the full sphere, and also include intrinsic alignments (NLA model).

[ascl:2108.011] BOSS-Without-Windows: Window-free analysis of the BOSS DR12 power spectrum and bispectrum

BOSS-Without-Windows analyzes Baryon Oscillation Spectroscopic Survey (BOSS) DR12 data using quadratic and cubic estimators. It contains analysis codes to estimate unwindowed power spectra and unwindowed bispectra. It also supplies the raw power and bispectrum spectrum measurements of BOSS and 999 Patchy simulations, and contains a utility function to generate the background number density, n(r) from the survey mask and n(z) distribution.

[ascl:2307.015] BOWIE: Gravitational wave binary signal analysis

BOWIE (Binary Observability With Illustrative Exploration) performs graphical analysis of binary signals from gravitational waves. It takes gridded data sets and produces different types of plots in customized arrangements for detailed analysis of gravitational wave sensitivity curves and/or binary signals. BOWIE offers three main tools: a gridded data generator, a plotting tool, and a waveform generator for general use. The waveform generator creates PhenomD waveforms for binary black hole inspiral, merger, and ringdown. Gridded data sets are created using the PhenomD generator for signal-to-noise (SNR) analysis. Using the gridded data sets, customized configurations of plots are created with the plotting package.

[ascl:2306.059] BOXFIT: Gamma-ray burst afterglow light curve generator

BOXFIT calculates light curves and spectra for arbitrary observer times and frequencies and of performing (broadband) data fits using the downhill simplex method combined with simulated annealing. The flux value for a given observer time and frequency is a function of various variables that set the explosion physics (energy of the explosion, circumburst number density and jet collimation angle), the radiative process (magnetic field generation efficiency, electron shock-acceleration efficiency and synchrotron power slope for the electron energy distribution) and observer position (distance, redshift and angle). The code can be run both in parallel and on a single core. Because a data fit takes many iterations, this is best done in parallel. Single light curves and spectra can readily be done on a single core.

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

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

[ascl:1108.011] BPZ: Bayesian Photometric Redshift Code

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

[ascl:1806.025] BRATS: Broadband Radio Astronomy ToolS

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

[ascl:2305.009] breizorro: Image masking tool

Given a FITS image, breizorro creates a binary mask. The software allows the user control various parameters and functions, such as setting a sigma threshold for masking, merging in or subtracting one or more masks or region files, filling holes, applying dilation within a defined radius of pixels, and inverting the mask.

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

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

[ascl:1407.016] Brut: Automatic bubble classifier

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

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

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

[submitted] BSAVI: Bayesian Sample Visualizer for Cosmological Likelihoods

BSAVI (Bayesian Sample Visualizer) is a tool to aid likelihood analysis of model parameters where samples from a distribution in the parameter space are used as inputs to calculate a given observable. For example, selecting a range of samples will allow you to easily see how the observables change as you traverse the sample distribution. At the core of BSAVI is the Observable object, which contains the data for a given observable and instructions for plotting it. It is modular, so you can write your own function that takes the parameter values as inputs, and BSAVI will use it to compute observables on the fly. It also accepts tabular data, so if you have pre-computed observables, simply import them alongside the dataset containing the sample distribution to start visualizing.

[ascl:1303.014] BSE: Binary Star Evolution

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

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

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

[ascl:2309.015] bskit: Bispectra from cosmological simulation snapshots

bskit, built upon the nbodykit (ascl:1904.027) simulation analysis package, measures density bispectra from snapshots of cosmological N-body or hydrodynamical simulations. It can measure auto or cross bispectra in a user-specified set of triangle bins (that is, triplets of 3-vector wavenumbers). Several common sets of bins are also implemented, including all triangle bins for specified k_min and k_max, equilateral triangles between specified k_min and k_max, isosceles triangles, and squeezed isosceles triangles.

[ascl:2001.007] BTS: Behind The Spectrum

Behind The Spectrum (BTS) is a fully-automated multiple-component fitter for optically-thin spectra. Written as a python module, the routine uses the first, second and third derivatives to determine thenumber of components in the spectrum. A least-squared fitting routine then determines the best fit with that number of components, checking for over-fitting and over-lapping velocity centroids.

[submitted] BTSbot: Automated Identification and Follow-up of Bright Transients with Deep Learning

BTSbot is a multi-modal convolutional neural network designed for real-time identification bright extragalactic transients in Zwicky Transient Facility (ZTF) data. BTSbot provides a bright transient score to individual ZTF detections using their image data and 25 extracted features. BTSbot is able to eliminate the need for daily visual inspection of new transients by automatically identifying and requesting spectroscopic follow-up observations of new bright transient candidates. BTSbot recovers all bright transients in our test split and performs on par with human experts in terms of identification speed (on average, ∼1 hour quicker than scanners).

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

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

[ascl:2312.003] BUQO: Bayesian Uncertainty Quantification by Optimization

BUQO solves large-scale imaging inverse problems. It leverages probability concentration phenomena and the underlying convex geometry to formulate the Bayesian hypothesis test as a convex problem that is then efficiently solved by using scalable optimization algorithms. This allows scaling to high-resolution and high-sensitivity imaging problems that are computationally unaffordable for other Bayesian computation approaches.

[ascl:2212.024] Burning Arrow: Black hole massive particles orbit degradation

Burning Arrow determines the destabilization of massive particle circular orbits due to thermal radiation, emitted in X-ray, from the hot accretion disk material. This code requires the radiation forces exerted on the material at the point of interest found by running the code Infinity (ascl:2212.021). Burning Arrow begins by assuming a target particle in the disk that moves in a circular orbit. It then introduces the recorded radiation forces from Infinity code for the target region. The forces are subsequently introduced into the target particle equations of motion and the trajectory is recalculated. Burning Arrow then produces images of the black hole - accretion disk system that includes the degenerated particle trajectories that obey the assorted velocity profiles.

[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:2306.030] Butterpy: Stellar butterfly diagram and rotational light curve simulator

Butterpy simulates star spot emergence, evolution, decay, and stellar rotational light curves. It tests the recovery of stellar rotation periods using different frequency analysis techniques. Butterpy can simulate light curves of stars with variable activity level, rotation period, spot lifetime, magnetic cycle duration and overlap, spot emergence latitudes, and latitudinal differential rotation shear.

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

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

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

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

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

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

[ascl:2312.022] C2-Ray: Time-dependent photo-ionization calculations

C2-Ray calculates spherical symmetric time-dependent photo-ionization in 1D with the source at the origin for hydrogen only. The code is explicitly photon-conserving and uses an analytical relaxation solution for the ionization rate equations for each time step, thus enabling integration of the equation of transfer along a ray with fewer cells and time steps than previous methods. It is suitable for coupling radiative transfer to gas and N-body dynamics methods on fixed or adaptive grids. C2-Ray is not parallelized but contains an MPI module for compatibility with the 3D version (C2-Ray3Dm).

[ascl:2312.023] C2-Ray3Dm: 3D version of C2-Ray for multiple sources, hydrogen only

C2-Ray3Dm performs time-dependent photo-ionization calculations for 3D multiple sources, and for hydrogen only. Based on C2-Ray (ascl:2312.022), it runs under both MPI and OpenMP. The length of subroutines has been reduced to make the code more manageable and easier to read.

[ascl:2312.024] C2-Ray3Dm1D_Helium: Hydrogen + helium version of C2-Ray

C2-Ray3Dm1D_Helium is the hydrogen + helium version of the radiative transfer photo-ionization code C2-Ray. It combines the 1D and 3D versions of the code.

[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:1102.013] Cactus: HPC infrastructure and programming tools

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

[ascl:2306.037] CADET: X-ray cavity detection tool

The machine learning pipeline CADET (CAvity DEtection Tool) finds and size-estimates arbitrary surface brightness depressions (X-ray cavities) on noisy Chandra images of galaxies. The pipeline is a self-standing Python script and inputs either raw Chandra images in units of counts (numbers of captured photons) or normalized background-subtracted and/or exposure-corrected images. CADET saves corresponding pixel-wise as well as decomposed cavity predictions in FITS format and also preserves the WCS coordinates; it also outputs a PNG file showing decomposed predictions for individual scales.

[ascl:1303.017] CADRE: CArma Data REduction pipeline

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

[ascl:2108.009] caesar-rest: Web service for the caesar source extractor

caesar-rest is a REST-ful web service for astronomical source extraction and classification with the caesar source extractor [ascl:1807.015]. The software is developed in python and consists of containerized microservices, deployable on standalone servers or on a distributed cloud infrastructure. The core component is the REST web application, based on the Flask framework and providing APIs for managing the input data (e.g. data upload/download/removal) and source finding jobs (e.g. submit, get status, get outputs) with different job management systems (Kubernetes, Slurm, Celery). Additional services (AAI, user DB, log storage, job monitor, accounting) enable the user authentication, the storage and retrieval of user data and job information, the monitoring of submitted jobs, and the aggregation of service logs and user data/job stats.

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

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

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

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

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

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

[ascl:2106.035] CalPriorSNIa: Effective calibration prior on the absolute magnitude of Type Ia supernovae

CalPriorSNIa quickly computes the effective calibration prior on the absolute magnitude MB of Type Ia supernovae that corresponds to a given determination of H0.

[ascl:2301.001] CALSAGOS: Select cluster members and search, find, and identify substructures

CALSAGOS (Clustering ALgorithmS Applied to Galaxies in Overdense Systems) selects cluster members and searches, finds, and identifies substructures and galaxy groups in and around galaxy clusters using the redshift and position in the sky of the galaxies. The package offers two ways to determine cluster members, ISOMER and CLUMBERI. The ISOMER (Identifier of SpectrOscopic MembERs) function selects the spectroscopic cluster members by defining cluster members as those galaxies with a peculiar velocity lower than the escape velocity of the cluster. The CLUMBERI (CLUster MemBER Identifier) function select the cluster members using a 3D-Gaussian Mixture Modules (GMM). Both functions remove the field interlopers by using a 3-sigma clipping algorithm. CALSAGOS uses the function LAGASU (LAbeller of GAlaxies within SUbstructures) to search, find, and identify substructures and groups in and around a galaxy cluster; this function is based on clustering algorithms (GMM and DBSCAN), which search areas with high density to define a substructure or groups.

[ascl:2207.015] calviacat: Calibrate star photometry by catalog comparison

calviacat calibrates star photometry by comparison to a catalog, including PanSTARRS 1, ATLAS-RefCat2, and SkyMapper catalogs. Catalog queries are cached so that subsequent calibrations of the same or similar fields can be more quickly executed.

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

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

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

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

[ascl:1801.007] cambmag: Magnetic Fields in CAMB

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

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

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

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

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

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

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

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

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

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

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

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

[ascl:2011.002] CAPTURE: Interferometric pipeline for image creation from GMRT data

CAPTURE (CAsa Pipeline-cum-Toolkit for Upgraded Giant Metrewave Radio Telescope data REduction) produces continuum images from radio interferometric data. Written in Python, it uses CASA (ascl:1107.013) tasks to analyze data obtained by the GMRT. It can produce self-calibrated images in a fully automatic mode or can run in steps to allow the data to be inspected throughout processing.

[ascl:2308.009] caput: Utilities for building radio astronomy data analysis pipelines

Caput (Cluster Astronomical Python Utilities) contains utilities for handling large datasets on computer clusters. Written with radio astronomy in mind, the package provides an infrastructure for building, managing and configuring pipelines for data processing. It includes modules for dynamically importing and utilizing mpi4py, in-memory mock-ups of h5py objects, and infrastructure for running data analysis pipelines on computer clusters. Caput features a generic container for holding self-documenting datasets in memory with straightforward syncing to h5py files, and offers specialization for holding time stream data. Caput also includes tools for MPI-parallel analysis and routines for converting between different time representations, dealing with leap seconds, and calculating celestial times.

[ascl:2006.014] CARACal: Containerized Automated Radio Astronomy Calibration pipeline

CARACal (Containerized Automated Radio Astronomy Calibration, formerly MeerKATHI) reduces radio-interferometric data. Developed originally as an end-to-end continuum- and line imaging pipeline for MeerKAT, it can also be used with other radio telescopes. CARACal reduces large data sets and produces high-dynamic-range continuum images and spectroscopic data cubes. The pipeline is platform-independent and delivers imaging quality metrics to efficiently assess the data quality.

[ascl:1505.003] caret: Classification and Regression Training

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

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

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

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

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

[ascl:2005.007] Carpyncho: VVV Catalog browser toolkit

Carpyncho browses catalogs to search for and characterize time variable data of the Vista Variables in the Via Lactea (VVV) Survey. The stacked pawprint data from the Cambridge Astronomical Science Unit's (CASU) Vista Data Flow System (VDFS) v>= 1.3 catalogs have been crossed matched with the VDFS CASU v1.3 tile catalogs into Parquet files, allowing detection and classification of periodic variables within this dataset.

[ascl:2103.021] Carsus: Atomic database for astronomy

Carsus manages atomic datasets. It requires Chianti (ascl:9911.004), and can read data from a variety of sources and output them to file formats readable by radiative transfer codes such as TARDIS (ascl:1402.018).

[ascl:2103.031] CARTA: Cube Analysis and Rendering Tool for Astronomy

CARTA (Cube Analysis and Rendering Tool for Astronomy) is a image visualization and analysis tool designed for the ALMA, VLA, SKA pathfinders, and the ngVLA. If offers catalog support, shared region analytics, profile smoothing, and spectral line query, and more. CARTA adopts a client-server architecture suitable for visualizing images with large file sizes (GB to TB) easily obtained from ALMA, VLA, or SKA pathfinder observations; computation and data storage are handled by remote enterprise-class servers or clusters with high performance storage, while processed products are sent to clients only for visualization with modern web features, such as GPU-accelerated rendering. This architecture also enables users to interact with the ALMA and VLA science archives by using CARTA as an interface. CARTA provides a desktop version and a server version. The former is suitable for single-user usage with a laptop, a desktop, or a remote server in the "remote" execution mode. The latter is suitable for institution-wide deployment to support multiple users with user authentication and additional server-side features.

[ascl:2207.025] casa_cube: Display and analyze astronomical data cubes

casa_cube provides an interface to data cubes generated by CASA (ascl:1107.013) or Gildas (ascl:1305.010). It performs simple tasks such as plotting given channel maps, moment maps, and line profile in various units, and also corrects for cloud extinction, reconvolves with a beam taper, and permits quick and easy comparisons with models.

[ascl:1107.013] CASA: Common Astronomy Software Applications

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

[ascl:1912.002] casacore: Suite of C++ libraries for radio astronomy data processing

The casacore package contains the core libraries of the old AIPS++/CASA (ascl:1107.013) package. This split was made to get a better separation of core libraries and applications. CASA is now built on top of Casacore. The system consists of a set of layered libraries (packages) and includes a library (using Boost-Python) that converts the basic Casacore types (e.g., Array, Record) to and from Python. Casacore includes the casa package for core functionality and data types like Array and Record; a scimath package for N-dim functions with auto-differentiation and linear or non-linear fitting; and a tables package for the table data system supporting N-dim arrays with advanced querying. It also includes the measures package to manage values in astronomical reference frames using physical units (Quanta) and the MeasurementSets for storing data in the UV-domain, and also the images package for N-dim images in world coordinates with various analysis operations.

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

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

[ascl:2009.005] CASI-3D: Convolutional Approach to Structure Identification-3D

CASI-3D identifies signatures of stellar feedback in molecular line spectra, such as 12CO and 13CO, using deep learning. The code is developed from CASI-2D (ascl:1905.023) and exploits the full 3D spectral information.

[ascl:1402.013] CASSIS: Interactive spectrum analysis

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

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

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

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

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

[ascl:2108.008] CatBoost: High performance gradient boosting on decision trees library

CatBoost is a machine learning method based on gradient boosting over decision trees and can be used for ranking, classification, regression and other machine learning tasks for Python, R, Java, C++. It supports both numerical and categorical features and computation on CPU and GPU, and is fast and scalable. Visualization tools are also included in CatBoost.

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

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

[ascl:2007.024] CaTffs: Calcium triplet indexes

CaTffs predicts the strength of calcium triplet indices (CaT*, PaT and CaT) on the basis of empirical fitting functions and performs required interpolations between the different local functions. Together with the indices predictions, the program also computes the random errors associated to such predictions resulting from the covariance matrices of the fits (for the indices CaT* and PaT). This ensures a reliable error index estimation for any combination of input atmospheric parameters.

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

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

[ascl:2108.007] catwoman: Transit modeling Python package for asymmetric light curves

catwoman models asymmetric transit lightcurves. Written in Python, it calculates light curves for any radially symmetric stellar limb darkening law, and where planets are modeled as two semi-circles of different radii. Catwoman is built on the batman library (ascl:1510.002) and uses its integration algorithm.

[submitted] Caustic Mass Estimator for Galaxy Clusters

The caustic technique is a powerful method to infer cluster mass profiles to clustrocentric distances well beyond the virial radius. It relies in the measure of the escape velocity of the sistem using only galaxy redshift information. This method was introduced by Diaferio & Geller (1997) and Diaferio (1999). This code allows the caustic mass estimation for galaxy clusters, as well as outlier identification as a side effect. However, a pre-cleaning of interlopers is recommended, using e.g., the shifting-gapper technique.

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

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

[submitted] cbeam: a coupled-mode propagator for slowly-varying waveguides

cbeam is a Python/Julia package which models the propagation of guided light through slowly-varying few-mode waveguides using the coupled-mode theory (CMT). When compared with more general numerical methods for waveguide simulation, such as the finite-differences beam propagation method (FD-BPM), numerical implementations of the CMT can be much more computationally efficient. cbeam also provides a Pythonic class structure to define waveguides, with simple classes for directional couplers and photonic lanterns already provided. Finally, cbeam doubles as a finite-element eigenmode solver.

[ascl:2402.004] CCBH-Numerics: Cosmologically-coupled-black-holes formation mass numerics

CCBH-Numerics (previously called CCBH-PLPP) computes the probability of the existence of a single cosmologically coupled black hole (BH) with a formation mass below a specified threshold for given observational data of binary black holes (BBHs) from gravitational waves. The code uses the unbiased population of BBHs, as given by the power-law-plus-peak (PLPP) profile, as the observational input, and assumes that the detected BBHs are formed from stellar evolution, not primordial BHs. CCBH-Numerics also works with individual data from BBHs and for NSBH pairs as well.

[ascl:2206.020] CCDLAB: FITS image viewer and data reducer

CCDLAB provides graphical user interface functionality for FITS image viewing and data reduction based on the JPFITS FITS-file interface. It can view, manipulate, and save FITS primary image data and image extensions, view and manipulate FITS image headers, and view FITS Bintable extensions. The code enables batch processing, viewing, and saving of FITS images and searching FITS files on disk. CCDLAB also provides general image reduction techniques, source detection and characterization, and can create World Coordinate Solutions automatically or manually for FITS images.

[ascl:1403.021] CCDPACK: CCD Data Reduction Package

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

[ascl:1510.007] ccdproc: CCD data reduction software

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

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

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

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

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

[ascl:1901.003] CCL: Core Cosmology Library

The Core Cosmology Library (CCL) computes basic cosmological observables and provides predictions for many cosmological quantities, including distances, angular power spectra, correlation functions, halo bias and the halo mass function through state-of-the-art modeling prescriptions. Fiducial specifications for the expected galaxy distributions for the Large Synoptic Survey Telescope (LSST) are also included, together with the capability of computing redshift distributions for a user-defined photometric redshift model. Predictions for correlation functions of galaxy clustering, galaxy-galaxy lensing and cosmic shear are within a fraction of the expected statistical uncertainty of the observables for the models and in the range of scales of interest to LSST. CCL is written in C and has a python interface.

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

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

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

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

[ascl:1904.006] CDAWeb: Coordinated Data Analysis Web

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

[ascl:2005.017] cdetools: Tools for Conditional Density Estimates

cdetools provides tools for evaluating conditional density estimates and has applications to photometric redshift estimation and likelihood-free cosmological inference. Available in R and Python, it provides functions for computing a so-called CDE loss function for tuning and assessing the quality of individual probability density functions (PDFs) and diagnostic functions that probe the population-level performance of the PDFs.

[ascl:2305.025] CELEBI: Precision localizations and polarimetric data for fast radio bursts

The Australian Square Kilometre Array Pathfinder (ASKAP) has been enabled by the Commensal Real-time ASKAP Fast Transients Collaboration (CRAFT) to detect Fast Radio Bursts (FRBs) in real-time and save raw antenna voltages containing FRB detections. CELEBI, the CRAFT Effortless Localization and Enhanced Burst Inspection pipeline, extends CRAFT’s existing software to process ASKAP voltages to produce sub-arcsecond precision localizations and polarimetric data at time resolutions as fine as 3 ns of FRB events. CELEBI uses Nextflow (ascl:2305.024) to link together Bash and Python code to perform software correlation, interferometric imaging, and beamforming, thereby making use of common astronomical software packages.

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

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

celerite has been superceded by celerite2 (ascl:2310.001).

[ascl:2310.001] celerite2: Fast and scalable Gaussian Processes in one dimension

celerite2 is a re-write of celerite (ascl:1709.008), an algorithm for fast and scalable Gaussian Process (GP) Regression in one dimension. celerite2 improves numerical stability and integration with various machine learning frameworks. The implementation includes interfaces in Python and C++, with full support for PyMC (ascl:1610.016) and JAX (ascl:2111.002).

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

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

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

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

[ascl:2302.005] celmech: Sandbox for celestial mechanics calculations

celmech provides a variety of analytical and semianalytical tools for celestial mechanics and dynamical astronomy. The package interfaces closely with the REBOUND N-body integrator (ascl:1110.016), thus facilitating comparisons between calculation results and direct N-body integrations. celmech can isolate the contribution of particular resonances to a system's dynamical evolution, and can develop simple analytical models with the minimum number of terms required to capture a particular dynamical phenomenon.

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

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

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

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

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

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

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

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

[ascl:2111.005] CEvNS: Calculate Coherent Elastic Neutrino-Nucleus Scattering cross sections and recoil spectra

CEvNS calculates Coherent Elastic Neutrino-Nucleus Scattering (CEvNS) cross sections and recoil spectra. It includes (among other things) the Standard Model contribution to the CEvNS cross section, along with the contribution from Simplified Models with new vector or scalar mediators. It also covers neutrino magnetic moments and non-standard contact neutrino interactions (NSI).

[ascl:1901.001] cFE: Core Flight Executive

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

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

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

[ascl:2101.009] cFS: core Flight System

cFS is a platform and project independent reusable software framework and set of reusable applications developed by NASA Goddard Space Flight Center. There are three key aspects to the cFS architecture: a dynamic run-time environment, layered software, and a component based design, making it suitable for reuse on NASA flight projects and/or embedded software systems. This framework is used as the basis for the flight software for satellite data systems and instruments, but can also be used on other embedded systems. Modules of this package are used in NICER (Neutron star Interior Composition Explorer). The modules are available as separate downloads from SourceForge through the NASA cFS website.

[ascl:1904.003] CGS: Collisionless Galactic Simulator

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

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

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

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

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

[ascl:1910.017] ChainConsumer: Corner plots, LaTeX tables and plotting walks

ChainConsumer consumes the chains output from Monte Carlo processes such as MCMC to produce plots of the posterior surface inferred from the chain distributions, to plot the chains as walks to check for mixing and convergence, and to output parameter summaries in the form of LaTeX tables. It handles multiple models (chains), allowing for model comparison using AIC, BIC or DIC metrics.

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

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

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

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

[ascl:2309.017] ChEAP: Chemical Evolution Analytic Package

ChEAP (Chemical Evolution Analytic Package) implements an analytic solution for the chemical evolution model of the Galaxy that extends the instantaneous recycling approximation with the contribution of Type Ia SNe. The code works for different prescriptions of the delay time distributions (DTDs), including the single and double degenerate scenarios, and allows the inclusion of an arbitrary number of pristine gas infalls. The required functions are contained in the CheapTools.py file, which is imported as a Python library. ChEAP also includes code to illustrate, with a random-parameter chemical evolution model, the accuracy of this analytic solution compared to one using numerical integration.

[ascl:1412.002] Cheetah: Starspot modeling code

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

[ascl:2107.020] Chem-I-Calc: Chemical Information Calculator

Chem-I-Calc evaluates the chemical information content of resolved star spectroscopy. It takes advantage of the Fisher information matrix and the Cramér-Rao inequality to quickly calculate the Cramér-Rao lower bounds (CRLBs), which give the best theoretically achievable precision from a set of observations.

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

ChempyMulti (ascl:1909.006) is available as an update to the ChempyScoring package.

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

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

[ascl:2108.016] Chemulator: Thermochemical emulator for hydrodynamical modeling

The neural network-based emulator Chemulator advances the gas temperature and chemical abundances of a single position in an astrophysical gas. It is accurate on a single timestep and stable over many iterations with decreased accuracy, though performs less well at low visual extinctions. The code is useful for applications such as large scale ISM modeling; by retraining the emulator for a given parameter space, Chemulator could also perform more specialized applications such as planetary atmosphere modeling.

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

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

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

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

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

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

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

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

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

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

[ascl:2306.046] CHIPS: Circumstellar matter and light curves of interaction-powered transients simulator

CHIPS (Complete History of Interaction-Powered Supernovae) simulates the circumstellar matter and light curves of interaction-powered transients. Coupled with MESA (ascl:1010.083), the combined codes can obtain the circumstellar matter profile and light curves of the interaction-powered supernovae. CHIPS generates a realistic CSM from a model-agnostic mass eruption calculation, which can serve as a reference for observers to compare with various observations of the CSM. The code can also generate bolometric light curves from CSM interaction, which can be compared with observed light curves. The calculation of mass eruption and light curve typically takes respectively half a day and half an hour on modern CPUs.

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

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

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

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

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

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

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

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

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

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

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

[ascl:1011.018] chrom_exact: Transit of a Spherical Planet of a Stellar Chromosphere which is Geometrically Thin

Transit light curves for stellar continua have only one minimum and a "U" shape. By contrast, transit curves for optically thin chromospheric emission lines can have a "W" shape because of stellar limb-brightening. We calculate light curves for an optically thin shell of emission and fit these models to time-resolved observations of Si IV absorption by the planet HD209458b. We find that the best fit Si IV absorption model has R_p,SIV/R_*= 0.34+0.07-0.12, similar to the Roche lobe of the planet. While the large radius is only at the limit of statistical significance, we develop formulae applicable to transits of all optically thin chromospheric emission lines.

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

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

[ascl:1701.008] ChromaStar (formerly GrayStar): Web-based pedagogical stellar modeling

ChromaStar (formerly 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] ChromaStarServer (formerly GrayStarServer): Stellar atmospheric modeling and spectrum synthesis

ChromaStarServer (formerly 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:2009.021] Chrono: Multi-physics simulation engine

Chrono is a physics-based modelling and simulation infrastructure implemented in C++. It can handle multibody dynamics, collision detection, and granular flows, among many other physical processes. Though the applications for which Chrono has been used most often are vehicle dynamics, robotics, and machine design, it has been used to simulate asteroid aggregation and granular systems for astrophysics research. Chrono is written in C++; a Python version, PyChrono, is also available.

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

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

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

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

[ascl:1111.004] CIGALE: Code Investigating GALaxy Emission

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

[ascl:1708.002] CINE: Comet INfrared Excitation

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

[ascl:2206.007] CircleCraters: Crater-counting plugin for QGIS

CircleCraters is a projection independent crater counting plugin for QGIS. It has the flexibility to crater count in a GIS environment on Windows, OS X, or Linux, and uses three-click input to define crater rims as a circle.

[ascl:1202.001] CISM_DX: Visualization and analysis tool

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

[ascl:2202.014] Citlalicue: Create and manipulate stellar light curves

Citlalicue allows you to create synthetic stellar light curves (transits, stellar variability and white noise) and detrend light curves using Gaussian Processes (GPs). Transits are implemented using PyTransit (ascl:1505.024). Python notebooks are provided to demonstrate using Citlalicue for both functions.

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

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

[ascl:2210.028] CK: Cloud modeling and removal

Cloud Killer recovers surface albedo maps by using reflected light photometry to map the clouds and surface of unresolved exoplanets. For light curves with negligible photometric uncertainties, the minimal top-of-atmosphere albedo at a location is a good estimate of its surface albedo. On synthetic data, it shows little bias, good precision, and accuracy, but slightly underestimated uncertainties; exoplanets with large, changing cloud structures observed near quadrature phases are good candidates for Cloud Killer cloud removal.

[ascl:2105.018] ClaRAN: Classifying Radio sources Automatically with Neural networks

ClaRAN (Classifying Radio sources Automatically with Neural networks) classifies radio source morphology based upon the Faster Region-based Convolutional Neutral Network (Faster R-CNN). It is capable of associating discrete and extended components of radio sources in an automated fashion. ClaRAN demonstrates the feasibility of applying deep learning methods for cross-matching complex radio sources of multiple components with infrared maps. The promising results from ClaRAN have implications for the further development of efficient cross-wavelength source identification, matching, and morphology classifications for future radio surveys.

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

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

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

CLASSgal computes large scale structure observables; it includes all relativistic corrections and computes both the power spectrum Cl(z1,z2) and the corresponding correlation function ξ(θ, z1, z2) of the matter density and the galaxy number fluctuations in linear perturbation theory. These quantities contain the full information encoded in the large scale matter distribution at the level of linear perturbation theory for Gaussian initial perturbations. CLASSgal is a modified version of CLASS (ascl:1106.020).

[ascl:1407.010] CLE: Coronal line synthesis

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

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

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

[ascl:2310.008] clfd: Clean folded data

clfd (clean folded data) implements GPU-accelerated smart interference removal algorithms to be used on folded pulsar search and pulsar timing data. The code converts each source profile to a small set of representative features, flagging outliers in the resulting feature space. clfd further visualizes the outlier flagging process, as well as the resulting two-dimensional time-frequency mask that is applied to the clean archive. The code provides access to cleaning algorithms that were initially developed for the High Time Resolution Universe (HTRU) survey which found several pulsars.

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

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

[ascl:2312.026] CloudFlex: Small-scale structure observational signatures modeling

CloudFlex models observational signatures associated with the small-scale structure of the circumgalactic medium. It populates cool gas structures in the CGM as a complex of cloudlets using a Monte Carlo method. Various parameters can be set to describe the structure of the cloudlet complexes, including cloudlet mass, density, velocity, and size. Functionality exists for generating the observational signatures of sightlines piercing these cloudlet complexes, borrowing heavily from the Trident code (ascl:1612.019).

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

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

Cloudy_3D has been superseded by pycloudy (ascl:1304.020).

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

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

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

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

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

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

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

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

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

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

[ascl:2209.004] Cluster Toolkit: Tools for analyzing galaxy clusters

Cluster Toolkit calculates weak lensing signals from galaxy clusters and cluster cosmology. It offers 3D density and correlation functions, halo bias models, projected density and differential profiles, and radially averaged profiles. It also calculates halo mass functions, mass-concentration relations, Sunyaev-Zel’dovich (SZ) cluster signals, and cluster magnification. Cluster Toolkit consists of a Python front end wrapped around a well optimized back end in C.

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

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

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

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

[ascl:1911.016] CLUSTEREASY: Lattice simulator for evolving interacting scalar fields in an expanding universe on parallel computing clusters

CLUSTEREASY is a parallel programming extension of the simulation program LATTICEEASY (ascl:1911.015); running the program in parallel greatly extends the range of scales and times that can be simulated. The program is particularly useful for the study of reheating and thermalization after inflation.

[ascl:2011.018] Clustering: Code for clustering single pulse events

Clustering is a modified version of the single-pulse sifting algorithm RRATrap (ascl:2011.017) combined with DBSCAN codes to cluster single pulse events.

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

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

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

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

[ascl:2102.008] CMasher: Scientific colormaps for making accessible, informative plots

CMasher provides a curated collection of scientific colormaps that are perceptually uniform sequential using the viscm package (ascl:2102.007). Most of them are color-vision deficiency friendly; they cover a wide range of different color combinations to accommodate for most applications. The package provides several alternatives to commonly used colormaps, such as chroma and rainforest for jet, sunburst for hot, neutral for binary, and fusion and redshift for coolwarm.

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

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

[ascl:1106.023] CMBACT: CMB from ACTive sources

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

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

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

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

[ascl:9909.004] CMBFAST: A microwave anisotropy code

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

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

[ascl:2104.021] cmblensplus: Cosmic microwave background tools

cmblensplus reconstructs lensing potential, cosmic bi-refringence, and patchy reionization from cosmic microwave background anisotropies (CMB) in full and flat sky. This Fortran wrapper for Python also includes modules for delensing and bi-spectrum calculations. cmblensplus contains a module of basic routines such as analytic calculation of delensed B-mode spectrum and lensing bispectrum. Two additional main modules are for curved sky and flat sky analyses, and measure lensing, bi-refringence, patchy tau, bias-hardening, bi-spectrum, delensing and analytic reconstruction normalization. The package also contains simple Python utility and demonstration scripts. cmblensplus uses FFTW (ascl:1201.015), HEALPix (ascl:1107.018), LAPACK (ascl:2104.020), CFITSIO (ascl:1010.001), and LensPix (ascl:1102.025).

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

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

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

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

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

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

  • rendering of the field of Stokes vectors
  • ray-tracing mode in which each screen pixel is projected onto the sphere for high quality rendering
  • control over sphere lighting
  • export an arbitrarily large rendered texture
  • variety of preset colormaps

[ascl:2108.023] CMC-COSMIC: Cluster Monte Carlo code

CMC-COSMIC models dense star clusters using Hénon's method using orbit-averaging collisional stellar dynamics. It includes all the relevant physics for modeling dense spherical star clusters, such as strong dynamical encounters, single and binary stellar evolution, central massive black holes, three-body binary formation, and relativistic dynamics, among others. CMC is parallelized using the Message Passing Interface (MPI), and is pinned to the COSMIC (ascl:2108.022) package for binary population synthesis, which itself was originally based on the version of BSE (ascl:1303.014). COSMIC is currently a submodule within CMC, ensuring that any cluster simulations or binary populations are integrated with the same physics.

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

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

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

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

[ascl:2008.015] CMEchaser: Coronal Mass Ejection line-of-sight occultation detector

CMEchaser looks for the occultation of background astronomical sources by CMEs to enable measurement of effects such as variations in the ionized content and the associated Faraday rotation of polarized signals along the line of sight to the background source. The code transforms a given Galactic coordinate to its concordant point in the Helioprojective, Sun-centered plane and estimates the point at which the line of sight from the source to the Earth passes through it. It then searches a user selected database to detect if any CMEs which launched before the observation date would have crossed the line of sight at the epoch of observation, and produces a number of useful plots. CMEchaser can run as a flat script orcan be installed as a package.

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

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

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

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

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

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

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

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

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

  • MSrad module: It uses long characteristics. The lateral boundaries have to be periodic. Top and bottom can be closed or open ("solar module'').
  • LHDrad module: It uses long characteristics and is restricted to an equidistant grid and open boundaries at all surfaces (old "supergiant module'').
  • SHORTrad module: It uses short characteristics and is restricted to an equidistant grid and open boundaries at all surfaces (new "supergiant module'').

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

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

[ascl:2003.008] CoastGuard: Automated timing data reduction pipeline

CoastGuard reduces Effelsberg data; it is written in python and based on PSRCHIVE (ascl:1105.014). Though primarily designed for Effelsberg PSRIX data, it contains components sufficiently general for use with psrchive-compatible data files from other observing systems. In particular, the radio frequency interference (RFI) removal algorithm has been applied to data from the Parkes Telescope and has also been adopted by the LOFAR pulsar timing data reduction pipeline.

[ascl:1910.019] Cobaya: Bayesian analysis in cosmology

Cobaya (Code for BAYesian Analysis) provides a framework for sampling and statistical modeling and enables exploration of an arbitrary prior or posterior using a range of Monte Carlo samplers, including the advanced MCMC sampler from CosmoMC (ascl:1106.025) and the advanced nested sampler PolyChord (ascl:1502.011). The results of the sampling can be analyzed with GetDist (ascl:1910.018). It supports MPI parallelization and is highly extensible, allowing the user to define priors and likelihoods and create new parameters as functions of other parameters.

It includes interfaces to the cosmological theory codes CAMB (ascl:1102.026) and CLASS (ascl:1106.020) and likelihoods of cosmological experiments, such as Planck, Bicep-Keck, and SDSS. Automatic installers are included for those external modules; Cobaya can also be used as a wrapper for cosmological models and likelihoods, and integrated it in other samplers and pipelines. The interfaces to most cosmological likelihoods are agnostic as to which theory code is used to compute the observables, which facilitates comparison between those codes. Those interfaces are also parameter-agnostic, allowing use of modified versions of theory codes and likelihoods without additional editing of Cobaya’s source.

[ascl:2002.016] Cobra: Bayesian pulsar searching

Cobra uses single pulse time series data to search for and time pulsars, performing a fully phase coherent timing analysis. The GPU-accelerated Bayesian analysis package, written in Python, incorporates models for both isolated and accelerated systems, as well as both Keplerian and relativistic binaries. Cobra builds a model pulse train that incorporates effects such as aliasing, scattering and binary motion and a simple Gaussian profile and compares this directly to the data; the software can thus combine data over multiple frequencies, epochs, or even across telescopes.

[ascl:1505.010] COBS: COnstrained B-Splines

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

[ascl:1406.017] COCO: Conversion of Celestial Coordinates

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

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

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

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

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

[ascl:2111.008] COCOPLOT: COlor COllapsed PLOTting software

The COCOPLOT (COlor COllapsed PLOTting) quick-look and context image code conveys spectral profile information from all of the spatial pixels in a 3D datacube as a single image using color. It can also identify and expose temporal behavior and display and highlight solar features. COCOPLOT thus aids in identifying regions of interest quickly. The software is available in Python and IDL, and can be used as a standalone package or integrated into other software.

[ascl:2306.041] COFFE: COrrelation Function Full-sky Estimator

COFFE (COrrelation Function Full-sky Estimator) computes quantities in linear perturbation theory. It computes the full-sky and flat-sky 2-point correlation function (2PCF) of galaxy number counts, taking into account all of the effects, including density, RSD, and lensing. It also determines the full-sky, flat-sky, and redshift-averaged multipoles of the 2PCF, and the flat-sky Gaussian covariance matrix of the multipoles of the 2PCF.

[ascl:1602.021] COLAcode: COmoving Lagrangian Acceleration code

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

[ascl:2306.047] COLASolver: Particle-Mesh N-body code

COLASolver creates Particle-Mesh (PM) N-body simulations; the code is fast and very flexible, and can compute a wide range of models. For models with complex dynamics (screened models), it provides several options from doing it exactly to approximate but fast to just simulating linear theory equations. Every time-consuming operation is parallelized over MPI and OpenMP. It uses a slab-based parallelization that works well for fast approximate (COLA) simulations but does not perform as well for high resolution simulations. COLASolver can also be used as an analysis code for results from other simulations.

[ascl:2309.006] CoLFI: Cosmological Likelihood-Free Inference

CoLFI (Cosmological Likelihood-Free Inference) estimates parameters directly from the observational data sets using neural density estimators (NDEs); it is a fully ANN-based framework that differs from the Bayesian inference. The package contains three NDEs that are used to estimate parameters: an artificial neural network (ANN), a mixture density network (MDN), and a mixture neural network (MNN). CoLFI can learn the conditional probability density using samples generated by models, and the posterior distribution can be obtained for given observational data.

[ascl:2305.021] COLIBRI: Cosmological libraries in Python

COLIBRÌ (which roughly stands for “Cosmological Libraries”) computes cosmological quantities such as ages, distances, power spectra, and correlation functions. It supports Lambda-CDM cosmologies plus extensions including massive neutrinos, non-flat geometries, evolving dark energy (w0-wa) models, and numerical recipes for f(R) gravity. COLIBRÌ is built especially for large-scale structure purposes and can interact with the Boltzmann solvers CAMB (ascl:1102.026) and CLASS (ascl:1106.020).

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

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

[ascl:2111.009] CoLoRe: Cosmological Lofty Realization

CoLoRe (Cosmological Lofty Realization) generates fast mock realizations of a given galaxy sample using a lognormal model or LPT for the matter density. Tt can simulate a variety of cosmological tracers, including photometric and spectroscopic galaxies, weak lensing, and intensity mapping. CoLoRe is a parallel C code, and its behavior is controlled primarily by the input param file.

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

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

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

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

[ascl:2306.034] COLT: Monte Carlo radiative transfer and simulation analysis toolkit

COLT (Cosmic Lyman-alpha Transfer) is a Monte Carlo radiative transfer (MCRT) solver for post-processing hydrodynamical simulations on arbitrary grids. These include a plane parallel slabs, spherical geometry, 3D Cartesian grids, adaptive resolution octrees, unstructured Voronoi tessellations, and secondary outputs. COLT also includes several visualization and analysis tools that exploit the underlying ray-tracing algorithms or otherwise benefit from an efficient hybrid MPI + OpenMP parallelization strategy within a flexible C++ framework.

[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:1911.024] comb: Spectral line data reduction and analysis package

comb is a single-dish radio astronomy spectral line data reduction and analysis package developed at AT&T Bell labs and was used for data reduction for many single-dish telescopes, including Bell Labs 7-m, NRAO 12-m, DSN network, FCRAO 14-m, Arecibo, AST/RO, SEST, BIMA, and in 2011-2012, the Stratospheric Terahertz Observatory. A cookbook for the code is available.

[ascl:1708.024] ComEst: Completeness Estimator

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

[ascl:2210.007] COMET: Emulated predictions of large-scale structure observables

COMET (Clustering Observables Modelled by Emulated perturbation Theory) provides emulated predictions of large-scale structure observables from models that are based on perturbation theory. It substantially speeds up these analytic computations without any relevant sacrifice in accuracy, enabling an extremely efficient exploration of large-scale structure likelihoods. At its core, COMET exploits an evolution mapping approach which gives it a high degree of flexibility and allows it to cover a wide cosmology parameter space at continuous redshifts up to z∼3z \sim 3z∼3. Among others, COMET supports parameters for cold dark matter density (ωc\omega_cωc​), baryon density (ωb\omega_bωb​), Scalar spectral index (nsn_sns​), Hubble expansion rate (hhh) and Curvature density (ΩK\Omega_KΩK​). The code can obtain the real-space galaxy power spectrum at one-loop order multipoles (monopole, quadrupole, hexadecapole) of the redshift-space, power spectrum at one-loop order, the linear matter power spectrum (with and without infrared resummation), Gaussian covariance matrices for the real-space power spectrum, and redshift-space multipoles and χ2\chi^2χ2's for arbitrary combinations of multipoles. COMET provides an easy-to-use interface for all of these computations.

[ascl:1404.008] Comet: Multifunction VOEvent broker

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

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

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

[ascl:2106.007] CoMover: Bayesian probability of co-moving stars

CoMover determines the probability that two stars are co-moving and thus gravitationally bound. It uses the sky position, proper motion, parallax and optionally the heliocentric radial velocity of a host star (with their respective measurement errors), and compares it to the observables of a potential companion (with their respective measurement errors). The sky position and proper motion of the potential companion star are required, and its heliocentric radial velocity and parallax are facultative inputs to refine its co-moving probability.

If all kinematic observables of the host star are provided, a single spatial-kinematic model is built, consisting of a single 6-dimensional multivariate Gaussian in Galactic coordinates (XYZ) and space velocities (UVW). The observables of the potential companion are then compared to this model and a given field-stars model with Bayes' theorem by marginalizing over any missing kinematic observables of the companion star with analytical integral solutions. The field stars are modeled using a 10-component multivariate Gaussian, accurate for stars within a few hundred parsecs of the Sun. In the case where a heliocentric radial velocity is missing for the host star, the single host-star multivariate Gaussian model is replaced with a series of host star models and numerically marginalized over by taking the numerical sum of the host-star model probabilities.

[submitted] Compact Binary Chebyshev Polynomial Representation Ephemeris Kernel

The software used to transform the tabular USNO/AE98 asteroid ephemerides into a Chebyshev polynomial representations, and evaluate them at an arbitrary time is available. The USNO/AE98 consisted of the ephemerides of fifteen of the largest asteroids, and were used in The Astronomical Almanac from 2000 through 2015. These ephemerides are outdated and no longer available, but the software used to store and evaluate them is still available and provides a robust method for storing compact ephemerides of solar system bodies.

The object of the software is to provide a compact binary representation of solar system bodies with eccentric orbits, which can produce the body's position and velocity at an arbitrary instant within the ephemeris' time span. It uses a modification of the Newhall (1989) algorithm to achieve this objective. The Newhall algorithm is used to store both the Jet Propulsion Laboratory DE and the Institut de mécanique céleste et de calcul des éphémérides INPOP high accuracy planetary ephemerides. The Newhall algorithm breaks an ephemeris into a number time contiguous segments, and each segment is stored as a set of Chebyshev polynomial coefficients. The length of the time segments and the maximum degree Chebyshev polynomial coefficient is fixed for each body. This works well for bodies with small eccentricities, but it becomes inefficient for a body in a highly eccentric orbit. The time segment length and maximum order Chebyshev polynomial coefficient must be chosen to accommodate the strong curvature and fast motion near pericenter, while the body spends most of its time either moving slowly near apocenter or in the lower curvature mid-anomaly portions of its orbit. The solution is to vary the time segment length and maximum degree Chebyshev polynomial coefficient with the body's position. The portion of the software that converts tabular ephemerides into a Chebyshev polynomial representation (CPR) performs this compaction automatically, and the portion that evaluates that representation requires only a modest increase in the evaluation time.

The software also allows the user to choose the required tolerance of the CPR. Thus, if less accuracy is required a more compact, somewhat quicker to evaluate CPR can be manufactured and evaluated. Numerical tests show that a fractional precision of 4e-16 may be achieved, only a factor of 4 greater than the 1e-16 precision of a 64-bit IEEE (2019) compliant floating point number.

The software is written in C and designed to work with the C edition of the Naval Observatory Vector Astrometry Software (NOVAS). The programs may be used to convert tabular ephemerides of other solar system bodies as well. The included READ.ME file provides the details of the software and how to use it.

REFERENCES

IEEE Computer Society 2019, IEEE Standard for Floating-Point Arithmetic. IEEE STD 754-2019, IEEE, pp. 1–84

Newhall, X X 1989, 'Numerical Representation of Planetary Ephemerides,' Celest. Mech., 45, 305 - 310

[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:2105.005] COMPAS: Rapid binary population synthesis code

COMPAS (Compact Object Mergers: Population Astrophysics & Statistics) draws properties for a binary star system from a set of initial distributions and evolves it from zero-age main sequence to the end of its life as two compact remnants. Evolution prescriptions and model parameters are easily adjustable in the software. COMPAS has been used for inference from observations of gravitational-wave mergers, Galactic neutron stars, X-ray binaries, and luminous red novae.

[ascl:2312.008] CompressedFisher: Library for testing Fisher forecasts

The CompressedFisher library tests whether Fisher forecasts using simulated components are converged. The library contains tools to compute standard Fisher estimates, estimate the level of bias due to the finite number of simulations, and compute the compressed Fisher information. Typical usage of CompressedFisher requires two ensembles of simulations: one set of simulations is given at the fiducial parameters (𝜃) to estimate the covariance matrix. The second is a set of simulated derivatives; these can either be in the form of realizations of the derivatives themselves or simulations evaluate at a set of point in the neighborhood of the fiducial point that the code can use to estimate the derivatives.

[ascl:1403.015] computePk: Power spectrum computation

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

[ascl:2306.035] CONCEPT: COsmological N-body CodE in PyThon

CONCEPT (COsmological N-body CodE in PyThon) simulates cosmological structure formation. It can simulate matter particles evolving under self-gravity in an expanding background. The code offers multiple gravitational solvers and has adaptive time integration built in. In addition to particles, CONCEPT also evolves fluids at various levels of non-linearity, providing the means for the inclusion of more exotic species such as massive neutrinos, as well as for simulations consistent with general relativistic perturbation theory. Various non-standard species, such as decaying cold dark matter, are fully supported. CONCEPT includes a sophisticated initial condition generator and can output snapshots, power spectra, bispectra ,and several kinds of renders.

[ascl:2306.042] CONDUCT: Electron transport coefficients of magnetized stellar plasmas

CONDUCT calculates all components of kinetic tensors in fully ionized electron-ion plasmas at arbitrary magnetic field. It employs a thermal averaging with the Fermi distribution function and can be used when electrons are partially degenerate; it provides, along with the electrical and thermal conductivities, also thermopower (thermoelectric coefficient). CONDUCT takes into account collisions of the electrons with ions and (in solid phase) charged impurities as well as quantum effects on ionic motion in the solid phase. The code's outputs are the longitudinal, transverse, and off-diagonal (Hall) components of electrical and thermal conductivity tensors as well as the components of thermoelectric tensor.

[ascl:2207.027] ConeRot: Velocity perturbations extractor

ConeRot extracts velocity perturbations in protoplanetary disks from observed line centroids maps ν∘, by creating axially-symmetric centroid maps. It also derives 3D rotation curves in disk-centered cylindrical coordinates, and can estimate the disk orientation based on line data alone. It approximates the unit opacity surface of an axially symmetric disc by a series of cones whose orientations are fit to the observed velocity centroid in concentric radial domains, or regions, with the disc orientation and the rotation curve both optimized to fit ν∘ in each region. ConeRot extracts the perturbations directly from observations without strong assumptions about the underlying disk model and employs a reduced number of free parameters.

[submitted] Coniferest: Python package for active anomaly detection

Coniferest is a Python package designed for implementing anomaly detection algorithms and interactive active learning tools. The centerpiece of the package is an Isolation Forest algorithm, known for its superior scoring performance and multi-threading evaluation. This robust anomaly detection algorithm operates by constructing random decision trees.

In addition to the Isolation Forest algorithm, Coniferest also offers two modified versions for active learning: AAD Forest and Pineforest. The AAD Forest modifies the Isolation Forest by reweighting its leaves based on responses from human experts, providing a faster alternative to the ad_examples package.

On the other hand, Pineforest, developed by the SNAD team, employs a filtering algorithm that builds and dismantles trees with each new human-machine iteration step.

Coniferest provides a user-friendly interface for conducting interactive human-machine sessions, facilitating the use of these active anomaly detection algorithms. The SNAD team maintains and utilizes this package primarily for anomaly detection in the field of astronomy, with a particular focus on light-curve data from large time-domain surveys.

[ascl:2307.061] connect: COsmological Neural Network Emulator of CLASS using TensorFlow

connect (COsmological Neural Network Emulator of CLASS using TensorFlow) emulates cosmological parameters using neural networks. This includes both sampling of training data and training of the actual networks using the TensorFlow library. connect aids in cosmological parameter inference by immensely speeding up the process, which is achieved by substituting the cosmological Einstein-Boltzmann solver codes, needed for every evaluation of the likelihood, with a neural network with a 102 to 103 times faster evaluation time. The code requires CLASS (ascl:1106.020) and Monte Python (ascl:1307.002) if iterative sampling is used.

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

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

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

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

[ascl:2202.019] Contaminante: Identify blended targets in Kepler, TESS, and K2 data

contaminante helps find the contaminant transiting source in NASA's Kepler, K2 or TESS data. When hunting for transiting planets, sometimes signals come from neighboring contaminants. This package helps users identify where the transiting signal comes from in their data. The code uses pixel level modeling of the TargetPixelFile data from NASA's astrophysics missions that are processed with the Kepler pipeline. The output of contaminante is a Python dictionary containing the source location and transit depth, and a contaminant location and depth. It can also output a figure showing where the main target is centered in all available TPFs, what the phase curve looks like for the main target, where the transiting source is centered in all available TPFs, if a transiting source is located outside the main target, or the transiting source phase curve, if a transiting source is located outside the main target.

[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:2212.025] CONTROL: Colorado Ultraviolet Transit Experiment data reduction pipeline

CONTROL (CUTE autONomous daTa ReductiOn pipeLine) produces science-quality output with a single command line with zero user interference for CUTE (Colorado Ultraviolet Transit Experiment) data. It can be used for any single order spectral data in any wavelength without any modification. The pipeline is governed by a parameter file, which is available with this distribution. CONTROL is fully automated and works in a series of steps following standard CCD reduction techniques. It creates a reduction log to track processes carried out and any parameters used.

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

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

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

ConvPhot measures colors between two images having different resolutions. ConvPhot is designed to work especially for faint galaxies, accurately measuring colors in relatively crowded fields. It makes full use of the spatial and morphological information contained in the highest quality images to analyze multiwavelength data with inhomogeneous image quality.
Written in 2007, ConvPhot has been superseded by T-PHOT (ascl:1609.001)

[ascl:2306.024] COpops: Compute CO sizes and fluxes

COpops computes semi-analytically the CO flux of a disc (given initial conditions and age) under the assumption of LTE and optically thick emission. It then runs disc population synthesis using observationally-informed initial conditions. CO fluxes is one of the most easily accessible observables for studying disc evolution; COpops is a faster alternative to running computationally-expensive thermochemical models for hundreds of discs and is accurate, recovering agreement within a factor of three.

[ascl:1304.022] Copter: Cosmological perturbation theory

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

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

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

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

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

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

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

[ascl:1702.002] corner.py: Corner plots

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

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

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

[ascl:1211.004] CORRFIT: Cross-Correlation Routines

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

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

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

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

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

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

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

[ascl:1010.040] Cosmic String Simulations

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

[ascl:2107.023] cosmic_variance: Cosmic variance calculator

cosmic_variance calculates the cosmic variance during the Epoch of Reionization (EoR) for the UV Luminosity Function (UV LF), Stellar Mass Function (SMF), and Halo Mass Function (HMF). The three functions in the package provide the output as the cosmic variance expressed in percentage. The code is written in Python, and simple examples that show how to use the functions are provided.

[ascl:2108.018] Cosmic-CoNN: Cosmic ray detection toolkit

Cosmic-CoNN detects cosmic rays (CR) in CCD-captured astronomical images. It offers a PyTorch deep-learning framework to train generic, robust CR detection models for ground- and space-based imaging data as well as spectroscopic observations. Cosmic-CoNN also includes a suite of tools, including console commands, a web app, and Python APIs, to make deep-learning models easily accessible.

[ascl:2207.004] cosmic-kite: Auto-encoding the Cosmic Microwave Background

Cosmic-kite performs a fast estimation of the TT Cosmic Microwave Background (CMB) power spectra corresponding to a set of cosmological parameters; it can also estimate the maximum-likelihood cosmological parameters from a power spectra. This software is an auto-encoder that was trained and calibrated using power spectra from random cosmologies computed with the CAMB code (ascl:1102.026).

[ascl:2108.022] COSMIC: Compact Object Synthesis and Monte Carlo Investigation Code

COSMIC (Compact Object Synthesis and Monte Carlo Investigation Code) generates synthetic populations with an adaptive size based on how the shape of binary parameter distributions change as the number of simulated binaries increases. It implements stellar evolution using SSE (ascl:1303.015) and binary interactions using BSE (ascl:1303.014). COSMIC can also be used to simulate a single binary at a time, a list of multiple binaries, a grid of binaries, or a fixed population size as well as restart binaries at a mid point in their evolution. The code is included in CMC-COSMIC (ascl:2108.023).

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

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

[submitted] CosmicEmu: High Precision Emulator for the Nonlinear Matter Power Spectrum

Modern cosmological surveys are delivering datasets characterized by unprecedented quality and statistical completeness. In order to maximally extract cosmological information from these observations, matching theoretical predictions are needed. In the nonlinear regime of structure formation, cosmological simulations are the primary means of obtaining the required information but the computational cost of sufficiently resolved large-volume simulations makes it prohibitive to run very large ensembles. Nevertheless, precision emulators built on a tractable number of high-quality simulations can be used to build very fast prediction schemes to enable a variety of cosmological inference studies. The "Mira-Titan Universe" simulation suite covers the standard six cosmological parameters and, in addition, includes massive neutrinos and a dynamical dark energy equation of state. It is based on 111 cosmological simulations, each covering a (2.1Gpc)^3 volume and evolving 3200^3 particles, and augments these higher-resolution simulations with an additional set of 1776 lower-resolution simulations and TimeRG perturbation theory results to cover scales straddling the linear to mildly nonlinear regimes. The emulator built on this suite, the CosmicEmu, provides predictions at the two to three percent level of accuracy over a wide range of cosmological parameters. Presented in: https://arxiv.org/abs/2207.12345.

[ascl:1304.006] CosmicEmuLog: Cosmological Power Spectra Emulator

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

[ascl:2307.027] CosmicFish: Cosmology forecasting tool

CosmicFish obtains expected bounds on cosmological parameters for a wide range of models and observables for cosmological forecasting. The package includes a Fortran library to produce Fisher matrices, a Python library that performs operations on the produced Fisher matrices, and a full set of plotting utilities. It works with many models, including CAMB (ascl:1102.026) and MGCAMB (ascl:1106.013), and can interface with any Boltzmann solver. The user can choose within a wide range of possible cosmological observables, including cosmic microwave background, weak lensing tomography, galaxy clustering, and redshift drift. CosmicFish is easy to customize; it provides a flexible package system and users can produce their own analyses and plotting pipelines following the default Python apps.

[ascl:1601.008] CosmicPy: Interactive cosmology computations

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

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

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

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

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

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

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

[ascl:2006.005] CosmoCov: Configuration space covariances for projected galaxy 2-point statistics

CosmoCov computes configuration space covariances for projected galaxy 2-point statistics based on the CosmoLike (ascl:2006.006) framework. The package provides a flat sky covariance module, computed with the 2D-FFTLog (ascl:2006.004) algorithm, and a curved sky covariance module.

[ascl:2009.020] cosmoFns: Functions for observational cosmology

cosmoFns computes distances, times, luminosities, and other quantities useful in observational cosmology, including molecular line observations. Written in R and coded for a flat universe, it contains functions for rest-frame line and luminosities, cosmic lookback time given z and cosmological parameters, and differential comoving volume. cosmoFns also computes comoving, luminosity, and angular diameter distances and molecular mass, among other quantities.

[ascl:2007.023] CosmoGRaPH: Cosmological General Relativity and (Perfect fluid | Particle) Hydrodynamics

CosmoGRaPH explores cosmological problems in a fully general relativistic setting. Written in C++, it implements various novel methods for numerically solving the Einstein field equations, including an N-body solver, full AMR capabilities via SAMRAI, and raytracing.

[ascl:2306.032] CosmoGraphNet: Cosmological parameters and galaxy power spectrum from galaxy catalogs

CosmoGraphNet infers cosmological parameters or the galaxy power spectrum. It creates a graph from a galaxy catalog with information the 3D position and intrinsic galactic properties. A Graph Neural Network is then applied to predict the cosmological parameters or the galaxy power spectrum.

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

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

[ascl:2311.012] CosmoLattice: Lattice simulator of scalar and gauge field dynamics in an expanding universe

CosmoLattice performs lattice simulations of field dynamics in an expanding universe. The code can simulate the dynamics of interacting scalar field theories, Abelian U(1) gauge theories, and non-Abelian SU(2) gauge theories, either in flat spacetime or an expanding FLRW background, including the case of self-consistent expansion sourced by the fields themselves. It can also compute gravitational waves sourced by U(1) Abelian Gauge fields. The CosmoLattice platform can implement any system of dynamical equations suitable for discretization on a lattice, as it introduces its own language describing fields and operations between them, and hence can implement new libraries to solve arbitrary field problems (related or not to cosmology).

[ascl:2312.007] CosmoLED: Cosmo code for Large Extra Dimension (LED) black holes

CosmoLED computes Hawking evaporation from black holes and set constraints on the fraction of black holes in dark matter. Based on ExoCLASS (ascl:1106.020), the code provides a DarkAges_LED module and C codes in class_LED to compute the evolution and energy deposition functions from LED black holes. Though CosmoLED is designed for large extra dimension black holes, it can also be used to study 4D black holes.

[ascl:2006.006] CosmoLike: Cosmological Likelihood analyses

CosmoLike analyzes cosmological data sets and forecasts future missions. It has been used in the analysis of the Dark Energy Survey and to optimize the Large Synoptic Survey Telescope and the Wide-Field Infrared Survey Telescope, and is useful for innovative theory projects that test new concepts and methods to enhance the constraining power of cosmological analyses.

[ascl:2009.017] CosmoloPy: Cosmology package for Python

CosmoloPy is a suite of cosmology routines built on NumPy/SciPy. Its capabilities include various cosmological densities, distance measures, and galaxy luminosity functions (Schecter functions). It also offers pre-defined sets of cosmological parameters (e.g., from WMAP), conversion in and out of the AB magnitude system, and the reionization of the IGM. Functions take cosmological parameters (which can be numpy arrays) as keywords and ignore any extra keywords, making it possible to build a dictionary of cosmological parameters and pass it to any function.

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

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

[ascl:1106.025] CosmoMC: Cosmological MonteCarlo

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

[ascl:1110.019] CosmoNest: Cosmological Nested Sampling

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

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

[ascl:2001.010] CosMOPED: Compressed Planck likelihood

CosMOPED (Cosmological MOPED) uses the MOPED (Multiple/Massively Optimised Parameter Estimation and Data compression) compression scheme to compress the Planck power spectrum. This convenient and lightweight compressed likelihood code is implemented in Python. To compute the likelihood for the LambdaCDM model using CosMOPED, one needs only six compression vectors, one for each parameter, and six numbers from compressing the Planck data using the six compression vectors. Using these, the likelihood of a theory power spectrum given the Planck data is the product of six one-dimensional Gaussians. Extended cosmological models require computing extra compression vectors.

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

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

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

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

[ascl:1304.017] CosmoRec: Cosmological Recombination code

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

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

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

[ascl:2401.005] CosmosCanvas: Useful color maps for different astrophysical properties

CosmosCanvas creates perception-based color maps for different astrophysical properties such as spectral index and velocity fields. Three tutorials demonstrate how to use python code to exploit and adjust the boundaries in these divergent colour schemes. Intended to work with human physiology, each tutorial offers at least one default scheme that is monotonic in value both as a redundancy for supporting data information and an aid for colour blind viewers. This library relies on Gilles Ferrand's colourspace library.

[ascl:1409.012] CosmoSIS: Cosmological parameter estimation

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

[ascl:1701.004] CosmoSlik: Cosmology sampler of likelihoods

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

[ascl:1311.009] CosmoTherm: Thermalization code

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

[ascl:1504.010] CosmoTransitions: Cosmological Phase Transitions

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

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

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

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

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

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

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

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

[ascl:2201.011] COWS: Cosmic web filament finder

COWS (COsmic Web Skeleton) implements the cosmic filament finder COsmic Web Skeleton (COWS). Written in Python, the cosmic filament finder works on Hessian-based cosmic web identifiers (such as the V-web) and returns a catalogue of filament spines. The code identifies the medial axis, or skeleton, of cosmic web filaments and then separates this skeleton into individual filaments.

[ascl:1808.003] CPF: Corral Pipeline Framework

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

[ascl:1402.010] CPL: Common Pipeline Library

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

[ascl:2205.021] CPNest: Parallel nested sampling

CPNest performs Bayesian inference using the nested sampling algorithm. It is designed to be simple for the user to provide a model via a set of parameters, their bounds and a log-likelihood function. An optional log-prior function can be given for non-uniform prior distributions. The nested sampling algorithm is then used to compute the marginal likelihood or evidence. As a by-product the algorithm produces samples from the posterior probability distribution. The implementation is based on an ensemble MCMC sampler which can use multiple cores to parallelize computation.

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

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

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

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

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

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

CR-SISTEM models lunar orbital and rotational dynamics, taking into account the effects of a liquid core. Orbits of the Moon and Earth are fully integrated, and other planets (or additional point-mass satellites) may be included in the integration. Lunar and solar tides on Earth, eccentricity and obliquity tides on the Moon, and lunar core-mantle friction are included. The integrator is one file (crsistem5.for) written in FORTRAN 90, uses seven input files (settings.in, planets.in, moons.in, tidal.in, lunar.in, precess.in and core.in), and has at least eight output files (planet101.out, moon101.out, pole.out, spin_orb.out, spin_ecl.out, cspin_ecl.out, long.out and clong.out); additional moons and planets would add more output. The input files provided with the code set up a 1 Myr simulation of a slow-spinning Moon on an orbit of 40 Earth radii, which will then dynamically relax to the lowest-energy state (in this case it is a synchronous rotation with a core spinning separately from the mantle).

[ascl:2009.018] CRAC: Cosmology R Analysis Code

CRAC (Cosmology R Analysis Code) provides R functions for cosmology. Its main functions are similar to the Python library CosmoloPy (ascl:2009.017); for example, it implements functions to compute spherical geometric quantities for cosmological research.

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

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

[ascl:2206.008] Craterstats2: Planetary surface dating from crater size-frequency distribution measurements

Craterstats2 plots crater counts and determining surface ages. The software plots isochrons in cumulative, differential, R-plot and Hartmann presentations, and makes isochron fits to both cumulative and differential data. Hartmann-style piecewise production functions may also be used. A Python implementation of the software, Craterstats3, is also available.

[ascl:2206.009] Craterstats3: Analyze and plot crater count data for planetary surface dating

Craterstats3 analyzes and plots crater count data for planetary surface dating. It is a Python implementation of Craterstats2 (ascl:2206.008) and is designed to replicate the output of the previous version as closely as possible. As before, it produces plots in cumulative, differential, Hartmann, and R-plot styles with possible overlays of crater counts, isochrons, equilibrium functions and epoch boundaries, as well aschronology and impact rate functions. Data can be shown with various binnings or unbinned, and age estimates made by either cumulative fitting, differential fitting, or Poisson timing evaluation. Numerical results can be output as text for further processing elsewhere. A number of published chronology systems are already set up for use, but new ones may be added by the user. The software is designed to be easily integrated into other software, which could allow the addition of a graphical interface or the inclusion of some Craterstats functions into a GIS.

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

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

[ascl:1308.009] CReSyPS: Stellar population synthesis code

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

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

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

[ascl:2103.017] CRIME: Cosmological Realizations for Intensity Mapping Experiments

CRIME (Cosmological Realizations for Intensity Mapping Experiments) generates mock realizations of intensity mapping observations of the neutral hydrogen distribution. It contains three separate tools, GetHI, ForGet, and JoinT. GetHI generates realizations of the temperature fluctuations due to the 21cm emission of neutral hydrogen. Optionally it can also generate a realization of the point-source continuum emission (for a given population) by sampling the same density distribution, though using this feature greatly affects performance. ForGet generates realizations of the different galactic and extra-galactic foregrounds relevant for intensity mapping experiments using some external datasets (e.g. the Haslam 408 MHz map) stored in the "data"folder. JoinT is provided for convenience; it joins the temperature maps generated by GetHI and ForGet and includes several instrument-dependent effects (in an overly simplistic way).

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

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

[ascl:1110.020] CROSS_CMBFAST: ISW-correlation Code

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

[ascl:2106.004] crowdsource: Crowded field photometry pipeline

crowdsource removes a rough sky (the median), find the brighter peaks and fits these sources, computes centroids, and then computes an improved PSF. With this model of the image, the code then iteratively subtracts it and recomputes the median to get a better sky estimate, finds fainter peaks, and calculates a better PSF. crowdsource performs at least four iterations, evaluates the results, and continues until certain thresholds are met. Once the iterative passes are complete, it makes one last pass. If no sources are detected and positions do not vary, it performs photometry for the existing list of stellar positions.

[submitted] CRPropa 3.2

The landscape of high- and ultra-high-energy astrophysics has changed in the last decade, largely due to the inflow of data collected by large-scale cosmic-ray, gamma-ray, and neutrino observatories. At the dawn of the multimessenger era, the interpretation of these observations within a consistent framework is important to elucidate the open questions in this field. CRPropa 3.2 is a Monte Carlo code for simulating the propagation of high-energy particles in the Universe. This version represents a major leap forward, significantly expanding the simulation framework and opening up the possibility for many more astrophysical applications. This includes, among others: efficient simulation of high-energy particles in diffusion-dominated domains, self-consistent and fast modelling of electromagnetic cascades with an extended set of channels for photon production, and studies of cosmic-ray diffusion tensors based on updated coherent and turbulent magnetic-field models. Furthermore, several technical updates and improvements are introduced with the new version, such as: enhanced interpolation, targeted emission of sources, and a new propagation algorithm (Boris push). The detailed description of all novel features is accompanied by a discussion and a selected number of example applications.

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

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

[ascl:2208.016] CRPropa3: Simulation framework for propagating extraterrestrial ultra-high energy particles

CRPropa3, an improved version of CRPropa2 (ascl:1412.013), provides a simulation framework to study the propagation of ultra-high-energy nuclei up to iron on their voyage through an (extra)galactic environment. It takes into account pion production, photodisintegration, and energy losses by pair production of all relevant isotopes in the ambient low-energy photon fields, as well as nuclear decay. CRPropa3 can model the deflection in (inter)galactic magnetic fields, the propagation of secondary electromagnetic cascades, and neutrinos for a multitude of scenarios for different source distributions and magnetic environments. It enables the user to predict the spectra of UHECR (and of their secondaries), their composition and arrival direction distribution. Additionally, the low-energy Galactic propagation can be simulated by solving the transport equation using stochastic differential equations. CRPropa3 features a very flexible simulation setup with python steering and shared-memory parallelization.

[ascl:2401.016] CRR: Convex Ridge Regularizer

CRR (Convex Ridge Regularizer) takes the gradient of regularizers that are the sum of convex-ridge functions and parameterizes them using a neural network that has a single hidden layer with increasing and learnable activation functions. The neural network is trained within a few minutes as a multistep Gaussian denoiser, and offers improvements for denoising and image reconstruction over other methods with similar reliability.

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

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

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

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

[ascl:2205.015] CS-ROMER: Compressed Sensing ROtation MEasure Reconstruction

CS-ROMER (Compressed Sensing ROtation MEasure Reconstruction) is a compressed sensing reconstruction framework for Faraday depth spectra. It can simulation Faraday depth sources, subtract Galactic RM, and reconstruct Faraday depth sources from linearly polarized data and Faraday depth sources using Compressed Sensing.

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

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

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

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

[ascl:1307.015] CTI Correction Code

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

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

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

[ascl:2104.005] CTR: Coronal Temperature Reconstruction

CTR (Coronal Temperature Reconstruction) reconstructs differential emission measures (DEMs) in the solar corona. Written in IDL, the code guarantees positivity of the recovered DEM, enforces an explicit smoothness constraint, returns a featureless (flat) solution in the absence of information, and converges quickly. The algorithm is robust and can be extended to other wavelengths where the DEM treatment is valid.

[ascl:1608.008] Cuba: Multidimensional numerical integration library

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

[ascl:1609.010] CuBANz: Photometric redshift estimator

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:1805.018] CUBE: Information-optimized parallel cosmological N-body simulation code

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

[ascl:2208.023] CubeFit: Regularized 3D fitting for spectro-imaging data

Cubefit is an OXY class that performs spectral fitting with spatial regularization in a spectro-imaging context. The 3D model is based on a 1D model and 2D parameter maps; the 2D maps are regularized using an L1L2 regularization by default. The estimator is a compound of a chi^2 based on the 1D model, a regularization term based of the 2D regularization of the various 2D parameter maps, and an optional decorrelation term based on the cross-correlation of specific pairs of parameter maps.

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

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

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

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

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

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

A successor to CubiCal, QuartiCal (ascl:2305.006), is available.

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

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

[ascl:2105.016] CUDAHM: MCMC sampling of hierarchical models with GPUs

CUDAHM accelerates Bayesian inference of Hierarchical Models using Markov Chain Monte Carlo by constructing a Metropolis-within-Gibbs MCMC sampler for a three-level hierarchical model, requiring the user to supply only a minimimal amount of CUDA code. CUDAHM assumes that a set of measurements are available for a sample of objects, and that these measurements are related to an unobserved set of characteristics for each object. For example, the measurements could be the spectral energy distributions of a sample of galaxies, and the unknown characteristics could be the physical quantities of the galaxies, such as mass, distance, or age. The measured spectral energy distributions depend on the unknown physical quantities, which enables one to derive their values from the measurements. The characteristics are also assumed to be independently and identically sampled from a parent population with unknown parameters (e.g., a Normal distribution with unknown mean and variance). CUDAHM enables one to simultaneously sample the values of the characteristics and the parameters of their parent population from their joint posterior probability distribution.

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

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

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

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

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

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

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

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

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

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

[ascl:2101.013] Curvit: Create light curves from UVIT data

Curvit produces light curves from UVIT (Ultraviolet Imaging Telescope) data. It uses the events list from the official UVIT L2 pipeline (version 6.3 onwards) as input. The makecurves function of curvit automatically detects sources from events list and creates light curves. Curvit provides source coordinates only in the instrument coordinate system. If you already have the source coordinates, the curve function of curvit can be used to create light curves. The package has several parameters that can be set by the user; some of these parameters have default values. Curvit is available on PyPI.

[ascl:2206.025] CuspCore: Core formation in dark matter haloes and ultra-diffuse galaxies by outflow episodes

CuspCore describes the formation of flat cores in dark matter haloes and ultra-diffuse galaxies from feedback-driven outflow episodes. The halo response is divided into an instantaneous change of potential at constant velocities followed by an energy-conserving relaxation. The core assumption of the model is that the total energy E=U+K is conserved for each shell enclosing a given dark matter mass, which is treated in the code as a least-square minimization of the difference between the final and the initial energy of each shell.

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

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

[ascl:1708.018] CUTEX: CUrvature Thresholding EXtractor

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

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

[ascl:2210.030] cuvarbase: fast period finding utilities for GPUs

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

[ascl:2008.017] CVXOPT: Convex Optimization

CVXOPT makes the development of software for convex optimization applications straightforward by building on Python’s extensive standard library and on the strengths of Python as a high-level programming language. It offers efficient Python classes for dense and sparse matrices (real and complex) with Python indexing and slicing and overloaded operations for matrix arithmetic, an interface to the fast Fourier transform routines from FFTW, and an interface to most of the double-precision real and complex BLAS. It contains routines for linear, second-order cone, and semidefinite programming problems, and for nonlinear convex optimization. CVXOPT also provides an interface to LAPACK routines for solving linear equations and least-squares problems, matrix factorizations (LU, Cholesky, LDLT and QR), symmetric eigenvalue and singular value decomposition, and Schur factorization, and a modeling tool for specifying convex piecewise-linear optimization problems.

[ascl:2011.028] CWITools: Tools for Cosmic Web Imager data

CWITools analyzes integral field spectroscopy data from the Palomar and Keck Cosmic Web Imagers, and can be adapted for any three-dimensional integral field spectroscopy data. The package is modular, allowing users to construct data analysis pipelines to suit their own scientific needs, and includes tools for reducing data cubes, extracting a target signal, making emission maps, spectra, and other products. It also fits emission line and radial profiles and obtains final scalar quantities such as size and luminosity, among other tasks. It also contains helper functions that can, for example, obtain the wavelength axis from a 3D header, and create an auto-populated list of nebular emission lines or sky lines.

[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:2303.001] cysgp4: Wrapper for C++ SGP4 satellite library

The cysgp4 Cython-powered package wraps the C++ SGP4 Library for computing satellite positions from two-line elements (TLE). It provides similar functionality as the sgp4 Python package, though also works well with arrays of TLEs and/or observing times and makes use of multi-core platforms (via OpenMP) to improve processing times.

[ascl:2203.010] D2O: Distributed Data Object

D2O acts as a layer of abstraction between algorithm code and data-distribution logic to manage cluster-distributed multi-dimensional numerical arrays; this provides usability without losing numerical performance and scalability. D2O's global interface makes the cluster node's local data directly accessible for use in customized high-performance modules. D2O is written in Python; the code is portable and easy to use and modify. Expensive operations are carried out by dedicated external libraries like numpy and mpi4py and performance scales well when moving to an MPI cluster. In combination with NIFTy, D2O enables supercomputer based astronomical imaging via RESOLVE (ascl:1505.028) and D3PO (ascl:1504.018).

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

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

[ascl:1612.007] dacapo_calibration: Photometric calibration code

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

[ascl:1804.005] DaCHS: Data Center Helper Suite

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

[ascl:1507.015] DALI: Derivative Approximation for LIkelihoods

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

[ascl:1912.004] DALiuGE: Data Activated Liu Graph Engine

DALiuGE provides a distributed data management platform and a scalable pipeline execution environment to support continuous, soft real-time, data-intensive processing for producing radio astronomy data products; it originated from a prototyping activity as part of the SKA SDP Consortium called Data Flow Management System (DFMS). Though the development of DALiuGE is largely based on radio astronomy processing requirements, it has adopted a generic, data-driven framework architecture potentially applicable to many other data-intensive applications.

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

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

[ascl:2102.018] DaMaSCUS-SUN: Dark Matter Simulation Code for Underground Scatterings - Sun Edition

DaMaSCUS-SUN is a Monte Carlo tool simulating the process of solar reflection of dark matter (DM) particles. It provides precise estimates of the DM particle flux reflected by the Sun and passing through a direct detection experiment on Earth. One application is to compute exclusion limits for low DM masses based on nuclear and electron recoil experiments.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[ascl:2401.008] DARC: Dirac Atomic R-matrix Codes

DARC (Dirac Atomic R-matrix Codes) enables the study of continuum processes for a general atomic system. The suite of programs calculate electron-atom or electron-ion collision cross-sections. In addition, the programs include code for bound-state and photoionization calculations.

[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:2201.006] dark-photons-perturbations: Dark photon conversions in our inhomogeneous Universe

dark-photons-perturbations determines constraints from Cosmic Microwave Background photons oscillating into dark photons, and from heating of the primordial plasma due to dark photon dark matter converting into low-energy photons in an inhomogeneous universe.

[ascl:2112.011] DarkARC: Dark Matter-induced Atomic Response Code

DarkARC computes and tabulates atomic response functions for direct sub-GeV dark matter (DM) searches. The tabulation of the atomic response functions is separated into two steps: 1.) the computation and tabulation of three radial integrals, and 2.) their combination into the response function tables. The computations are performed in parallel using the multiprocessing library.

[ascl:2011.029] DarkBit: Dark matter constraints calculator

DarkBit computes dark matter constraints on extensions to the Standard Model of particle physics. Written in the GAMBIT (ascl:1708.030) framework, it seamlessly integrates with other tools in the statistical fitting framework; it is also available as a standalone tool. It offers a signal yield calculator for gamma-ray observations, provides likelihoods for arbitrary combinations of spin-independent and spin-dependent scattering processes, and provides a general solution for studying complex particle physics models that predict dark matter annihilation to a multitude of final states.

[ascl:2011.005] DarkCapPy: Dark Matter Capture and Annihilation

DarkCapPy calculates rates associated with dark matter capture in the Earth, annihilation into light mediators, and observable decay of the light mediators near the surface of the Earth. This Python/Jupyter package can calculate the Sommerfeld enhancement at the center of the Earth and the timescale for capture-annihilation equilibrium, and can be modified for other compact astronomical objects and mediator spins.

[ascl:2103.009] DarkEmulator: Cosmological emulation code for halo clustering statistics

The cosmology code DarkEmulator calculates summary statistics of large scale structure constructed as a part of Dark Quest Project. The “dark_emulator” python package enables fast and accurate computations of halo clustering quantities. The code supports the halo mass function, halo-matter cross-correlation, and halo auto-correlation as a function of halo masses, redshift, separations and cosmological models.

[ascl:2204.019] DarkFlux: Dark Matter annihilation spectrum computer

DarkFlux analyzes indirect-detection signatures for next-generation models of dark matter (DM) with multiple annihilation channels. Input is user-generated models with 2 → 2 tree-level dark matter annihilation to pairs of Standard Model (SM) particles. The code analyzes DM annihilation to γ rays using three modules; one computes the fractional annihilation rate, the second computes the total flux at Earth due to DM annihilation, and the third compares the total flux to observational data and computes the upper limit at 95% confidence level (CL) on the total thermally averaged DM annihilation cross section.

[ascl:2007.010] DarkHistory: Modified cosmic ionization and thermal histories calculator

DarkHistory calculates the global temperature and ionization history of the universe given an exotic source of energy injection, such as dark matter annihilation or decay. The software simultaneously solves for the evolution of the free electron fraction and gas temperature, and for the cooling of annihilation/decay products and the secondary particles produced in the process. Consequently, we can self-consistently include the effects of both astrophysical and exotic sources of heating and ionization, and automatically take into account backreaction, where modifications to the ionization/temperature history in turn modify the energy-loss processes for injected particles.

[ascl:2305.011] DarkMappy: Mapping the dark universe

DarkMappy reconstructs maximum a posteriori (MAP) convergence maps by formulating an unconstrained Bayesian inference problem in order to implement hybrid Bayesian dark-matter reconstruction techniques on the plane and on the celestial sphere. These convergence maps support principled uncertainty quantification and provide hypothesis testing of structure, from which it is possible to distinguish between physical objects and artifacts of the reconstruction.

[ascl:2106.032] DarkSirensStat: Measuring modified GW propagation and the Hubble parameter

DarkSirensStat statistically measures modified gravitational wave (GW) propagation and the Hubble parameter. The package implements a hierarchical Bayesian framework for constraining the Hubble parameter and modified GW propagation with dark sirens and galaxy catalogs. The package downloads the needed data; which include the GLADE galaxy catalog, O2 and O3 skymaps from the LVC official data releases, and O2 and O3 strain sensitivities. The default options are for running inference for H0 on the O3 BBH events, with flat prior between 20 and 140, mask completeness with 9 masks, interpolation between multiplicative and homogeneous completion, B-band luminosity weights, and a completeness threshold of 50%. The selection effects are computed with MC.

[ascl:1110.002] DarkSUSY: Supersymmetric Dark Matter Calculations

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

[ascl:2101.015] DarpanX: X-ray reflectivity of multilayer mirrors

DarpanX computes reflectivity and other specular optical functions of a multilayer or single layer mirror for different energy and angles as well as to fit the XRR measurements of the mirrors. It can be used as a standalone package. It has also been implemented as a local module for XSPEC (ascl:9910.005), which is accessible through and requires PyXspec (ascl:2101.014), and can accurately fit experimentally measured X-ray reflectivity data. DarpanX is implemented as a Python 3 module and an API is provided to access the underlying algorithms.

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

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

[ascl:2002.009] DASH: Deep Automated Supernova and Host classifier

DASH classifies the type, age, redshift and host for any supernova spectra based on the learned features, through use of a deep convolutional neural network to train a matching algorithm, of each supernova’s type and age. The Python library allows a user to classify spectra; the software is fast and can classify thousands of spectra in seconds. A graphical interface that enables a user to view and classify a spectrum is also available.

[ascl:2009.023] DASTCOM5: JPL small-body data browser

DASTCOM5 is a portable direct-access database containing all NASA/JPL asteroid and comet orbit solutions, and the software to access it. Available data include orbital elements, orbit diagrams, physical parameters, and discovery circumstances. A JPL implementation of the software is available at http://ssd.jpl.nasa.gov/sbdb.cgi.

[submitted] Data modelling approaches to astronomical data - Mapping large spectral line data cubes to dimensional data models

As a new generation of large-scale telescopes are expected to produce single data products in the range of hundreds of GBs to multiple TBs, different approaches to I/O efficient data interaction and extraction need to be investigated and made available to researchers. This will become increasingly important as the downloading and distribution of TB scale data products will become unsustainable, and researchers will have to take their processing analysis to the data. We present a methodology to extract 3 dimensional spatial-spectral data from dimensionally modelled tables in Parquet format on a Hadoop system. The data is loaded into the Parquet tables from FITS cube files using a dedicated process. We compare the performance of extracting data using the Apache Spark parallel compute framework on top of the Parquet-Hadoop ecosystem with data extraction from the original source files on a shared file system. We have found that the Spark-Parquet-Hadoop solution provides significant performance benefits, particularly in a multi user environment. We present a detailed analysis of the single and multi-user experiments conducted and also discuss the benefits and limitations of the platform used for this study.

[ascl:2307.016] DataComb: Combining data for better images

DataComb combines radio interferometric and single dish observations and obtains quantitative measures of how different techniques perform to obtain better fidelity images. The package relies on CASA (ascl:1107.013) for the combinations and on AstroPy (ascl:1304.002) for making quantitative
comparisons between different images produced by different methods. Model images and simulations are also used to assess the different combination methods.

[ascl:1405.011] DATACUBE: A datacube manipulation package

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

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

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

[ascl:2108.020] DBSP_DRP: DBSP Data Reduction Pipeline

DBSP_DRP reduces data from the Palomar spectrograph DBSP. Built on top of PypeIt (ascl:1911.004), it automates the reduction, fluxing, telluric correction, and combining of the red and blue sides of one night's data. The pipeline also provides several GUIs for easier control of the reduction, with one for selecting which data to reduce, and verifying the correctness of FITS headers in an editable table. Another GUI manually places traces for a sort of manually "forced" spectroscopy with the -m option, and after manually placing traces, manually selects sky regions and tweaks the FWHM of the manual traces.

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

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

[ascl:1207.006] dcr: Cosmic Ray Removal

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

[ascl:2011.030] DDCalc: Dark matter direct detection phenomenology package

DDCalc performs various dark matter direct detection calculations, including signal rate predictions, constraints on light DM, and likelihoods for several experiments. It offers eighteen non-relativistic effective operators to describe velocity and momentum transfer, and elastic scattering of DM particles off nucleons, and has an extended detector interface.

[ascl:2305.008] DDFacet: Facet-based radio imaging package

DDFacet provides a wideband wide-field spectral imaging and deconvolution framework that accounts for generic direction-dependent effects (DDEs). It implements a wide-field coplanar faceting scheme and uses nontrivial facet-dependent w-kernels to correct for noncoplanarity within the facets. In the imaging and deconvolution steps, DDFacet can handle generic, spatially discrete, time-frequency-baseline-direction-dependent full polarization Jones matrices, and computes a direction dependent PSF for use in the minor cycle of deconvolution for time-frequency-baseline dependent Mueller matrices. The code also allows for the effects of time and bandwidth averaging to be explicitly incorporated into deconvolution. DDFacet has been successfully tested with data diverse telescopes such as LOFAR, VLA, MeerKAT AR1, and ATCA.

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

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

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

DDS simulates scattered light and thermal reemission in arbitrary optically dust distributions with spherical, homogeneous grains where the dust parameters (optical properties, sublimation temperature, grain size) and SED of the illuminating/ heating radiative source can be arbitrarily defined. The code is optimized for studying circumstellar debris disks where large grains (i.e., with large size parameters) are expected to determine the far-infrared through millimeter dust reemission spectral energy distribution. The approach to calculate dust temperatures and dust reemission spectra is only valid in the optically thin regime. The validity of this constraint is verified for each model during the runtime of the code. The relative abundances of different grains can be arbitrarily chosen, but must be constant outside the dust sublimation region., i.e., the shape of the (arbitrary) radial dust density distribution outside the dust sublimation region is the same for all grain sizes and chemistries.

[ascl:0008.001] DDSCAT: The discrete dipole approximation for scattering and absorption of light by irregular particles

DDSCAT is a freely available software package which applies the "discrete dipole approximation" (DDA) to calculate scattering and absorption of electromagnetic waves by targets with arbitrary geometries and complex refractive index. The DDA approximates the target by an array of polarizable points. DDSCAT.5a requires that these polarizable points be located on a cubic lattice. DDSCAT allows accurate calculations of electromagnetic scattering from targets with "size parameters" 2 pi a/lambda < 15 provided the refractive index m is not large compared to unity (|m-1| < 1). The DDSCAT package is written in Fortran and is highly portable. The program supports calculations for a variety of target geometries (e.g., ellipsoids, regular tetrahedra, rectangular solids, finite cylinders, hexagonal prisms, etc.). Target materials may be both inhomogeneous and anisotropic. It is straightforward for the user to import arbitrary target geometries into the code, and relatively straightforward to add new target generation capability to the package. DDSCAT automatically calculates total cross sections for absorption and scattering and selected elements of the Mueller scattering intensity matrix for specified orientation of the target relative to the incident wave, and for specified scattering directions. This User Guide explains how to use DDSCAT to carry out EM scattering calculations. CPU and memory requirements are described.

[ascl:2401.007] deal.II: Finite element library

deal.II computes solutions to partial differential equations (PDEs) using adaptive finite elements. The code provides an interface for processing PDEs accessible to both laptops and supercomputers, and has been used to investigate the local and global waveform effects of gravitational waves by numerical simulation. deal.II supports massively parallel computing of very large linear systems of equations and provides access to triangulation of various geometries of the simulation domain.

[ascl:1510.004] DEBiL: Detached Eclipsing Binary Light curve fitter

DEBiL rapidly fits a large number of light curves to a simple model. It is the central component of a pipeline for systematically identifying and analyzing eclipsing binaries within a large dataset of light curves; the results of DEBiL can be used to flag light curves of interest for follow-up analysis.

[ascl:2001.008] DebrisDiskFM: Debris Disk Forward Modeling

DebrisDiskFM provides forward modeling for circumstellar debris disks in scattered light using the MCFOST disk modeling software to generate disk model images using given input parameters and emcee (ascl:1303.002) to obtain the posterior distributions for these parameters.

[ascl:1501.005] DECA: Decomposition of images of galaxies

DECA performs photometric analysis of images of disk and elliptical galaxies having a regular structure. It is written in Python and combines the capabilities of several widely used packages for astronomical data processing such as IRAF (ascl:9911.002), SExtractor (ascl:1010.064), and the GALFIT (ascl:1104.010) code to perform two-dimensional decomposition of galaxy images into several photometric components (bulge+disk). DECA can be applied to large samples of galaxies with different orientations with respect to the line of sight (including edge-on galaxies) and requires minimum human intervention.

[ascl:2302.002] deconfuser: Fast orbit fitting to directly imaged multi-planetary systems

Deconfuser performs fast orbit fitting to directly imaged multi-planetary systems. It quickly fits orbits to planet detections in 2D images and ensures that all orbits within a certain tolerance are found. The code also tests all groupings of detections by planets (which detection belongs to which planet), and ranks partitions of detections by planets by deciding which assignment of detection-to-planet best fits the data.

[ascl:1801.006] DecouplingModes: Passive modes amplitudes

DecouplingModes calculates the amplitude of the passive modes, which requires solving the Einstein equations on superhorizon scales sourced by the anisotropic stress from the magnetic fields (prior to neutrino decoupling), and the magnetic and neutrino stress (after decoupling). The code is available as a Mathematica notebook.

[ascl:1603.015] Dedalus: Flexible framework for spectrally solving differential equations

Dedalus solves differential equations using spectral methods. It implements flexible algorithms to solve initial-value, boundary-value, and eigenvalue problems with broad ranges of custom equations and spectral domains. Its primary features include symbolic equation entry, multidimensional parallelization, implicit-explicit timestepping, and flexible analysis with HDF5. The code is written primarily in Python and features an easy-to-use interface. The numerical algorithm produces highly sparse systems for many equations which are efficiently solved using compiled libraries and MPI.

[submitted] Deep Embedded Clustering for Open Cluster Characterization with Gaia DR2 Data

Characterize and understandOpen Clusters(OCs) allow us to understand better properties and mechanisms about the Universe such as stellar formation and the regions where these events occur. They also provide information about stellar processes and the evolution of the galactic disk.

In this paper, we present a novel method to characterize OCs. Our method employs a model built on Artificial Neural Networks(ANNs). More specifically, we adapted a state of the art model, the Deep Embedded Clustering(DEC) model for our purpose. The developed method aims to improve classical state of the arts techniques. We improved not only in terms of computational efficiency (with lower computational requirements), but inusability (reducing the number of hyperparameters to get a good characterization of the analyzed clusters). For our experiments, we used the Gaia DR2 database as the data source, and compared our model with the clustering technique K-Means. Our method achieves good results, becoming even better (in some of the cases) than current techniques.

[ascl:2309.005] DeepGlow: Neural network emulator for BOXFIT

The feed-forward neural network DeepGlow emulates BOXFIT (ascl:2306.059) simulation data of gamma-ray burst (GRB) afterglows. The package provides an easy interface to generate GRB afterglow spectra and light curves mimicking those generated through BOXFIT with high accuracy. The code used to generate the training data and to train the neural networks is also included.

[ascl:2112.017] deeplenstronomy: Pipeline for versatile strong lens sample simulations

deeplenstronomy simulates large datasets for applying deep learning to strong gravitational lensing. It wraps the functionalities of lenstronomy (ascl:1804.012) in a convenient yaml-style interface to generate training datasets. The code can use built-in astronomical surveys, realistic galaxy colors, real images of galaxies, and physically motivated distributions of all parameters to train the neural network to create a simulated dataset.

[ascl:2209.003] DeepMass: Cosmological map inference with deep learning

DeepMass infers dark matter maps from weak gravitational lensing measurements and uses deep learning to reconstruct cosmological maps. The code can also be incorporated into a Moment Network to enable high-dimensional likelihood-free inference.

[ascl:1805.029] DeepMoon: Convolutional neural network trainer to identify moon craters

DeepMoon trains a convolutional neural net using data derived from a global digital elevation map (DEM) and catalog of craters to recognize craters on the Moon. The TensorFlow-based pipeline code is divided into three parts. The first generates a set images of the Moon randomly cropped from the DEM, with corresponding crater positions and radii. The second trains a convnet using this data, and the third validates the convnet's predictions.

[ascl:2011.026] DeepShadows: Finding low-surface-brightness galaxies in survey images

DeepShadows uses a convolutional neural networks (CNNs) to separate low-surface-brightness galaxies (LSBGs) from artifacts (such as Galactic cirrus and star-forming regions) in survey images. The model is trained and tested on labeled LSBGs and artifacts from the Dark Energy Survey and demonstrates that CNNs offer a promising path in the quest to study the low-surface-brightness universe.

[ascl:2006.023] deepSIP: deep learning of Supernova Ia Parameters

deepSIP (deep learning of Supernova Ia Parameters) measures the phase and light-curve shape of a Type Ia Supernova (SN Ia) from an optical spectrum. The package contains a set of three trained Convolutional Neural Networks (CNNs) for the aforementioned purposes, but tools for preprocessing spectra, modifying the neural architecture, training models, and sweeping through hyperparameters are also included.

[ascl:2006.008] DeepSphere: Graph-based spherical convolutional neural network for cosmology

DeepSphere implements a generalization of Convolutional Neural Networks (CNNs) to the sphere. It models the discretized sphere as a graph of connected pixels. The resulting convolution is more efficient (especially when data doesn't span the whole sphere) and mostly equivariant to rotation (small distortions are due to the non-existence of a regular sampling of the sphere). The pooling strategy exploits a hierarchical pixelization of the sphere (HEALPix) to analyze the data at multiple scales. The graph neural network model is based on ChebNet and its TensorFlow implementation.

[ascl:2112.004] Defringe: Fringe artifact correction

Defringe corrects fringe artifacts in near-infrared astronomical images taken with old generation CCD cameras. It essentially solves a robust PCA problem, masking out astrophysical sources, and models the contaminants as a linear superposition of (unknown) modes, with (unknown) projection coefficients. The problem uses nuclear norm regularization, which acts as a convex proxy for rank minimization. The code is written in python, using cupy for GPU acceleration, but will also work on CPUs.

[ascl:1405.004] Defringeflat: Fringe pattern removal

The IDL package Defringeflat identifies and removes fringe patterns from images such as spectrograph flat fields. It uses a wavelet transform to calculate the frequency spectrum in a region around each point of a one-dimensional array. The wavelet transform amplitude is reconstructed from (smoothed) parameters obtaining the fringe's wavelet transform, after which an inverse wavelet transform is performed to obtain the computed fringe pattern which is then removed from the flat.

[ascl:1011.012] DEFROST: Simulating preheating after inflation

At the end of inflation, dynamical instability can rapidly deposit the energy of homogeneous cold inflaton into excitations of other fields. This process, known as preheating, is rather violent, inhomogeneous and non-linear, and has to be studied numerically. DEFROST simulates preheating of the Universe after the end of the inflation. It is small, easy to modify, very fast, and fully instrumented for 3D visualizations. An MPI extension for this code, MPI-DEFROST (ascl:1106.022), is available.

[ascl:2208.012] DELIGHT: Identify host galaxies of transient candidates

DELIGHT (Deep Learning Identification of Galaxy Hosts of Transients) automatically identifies host galaxies of transient candidates using multi-resolution images and a convolutional neural network. This library has a class with several methods to get the most likely host coordinates starting from given transient coordinates. In order to do this, the DELIGHT object needs a list of object identifiers and coordinates (oid, ra, dec). With this information, it downloads PanSTARRS images centered around the position of the transients (2 arcmin x 2 arcmin), gets their WCS solutions, creates the multi-resolution images, does some extra preprocessing of the data, and finally predicts the position of the hosts using a multi-resolution image and a convolutional neural network. DELIGHT can also estimate the host's semi-major axis if requested, taking advantage of the multi-resolution images.

[ascl:2306.005] Delight: Photometric redshift via Gaussian processes with physical kernels

Delight infers photometric redshifts in deep galaxy and quasar surveys. It uses a data-driven model of latent spectral energy distributions (SEDs) and a physical model of photometric fluxes as a function of redshift, thus leveraging the advantages of both machine- learning and template-fitting methods by building template SEDs directly from the training data. Delight obtains accurate redshift point estimates and probability distributions and can also be used to predict missing photometric fluxes or to simulate populations of galaxies with realistic fluxes and redshifts.

[ascl:1602.012] DELightcurveSimulation: Light curve simulation code

DELightcurveSimulation (also called DELCgen) simulates light curves with any given power spectral density and any probability density function, following the algorithm described in Emmanoulopoulos et al. (2013). The simulated products have exactly the same variability and statistical properties as the observed light curves. The code is a Python implementation of the Mathematica code provided by Emmanoulopoulos et al.

[ascl:2303.014] Delphes: Fast simulation of a generic collider experiment

Delphes simulates a fast multipurpose detector response. The simulation includes a tracking system, embedded into a magnetic field, calorimeters and a muon system. The Delphes framework is interfaced to standard file formats (e.g. Les Houches Event File or HepMC) and outputs observables such as isolated leptons, missing transverse energy and collection of jets that can be used for dedicated analyses. The simulation of the detector response takes into account the effect of magnetic field, the granularity of the calorimeters and sub-detector resolutions. Visualization of the final state particles is also built-in using the corresponding ROOT library.

[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:2104.015] dense_basis: Dense Basis SED fitting

dense_basis implements the Dense Basis method tailored to SED fitting, in particular, the task of recovering accurate star formation history (SFH) information from galaxy spectral energy distributions (SEDs). The code's original use-case was simultaneously fitting specific large catalogs of galaxies; it is adapted to a general purpose SED fitting code, and acts as a module to compress and decompress SFHs and other time-series.

[ascl:2312.004] DENSe: Bayesian density estimation for Poisson data

DENSe enables Bayesian non-parametric inferences of densities of Poisson data counts. Its framework of stateless methods is written in Python, although it relies on NIFTy (ascl:1302.013, ascl:1903.008) for the heavy lifting. DENSe utilizes all available information in the data by modeling the inherent correlation structure using a Matérn kernel. The inference of the density from count data can be written in a single line of python code. The fitting method takes a multidimensional numpy array as input and returns multidimensional arrays of the same dimensions encoding the density field.

[ascl:1904.009] deproject: Deprojection of two-dimensional annular X-ray spectra

Deproject extends Sherpa (ascl:1107.005) to facilitate deprojection of two-dimensional annular X-ray spectra to recover the three-dimensional source properties. For typical thermal models, this includes the radial temperature and density profiles. This basic method is used for X-ray cluster analysis and is the basis for the XSPEC (ascl:9910.005) model project. The deproject module is written in Python and is straightforward to use and understand. The basic physical assumption of deproject is that the extended source emissivity is constant and optically thin within spherical shells whose radii correspond to the annuli used to extract the specta. Given this assumption, one constructs a model for each annular spectrum that is a linear volume-weighted combination of shell models.

[ascl:1511.017] DES exposure checker: Dark Energy Survey image quality control crowdsourcer

DES exposure checker renders science-grade images directly to a web browser and allows users to mark problematic features from a set of predefined classes, thus allowing image quality control for the Dark Energy Survey to be crowdsourced through its web application. Users can also generate custom labels to help identify previously unknown problem classes; generated reports are fed back to hardware and software experts to help mitigate and eliminate recognized issues. These problem reports allow rapid correction of artifacts that otherwise may be too subtle or infrequent to be recognized.

[ascl:1804.011] DESCQA: Synthetic Sky Catalog Validation Framework

The DESCQA framework provides rigorous validation protocols for assessing the quality of high-quality simulated sky catalogs in a straightforward and comprehensive way. DESCQA enables the inspection, validation, and comparison of an inhomogeneous set of synthetic catalogs via the provision of a common interface within an automated framework. An interactive web interface is also available at https://portal.nersc.gov/projecta/lsst/descqa/v2/.

[ascl:2301.025] desitarget: Selecting DESI targets from photometric catalogs

desitarget selects targets for spectroscopic follow-up by Dark Energy Spectroscopic Instrument (DESI). The pipeline uses bitmasks to record that a specific source has been selected by a particular targeting algorithm, setting bit-values in output data files in a number of different columns that indicate whether a particular target meets specific selection criteria. desitarget also outputs a unique TARGETID that allows each target to be tracked throughout the DESI survey. This TARGETID encodes information about each DESI target, such as the catalog the target was selected from, whether a target is a sky location or part of a random catalog, and whether a target is part of a secondary program.

[ascl:1304.007] DESPOTIC: Derive the Energetics and SPectra of Optically Thick Interstellar Clouds

DESPOTIC (Derive the Energetics and SPectra of Optically Thick Interstellar Clouds), written in Python, represents optically thick interstellar clouds using a one-zone model and calculates line luminosities, line cooling rates, and in restricted cases line profiles using an escape probability formalism. DESPOTIC calculates clouds' equilibrium gas and dust temperatures and their time-dependent thermal evolution. The code allows rapid and interactive calculation of clouds' characteristic temperatures, identification of their dominant heating and cooling mechanisms, and prediction of their observable spectra across a wide range of interstellar environments.

[submitted] Determination of Length of (Earth) Day [LOD] in the past geologic epochs

The protocol describes the algorithm of arriving at LOD in a given past geological Epoch. First the lunar orbital radius of the given geologic epoch has to be determined. For this the velocity of recession of Moon for the accelerated phase has to be determined. The spatial integral of the reciprocal of Velocity of recession gives the the transit time of Moon from desired orbit to the present orbit.Through several iterations the transit time is made to converge on the geologic epoch. Once we determine the desired orbital radius it has to be substituted in the LOD expression to determine the LOD in the given geologic epoch.

[ascl:1907.008] Dewarp: Distortion removal and on-sky orientation solution for LBTI detectors

Dewarp constructs pipelines to remove distortion from a detector and find the orientation with true North. It was originally written for the LBTI LMIRcam detector, but is generalizable to any project with reference sources and/or an astrometric field paired with a machine-readable file of astrometric target locations.

[ascl:1402.022] DexM: Semi-numerical simulations for very large scales

DexM (Deus ex Machina) efficiently generates density, halo, and ionization fields on very large scales and with a large dynamic range through seminumeric simulation. These properties are essential for reionization studies, especially those involving rare, massive QSOs, since one must be able to statistically capture the ionization field. DexM can also generate ionization fields directly from the evolved density field to account for the ionizing contribution of small halos. Semi-numerical simulations use more approximate physics than numerical simulations, but independently generate 3D cosmological realizations. DexM is portable and fast, and allows for explorations of wide swaths of astrophysical parameter space and an unprecedented dynamic range.

[ascl:1112.015] Dexter: Data Extractor for scanned graphs

The NASA Astrophysics Data System (ADS) now holds 1.3 million scanned pages, containing numerous plots and figures for which the original data sets are lost or inaccessible. The availability of scans of the figures can significantly ease the regeneration of the data sets. For this purpose, the ADS has developed Dexter, a Java applet that supports the user in this process. Dexter's basic functionality is to let the user manually digitize a plot by marking points and defining the coordinate transformation from the logical to the physical coordinate system. Advanced features include automatic identification of axes, tracing lines and finding points matching a template.

[ascl:1904.017] dfitspy: A dfits/fitsort implementation in Python

dfitspy searches and displays metadata contained in FITS files. Written in Python, it displays the results of a metadata search and is able to grep certain values of keywords inside large samples of files in the terminal. dfitspy can be used directly with the command line interface and can also be imported as a python module into other python code or the python interpreter.

[ascl:1805.002] dftools: Distribution function fitting

dftools, written in R, finds the most likely P parameters of a D-dimensional distribution function (DF) generating N objects, where each object is specified by D observables with measurement uncertainties. For instance, if the objects are galaxies, it can fit a mass function (D=1), a mass-size distribution (D=2) or the mass-spin-morphology distribution (D=3). Unlike most common fitting approaches, this method accurately accounts for measurement in uncertainties and complex selection functions.

[ascl:1410.001] DIAMONDS: high-DImensional And multi-MOdal NesteD Sampling

DIAMONDS (high-DImensional And multi-MOdal NesteD Sampling) provides Bayesian parameter estimation and model comparison by means of the nested sampling Monte Carlo (NSMC) algorithm, an efficient and powerful method very suitable for high-dimensional and multi-modal problems; it can be used for any application involving Bayesian parameter estimation and/or model selection in general. Developed in C++11, DIAMONDS is structured in classes for flexibility and configurability. Any new model, likelihood and prior PDFs can be defined and implemented upon a basic template.

[ascl:2103.030] DIAPHANE: Library for radiation and neutrino transport in hydrodynamical simulations

DIAPHANE provides a common platform for application-independent radiation and neutrino transport in astrophysical simulations. The library contains radiation and neutrino transport algorithms for modeling galaxy formation, black hole formation, and planet formation, as well as supernova stellar explosions. DIAPHANE is written in C and C++, but as many hydrodynamic codes use Fortran, the library includes examples of how to interface the library from the Fortran codes SPHYNX (ascl:1709.001) and RAMSES (ascl:1011.007).

[ascl:1607.002] DICE: Disk Initial Conditions Environment

DICE models initial conditions of idealized galaxies to study their secular evolution or their more complex interactions such as mergers or compact groups using N-Body/hydro codes. The code can set up a large number of components modeling distinct parts of the galaxy, and creates 3D distributions of particles using a N-try MCMC algorithm which does not require a prior knowledge of the distribution function. The gravitational potential is then computed on a multi-level Cartesian mesh by solving the Poisson equation in the Fourier space. Finally, the dynamical equilibrium of each component is computed by integrating the Jeans equations for each particles. Several galaxies can be generated in a row and be placed on Keplerian orbits to model interactions. DICE writes the initial conditions in the Gadget1 or Gadget2 (ascl:0003.001) format and is fully compatible with Ramses (ascl:1011.007).

[ascl:1801.010] DICE/ColDICE: 6D collisionless phase space hydrodynamics using a lagrangian tesselation

DICE is a C++ template library designed to solve collisionless fluid dynamics in 6D phase space using massively parallel supercomputers via an hybrid OpenMP/MPI parallelization. ColDICE, based on DICE, implements a cosmological and physical VLASOV-POISSON solver for cold systems such as dark matter (CDM) dynamics.

[ascl:1704.013] Difference-smoothing: Measuring time delay from light curves

The Difference-smoothing MATLAB code measures the time delay from the light curves of images of a gravitationally lendsed quasar. It uses a smoothing timescale free parameter, generates more realistic synthetic light curves to estimate the time delay uncertainty, and uses 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:2302.025] Diffmah: Differentiable models of halo and galaxy formation history

Diffmah approximates the growth of individual halos as a simple power-law function of time, where the power-law index smoothly decreases as the halo transitions from the fast-accretion regime at early times to the slow-accretion regime at late times. The code has a typical accuracy of 0.1 dex for times greater than one billion years in halos of mass greater than 10e11 M_sun. Diffmah self-consistently captures the mean and variance of halo mass accretion rates across long time scales, and it generates Monte Carlo simulations of cosmologically-representative and differentiable halo histories.

[ascl:2302.012] Diffstar: Differentiable star formation histories

Diffstar fits the star formation history (SFH) of galaxies to a smooth parametric model. Diffstar differs from existing SFH models because the parameterization of the model is directly based on basic features of galaxy formation physics, including halo mass assembly history, accretion of gas into the dark matter halo, the fraction of gas that is converted into stars, the time scale over which star formation occurs, and the possibility of rejuvenated star formation. The SFHs of a large number of simulated galaxies can be fit in parallel using mpi4py.

[ascl:1512.012] DiffuseModel: Modeling the diffuse ultraviolet background

DiffuseModel calculates the scattered radiation from dust scattering in the Milky Way based on stars from the Hipparcos catalog. It uses Monte Carlo to implement multiple scattering and assumes a user-supplied grid for the dust distribution. The output is a FITS file with the diffuse light over the Galaxy. It is intended for use in the UV (900 - 3000 A) but may be modified for use in other wavelengths and galaxies.

[ascl:1304.008] Diffusion.f: Diffusion of elements in stars

Diffusion.f is an exportable subroutine to calculate the diffusion of elements in stars. The routine solves exactly the Burgers equations and can include any number of elements as variables. The code has been used successfully by a number of different groups; applications include diffusion in the sun and diffusion in globular cluster stars. There are many other possible applications to main sequence and to evolved stars. The associated README file explains how to use the subroutine.

[ascl:1103.001] Difmap: Synthesis Imaging of Visibility Data

Difmap is a program developed for synthesis imaging of visibility data from interferometer arrays of radio telescopes world-wide. Its prime advantages over traditional packages are its emphasis on interactive processing, speed, and the use of Difference mapping techniques.

[ascl:1102.024] DiFX2: A more flexible, efficient, robust and powerful software correlator

Software correlation, where a correlation algorithm written in a high-level language such as C++ is run on commodity computer hardware, has become increasingly attractive for small to medium sized and/or bandwidth constrained radio interferometers. In particular, many long baseline arrays (which typically have fewer than 20 elements and are restricted in observing bandwidth by costly recording hardware and media) have utilized software correlators for rapid, cost-effective correlator upgrades to allow compatibility with new, wider bandwidth recording systems and improve correlator flexibility. The DiFX correlator, made publicly available in 2007, has been a popular choice in such upgrades and is now used for production correlation by a number of observatories and research groups worldwide. Here we describe the evolution in the capabilities of the DiFX correlator over the past three years, including a number of new capabilities, substantial performance improvements, and a large amount of supporting infrastructure to ease use of the code. New capabilities include the ability to correlate a large number of phase centers in a single correlation pass, the extraction of phase calibration tones, correlation of disparate but overlapping sub-bands, the production of rapidly sampled filterbank and kurtosis data at minimal cost, and many more. The latest version of the code is at least 15% faster than the original, and in certain situations many times this value. Finally, we also present detailed test results validating the correctness of the new code.

[ascl:1904.023] digest2: NEO binary classifier

digest2 classifies Near-Earth Object (NEO) candidates by providing a score, D2, that represents a pseudo-probability that a tracklet belongs to a given solar system orbit type. The code accurately and precisely distinguishes NEOs from non-NEOs, thus helping to identify those to be prioritized for follow-up observation. This fast, short-arc orbit classifier for small solar system bodies code is built upon the Pangloss code developed by Robert McNaught and further developed by Carl Hergenrother and Tim Spahr and Robert Jedicke's 223.f code.

[ascl:1010.031] DimReduce: Nonlinear Dimensionality Reduction of Very Large Datasets with Locally Linear Embedding (LLE) and its Variants

DimReduce is a C++ package for performing nonlinear dimensionality reduction of very large datasets with Locally Linear Embedding (LLE) and its variants. DimReduce is built for speed, using the optimized linear algebra packages BLAS, LAPACK (ascl:2104.020), and ARPACK (ascl:1311.010). Because of the need for storing very large matrices (1000 by 10000, for our SDSS LLE work), DimReduce is designed to use binary FITS files as inputs and outputs. This means that using the code is a bit more cumbersome. For smaller-scale LLE, where speed of computation is not as much of an issue, the Modular Data Processing toolkit may be a better choice. It is a python toolkit with some LLE functionality, which VanderPlas contributed.

This code has been rewritten and included in scikit-learn and an improved version is included in http://mmp2.github.io/megaman/

[submitted] DIPol-UF: Remote control software for DIPol-UF polarimeter

DIPol-UF provides tools for remote control and operation of DIPol-UF, an optical (BVR) imaging CCD polarimeter. The project contains libraries that handle low-level interoperation with ANDOR SDK (provided by the CCD manufacturer), communication with stepper motors (which perform plate rotations), FITS file serialization/deserialization, over-network communication between different system components (each CCD is connected to a standalone PC), as well as provide GUI (built with WPF).

[ascl:1908.005] dips: Detrending periodic signals in timeseries

dips detrends timeseries of strictly periodic signals. It does not assume any functional form for the signal or the background or the noise; it disentangles the strictly periodic component from everything else. It has been used for detrending Kepler, K2 and TESS timeseries of periodic variable stars, eclipsing binary stars, and exoplanets.

[ascl:1405.016] DIPSO: Spectrum analysis code

DIPSO plots spectroscopic data rapidly and combines analysis and high-quality graphical output in a simple command-line driven interactive environment. It can be used, for example, to fit emission lines, measure equivalent widths and fluxes, do Fourier analysis, and fit models to spectra. A macro facility allows convenient execution of regularly used sequences of commands, and a simple Fortran interface permits "personal" software to be integrated with the program. DIPSO is part of the Starlink software collection (ascl:1110.012).

[ascl:2112.012] DiracVsMajorana: Statistical discrimination of sub-GeV Majorana and Dirac dark matter

DiracVsMajorana determines the statistical significance with which a successful electron scattering experiment could reject the Majorana hypothesis -- that dark matter (DM) particles are their own anti-particles, a so-called Majorana fermion -- using the likelihood ratio test in favor of the hypothesis of Dirac DM. The code assumes that the DM interacts with the photon via higher-order electromagnetic moments. It requires tabulated atomic response functions, which can be computed with DarkARC (ascl:2112.011), to compute ionization spectra and predictions for signal event rates.

[ascl:1806.015] DirectDM-mma: Dark matter direct detection

The Mathematica code DirectDM takes the Wilson coefficients of relativistic operators that couple DM to the SM quarks, leptons, and gauge bosons and matches them onto a non-relativistic Galilean invariant EFT in order to calculate the direct detection scattering rates. A Python implementation of DirectDM is also available (ascl:1806.016).

[ascl:1806.016] DirectDM-py: Dark matter direct detection

DirectDM, written in Python, takes the Wilson coefficients of relativistic operators that couple DM to the SM quarks, leptons, and gauge bosons and matches them onto a non-relativistic Galilean invariant EFT in order to calculate the direct detection scattering rates. A Mathematica implementation of DirectDM is also available (ascl:1806.015).

[ascl:1102.021] DIRT: Dust InfraRed Toolbox

DIRT is a Java applet for modelling astrophysical processes in circumstellar dust shells around young and evolved stars. With DIRT, you can select and display over 500,000 pre-run model spectral energy distributions (SEDs), find the best-fit model to your data set, and account for beam size in model fitting. DIRT also allows you to manipulate data and models with an interactive viewer, display gas and dust density and temperature profiles, and display model intensity profiles at various wavelengths.

[ascl:1403.020] disc2vel: Tangential and radial velocity components derivation

Disc2vel derives tangential and radial velocity components in the equatorial plane of a barred stellar disc from the observed line-of-sight velocity, assuming geometry of a thin disc. The code is written in IDL, and the method assumes that the bar is close to steady state (i.e. does not evolve fast) and that both morphology and kinematics are symmetrical with respect to the major axis of the bar.

[ascl:1605.011] DISCO: 3-D moving-mesh magnetohydrodynamics package

DISCO evolves orbital fluid motion in two and three dimensions, especially at high Mach number, for studying astrophysical disks. The software uses a moving-mesh approach with a dynamic cylindrical mesh that can shear azimuthally to follow the orbital motion of the gas, thus removing diffusive advection errors and permitting longer timesteps than a static grid. DISCO uses an HLLD Riemann solver and a constrained transport scheme compatible with the mesh motion to implement magnetohydrodynamics.

[ascl:2307.011] DiscVerSt: Vertical structure calculator for accretion discs around neutron stars and black holes

DiscVerSt calculates the vertical structure of accretion discs around neutron stars and black holes. Different classes represent the vertical structure for different types of EoS and opacity, temperature gradient and irradiation scheme; the code includes an interface for initializing the chosen structure type. DiscVerSt also contains functions to calculate S-curves and the vertical and radial profile of a stationary disc.

[ascl:1209.011] DiskFit: Modeling Asymmetries in Disk Galaxies

DiskFit implements procedures for fitting non-axisymmetries in either kinematic or photometric data. DiskFit can analyze H-alpha and CO velocity field data as well as HI kinematics to search for non-circular motions in the disk galaxies. DiskFit can also be used to constrain photometric models of the disc, bar and bulge. It deprecates an earlier version, by a subset of these authors, called velfit.

[ascl:1603.011] DiskJockey: Protoplanetary disk modeling for dynamical mass derivation

DiskJockey derives dynamical masses for T Tauri stars using the Keplerian motion of their circumstellar disks, applied to radio interferometric data from the Atacama Large Millimeter Array (ALMA) and the Submillimeter Array (SMA). The package relies on RADMC-3D (ascl:1202.015) to perform the radiative transfer of the disk model. DiskJockey is designed to work in a parallel environment where the calculations for each frequency channel can be distributed to independent processors. Due to the computationally expensive nature of the radiative synthesis, fitting sizable datasets (e.g., SMA and ALMA) will require a substantial amount of CPU cores to explore a posterior distribution in a reasonable timeframe.

[ascl:2308.007] DiskMINT: Disk Model For INdividual Targets

DiskMINT (Disk Model for INdividual Targets) models individual disks and derives robust disk mass estimates. Built on RADMC-3D (ascl:1202.015) for continuum (and gas line) radiative transfer, the code includes a reduced chemical network to determine the C18O emission. DiskMINT has a Python3 module that generates a self-consistent 2D disk structure to satisfy VHSE (Vertical Hydrostatic Equilibrium). It also contains a Fortran code of the reduced chemical network that contains the main chemical processes necessary for C18O modeling: the isotopologue-selective photodissociation, and the grain-surface chemistry where the CO converting to CO2 ice is the main reaction.

[ascl:2002.022] DISKMODs: Accretion Disk Radial Structure Models

DISKMODs provides radial structure models of accretion disk solutions. The following models are included: Novikov-Thorne thin disk model and Sadowski polytropic slim disk model. Each model implements a common interface that gives the radial dependence of selected geometrical, physical and thermodynamic quantities of the accretion flow. The model interpolates through a set of tabulated numerical solutions. These solutions are computed for a reference mass M=10 Msun. The model can rescale the disk structure to any mass, with masses in the range of 5-20 Msun giving reasonably good results.

[ascl:1811.013] DiskSim: Modeling Accretion Disk Dynamics with SPH

DiskSim is a source-code distribution of the SPH accretion disk modeling code previously released in a Windows executable form as FITDisk (ascl:1305.011). The code released now is the full research code in Fortran and can be modified as needed by the user.

[ascl:1108.015] DISKSTRUCT: A Simple 1+1-D Disk Structure Code

DISKSTRUCT is a simple 1+1-D code for modeling protoplanetary disks. It is not based on multidimensional radiative transfer! Instead, a flaring-angle recipe is used to compute the irradiation of the disk, while the disk vertical structure at each cylindrical radius is computed in a 1-D fashion; the models computed with this code are therefore approximate. Moreover, this model cannot deal with the dust inner rim.

In spite of these simplifications and drawbacks, the code can still be very useful for disk studies, for the following reasons:

  • It allows the disk structure to be studied in a 1-D vertical fashion (one radial cylinder at a time). For understanding the structure of disks, and also for using it as a basis of other models, this can be a great advantage.
  • For very optically thick disks this code is likely to be much faster than the RADMC full disk model.
  • Viscous internal heating of the disk is implemented and converges quickly, whereas the RADMC code is still having difficulty to deal with high optical depth combined with viscously generated internal heat.

[ascl:2207.028] disksurf: Measure the molecular emission surface of protoplanetary disks

disksurf measures the height of optically thick emission or photosphere in moderately inclined protoplanetary disks. The package is dependent on AstroPy (ascl:1304.002) and uses GoFish (ascl:2011.016) to retrieve data from FITS data cubes and user-specified parameters to return a surface object containing the disk-centric coordinates of the surface and the gas temperature and rotation velocity at those locations. disksurf provides clipping, smoothing, and diagnostic functions as well.

[ascl:2201.013] disnht: Absorption spectrum solver

disnht computes the absorption spectrum for a user-defined distribution of column densities. The input is a file including the array of column density values; a python routine is provided that can make logarithmic distribution of column density that can be used as an input. Other optional inputs are a cross-section file that includes the 2-d array [energy, cross-section]; a script is provided for computing cross sections for different abundance model for the interstellar medium (solar values). Other boolean flags can be used for input and output description, rebin, plot or save.

[ascl:1708.006] DISORT: DIScrete Ordinate Radiative Transfer

DISORT (DIScrete Ordinate Radiative Transfer) solves the problem of 1D scalar radiative transfer in a single optical medium, such as a planetary atmosphere. The code correctly accounts for multiple scattering by an isotropic or plane-parallel beam source, internal Planck sources, and reflection from a lower boundary. Provided that polarization effects can be neglected, DISORT efficiently calculates accurate fluxes and intensities at any user-specified angle and location within the user-specified medium.

[ascl:1302.015] DisPerSE: Discrete Persistent Structures Extractor

DisPerSE is open source software for the identification of persistent topological features such as peaks, voids, walls and in particular filamentary structures within noisy sampled distributions in 2D, 3D. Using DisPerSE, structure identification can be achieved through the computation of the discrete Morse-Smale complex. The software can deal directly with noisy datasets via the concept of persistence (a measure of the robustness of topological features). Although developed for the study of the properties of filamentary structures in the cosmic web of galaxy distribution over large scales in the Universe, the present version is quite versatile and should be useful for any application where a robust structure identification is required, such as for segmentation or for studying the topology of sampled functions (for example, computing persistent Betti numbers). Currently, it can be applied can work indifferently on many kinds of cell complex (such as structured and unstructured grids, 2D manifolds embedded within a 3D space, discrete point samples using delaunay tesselation, and Healpix tesselations of the sphere). The only constraint is that the distribution must be defined over a manifold, possibly with boundaries.

[ascl:2202.020] distance-omnibus: Distance estimation method for molecular cloud clumps in the Milky Way

distance-omnibus computes posterior DPDFs for catalog sources using the Bayesian application of kinematic distance likelihoods derived from a Galactic rotation curve with prior Distance Probability Density Functions (DPDFs) derived from ancillary data. The methodology and code base are generalized for use with any (sub-)millimeter survey of the Galactic plane.

[ascl:2403.002] DistClassiPy: Distance-based light curve classification

DistClassiPy uses different distance metrics to classify objects such as light curves. It provides state-of-the-art performance for time-domain astronomy, and offers lower computational requirements and improved interpretability over traditional methods such as Random Forests, making it suitable for large datasets. DistClassiPy allows fine-tuning based on scientific objectives by selecting appropriate distance metrics and features, which enhances its performance and improves classification interpretability.

[ascl:1812.012] distlink: Minimum orbital intersection distance (MOID) computation library

distlink computes the minimum orbital intersection distance (MOID), or global minimum of the distance between the points lying on two Keplerian ellipses by finding all stationary points of the distance function, based on solving an algebraic polynomial equation of 16th degree. The program tracks numerical errors and carefully treats nearly degenerate cases, including practical cases with almost circular and almost coplanar orbits. Benchmarks confirm its high numeric reliability and accuracy, and even with its error-controlling overheads, this algorithm is a fast MOID computation method that may be useful in processing large catalogs. Written in C++, the library also includes auxiliary functions.

[ascl:1910.004] DM_phase: Algorithm for correcting dispersion of radio signals

DM_phase maximizes the coherent power of a radio signal instead of its intensity to calculate the best dispersion measure (DM) for a burst such as those emitted by pulsars and fast radio bursts (FRBs). It is robust to complex burst structures and interference, thus mitigating the limitations of traditional methods that search for the best DM value of a source by maximizing the signal-to-noise ratio (S/N) of the detected signal.

[ascl:2106.030] DM_statistics: Statistics of the cosmological dispersion measure (DM)

DM_statistics calculates the free-electron power spectrum and the cosmological dispersion measure (DM) statistics (such as its mean and variance, angular power spectrum and correlation function). The default cosmological parameters are consistent with the Planck 2015 LambdaCDM model; the cosmological model can be easily changed by editing a few lines of the C code.

[ascl:1705.002] DMATIS: Dark Matter ATtenuation Importance Sampling

DMATIS (Dark Matter ATtenuation Importance Sampling) calculates the trajectories of DM particles that propagate in the Earth's crust and the lead shield to reach the DAMIC detector using an importance sampling Monte-Carlo simulation. A detailed Monte-Carlo simulation avoids the deficiencies of the SGED/KS method that uses a mean energy loss description to calculate the lower bound on the DM-proton cross section. The code implementing the importance sampling technique makes the brute-force Monte-Carlo simulation of moderately strongly interacting DM with nucleons computationally feasible. DMATIS is written in Python 3 and MATHEMATICA.

[ascl:1506.002] dmdd: Dark matter direct detection

The dmdd package enables simple simulation and Bayesian posterior analysis of recoil-event data from dark-matter direct-detection experiments under a wide variety of scattering theories. It enables calculation of the nuclear-recoil rates for a wide range of non-relativistic and relativistic scattering operators, including non-standard momentum-, velocity-, and spin-dependent rates. It also accounts for the correct nuclear response functions for each scattering operator and takes into account the natural abundances of isotopes for a variety of experimental target elements.

[ascl:2002.012] DMRadon: Radon Transform calculation tools

DMRadon calculates the Radon Transform for use in the analysis of Directional Dark Matter Direct Detection. The code can calculate speed distributions, velocity distribution, velocity integral (eta) and Radon Transforms or a standard Maxwell-Boltzmann distribution. DMRadon also calculates the velocity distribution averaged over different angular bins.

[ascl:1010.029] DNEST: Diffusive Nested Sampling

This code is a general Monte Carlo method based on Nested Sampling (NS) for sampling complex probability distributions and estimating the normalising constant. The method uses one or more particles, which explore a mixture of nested probability distributions, each successive distribution occupying ~e^-1 times the enclosed prior mass of the previous distribution. While NS technically requires independent generation of particles, Markov Chain Monte Carlo (MCMC) exploration fits naturally into this technique. This method can achieve four times the accuracy of classic MCMC-based Nested Sampling, for the same computational effort; equivalent to a factor of 16 speedup. An additional benefit is that more samples and a more accurate evidence value can be obtained simply by continuing the run for longer, as in standard MCMC.

[ascl:1604.007] DNest3: Diffusive Nested Sampling

DNest3 is a C++ implementation of Diffusive Nested Sampling (ascl:1010.029), a Markov Chain Monte Carlo (MCMC) algorithm for Bayesian Inference and Statistical Mechanics. Relative to older DNest versions, DNest3 has improved performance (in terms of the sampling overhead, likelihood evaluations still dominate in general) and is cleaner code: implementing new models should be easier than it was before. In addition, DNest3 is multi-threaded, so one can run multiple MCMC walkers at the same time, and the results will be combined together.

[ascl:2012.014] dolphin: Automated pipeline for lens modeling

Dolphin uniformly models large lens samples. It is a wrapper for Lenstronomy (ascl:1804.012), and features semi-automated modeling of a large sample of quasar and galaxy-galaxy lenses. Dolphin, written in Python, provides easy portability between local and MPI environments.

[ascl:1608.013] DOLPHOT: Stellar photometry

DOLPHOT is a stellar photometry package that was adapted from HSTphot for general use. It supports two modes; the first is a generic PSF-fitting package, which uses analytic PSF models and can be used for any camera. The second mode uses ACS PSFs and calibrations, and is effectively an ACS adaptation of HSTphot. A number of utility programs are also included with the DOLPHOT distribution, including basic image reduction routines.

[ascl:1709.004] DOOp: DAOSPEC Output Optimizer pipeline

The DAOSPEC Output Optimizer pipeline (DOOp) runs efficient and convenient equivalent widths measurements in batches of hundreds of spectra. It uses a series of BASH scripts to work as a wrapper for the FORTRAN code DAOSPEC (ascl:1011.002) and uses IRAF (ascl:9911.002) to automatically fix some of the parameters that are usually set by hand when using DAOSPEC. This allows batch-processing of quantities of spectra that would be impossible to deal with by hand. DOOp was originally built for the large quantity of UVES and GIRAFFE spectra produced by the Gaia-ESO Survey, but just like DAOSPEC, it can be used on any high resolution and high signal-to-noise ratio spectrum binned on a linear wavelength scale.

[ascl:2106.002] dopmap: Fast Doppler mapping program

dopmap constructs Doppler maps from the orbital variation of line profiles of (mass transferring) binaries. It uses an algorithm related to Richardson-Lucy iteration and includes an IDL-based set of routines for manipulating and plotting the input and output data.

[ascl:1206.011] Double Eclipsing Binary Fitting

The parameters of the mutual orbit of eclipsing binaries that are physically connected can be obtained by precision timing of minima over time through light travel time effect, apsidal motion or orbital precession. This, however, requires joint analysis of data from different sources obtained through various techniques and with insufficiently quantified uncertainties. In particular, photometric uncertainties are often underestimated, which yields too small uncertainties in minima timings if determined through analysis of a χ2 surface. The task is even more difficult for double eclipsing binaries, especially those with periods close to a resonance such as CzeV344, where minima get often blended with each other.

This code solves the double binary parameters simultaneously and then uses these parameters to determine minima timings (or more specifically O-C values) for individual datasets. In both cases, the uncertainties (or more precisely confidence intervals) are determined through bootstrap resampling of the original data. This procedure to a large extent alleviates the common problem with underestimated photometric uncertainties and provides a check on possible degeneracies in the parameters and the stability of the results. While there are shortcomings to this method as well when compared to Markov Chain Monte Carlo methods, the ease of the implementation of bootstrapping is a significant advantage.

[ascl:2305.014] DP3: Streaming processing pipeline for radio interferometric data

DP3 (the Default Preprocessing Pipeline) is the LOFAR data pipeline processing program and is the successor to DPPP (ascl:1804.003). It performs many kinds of operations on the data in a pipelined way so the data are read and written only once. DP3 preprocesses the data of a LOFAR observation by executing steps such as flagging or averaging. Such steps can be used for the raw data as well as the calibrated data by defining the data column to use. One or more of the following steps can be defined as a pipeline. DP3 has an implicit input and output step. It is also possible to have intermediate output steps. DP3 comes with predefined steps, but also allows the user to plug in arbitrary steps implemented in either C++ or Python.

[ascl:1504.012] DPI: Symplectic mapping for binary star systems for the Mercury software package

DPI is a FORTRAN77 library that supplies the symplectic mapping method for binary star systems for the Mercury N-Body software package (ascl:1201.008). The binary symplectic mapping is implemented as a hybrid symplectic method that allows close encounters and collisions between massive bodies and is therefore suitable for planetary accretion simulations.

[ascl:1804.003] DPPP: Default Pre-Processing Pipeline

DPPP (Default Pre-Processing Pipeline, also referred to as NDPPP) reads and writes radio-interferometric data in the form of Measurement Sets, mainly those that are created by the LOFAR telescope. It goes through visibilities in time order and contains standard operations like averaging, phase-shifting and flagging bad stations. Between the steps in a pipeline, the data is not written to disk, making this tool suitable for operations where I/O dominates. More advanced procedures such as gain calibration are also included. Other computing steps can be provided by loading a shared library; currently supported external steps are the AOFlagger (ascl:1010.017) and a bridge that enables loading python steps.

[ascl:1303.025] DPUSER: Interactive language for image analysis

DPUSER is an interactive language capable of handling numbers (both real and complex), strings, and matrices. Its main aim is to do astronomical image analysis, for which it provides a comprehensive set of functions, but it can also be used for many other applications.

[ascl:1712.005] draco: Analysis and simulation of drift scan radio data

draco analyzes transit radio data with the m-mode formalism. It is telescope agnostic, and is used as part of the analysis and simulation pipeline for the CHIME (Canadian Hydrogen Intensity Mapping Experiment) telescope. It can simulate time stream data from maps of the sky (using the m-mode formalism) and add gain fluctuations and correctly correlated instrumental noise (i.e. Wishart distributed). Further, it can perform various cuts on the data and make maps of the sky from data using the m-mode formalism.

[ascl:1512.009] DRACULA: Dimensionality Reduction And Clustering for Unsupervised Learning in Astronomy

DRACULA classifies objects using dimensionality reduction and clustering. The code has an easy interface and can be applied to separate several types of objects. It is based on tools developed in scikit-learn, with some usage requiring also the H2O package.

[ascl:1011.009] DRAGON: DRoplet and hAdron GeneratOr for Nuclear collisions

A Monte Carlo generator of the final state of hadrons emitted from an ultrarelativistic nuclear collision is introduced. An important feature of the generator is a possible fragmentation of the fireball and emission of the hadrons from fragments. Phase space distribution of the fragments is based on the blast wave model extended to azimuthally non-symmetric fireballs. Parameters of the model can be tuned and this allows to generate final states from various kinds of fireballs. A facultative output in the OSCAR1999A format allows for a comprehensive analysis of phase-space distributions and/or use as an input for an afterburner. DRAGON's purpose is to produce artificial data sets which resemble those coming from real nuclear collisions provided fragmentation occurs at hadronisation and hadrons are emitted from fragments without any further scattering. Its name, DRAGON, stands for DRoplet and hAdron GeneratOr for Nuclear collisions. In a way, the model is similar to THERMINATOR, with the crucial difference that emission from fragments is included.

[ascl:1106.011] DRAGON: Galactic Cosmic Ray Diffusion Code

DRAGON adopts a second-order Cranck-Nicholson scheme with Operator Splitting and time overrelaxation to solve the diffusion equation. This provides a fast solution that is accurate enough for the average user. Occasionally, users may want to have very accurate solutions to their problem. To enable this feature, users may get close to the accurate solution by using the fast method, and then switch to a more accurate solution scheme featuring the Alternating-Direction-Implicit (ADI) Cranck-Nicholson scheme.

[ascl:1811.002] DRAGONS: Gemini Observatory data reduction platform

DRAGONS (Data Reduction for Astronomy from Gemini Observatory North and South) is Gemini's Python-based data reduction platform. DRAGONS offers an automation system that allows for hands-off pipeline reduction of Gemini data, or of any other astronomical data once configured. The platform also allows researchers to control input parameters and in some cases will offer to interactively optimize some data reduction steps, e.g. change the order of fit and visualize the new solution.

[ascl:2012.024] DRAGraces: Reduction pipeline for GRACES spectra

DRAGraces (Data Reduction and Analysis for GRACES) reduces GRACES spectra taken with the Gemini North high-resolution spectrograph. It finds GRACES frames in a given directory, determines the list of bias, flat, arc and science frames, and performs the reduction and extraction. Written in IDL, DRAGraces is straightforward and easy to use.

[ascl:2103.023] DRAKE: Relic density in concrete models prediction

DRAKE (Dark matter Relic Abundance beyond Kinetic Equilibrium) predicts the dark matter relic abundance in situations where the standard assumption of kinetic equilibrium during the freeze-out process may not be satisfied. The code comes with a set of three dedicated Boltzmann equation solvers that implement, respectively, the traditionally adopted equation for the dark matter number density, fluid-like equations that couple the evolution of number density and velocity dispersion, and a full numerical evolution of the phase-space distribution.

[ascl:1507.012] DRAMA: Instrumentation software environment

DRAMA is a fast, distributed environment for writing instrumentation control systems. It allows low level instrumentation software to be controlled from user interfaces running on UNIX, MS Windows or VMS machines in a consistent manner. Such instrumentation tasks can run either on these machines or on real time systems such as VxWorks. DRAMA uses techniques developed by the AAO while using the Starlink-ADAM environment, but is optimized for the requirements of instrumentation control, portability, embedded systems and speed. A special program is provided which allows seamless communication between ADAM and DRAMA tasks.

[ascl:2308.013] Driftscan: Drift scan telescope analysis

Driftscan simulates and analyzes transit radio interferometers, with a particular focus on 21cm cosmology. Given a design of a telescope, it generates a set of products used to analyze data from it and simulate timestreams. Driftscan also constructs a filter to extract cosmological 21 cm emission from astrophysical foregrounds, such as our galaxy and radio point sources, and estimates the 21cm power spectrum using an optimal quadratic estimator.

[ascl:1504.006] drive-casa: Python interface for CASA scripting

drive-casa provides a Python interface for scripting of CASA (ascl:1107.013) subroutines from a separate Python process, allowing for utilization alongside other Python packages which may not easily be installed into the CASA environment. This is particularly useful for embedding use of CASA subroutines within a larger pipeline. drive-casa runs plain-text casapy scripts directly; alternatively, the package includes a set of convenience routines which try to adhere to a consistent style and make it easy to chain together successive CASA reduction commands to generate a command-script programmatically.

[ascl:1212.011] DrizzlePac: HST image software

DrizzlePac allows users to easily and accurately align and combine HST images taken at multiple epochs, and even with different instruments. It is a suite of supporting tasks for AstroDrizzle which includes:

- astrodrizzle to align and combine images
- tweakreg and tweakback for aligning images in different visits
- pixtopix transforms an X,Y pixel position to its pixel position after distortion corrections
- skytopix transforms sky coordinates to X,Y pixel positions. A reverse transformation can be done using the task pixtosky.

[ascl:1610.003] DSDEPROJ: Direct Spectral Deprojection

Deprojection of X-ray data by methods such as PROJCT, which are model dependent, can produce large and unphysical oscillating temperature profiles. Direct Spectral Deprojection (DSDEPROJ) solves some of the issues inherent to model-dependent deprojection routines. DSDEPROJ is a model-independent approach, assuming only spherical symmetry, which subtracts projected spectra from each successive annulus to produce a set of deprojected spectra.

[ascl:2204.006] dsigma: Galaxy-galaxy lensing Python package

dsigma analyzes galaxy-galaxy lensing. Written in Python, it has a broadly applicable API and is optimized for computational efficiency. While originally intended to be used with the shape catalog of the Hyper-Suprime Cam (HSC) survey, it should work for other surveys, most prominently the Dark Energy Survey (DES) and the Kilo-Degree Survey (KiDS).

[ascl:2302.024] DSPS: Differentiable Stellar Population Synthesis

DSPS synthesizes stellar populations, leading to fully-differentiable predictions for galaxy photometry and spectroscopy. The code implements an empirical model for stellar metallicity, and it also supports the Diffstar (ascl:2302.012) model of star formation and dark matter halo history. DSPS rapidly generates and simulates galaxy-halo histories on both CPU and GPU hardware.

[ascl:1010.006] DSPSR: Digital Signal Processing Software for Pulsar Astronomy

DSPSR, written primarily in C++, is an open-source, object-oriented, digital signal processing software library and application suite for use in radio pulsar astronomy. The library implements an extensive range of modular algorithms for use in coherent dedispersion, filterbank formation, pulse folding, and other tasks. The software is installed and compiled using the standard GNU configure and make system, and is able to read astronomical data in 18 different file formats, including FITS, S2, CPSR, CPSR2, PuMa, PuMa2, WAPP, ASP, and Mark5.

[ascl:1501.004] dst: Polarimeter data destriper

Dst is a fully parallel Python destriping code for polarimeter data; destriping is a well-established technique for removing low-frequency correlated noise from Cosmic Microwave Background (CMB) survey data. The software destripes correctly formatted HDF5 datasets and outputs hitmaps, binned maps, destriped maps and baseline arrays.

[ascl:1505.034] dStar: Neutron star thermal evolution code

dStar is a collection of modules for computing neutron star structure and evolution, and uses the numerical, utility, and equation of state libraries of MESA (ascl:1010.083).

[ascl:2008.023] DUCC: Distinctly Useful Code Collection

DUCC (Distinctly Useful Code Collection) provides basic programming tools for numerical computation, including Fast Fourier Transforms, Spherical Harmonic Transforms, non-equispaced Fourier transforms, as well as some concrete applications like 4pi convolution on the sphere and gridding/degridding of radio interferometry data. The code is written in C++17 and provides a simple and comprehensive Python
interface.

[ascl:1201.011] Duchamp: A 3D source finder for spectral-line data

Duchamp is software designed to find and describe sources in 3-dimensional, spectral-line data cubes. Duchamp has been developed with HI (neutral hydrogen) observations in mind, but is widely applicable to many types of astronomical images. It features efficient source detection and handling methods, noise suppression via smoothing or multi-resolution wavelet reconstruction, and a range of graphical and text-based outputs to allow the user to understand the detections.

[ascl:1605.014] DUO: Spectra of diatomic molecules

Duo computes rotational, rovibrational and rovibronic spectra of diatomic molecules. The software, written in Fortran 2003, solves the Schrödinger equation for the motion of the nuclei for the simple case of uncoupled, isolated electronic states and also for the general case of an arbitrary number and type of couplings between electronic states. Possible couplings include spin–orbit, angular momenta, spin-rotational and spin–spin. Introducing the relevant couplings using so-called Born–Oppenheimer breakdown curves can correct non-adiabatic effects.

[ascl:1503.005] dust: Dust scattering and extinction in the X-ray

Written in Python, dust calculates X-ray dust scattering and extinction in the intergalactic and local interstellar media.

[ascl:1908.016] DustCharge: Charge distribution for a dust grain

DustCharge calculates the equilibrium charge distribution for a dust grain of a given size and composition, depending on the local interstellar medium conditions, such as density, temperature, ionization fraction, local radiation field strength, and cosmic ray ionization fraction.

[ascl:1307.001] DustEM: Dust extinction and emission modelling

DustEM computes the extinction and the emission of interstellar dust grains heated by photons. It is written in Fortran 95 and is jointly developed by IAS and CESR. The dust emission is calculated in the optically thin limit (no radiative transfer) and the default spectral range is 40 to 108 nm. The code is designed so dust properties can easily be changed and mixed and to allow for the inclusion of new grain physics.

[ascl:2206.027] DustFilaments: Paint filaments to produce a thermal dust full sky map at mm frequencies

DustFilaments paints filaments in the Celestial Sphere to generate a full sky map of the Thermal Dust emission at millimeter frequencies by integrating a population of 3D filaments. The code requires a magnetic field cube, which can be calculated separately or by DustFilaments. With the magnetic field cube as input, the package creates a random filament population with a given seed, and then paints a filament into a healpix map provided as input; the healpix map is updated in place.

[ascl:2207.016] DustPy: Simulation of dust evolution in protoplanetary disks

DustPy simulates the radial evolution of gas and dust in protoplanetary disks, involving viscous evolution of the gas disk and advection and diffusion of the dust disk, as well as dust growth by solving the Smoluchowski equation. The package provides a standard simulation and the ability to plot results, and also allows modification of the initial conditions for dust, gas, the grid, and the central star.

[ascl:2310.005] DustPyLib: A library of DustPy extensions

The DustPyLib library contains auxiliary modules for the dust evolution software DustPy (ascl:2207.016), which simulates the evolution of dust and gas in protoplanetary disks. DustPyLib includes interfaces to radiative transfer codes and modules with extensions to the DustPy defaults.

[ascl:9911.001] DUSTY: Radiation transport in a dusty environment

DUSTY solves the problem of radiation transport in a dusty environment. The code can handle both spherical and planar geometries. The user specifies the properties of the radiation source and dusty region, and the code calculates the dust temperature distribution and the radiation field in it. The solution method is based on a self-consistent equation for the radiative energy density, including dust scattering, absorption and emission, and does not introduce any approximations. The solution is exact to within the specified numerical accuracy. DUSTY has built in optical properties for the most common types of astronomical dust and comes with a library for many other grains. It supports various analytical forms for the density distribution, and can perform a full dynamical calculation for radiatively driven winds around AGB stars. The spectral energy distribution of the source can be specified analytically as either Planckian or broken power-law. In addition, arbitrary dust optical properties, density distributions and external radiation can be entered in user supplied files. Furthermore, the wavelength grid can be modified to accommodate spectral features. A single DUSTY run can process an unlimited number of models, with each input set producing a run of optical depths, as specified. The user controls the detail level of the output, which can include both spectral and imaging properties as well as other quantities of interest.

[ascl:1602.004] DUSTYWAVE: Linear waves in gas and dust

Written in Fortran, DUSTYWAVE computes the exact solution for linear waves in a two-fluid mixture of gas and dust. The solutions are general with respect to both the dust-to-gas ratio and the amplitude of the drag coefficient.

[ascl:2109.004] DviSukta: Spherically Averaged Bispectrum calculator

DviSukta calculates the Spherically Averaged Bispectrum (SABS). The code is based on an optimized direct estimation method, is written in C, and is parallelized. DviSukta starts by reading the real space gridded data and performing a 3D Fourier transform of it. Alternatively, it starts by reading the data already in Fourier space. The grid spacing, number of k1 bins, number of n bins, and number of cos(theta) bins need to be specified in the input file.

[ascl:2011.007] DYNAMITE: DYnamics, Age and Metallicity Indicators Tracing Evolution

DYNAMITE (DYnamics, Age and Metallicity Indicators Tracing Evolution) is a triaxial dynamical modeling code for stellar systems and is based on existing codes for Schwarzschild modeling in triaxial systems. DYNAMITE provides an easy-to-use object oriented Python wrapper that extends the scope of pre-existing triaxial Schwarzschild codes with a number of new features, including discrete kinematics, more flexible descriptions of line-of-sight velocity distributions, and modeling of stellar population information. It also offers more efficient steps through parameter space, and can use GPU acceleration.

[ascl:1809.013] dynesty: Dynamic Nested Sampling package

dynesty is a Dynamic Nested Sampling package for estimating Bayesian posteriors and evidences. dynesty samples from a given distribution when provided with a loglikelihood function, a prior_transform function (that transforms samples from the unit cube to the target prior), and the dimensionality of the parameter space.

[ascl:1902.010] dyPolyChord: Super fast dynamic nested sampling with PolyChord

dyPolyChord implements dynamic nested sampling using the efficient PolyChord (ascl:1502.011) sampler to provide state-of-the-art nested sampling performance. Any likelihoods and priors which work with PolyChord can be used (Python, C++ or Fortran), and the output files produced are in the PolyChord format.

[ascl:1407.017] e-MERLIN data reduction pipeline

Written in Python and utilizing ParselTongue (ascl:1208.020) to interface with AIPS (ascl:9911.003), the e-MERLIN data reduction pipeline processes, calibrates and images data from the UK's radio interferometric array (Multi-Element Remote-Linked Interferometer Network). Driven by a plain text input file, the pipeline is modular and can be run in stages. The software includes options to load raw data, average in time and/or frequency, flag known sources of interference, flag more comprehensively with SERPent (ascl:1312.001), carry out some or all of the calibration procedures (including self-calibration), and image in either normal or wide-field mode. It also optionally produces a number of useful diagnostic plots at various stages so data quality can be assessed.

[ascl:1910.013] E0102-VR: Virtual Reality application to visualize the optical ejecta in SNR 1E 0102.2-7219

E0102-VR facilitates the characterization of the 3D structure of the oxygen-rich optical ejecta in the young supernova remnant 1E 0102.2-7219 in the Small Magellanic Cloud. This room-scale Virtual Reality application written for the HTC Vive contributes to the exploration of the scientific potential of this technology for the field of observational astrophysics.

[ascl:1106.004] E3D: The Euro3D Visualization Tool

E3D is a package of tools for the analysis and visualization of IFS data. It is capable of reading, writing, and visualizing reduced data from 3D spectrographs of any kind.

[ascl:2307.043] EAGLES: Estimating AGes from Lithium Equivalent widthS

EAGLES (Estimating AGes from Lithium Equivalent widthS) implements an empirical model that predicts the lithium equivalent width (EW) of a star as a function of its age and effective temperature. The code computes the age probability distribution for a star with a given EW and Teff, subject to an age probability prior that may be flat in age or flat in log age. Data for more than one star can be entered; EAGLES then treats these as a cluster and determines the age probability distribution for the ensemble. The code produces estimates of the most probable age, uncertainties and the median age; output files consisting of probability plots, best-fit isochrone plots, and tables of the posterior age probability distribution(s).

[ascl:1805.004] EARL: Exoplanet Analytic Reflected Lightcurves package

EARL (Exoplanet Analytic Reflected Lightcurves) computes the analytic form of a reflected lightcurve, given a spherical harmonic decomposition of the planet albedo map and the viewing and orbital geometries. The EARL Mathematica notebook allows rapid computation of reflected lightcurves, thus making lightcurve numerical experiments accessible.

[ascl:2205.007] EarthScatterLikelihood: Event rates and likelihoods for Dark Matter direct detection in the presence of Earth-Scattering

EarthScatterLikelihood calculates event rates and likelihoods for Earth-scattering Dark Matter. It is written in Fortran with plotting routines in Python. For input, it uses results from Monte Carlo simulations generated by DaMaSCUS (ascl:1706.003). It includes routines for submitting many reconstructions in parallel on a cluster, and the properties of the detector, such as for a Germanium and a Sapphire detector, can be edited.

[ascl:1611.012] EarthShadow: Calculator for dark matter particle velocity distribution after Earth-scattering

EarthShadow calculates the impact of Earth-scattering on the distribution of Dark Matter (DM) particles. The code calculates the speed and velocity distributions of DM at various positions on the Earth and also helps with the calculation of the average scattering probabilities. Tabulated data for DM-nuclear scattering cross sections and various numerical results, plots and animations are also included in the code package.

[ascl:1612.010] Earthshine simulator: Idealized images of the Moon

Terrestrial albedo can be determined from observations of the relative intensity of earthshine. Images of the Moon at different lunar phases can be analyzed to derive the semi-hemispheric mean albedo of the Earth, and an important tool for doing this is simulations of the appearance of the Moon for any time. This software produces idealized images of the Moon for arbitrary times. It takes into account the libration of the Moon and the distances between Sun, Moon and the Earth, as well as the relevant geometry. The images of the Moon are produced as FITS files. User input includes setting the Julian Day of the simulation. Defaults for image size and field of view are set to produce approximately 1x1 degree images with the Moon in the middle from an observatory on Earth, currently set to Mauna Loa.

[ascl:1812.008] easyaccess: SQL command line interpreter for astronomical surveys

easyaccess facilitates access to astronomical catalogs stored in SQL Databases. It is an enhanced command line interpreter and provides a custom interface with custom commands and was specifically designed to access data from the Dark Energy Survey Oracle database, including autocompletion of tables, columns, users and commands, simple ways to upload and download tables using csv, fits and HDF5 formats, iterators, search and description of tables among others. It can easily be extended to other surveys or SQL databases. The package is written in Python and supports customized addition of commands and functionalities.

[ascl:2203.015] easyFermi: Fermi-LAT data analyzer

easyFermi provides a user-friendly graphical interface for basic to intermediate analysis of Fermi-LAT data in the framework of Fermipy (ascl:1812.006). The code can measure the gamma-ray flux and photon index, build spectral energy distributions, light curves, test statistic maps, test for extended emission, and relocalize the coordinates of gamma-ray sources. Tutorials for easyFermi are available on YouTube and GitHub.

[ascl:1011.013] EasyLTB: Code for Testing LTB Models against CosmologyConfronting Lemaitre-Tolman-Bondi Models with Observational Cosmology

The possibility that we live in a special place in the universe, close to the centre of a large void, seems an appealing alternative to the prevailing interpretation of the acceleration of the universe in terms of a LCDM model with a dominant dark energy component. In this paper we confront the asymptotically flat Lemaitre-Tolman-Bondi (LTB) models with a series of observations, from Type Ia Supernovae to Cosmic Microwave Background and Baryon Acoustic Oscillations data. We propose two concrete LTB models describing a local void in which the only arbitrary functions are the radial dependence of the matter density Omega_M and the Hubble expansion rate H. We find that all observations can be accommodated within 1 sigma, for our models with 4 or 5 independent parameters. The best fit models have a chi^2 very close to that of the LCDM model. We perform a simple Bayesian analysis and show that one cannot exclude the hypothesis that we live within a large local void of an otherwise Einstein-de Sitter model.

[ascl:1010.052] EAZY: A Fast, Public Photometric Redshift Code

EAZY, Easy and Accurate Zphot from Yale, determines photometric redshifts. The program is optimized for cases where spectroscopic redshifts are not available, or only available for a biased subset of the galaxies. The code combines features from various existing codes: it can fit linear combinations of templates, it includes optional flux- and redshift-based priors, and its user interface is modeled on the popular HYPERZ (ascl:1108.010) code. The default template set, as well as the default functional forms of the priors, are not based on (usually highly biased) spectroscopic samples, but on semi-analytical models. Furthermore, template mismatch is addressed by a novel rest-frame template error function. This function gives different wavelength regions different weights, and ensures that the formal redshift uncertainties are realistic. A redshift quality parameter, Q_z, provides a robust estimate of the reliability of the photometric redshift estimate.

[ascl:1908.018] EBAI: Eclipsing Binaries with Artificial Intelligence

Eclipsing Binaries via Artificial Intelligence (EBAI) automates the process of solving light curves of eclipsing binary stars. EBAI is based on the back-propagating neural network paradigm and is highly flexible in construction of neural networks. EBAI comes in two flavors, serial (ebai) and multi-processor (ebai.mpi), and can be run in training, continued training, and recognition mode.

[ascl:1909.007] EBHLIGHT: General relativistic radiation magnetohydrodynamics with Monte Carlo transport

EBHLIGHT (also referred to as BHLIGHT) solves the equations of general relativistic radiation magnetohydrodynamics in stationary spacetimes. Fluid integration is performed with the second order shock-capturing scheme HARM (ascl:1209.005) and frequency-dependent radiation transport is performed with the second order Monte Carlo code grmonty (ascl:1306.002). Fluid and radiation exchange four-momentum in an explicit first-order operator-split fashion.

[ascl:1203.007] EBTEL: Enthalpy-Based Thermal Evolution of Loops

Observational and theoretical evidence suggests that coronal heating is impulsive and occurs on very small cross-field spatial scales. A single coronal loop could contain a hundred or more individual strands that are heated quasi-independently by nanoflares. It is therefore an enormous undertaking to model an entire active region or the global corona. Three-dimensional MHD codes have inadequate spatial resolution, and 1D hydro codes are too slow to simulate the many thousands of elemental strands that must be treated in a reasonable representation. Fortunately, thermal conduction and flows tend to smooth out plasma gradients along the magnetic field, so "0D models" are an acceptable alternative. We have developed a highly efficient model called Enthalpy-Based Thermal Evolution of Loops (EBTEL) that accurately describes the evolution of the average temperature, pressure, and density along a coronal strand. It improves significantly upon earlier models of this type--in accuracy, flexibility, and capability. It treats both slowly varying and highly impulsive coronal heating; it provides the differential emission measure distribution, DEM(T), at the transition region footpoints; and there are options for heat flux saturation and nonthermal electron beam heating. EBTEL gives excellent agreement with far more sophisticated 1D hydro simulations despite using four orders of magnitude less computing time. It promises to be a powerful new tool for solar and stellar studies.

[ascl:1411.017] ECCSAMPLES: Bayesian Priors for Orbital Eccentricity

ECCSAMPLES solves the inverse cumulative density function (CDF) of a Beta distribution, sometimes called the IDF or inverse transform sampling. This allows one to sample from the relevant priors directly. ECCSAMPLES actually provides joint samples for both the eccentricity and the argument of periastron, since for transiting systems they display non-zero covariance.

[ascl:2207.005] echelle: Dynamic echelle diagrams for asteroseismology

Echelle diagrams are used mainly in asteroseismology, where they function as a diagnostic tool for estimating Δν, the separation between modes of the same degree ℓ; the amplitude spectrum of a star is stacked in equal slices of Δν, the large separation. The echelle Python code creates and manipulates echelle diagrams. The code provides the ability to dynamically change Δν for rapid identification of the correct value. echelle features performance optimized dynamic echelle diagrams and multiple backends for supporting Jupyter or terminal usage.

[ascl:1810.006] Echelle++: Generic spectrum simulator

Echelle++ simulates realistic raw spectra based on the Zemax model of any spectrograph, with a particular emphasis on cross-dispersed Echelle spectrographs. The code generates realistic spectra of astronomical and calibration sources, with accurate representation of optical aberrations, the shape of the point spread function, detector characteristics, and photon noise. It produces high-fidelity spectra fast, an important feature when testing data reduction pipelines with a large set of different input spectra, when making critical choices about order spacing in the design phase of the instrument, or while aligning the spectrograph during construction. Echelle++ also works with low resolution, low signal to noise, multi-object, IFU, or long slit spectra, for simulating a wide array of spectrographs.

[ascl:1405.018] ECHOMOP: Echelle data reduction package

ECHOMOP extracts spectra from 2-D data frames. These data can be single-order spectra or multi-order echelle spectra. A substantial degree of automation is provided, particularly in the traditionally manual functions for cosmic-ray detection and wavelength calibration; manual overrides are available. Features include robust and flexible order tracing, optimal extraction, support for variance arrays, and 2-D distortion fitting and extraction. ECHOMOP is distributed as part of the Starlink software collection (ascl:1110.012).

[ascl:2008.020] Eclaire: CUDA-based Library for Astronomical Image REduction

Eclaire is a GPU-accelerated image-reduction pipeline; it uses CuPy, a Python package for general-purpose computing on graphics processing units (GPGPU), to perform image processing, including bias subtraction, dark subtraction, flat fielding, bad pixel masking, alignment, and co-adding. It has been used for real-time image reduction of MITSuME observational data, and can be used with data from other observatories.

[ascl:1810.011] Eclairs: Efficient Codes for the LArge scales of the unIveRSe

Eclairs calculates matter power spectrum based on standard perturbation theory and regularized pertubation theory. The codes are written in C++ with a python wrapper which is designed to be easily combined with MCMC samplers.

[ascl:1910.008] ECLIPS3D: Linear wave and circulation calculations

ECLIPS3D (Eigenvectors, Circulation, and Linear Instabilities for Planetary Science in 3 Dimensions) calculates a posteriori energy equations for the study of linear processes in planetary atmospheres with an arbitrary steady state, and provides both increased robustness and physical meaning to the obtained eigenmodes. It was developed originally for planetary atmospheres and includes python scripts for data analysis. ECLIPS3D can be used to study the initial spin up of superrotation of GCM simulations of hot Jupiters in addition to being applied to other problems.

[ascl:2306.031] ECLIPSE: Efficient Cmb poLarization and Intensity Power Spectra Estimator

ECLIPSE (Efficient Cmb poLarization and Intensity Power Spectra Estimator) implements an optimized version of the Quadratic Maximum Likelihood (QML) method for the estimation of the power spectra of the Cosmic Microwave Background (CMB) from masked skies. Written in Fortran, ECLIPSE can be used in a personal computer but also benefits from the capabilities of a supercomputer to tackle large scale problems; it is designed to run parallel on many MPI tasks. ECLIPSE analyzes masked CMB maps in which the signal can be affected by the beam and pixel window functions. The masks of intensity and polarization can be different and the noise can be isotropic or anisotropic. The program can estimate auto and cross-correlation power spectrum, that can be binned or unbinned.

[ascl:1112.001] Eclipse: ESO C Library for an Image Processing Software Environment

Written in ANSI C, eclipse is a library offering numerous services related to astronomical image processing: FITS data access, various image and cube loading methods, binary image handling and filtering (including convolution and morphological filters), 2-D cross-correlation, connected components, cube and image arithmetic, dead pixel detection and correction, object detection, data extraction, flat-fielding with robust fit, image generation, statistics, photometry, image-space resampling, image combination, and cube stacking. It also contains support for mathematical tools like random number generation, FFT, curve fitting, matrices, fast median computation, and point-pattern matching. The main feature of this library is its ability to handle large amounts of input data (up to 2GB in the current version) regardless of the amount of memory and swap available on the local machine. Another feature is the very high speed allowed by optimized C, making it an ideal base tool for programming efficient number-crunching applications, e.g., on parallel (Beowulf) systems.

[ascl:2402.007] ECLIPSR: Automatically find individual eclipses in light curves, determine ephemerides, and more

ECLIPSR fully and automatically analyzes space based light curves to find eclipsing binaries and provide some first order measurements, such as the binary star period and eclipse depths. It provides a recipe to find individual eclipses using the time derivatives of the light curves, including eclipses in light curves of stars where the dominating variability is, for example, pulsations. Since the algorithm detects each eclipse individually, even light curves containing only one eclipse can (in principle) be successfully analyzed and classified. ECLIPSR can find eclipsing binaries among both pulsating and non-pulsating stars in a homogeneous and quick manner and process large amounts of light curves in reasonable amounts of time. The output includes, among other things, the individual eclipse markers, the period and time of first (primary) eclipse, and a score between 0 and 1 indicating the likelihood that the analyzed light curve is that of an eclipsing binary.

[ascl:1901.010] eddy: Extracting Disk DYnamics

The Python suite eddy recovers precise rotation profiles of protoplanetary disks from Doppler shifted line emission, providing an easy way to fit first moment maps and the inference of a rotation velocity from an annulus of spectra.

[ascl:2202.009] EDIV: Exoplanet Detection Identifier Vetter

EDI (Exoplanet Detection Identifier) Vetter identifies false positive transit signal in the K2 data set. It combines the functionalities of Terra (ascl:2202.008) and RoboVetter (ascl:2012.006) and is optimized to test single transiting planet signals. An easily implemented suite of vetting metrics built to run alongside TLS of EDI Vetter, EDI-Vetter Unplugged (ascl:2202.010), is also available.

[ascl:2202.010] EDIVU: Exoplanet Detection Identifier Vetter Unplugged

The EDI (Exoplanet Detection Identifier) Vetter Unplugged software identifies false positive transit signals using Transit Least Squares (TLS) information and has been simplified from the full EDI-Vetter algorithm (ascl:2202.009) for easy implementation with the TLS output.

[ascl:1512.003] EDRS: Electronography Data Reduction System

The Electronography Data Reduction System (EDRS) reduces and analyzes large format astronomical images and was written to be used from within ASPIC (ascl:1510.006). In its original form it specialized in the reduction of electronographic data but was built around a set of utility programs which were widely applicable to astronomical images from other sources. The programs align and calibrate images, handle lists of (X,Y) positions, apply linear geometrical transformations and do some stellar photometry. This package is now obsolete.

[ascl:1512.004] EDRSX: Extensions to the EDRS package

EDRSX extends the Electronography Data Reduction System (EDRS, ascl:1512.0030). It makes more versatile analysis of IRAS images than was otherwise available possible. EDRSX provides facilities for converting images into and out of EDRS format, accesses RA and DEC information stored with IRAS images, and performs several standard image processing operations such as displaying image histograms and statistics, and Fourier transforms. This enables such operations to be performed as estimation and subtraction of non-linear backgrounds, de-striping of IRAS images, modelling of image features, and easy aligning of separate images, among others.

[ascl:2307.041] EFTCAMB: Effective Field Theory with CAMB

EFTCAMB patches the public Einstein-Boltzmann solver CAMB (ascl:1102.026) to implement the Effective Field Theory approach to cosmic acceleration. It can be used to investigate the effect of different EFT operators on linear perturbations and to study perturbations in any specific DE/MG model that can be cast into EFT framework. To interface EFTCAMB with cosmological data sets, it is equipped with a modified version of CosmoMC (ascl:1106.025), EFTCosmoMC, to create a bridge between the EFT parametrization of the dynamics of perturbations and observations.

[ascl:1804.008] EGG: Empirical Galaxy Generator

The Empirical Galaxy Generator (EGG) generates fake galaxy catalogs and images with realistic positions, morphologies and fluxes from the far-ultraviolet to the far-infrared. The catalogs are generated by egg-gencat and stored in binary FITS tables (column oriented). Another program, egg-2skymaker, is used to convert the generated catalog into ASCII tables suitable for ingestion by SkyMaker (ascl:1010.066) to produce realistic high resolution images (e.g., Hubble-like), while egg-gennoise and egg-genmap can be used to generate the low resolution images (e.g., Herschel-like). These tools can be used to test source extraction codes, or to evaluate the reliability of any map-based science (stacking, dropout identification, etc.).

[ascl:1904.004] ehtim: Imaging, analysis, and simulation software for radio interferometry

ehtim (eht-imaging) simulates and manipulates VLBI data and produces images with regularized maximum likelihood methods. The package contains several primary classes for loading, simulating, and manipulating VLBI data. The main classes are the Image, Array, Obsdata, Imager, and Caltable classes, which provide tools for loading images and data, producing simulated data from realistic u-v tracks, calibrating, inspecting, and plotting data, and producing images from data sets in various polarizations using various data terms and regularizers.

[ascl:2106.038] ehtplot: Plotting functions for the Event Horizon Telescope

ehtplot creates publication quality, elegant, and consistent plots. Written for the Event Horizon Telescope (EHT) Collaboration, it provides a set of easy-to-use plotting functions for EHT and Very-Long-Baseline Interferometry (VLBI) specific figures. This includes plotting visibility and images for both synthetic and real data, adding uv-tracks to the plots, and adding the expected event horizon size to the plots, among other functions.

[submitted] Eidein: Interactive Visualization Tool for Deep Active Learning

Eidein interactively visualizes a data sample for the selection of an informative (contains data with high predictive uncertainty, is diverse, but not redundant) data subsample for deep active learning. The data sample is projected to 2-D with a dimensionality reduction technique. It is visualized in an interactive scatter plot that allows a human expert to select and annotate the data subsample.

[ascl:2305.015] EIDOS: Modeling primary beams of radio astronomy antennas

EIDOS models the primary beam of radio astronomy antennas. The code can be used to create MeerKAT L-band beams from both holographic (AH) observations and EM simulations within a maximum diameter of 10 degrees. The beam model is less accurate at higher frequencies, and performs much better below 1400 MHz. The diagonal terms of the model beam Jones matrix are much better known than the off-diagonal terms. The performance of EIDOS is dependent on the quality of the given AH and EM datasets; as more accurate AH models and EM simulations become available, this pipeline can be used to create more accurate sparse representation of primary beams using Zernike polynomials.

[ascl:2101.017] Eigentools: Tools for studying linear eigenvalue problems

Eigentools is a set of tools for studying linear eigenvalue problems. The underlying eigenproblems are solved using Dedalus (ascl:1603.015), which provides a domain-specific language for partial differential equations. Eigentools extends Dedalus's EigenvalueProblem object and provides automatic rejection of unresolved eigenvalues, simple plotting of specified eigenmodes and of spectra, and computation of $\epsilon$-pseudospectra for any Differential-Algebraic Equations with user-specifiable norms. It includes tools to find critical parameters for linear stability analysis and is able to project eigenmode onto 2- or 3-D domain for visualization. It can also output projected eigenmodes as Dedalus-formatted HDF5 file to be used as initial conditions for Initial Value Problems, and provides simple plotting of drift ratios (both ordinal and nearest) to evaluate tolerance for eigenvalue rejection.

[ascl:1904.013] EightBitTransit: Calculate light curves from pixel grids

EightBitTransit calculates the light curve of any pixelated image transiting a star and inverts a light curve to recover the "shadow image" that produced it.

[ascl:1102.014] Einstein Toolkit for Relativistic Astrophysics

The Einstein Toolkit is a collection of software components and tools for simulating and analyzing general relativistic astrophysical systems. Such systems include gravitational wave space-times, collisions of compact objects such as black holes or neutron stars, accretion onto compact objects, core collapse supernovae and Gamma-Ray Bursts.

The Einstein Toolkit builds on numerous software efforts in the numerical relativity community including CactusEinstein, Whisky, and Carpet. The Einstein Toolkit currently uses the Cactus Framework as the underlying computational infrastructure that provides large-scale parallelization, general computational components, and a model for collaborative, portable code development.

[ascl:2012.026] EinsteinPy: General Relativity and gravitational physics problems solver

EinsteinPy performs General Relativity and gravitational physics tasks, including geodesics plotting for Schwarzschild, Kerr and Kerr Newman space-time models, calculation of Schwarzschild radius, and calculation of event horizon and ergosphere for Kerr space-time. It can perform symbolic manipulations of various tensors such as Metric, Riemann, Ricci and Christoffel symbols. EinsteinPy also features hypersurface embedding of Schwarzschild space-time, and includes other utilities and functions. It is a community-developed package and is written in Python.

[ascl:1904.022] eleanor: Extracted and systematics-corrected light curves for TESS-observed stars

eleanor extracts target pixel files from TESS Full Frame Images and produces systematics-corrected light curves for any star observed by the TESS mission. eleanor takes a TIC ID, a Gaia source ID, or (RA, Dec) coordinates of a star observed by TESS and returns, as a single object, a light curve and accompanying target pixel data. The process can be customized, allowing, for example, examination of intermediate data products and changing the aperture used for light curve extraction. eleanor also offers tools that make it easier to work with stars observed in multiple TESS sectors.

[submitted] EleFits

EleFits is a modern C++ package to read and write FITS files which focuses on safety, user-friendliness, and performance.

[ascl:2108.015] ELISa: Eclipsing binaries Learning Interactive System

ELISa models light curves of close eclipsing binaries. It models surfaces of detached, semi-detached, and over-contact binaries, generates light curves, and generates stellar spots with given longitude, latitude, radius, and temperature. It can also fit radial velocity curves and light curves via the implementation of the non-linear least squares method and also via Markov Chain Monte Carlo method.

[ascl:1603.016] ellc: Light curve model for eclipsing binary stars and transiting exoplanets

ellc analyzes the light curves of detached eclipsing binary stars and transiting exoplanet systems. The model represents stars as triaxial ellipsoids, and the apparent flux from the binary is calculated using Gauss-Legendre integration over the ellipses that are the projection of these ellipsoids on the sky. The code can also calculate the fluxweighted radial velocity of the stars during an eclipse (Rossiter-McLaghlin effect). ellc can model a wide range of eclipsing binary stars and extrasolar planetary systems, and can enable the use of modern Monte Carlo methods for data analysis and model testing.

[ascl:1106.024] ELMAG: Simulation of Electromagnetic Cascades

A Monte Carlo program for the simulation of electromagnetic cascades initiated by high-energy photons and electrons interacting with extragalactic background light (EBL) is presented. Pair production and inverse Compton scattering on EBL photons as well as synchrotron losses and deflections of the charged component in extragalactic magnetic fields (EGMF) are included in the simulation. Weighted sampling of the cascade development is applied to reduce the number of secondary particles and to speed up computations. As final result, the simulation procedure provides the energy, the observation angle, and the time delay of secondary cascade particles at the present epoch. Possible applications are the study of TeV blazars and the influence of the EGMF on their spectra or the calculation of the contribution from ultrahigh energy cosmic rays or dark matter to the diffuse extragalactic gamma-ray background. As an illustration, we present results for deflections and time-delays relevant for the derivation of limits on the EGMF.

[ascl:2212.022] Elysium: Observing black hole accretion disks

Elysium creates an observing screen at the desirable distance away from a black hole system. Observers set on every pixel of this screen then photograph the area toward the black hole - accretion disk system and report back what they record. This can be the accretion disk (incoming photons bring in radiation and thus energy), the black hole event horizon, or the empty space outside and beyond the system (there are no incoming photons or energy). The central black hole can be either Schwarzschild (nonrotating) or Kerr (rotating) by choice of the user.

[ascl:1203.006] EMACSS: Evolve Me A Cluster of StarS

The star cluster evolution code Evolve Me A Cluster of StarS (EMACSS) is a simple yet physically motivated computational model that describes the evolution of some fundamental properties of star clusters in static tidal fields. The prescription is based upon the flow of energy within the cluster, which is a constant fraction of the total energy per half-mass relaxation time. According to Henon's predictions, this flow is independent of the precise mechanisms for energy production within the core, and therefore does not require a complete description of the many-body interactions therein. Dynamical theory and analytic descriptions of escape mechanisms is used to construct a series of coupled differential equations expressing the time evolution of cluster mass and radius for a cluster of equal-mass stars. These equations are numerically solved using a fourth-order Runge-Kutta integration kernel; the results were benchmarked against a data base of direct N-body simulations. EMACSS is publicly available and reproduces the N-body results to within ~10 per cent accuracy for the entire post-collapse evolution of star clusters.

[ascl:2106.029] EMBERS: Experimental Measurement of BEam Responses with Satellites

EMBERS provides a modular framework for radio telescopes and interferometric arrays such as the MWA, HERA, and the upcoming SKA-Low to accurately measure the all sky polarized beam responses of their antennas using weather and communication satellites. This tool enables astronomers and system engineers, all over the world, to characterize the in-situ antenna beam patterns of large arrays with ease.

[ascl:1303.002] emcee: The MCMC Hammer

emcee is an extensible, pure-Python implementation of Goodman & Weare's Affine Invariant Markov chain Monte Carlo (MCMC) Ensemble sampler. It's designed for Bayesian parameter estimation. The algorithm behind emcee has several advantages over traditional MCMC sampling methods and has excellent performance as measured by the autocorrelation time (or function calls per independent sample). One advantage of the algorithm is that it requires hand-tuning of only 1 or 2 parameters compared to $sim N^2$ for a traditional algorithm in an N-dimensional parameter space. Exploiting the parallelism of the ensemble method, emcee permits any user to take advantage of multiple CPU cores without extra effort.

[ascl:2109.006] eMCP: e-MERLIN CASA pipeline

The e-MERLIN CASA Pipeline calibrates and processes data from the e-MERLIN radio interferometer. It works on top of CASA (ascl:1107.013) and can convert, concatenate, prepare, flag and calibrate raw to produce advanced calibrated products for both continuum and spectral line data. The main outputs of the data are calibration tables, calibrated data, assessment plots, preliminary images of target and calibrator sources and a summary weblog. The pipeline provides an easy, ready-to-use toolkit that delivers calibrated data in a consistent, clear, and repeatable way. A parameters file is used to control the pipeline execution, so optimization of the algorithms is straightforward and reproducible. Good quality images are usually obtained with minimum human intervention.

[ascl:1910.006] EMERGE: Empirical ModEl for the foRmation of GalaxiEs

Emerge (Empirical ModEl for the foRmation of GalaxiEs) populates dark matter halo merger trees with galaxies using simple empirical relations between galaxy and halo properties. For each model represented by a set of parameters, it computes a mock universe, which it then compares to observed statistical data to obtain a likelihood. Parameter space can be explored with several advanced stochastic algorithms such as MCMC to find the models that are in agreement with the observations.

[ascl:1201.004] emGain: Determination of EM gain of CCD

The determination of the EM gain of the CCD is best done by fitting the histogram of many low-light frames. Typically, the dark+CIC noise of a 30ms frame itself is a sufficient amount of signal to determine accurately the EM gain with about 200 512x512 frames. The IDL code emGain takes as an input a cube of frames and fit the histogram of all the pixels with the EM stage output probability function. The function returns the EM gain of the frames as well as the read-out noise and the mean signal level of the frames.

[ascl:1708.027] empiriciSN: Supernova parameter generator

empiriciSN generates realistic supernova parameters given photometric observations of a potential host galaxy, based entirely on empirical correlations measured from supernova datasets. It is intended to be used to improve supernova simulation for DES and LSST. It is extendable such that additional datasets may be added in the future to improve the fitting algorithm or so that additional light curve parameters or supernova types may be fit.

[ascl:1010.018] Emu CMB: Power spectrum emulator

Emu CMB is a fast emulator the CMB temperature power spectrum based on CAMB (ascl:1102.026, Jan 2010 version). Emu CMB is based on a "space-filling" Orthogonal Array Latin Hypercube design in a de-correlated parameter space obtained by using a fiducial WMAP5 CMB Fisher matrix as a rotation matrix. This design strategy allows for accurate interpolation with small numbers of simulation design points. The emulator presented here is calibrated with 100 CAMB runs that are interpolated over the design space using a global quadratic polynomial fit.

[ascl:1109.012] EnBiD: Fast Multi-dimensional Density Estimation

We present a method to numerically estimate the densities of a discretely sampled data based on a binary space partitioning tree. We start with a root node containing all the particles and then recursively divide each node into two nodes each containing roughly equal number of particles, until each of the nodes contains only one particle. The volume of such a leaf node provides an estimate of the local density and its shape provides an estimate of the variance. We implement an entropy-based node splitting criterion that results in a significant improvement in the estimation of densities compared to earlier work. The method is completely metric free and can be applied to arbitrary number of dimensions. We use this method to determine the appropriate metric at each point in space and then use kernel-based methods for calculating the density. The kernel-smoothed estimates were found to be more accurate and have lower dispersion. We apply this method to determine the phase-space densities of dark matter haloes obtained from cosmological N-body simulations. We find that contrary to earlier studies, the volume distribution function v(f) of phase-space density f does not have a constant slope but rather a small hump at high phase-space densities. We demonstrate that a model in which a halo is made up by a superposition of Hernquist spheres is not capable in explaining the shape of v(f) versus f relation, whereas a model which takes into account the contribution of the main halo separately roughly reproduces the behaviour as seen in simulations. The use of the presented method is not limited to calculation of phase-space densities, but can be used as a general purpose data-mining tool and due to its speed and accuracy it is ideally suited for analysis of large multidimensional data sets.

[ascl:2105.014] encore: Efficient isotropic 2-, 3-, 4-, 5- and 6-point correlation functions

encore (Efficient N-point Correlator Estimation) estimates the isotropic NPCF multipoles for an arbitrary survey geometry in O(N2) time, with optional GPU support. The code features support for the isotropic 2PCF, 3PCF, 4PCF, 5PCF and 6PCF, with the option to subtract the Gaussian 4PCF contributions at the estimator level. For the 4PCF, 5PCF and 6PCF algorithms, the runtime is dominated by sorting the spherical harmonics into bins, which has complexity O(N_galaxy x N_bins3 x N_ell5) [4PCF], O(N_galaxy x N_bins4 x N_ell8) [5PCF] or O(N_galaxy x N_bins5 x N_ell11) [6PCF]. The higher-point functions are slow to compute unless N_bins and N_ell are small.

[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:1501.008] Enrico: Python package to simplify Fermi-LAT analysis

Enrico analyzes Fermi data. It produces spectra (model fit and flux points), maps and lightcurves for a target by editing a config file and running a python script which executes the Fermi science tool chain.

[ascl:1912.015] ENTERPRISE: Enhanced Numerical Toolbox Enabling a Robust PulsaR Inference SuitE

ENTERPRISE (Enhanced Numerical Toolbox Enabling a Robust PulsaR Inference SuitE) is a pulsar-timing analysis code which performs noise analysis, gravitational-wave searches, and timing model analysis. It uses Tempo2 (ascl:1210.015) to find the maximum-likelihood fit for the timing parameters and the basis of the fit for the red noise parameters if they are significant.

[ascl:1010.072] Enzo: AMR Cosmology Application

Enzo is an adaptive mesh refinement (AMR), grid-based hybrid code (hydro + N-Body) which is designed to do simulations of cosmological structure formation. It uses the algorithms of Berger & Collela to improve spatial and temporal resolution in regions of large gradients, such as gravitationally collapsing objects. The Enzo simulation software is incredibly flexible, and can be used to simulate a wide range of cosmological situations with the available physics packages.

Enzo has been parallelized using the MPI message-passing library and can run on any shared or distributed memory parallel supercomputer or PC cluster. Simulations using as many as 1024 processors have been successfully carried out on the San Diego Supercomputing Center's Blue Horizon, an IBM SP.

[ascl:2012.007] EOS: Equation of State for planetary impacts

EOS is an analytical equation of state which models high pressure theory and fits well to the experimental data of ∊-Fe, SiO2, Mg2SiO4, and the Earth. The cold part of the EOS is modeled after the Varpoly EOS. The thermal part is based on a new formalism of the Gruneisen parameter, which improves behavior from earlier models and bridges the gap between elasticity and thermoelasticity. The EOS includes an expanded state model, which allows for the accurate modeling of material vapor curves.

[ascl:2101.008] EphemMatch: Ephemeris matching of DR25 TCEs, KOIs, and EBs for false positive identification

EphemMatch reads in the period, epoch, positional, and other information of all the Kepler DR25 TCEs, as well as the cumulative KOI list, and lists of EBs from the Kepler Eclipsing Binary Working Group (http://keplerebs.villanova.edu) as well as several catalogs of EBs known from ground-based surveys. The code then performs matching to identify two different objects that have a statistically identical period and epoch (within some tolerance) and perform logic to identify which is the real source (the parent) and which is a false positive due to contamination from the parent (a child).

[ascl:1511.021] EPIC: E-field Parallel Imaging Correlator

E-field Parallel Imaging Correlator (EPIC), a highly parallelized Object Oriented Python package, implements the Modular Optimal Frequency Fourier (MOFF) imaging technique. It also includes visibility-based imaging using the software holography technique and a simulator for generating electric fields from a sky model. EPIC can accept dual-polarization inputs and produce images of all four instrumental cross-polarizations.

[ascl:2104.007] EPIC5: Lindblad orbits in ovally perturbed potentials

EPIC5 computes positions, velocities and densities along closed orbits of interstellar matter, including frictional forces, in a galaxy with an arbitrary perturbing potential. Radial velocities are given for chosen lines of sight. These are analytic gas orbits in an arbitrary rotating galactic potential using the linear epicyclic approximation

[ascl:1302.005] EPICS: Experimental Physics and Industrial Control System

EPICS is a set of software tools and applications developed collaboratively and used to create distributed soft real-time control systems for scientific instruments such as particle accelerators and telescopes. Such distributed control systems typically comprise tens or even hundreds of computers, networked together to allow communication between them and to provide control and feedback of the various parts of the device from a central control room, or even remotely over the internet. EPICS uses Client/Server and Publish/Subscribe techniques to communicate between the various computers. A Channel Access Gateway allows engineers and physicists elsewhere in the building to examine the current state of the IOCs, but prevents them from making unauthorized adjustments to the running system. In many cases the engineers can make a secure internet connection from home to diagnose and fix faults without having to travel to the site.

EPICS is used by many facilities worldwide, including the Advanced Photon Source at Argonne National Laboratory, Fermilab, Keck Observatory, Laboratori Nazionali di Legnaro, Brazilian Synchrotron Light Source, Los Alamos National Laboratory, Australian Synchrotron, and Stanford Linear Accellerator Center.

[ascl:1909.013] EPOS: Exoplanet Population Observation Simulator

EPOS (Exoplanet Population Observation Simulator) simulates observations of exoplanet populations. It provides an interface between planet formation simulations and exoplanet surveys such as Kepler. EPOS can also be used to estimate planet occurrence rates and the orbital architectures of planetary systems.

[ascl:1204.017] epsnoise: Pixel noise in ellipticity and shear measurements

epsnoise simulates pixel noise in weak-lensing ellipticity and shear measurements. This open-source python code can efficiently create an intrinsic ellipticity distribution, shear it, and add noise, thereby mimicking a "perfect" measurement that is not affected by shape-measurement biases. For theoretical studies, we provide the Marsaglia distribution, which describes the ratio of normal variables in the general case of non-zero mean and correlation. We also added a convenience method that evaluates the Marsaglia distribution for the ratio of moments of a Gaussian-shaped brightness distribution, which gives a very good approximation of the measured ellipticity distribution also for galaxies with different radial profiles. We provide four shear estimators, two based on the ε ellipticity measure, two on χ. While three of them are essentially plain averages, we introduce a new estimator which requires a functional minimization.

[ascl:1802.016] eqpair: Electron energy distribution calculator

eqpair computes the electron energy distribution resulting from a balance between heating and direct acceleration of particles, and cooling processes. Electron-positron pair balance, bremstrahlung, and Compton cooling, including external soft photon input, are among the processes considered, and the final electron distribution can be hybrid, thermal, or non-thermal.

[ascl:2102.009] EqTide: Equilibrium Tide calculations

EqTide calculates the evolution of 2 bodies experiencing tidal evolution according to the "equilibrium tide" framework's "constant-phase-lag" and "constant-time-lag" models. The input file contains a list of options that can be set, as well as output parameters that print to a file during an integration. The example input files provide a guide for the syntax and grammar of EqTide.

[ascl:1603.005] EQUIB: Atomic level populations and line emissivities calculator

The Fortran program EQUIB solves the statistical equilibrium equation for each ion and yields atomic level populations and line emissivities for given physical conditions, namely electron temperature and electron density, appropriate to the zones in an ionized nebula where the ions are expected to exist.

[ascl:2401.020] escatter: Electron scattering in Python

escatter.py performs Monte Carlo simulations of electron scattering events. The code was developed to better understand the emission lines from the interacting supernova SN 2021adxl, specifically the blue excess seen in the Hα 6563A emission line. escatter follows a photon that was formed in a thin interface between the supernova ejecta and surrounding material as it travels radially outwards through the dense material, scattering electrons outwards until it reaches an optically thin region, and plots a histogram of the emergent photons.

[ascl:1302.017] ESO-MIDAS: General tools for image processing and data reduction

The ESO-MIDAS system provides general tools for image processing and data reduction with emphasis on astronomical applications including imaging and special reduction packages for ESO instrumentation at La Silla and the VLT at Paranal. In addition it contains applications packages for stellar and surface photometry, image sharpening and decomposition, statistics, data fitting, data presentation in graphical form, and more.

[ascl:1504.003] EsoRex: ESO Recipe Execution Tool

EsoRex (ESO Recipe Execution Tool) lists, configures, and executes Common Pipeline Library (CPL) (ascl:1402.010) recipes from the command line. Its features include automatically generating configuration files, recursive recipe-path searching, command line and configuration file parameters, and recipe product naming control, among many others.

[ascl:1405.017] ESP: Extended Surface Photometry

ESP (Extended Surface Photometry) determines the photometric properties of galaxies and other extended objects. It has applications that detect flatfielding faults, remove cosmic rays, median filter images, determine image statistics and local background values, perform galaxy profiling, fit 2-D Gaussian profiles to galaxies, generate pie slice cross-sections of galaxies, and display profiling results. It is distributed as part of the Starlink software collection (ascl:1110.012).

[ascl:2306.055] ESSENCE: Evaluate spatially correlated noise in interferometric images

ESSENCE (Evaluating Statistical Significance undEr Noise CorrElation) evaluates the statistical significance of image analysis and signal detection under correlated noise in interferometric images (e.g., ALMA, NOEMA). It measures the noise autocorrelation function (ACF) to fully characterize the statistical properties of spatially correlated noise in the interferometric image, computes the noise in the spatially integrated quantities (e.g., flux, spectrum) with a given aperture, and simulates noise maps with the same correlation property. ESSENSE can also construct a covariance matrix from noise ACF, which can be used for a 2d image or 3d cube model fitting.

[ascl:1305.001] ESTER: Evolution STEllaire en Rotation

The ESTER code computes the steady state of an isolated star of mass larger than two solar masses. The only convective region computed as such is the core where isentropy is assumed. ESTER provides solutions of the partial differential equations, for the pressure, density, temperature, angular velocity and meridional velocity for the whole volume. The angular velocity (differential rotation) and meridional circulation are computed consistently with the structure and are driven by the baroclinic torque. The code uses spectral methods, both radially and horizontally, with spherical harmonics and Chebyshev polynomials. The iterations follow Newton's algorithm. The code is object-oriented and is written in C++; a python suite allows an easy visualization of the results. While running, PGPLOT graphs are displayed to show evolution of the iterations.

[ascl:2208.018] EstrellaNueva: Expected rates of supernova neutrinos calculator

EstrellaNueva calculates expected rates of supernova neutrinos in detectors. It provides a link between supernova simulations and the expected events in detectors by calculating fluences and event rates in order to ease any comparison between theory and observation. The software is a standalone tool for exploring many physics scenarios, and offers an option to add analytical cross sections and define any target material.

[ascl:1311.012] ETC: Exposure Time Calculator

Written for the Wide-Field Infrared Survey Telescope (WFIRST) high-latitude survey, the exposure time calculator (ETC) works in both imaging and spectroscopic modes. In addition to the standard ETC functions (e.g. background and S/N determination), the calculator integrates over the galaxy population and forecasts the density and redshift distribution of galaxy shapes usable for weak lensing (in imaging mode) and the detected emission lines (in spectroscopic mode). The program may be useful outside of WFIRST but no warranties are made regarding its suitability for general purposes. The software is available for download; IPAC maintains a web interface for those who wish to run a small number of cases without having to download the package.

[ascl:1307.018] ETC++: Advanced Exposure-Time Calculations

ETC++ is a exposure-time calculator that considers the effect of cosmic rays, undersampling, dithering, and imperfect pixel response functions. Errors on astrometry and galaxy shape measurements can be predicted as well as photometric errors.

[ascl:2011.015] EvapMass: Minimum mass of planets predictor

EvapMass predicts the minimum masses of planets in multi-planet systems using the photoevaporation-driven evolution model. The planetary system requires both a planet above and below the radius gap to be useful for this test. EvapMass includes an example Jupyter notebook for the Kepler-36 system. EvalMass can be used to identify TESS systems that warrant radial-velocity follow-up to further test the photoevaporation model.

[ascl:2212.002] Eventdisplay: Analysis and reconstruction package for ground-based Gamma-ray astronomy

Eventdisplay reconstructs and analyzes data from the Imaging Atmospheric Cherenkov Telescopes (IACT). It has been primarily developed for VERITAS and CTA analysis. The package calibrates and parametrizes images, event reconstruction, and stereo analysis, and provides train boosted decision trees for direction and energy reconstruction. It fills and uses lookup tables for mean scaled width and length calculation, energy reconstruction, and stereo reconstruction, and calculates radial camera acceptance from data files and instrument response functions such as effective areas, angular point-spread function, and energy resolution. Eventdisplay offers additional tools as well, including tools for calculating sky maps and spectral energy distribution, and to plot instrument response function, spectral energy distributions, light curves, and sky maps, among others.

[ascl:1807.029] EVEREST: Tools for de-trending stellar photometry

EVEREST (EPIC Variability Extraction and Removal for Exoplanet Science Targets) removes instrumental noise from light curves with pixel level decorrelation and Gaussian processes. The code, written in Python, generates the EVEREST catalog and offers tools for accessing and interacting with the de-trended light curves. EVEREST exploits correlations across the pixels on the CCD to remove systematics introduced by the spacecraft’s pointing error. For K2, it yields light curves with precision comparable to that of the original Kepler mission. Interaction with the EVEREST catalog catalog is available via the command line and through the Python interface. Though written for K2, EVEREST can be applied to additional surveys, such as the TESS mission, to correct for instrumental systematics and enable the detection of low signal-to-noise transiting exoplanets.

[ascl:2307.052] EVo: Thermodynamic magma degassing model

EVo calculates the speciation and volume of a volcanic gas phase erupting in equilibrium with its parent magma. Models can be run to calculate the gas phase in equilibrium with a melt at a single pressure, or the melt can be decompressed from depth rising to the surface as a closed-system case. Single pressure and decompression can be run for OH, COH, SOH, COHS and COHSN systems. EVo can calculate gas phase weight and volume fraction within the system, gas phase speciation as mole fraction or weight fraction across numerous compounds, and the volatile content of the melt at each pressure. It also calculates melt density, f02 of the system, and more. EVo can be set up using either melt volatile contents, or for a set amount of atomic volatile which is preferable for conducting experiments over a wide range of fO2 values.

[ascl:2303.012] EvoEMD: Cosmic Evolution with an Early Matter-Dominated era

EvoEMD evaluates cosmic evolution with or without an early matter dominated (EMD) era. The framework includes global parameter, particle, and process systems, and different methods for Hubble parameter calculation. EvoEMD automatically builds up the Boltzmann equation according to the user's definition of particle and process,solves the Boltzmann equation using 4th order Runge-Kutta method with adaptive steps tailored to cosmology application, and caches the collision rate calculation results for fast evaluation.

[ascl:1905.003] evolstate: Assign simple evolutionary states to stars

evolstate assigns crude evolutionary states (main-sequence, subgiant, red giant) to stars given an input temperature and radius/surface gravity, based on physically motivated boundaries from solar metallicity interior models.

[ascl:2307.053] EVolve: Growth and evolution of volcanically-derived atmospheres

EVolve calculates the chemical composition and surface pressure of a ID atmosphere on a rocky planet that is being produced by volcanic activity, as it grows over time. Once the initial volatile content of the planet's mantle and the composition and resultant surface pressure of any pre-existing atmosphere is set, the volcanic degassing model EVo (ascl:2307.052) calculates the amount and speciation of any volcanic gases released into the atmosphere over each time step. Atmospheric processing is calculated using FastChem (ascl:1804.025); thermochemical equilibrium is assumed so the final chemical composition of the atmosphere is calculated according to the pre-set surface temperature.

[ascl:2211.020] EXCEED-DM: EXtended Calculation of Electronic Excitations for Direct detection of Dark Matter

EXCEED-DM (EXtended Calculation of Electronic Excitations for Direct detection of Dark Matter) provides a complete framework for computing DM-electron interaction rates. Given an electronic configuration, EXCEED-DM computes the relevant electronic matrix elements, then particle physics specific rates from these matrix elements. This allows for separation between approximations regarding the electronic state configuration, and the specific calculation being performed.

[ascl:1204.011] EXCOP: EXtraction of COsmological Parameters

The EXtraction of COsmological Parameters software (EXCOP) is a set of C and IDL programs together with a very large database of cosmological models generated by CMBFAST (ascl:9909.004) that will compute likelihood functions for cosmological parameters given some CMB data. This is the software and database used in the Stompor et al. (2001) analysis of a high resoultion Maxima1 CMB anisotropy map.

[ascl:2010.008] Exo-DMC: Exoplanet Detection Map Calculator

The Exoplanet Detection Map Calculator (Exo-DMC) performs statistical analysis of exoplanet surveys results using Monte Carlo methods. Written in Python, it is the latest rendition of the MESS (Multi-purpose Exoplanet Simulation System, ascl:1111.009). Exo-DMC combines the information on the target stars with instrument detection limits to estimate the probability of detection of companions within a user defined range of masses and physical separations, ultimately generating detection probability maps. The software allows for a high level of flexibility in terms of possible assumptions on the synthetic planet population to be used for the determination of the detection probability.

[submitted] Exo-MerCat: a merged exoplanet catalog with Virtual Observatory connection

The heterogeneity of papers dealing with the discovery and characterization of exoplanets makes every attempt to maintain a uniform exoplanet catalog almost impossible. Four sources currently available online (NASA Exoplanet Archive, Exoplanet Orbit Database, Exoplanet Encyclopaedia, and Open Exoplanet Catalogue) are commonly used by the community, but they can hardly be compared, due to discrepancies in notations and selection criteria.
Exo-MerCat is a Python code that collects and selects the most precise measurement for all interesting planetary and orbital parameters contained in the four databases, accounting for the presence of multiple aliases for the same target. It can download information about the host star as well by the use of Virtual Observatory ConeSearch connections to the major archives such as SIMBAD and those available in VizieR. A Graphical User Interface is provided to filter data based on the user's constraints and generate automatic plots that are commonly used in the exoplanetary community.
With Exo-MerCat, we retrieved a unique catalog that merges information from the four main databases, standardizing the output and handling notation differences issues. Exo-MerCat can correct as many issues that prevent a direct correspondence between multiple items in the four databases as possible, with the available data. The catalog is available as a VO resource for everyone to use and it is periodically updated, according to the update rates of the source catalogs.

[ascl:1806.029] EXO-NAILER: EXOplanet traNsits and rAdIal veLocity fittER

EXO-NAILER (EXOplanet traNsits and rAdIal veLocity fittER) efficiently fits exoplanet transit lightcurves, radial velocities (RVs) or both. The code handles data taken with different instruments. For RVs, a different center-of-mass velocity can be fitted for each instrument to account for offsets between them; if jitter is included, a different jitter term can also fitted for each instrument. For transits, a different photometric jitter can be fitted to each instrument as can different limb-darkening coefficients and different transit depths. In addition to general options that need to be set, EXO-NAILER also requires that photometry and radial velocity options be defined for each instrument.

[ascl:1611.005] Exo-Transmit: Radiative transfer code for calculating exoplanet transmission spectra

Exo-Transmit calculates the transmission spectrum of an exoplanet atmosphere given specified input information about the planetary and stellar radii, the planet's surface gravity, the atmospheric temperature-pressure (T-P) profile, the location (in terms of pressure) of any cloud layers, the composition of the atmosphere, and opacity data for the atoms and molecules that make up the atmosphere. The code solves the equation of radiative transfer for absorption of starlight passing through the planet's atmosphere as it transits, accounting for the oblique path of light through the planetary atmosphere along an Earth-bound observer's line of sight. The fraction of light absorbed (or blocked) by the planet plus its atmosphere is calculated as a function of wavelength to produce the wavelength-dependent transmission spectrum. Functionality is provided to simulate the presence of atmospheric aerosols in two ways: an optically thick (gray) cloud deck can be generated at a user-specified height in the atmosphere, and the nominal Rayleigh scattering can be increased by a specified factor.

[ascl:2002.020] ExoCAM: Exoplanet Community Atmospheric Model

ExoCAM adapts the NCAR Community Earth System Model (CESM) for planetary and exoplanetary applications. The system files, source code, initial conditions files, and namelists provided do not run standalone. ExoCAM is a patch to be used with standard distributions of CESM version 1.2.1 (http://www.cesm.ucar.edu/models/current.html), and is also intended to be run with ExoRT (ascl:2002.019), a correlated-k radiative transfer package.

[ascl:1805.007] exocartographer: Constraining surface maps orbital parameters of exoplanets

exocartographer solves the exo-cartography inverse problem. This flexible forward-modeling framework, written in Python, retrieves the albedo map and spin geometry of a planet based on time-resolved photometry; it uses a Markov chain Monte Carlo method to extract albedo maps and planet spin and their uncertainties. Gaussian Processes use the data to fit for the characteristic length scale of the map and enforce smooth maps.

[ascl:1803.014] ExoCross: Spectra from molecular line lists

ExoCross generates spectra and thermodynamic properties from molecular line lists in ExoMol, HITRAN, or several other formats. The code is parallelized and also shows a high degree of vectorization; it works with line profiles such as Doppler, Lorentzian and Voigt and supports several broadening schemes. ExoCross is also capable of working with the recently proposed method of super-lines. It supports calculations of lifetimes, cooling functions, specific heats and other properties. ExoCross converts between different formats, such as HITRAN, ExoMol and Phoenix, and simulates non-LTE spectra using a simple two-temperature approach. Different electronic, vibronic or vibrational bands can be simulated separately using an efficient filtering scheme based on the quantum numbers.

[ascl:2207.012] ExoCTK: Exoplanet Characterization Tool Kit

The Exoplanet Characterization ToolKit (ExoCTK) focuses primarily on the atmospheric characterization of exoplanets and provides tools for time-series observation planning, forward modeling, data reduction, limb darkening, light curve fitting, and retrievals. It contains calculators for contamination, visibility, integrations and groups, and includes several Jupyter Notebooks to aid in learning how to use the various tools included in the ExoCTK package.

[ascl:1512.011] ExoData: Open Exoplanet Catalogue exploration and analysis tool

ExoData is a python interface for accessing and exploring the Open Exoplanet Catalogue. It allows searching of planets (including alternate names) and easy navigation of hierarchy, parses spectral types and fills in missing parameters based on programmable specifications, and provides easy reference of planet parameters such as GJ1214b.ra, GJ1214b.T, and GJ1214b.R. It calculates values such as transit duration, can easily rescale units, and can be used as an input catalog for large scale simulation and analysis of planets.

[ascl:2110.002] exodetbox: Finding planet-star projected separation extrema and difference in magnitude extrema

Exodetbox provides mathematical methods for calculating the planet-star separation and difference in magnitude extrema as well as when planets have particular planet-star separations or differences in magnitude. The code also projects the 3D Keplerian Orbit into a reparameterized 2D ellipse in the plane of the sky. Exodetbox is implemented in the EXOSIMS modeling software (ascl:1706.010).

[ascl:1207.001] EXOFAST: Fast transit and/or RV fitter for single exoplanet

EXOFAST is a fast, robust suite of routines written in IDL which is designed to fit exoplanetary transits and radial velocity variations simultaneously or separately, and characterize the parameter uncertainties and covariances with a Differential Evolution Markov Chain Monte Carlo method. Our code self-consistently incorporates both data sets to simultaneously derive stellar parameters along with the transit and RV parameters, resulting in consistent, but tighter constraints on an example fit of the discovery data of HAT-P-3b that is well-mixed in under two minutes on a standard desktop computer. EXOFAST has an easy-to-use online interface for several basic features of our transit and radial velocity fitting. A more robust version of EXOFAST, EXOFASTv2 (ascl:1710.003), is also available.

[ascl:1710.003] EXOFASTv2: Generalized publication-quality exoplanet modeling code

EXOFASTv2 improves upon EXOFAST (ascl:1207.001) for exoplanet modeling. It uses a differential evolution Markov Chain Monte Carlo code to fit an arbitrary number of transits (each with their own error scaling, normalization, TTV, and/or detrending parameters), an arbitrary number of RV sources (each with their own zero point and jitter), and an arbitrary number of planets, changing nothing but command line arguments and configuration files. The global model includes integrated isochrone and SED models to constrain the stellar properties and can accept priors on any fitted or derived quantities (e.g., parallax from Gaia). It is easily extensible to add additional effects or parameters.

[ascl:1201.009] ExoFit: Orbital parameters of extra-solar planets from radial velocity

ExoFit is a freely available software package for estimating orbital parameters of extra-solar planets. ExoFit can search for either one or two planets and employs a Bayesian Markov Chain Monte Carlo (MCMC) method to fit a Keplerian radial velocity curve onto the radial velocity data.

[ascl:1812.007] ExoGAN: Exoplanets Generative Adversarial Network

ExoGAN (Exoplanets Generative Adversarial Network) analyzes exoplanetary atmospheres using an unsupervised deep-learning algorithm that recognizes molecular features, atmospheric trace-gas abundances, and planetary parameters. After training, ExoGAN can be applied to a large number of instruments and planetary types and can be used either as a final atmospheric analysis or to provide prior constraints to subsequent retrieval.

[ascl:1806.020] exoinformatics: Compute the entropy of a planetary system's size-ordering

exoinformatics computes the entropy of a planetary system's size ordering using three different entropy methods: tally-scores, integral path, and change points.

[ascl:2206.003] ExoJAX: Spectrum modeling of exoplanets and brown dwarfs

ExoJAX provides auto-differentiable line-by-line spectral modeling of exoplanets/brown dwarfs/M dwarfs using JAX (ascl:2111.002). In a nutshell, ExoJAX allows the user to do a HMC-NUTS fitting using the latest molecular/atomic data in ExoMol, HITRAN/HITEMP, and VALD3. The code enables a fully Bayesian inference of the high-dispersion data to fit the line-by-line spectral computation to the observed spectrum, from end-to-end (i.e. from molecular/atomic databases to real spectra), by combining it with the Hamiltonian Monte Carlo in recent probabilistic programming languages such as NumPyro.

[submitted] ExoPix: Exoplanet Imaging with JWST

ExoPix is a collection of tutorials aimed at illustrating the imaging of exoplanets with the James Webb Space Telescope (JWST). ExoPix tutorials are meant to demonstrate the application of the PSF-subtraction algorithm pyKLIP (ascl:1506.001) to simulated JWST NIRCAM data. We provide simple walkthroughs of pyKLIP’s ability to reveal exoplanets, compute contrast curves, and measure exoplanet astrometry and photometry in imaged extrasolar systems.

[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:1910.005] exoplanet: Probabilistic modeling of transit or radial velocity observations of exoplanets

exoplanet is a toolkit for probabilistic modeling of transit and/or radial velocity observations of exoplanets and other astronomical time series using PyMC3 (ascl:1610.016), a flexible and high-performance model building language and inference engine. exoplanet extends PyMC3's language to support many of the custom functions and distributions required when fitting exoplanet datasets. These features include a fast and robust solver for Kepler's equation; scalable Gaussian processes using celerite (ascl:1709.008); and fast and accurate limb darkened light curves using the code starry (ascl:1810.005). It also offers common reparameterizations for limb darkening parameters, and planet radius and impact parameters.

[ascl:1501.015] Exoplanet: Trans-dimensional MCMC method for exoplanet discovery

Exoplanet determines the posterior distribution of exoplanets by use of a trans-dimensional Markov Chain Monte Carlo method within Nested Sampling. This method finds the posterior distribution in a single run rather than requiring multiple runs with trial values.

[ascl:2108.021] ExoPlaSim: Exoplanet climate simulator

ExoPlaSim extends the PlaSim (ascl:2107.019) 3D general climate model to terrestrial exoplanets. It includes the PlaSim general circulation model and modifications that allow this code to run tidally-locked planets, planets with substantially different surface pressures than Earth, planets orbiting stars with different effective temperatures, super-Earths, and more. ExoPlaSim includes the ability to compute carbon-silicate weathering, dynamic orography through the glacier module (though only accumulation and ablation/evaporation/melting are included; glacial flow and spreading are not), and storm climatology.

[ascl:1407.008] Exopop: Exoplanet population inference

Exopop is a general hierarchical probabilistic framework for making justified inferences about the population of exoplanets. Written in python, it requires that the occurrence rate density be a smooth function of period and radius (employing a Gaussian process) and takes survey completeness and observational uncertainties into account. Exopop produces more accurate estimates of the whole population than standard procedures based on weighting by inverse detection efficiency.

[ascl:1603.010] ExoPriors: Accounting for observational bias of transiting exoplanets

ExoPriors calculates a log-likelihood penalty for an input set of transit parameters to account for observational bias (geometric and signal-to-noise ratio detection bias) of transiting exoplanets. Written in Python, the code calculates this log-likelihood penalty in one of seven user-specified cases specified with Boolean input parameters for geometric and/or SNR bias, grazing or non-grazing events, and occultation events.

[ascl:2210.006] ExoRad2: Generic point source radiometric model

ExoRad 2.0, a generic point source radiometric model, interfaces with any instrument to provide an estimate of several Payload performance metrics. For each target and for each photometric and spectroscopic channel, the code provides estimates of signals in pixels, saturation times, and read, photon, and dark current noise. ExoRad also provides estimates for the zodiacal background, inner sanctum, and sky foreground.

[ascl:1501.012] Exorings: Exoring modelling software

Exorings, written in Python, contains tools for displaying and fitting giant extrasolar planet ring systems; it uses FITS formatted data for input.

[ascl:1703.008] exorings: Exoring Transit Properties

Exorings is suitable for surveying entire catalogs of transiting planet candidates for exoring candidates, providing a subset of objects worthy of more detailed light curve analysis. Moreover, it is highly suited for uncovering evidence of a population of ringed planets by comparing the radius anomaly and PR-effects in ensemble studies.

[ascl:2002.019] ExoRT: Two-stream radiative transfer code

ExoRT is a flexible, two-stream radiative transfer code that interfaces with CAM/CESM (http://www.cesm.ucar.edu/models/current.html) or 1D offline; it is also used with ExoCAM (ascl:2002.020). Quadrature is used for shortwave and hemispheric mean is used for longwave. The gas phase optical depths are calculate using a correlated K-distribution method, with overlapping bands treated using an amount weighted scheme. Cloud optics are treated using mie scattering for both liquid and ice clouds, and cloud overlap is treated using Monte Carlo Independent Column Approximation.

[ascl:2002.008] ExoSim: Simulator for predicting signal and noise in transit spectroscopy observations

ExoSim models host star and planet transit events, simulating the temporal change in stellar flux due to the light curve. It is wavelength-dependent, using an input planet spectrum to determine the light curve depth for any given wavelength and can capture temporal effects, such as correlated noise. ExoSim's star spot simulator produces simulated observations that include spot and facula contamination. The code is flexible and can be generically applied to different instruments that simulate specific time-dependent processes.

[ascl:1706.010] EXOSIMS: Exoplanet Open-Source Imaging Mission Simulator

EXOSIMS generates and analyzes end-to-end simulations of space-based exoplanet imaging missions. The software is built up of interconnecting modules describing different aspects of the mission, including the observatory, optical system, and scheduler (encoding mission rules) as well as the physical universe, including the assumed distribution of exoplanets and their physical and orbital properties. Each module has a prototype implementation that is inherited by specific implementations for different missions concepts, allowing for the simulation of widely variable missions.

[ascl:1708.023] ExoSOFT: Exoplanet Simple Orbit Fitting Toolbox

ExoSOFT provides orbital analysis of exoplanets and binary star systems. It fits any combination of astrometric and radial velocity data, and offers four parameter space exploration techniques, including MCMC. It is packaged with an automated set of post-processing and plotting routines to summarize results, and is suitable for performing orbital analysis during surveys with new radial velocity and direct imaging instruments.

[ascl:2001.011] ExoTETHyS: Exoplanetary transits and eclipsing binaries modeler

ExoTETHyS models exoplanetary transits, eclipsing binaries, and related phenomena. The package calculates stellar limb-darkening coefficients down to <10 parts per million (ppm) and generates an exact transit light-curve based on the entire stellar intensity profile rather than limb-darkening coefficients.

[ascl:2302.009] EXOTIC: EXOplanet Transit Interpretation Code

EXOTIC (EXOplanet Transit Interpretation Code) analyzes photometric data of transiting exoplanets into lightcurves and retrieves transit epochs and planetary radii. The software reduces images of a transiting exoplanet into a lightcurve, and fits a model to the data to extract planetary information crucial to increasing the efficiency of larger observational platforms. EXOTIC is written in Python and supports the citizen science project Exoplanet Watch. The software runs on Windows, Macintosh, and Linux/Unix computer, and can also be used via Google Colab.

[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:2203.002] exoVista: Planetary systems generator

exoVista generates a "universe" of planetary systems, creating thousands of models of quasi-self-consistent planetary systems around known nearby stars at scattered light wavelengths. It efficiently records the position, velocity, spectrum, and physical parameters of all bodies as functions of time. exoVista models can be used for simulating surveys using the direct imaging, transit, astrometric, and radial velocity techniques.

[ascl:1902.009] ExPRES: Exoplanetary and Planetary Radio Emissions Simulator

ExPRES (Exoplanetary and Planetary Radio Emission Simulator) reproduces the occurrence of CMI-generated radio emissions from planetary magnetospheres, exoplanets or star-planet interacting systems in time-frequency plane, with special attention given to computation of the radio emission beaming at and near its source. Physical information drawn from such radio observations may include the location and dynamics of the radio sources, the type of current system leading to electron acceleration and their energy and, for exoplanetary systems, the magnetic field strength, the orbital period of the emitting body and the rotation period, tilt and offset of the planetary magnetic field. Most of these parameters can be remotely measured only via radio observations. ExPRES code provides the proper framework of analysis and interpretation for past (Cassini, Voyager, Galileo), current (Juno, ground-based radio telescopes) and future (BepiColombo, Juice) observations of planetary radio emissions, as well as for future detection of radio emissions from exoplanetary systems.

[ascl:1212.013] EXSdetect: Extended X-ray Source Detection

EXSdetect is a python implementation of an X-ray source detection algorithm which is optimally designed to detected faint extended sources and makes use of Voronoi tessellation and Friend-of-Friend technique. It is a flexible tool capable of detecting extended sources down to the lowest flux levels attainable within instrumental limitations while maintaining robust photometry, high completeness, and low contamination, regardless of source morphology. EXSdetect was developed mainly to exploit the ever-increasing wealth of archival X-ray data, but is also ideally suited to explore the scientific capabilities of future X-ray facilities, with a strong focus on investigations of distant groups and clusters of galaxies.

[ascl:9906.002] EXTINCT: A computerized model of large-scale visual interstellar extinction

The program EXTINCT.FOR is a FORTRAN subroutine summarizing a three-dimensional visual Galactic extinction model, based on a number of published studies. INPUTS: Galactic latitude (degrees), Galactic longitude (degrees), and source distance (kpc). OUTPUTS (magnitudes): Extinction, extinction error, a statistical correction term, and an array containing extinction and extinction error from each subroutine. The model is useful for correcting visual magnitudes of Galactic sources (particularly in statistical models), and has been used to find Galactic extinction of extragalactic sources. The model's limited angular resolution (subroutine-dependent, but with a minimum resolution of roughly 2 degrees) is necessitated by its ability to describe three-dimensional structure.

[ascl:1708.025] extinction-distances: Estimating distances to dark clouds

Extinction-distances uses the number of foreground stars and a Galactic model of the stellar distribution to estimate the distance to dark clouds. It exploits the relatively narrow range of intrinsic near-infrared colors of stars to separate foreground from background stars. An advantage of this method is that the distribution of stellar colors in the Galactic model need not be precisely correct, only the number density as a function of distance from the Sun.

[ascl:2102.026] extinction: Dust extinction laws

extinction is an implementation of fast interstellar dust extinction laws in Python. It contains Cython-optimized implementations of empirical dust extinction laws found in the literature. Flux values can be reddened or dereddened using included functions, and all extinction laws accept a unit keyword to change the interpretation of the wavelength array from Angstroms to inverse microns. Part of this code originated in the specutils package (ascl:1902.012).

[ascl:1803.011] ExtLaw_H18: Extinction law code

ExtLaw_H18 generates the extinction law between 0.8 - 2.2 microns. The law is derived using the Westerlund 1 (Wd1) main sequence (A_Ks ~ 0.6 mag) and Arches cluster field Red Clump at the Galactic Center (A_Ks ~ 2.7 mag). To derive the law a Wd1 cluster age of 5 Myr is assumed, though changing the cluster age between 4 Myr -- 7 Myr has no effect on the law. This extinction law can be applied to highly reddened stellar populations that have similar foreground material as Wd1 and the Arches RC, namely dust from the spiral arms of the Milky Way in the Galactic Plane.

[ascl:2305.003] extrapops: Fast simulation and analysis of extra-galactic binary GW sources

extrapops simulates extra-galactic populations of gravitational waves sources and models their emission during the inspiral phase. The code approximately assesses the detectability of individual sources by LISA and computes the background due to unresolved sources in the LISA band using different methods. The simulated populations can be saved in a format compatible with LISA LDC. Simulations are well calibrated to produce accurate background calculations and fair random generation at the tails of the distributions, which is important for accurate probability of detectable events. extrapops uses a number of ad-hoc techniques for rapid simulation and allows room for further optimization up to almost 1 order of magnitude.

[ascl:1010.032] Extreme Deconvolution: Density Estimation using Gaussian Mixtures in the Presence of Noisy, Heterogeneous and Incomplete Data

Extreme-deconvolution is a general algorithm to infer a d-dimensional distribution function from a set of heterogeneous, noisy observations or samples. It is fast, flexible, and treats the data's individual uncertainties properly, to get the best description possible for the underlying distribution. It performs well over the full range of density estimation, from small data sets with only tens of samples per dimension, to large data sets with hundreds of thousands of data points.

[ascl:1010.061] EyE: Enhance Your Extraction

In EyE (Enhance Your Extraction) an artificial neural network connected to pixels of a moving window (retina) is trained to associate these input stimuli to the corresponding response in one or several output image(s). The resulting filter can be loaded in SExtractor (ascl:1010.064) to operate complex, wildly non-linear filters on astronomical images. Typical applications of EyE include adaptive filtering, feature detection and cosmetic corrections.

[ascl:1407.019] EZ_Ages: Stellar population age calculator

EZ_Ages is an IDL code package that computes the mean, light-weighted stellar population age, [Fe/H], and abundance enhancements [Mg/Fe], [C/Fe], [N/Fe], and [Ca/Fe] for unresolved stellar populations. This is accomplished by comparing Lick index line strengths between the data and the stellar population models of Schiavon (2007), using a method described in Graves & Schiavon (2008). The algorithm uses the inversion of index-index model grids to determine ages and abundances, and exploits the sensitivities of the various Lick indices to measure Mg, C, N, and Ca enhancements over their solar abundances with respect to Fe.

[ascl:1210.004] EZ: A Tool For Automatic Redshift Measurement

EZ (Easy-Z) estimates redshifts for extragalactic objects. It compares the observed spectrum with a set of (user given) spectral templates to find out the best value for the redshift. To accomplish this task, it uses a highly configurable set of algorithms. EZ is easily extendible with new algorithms. It is implemented as a set of C programs and a number of python classes. It can be used as a standalone program, or the python classes can be directly imported by other applications.

[ascl:1208.021] EzGal: A Flexible Interface for Stellar Population Synthesis Models

EzGal is a flexible Python program which generates observable parameters (magnitudes, colors, and mass-to-light ratios) for arbitrary input stellar population synthesis (SPS) models; it enables simple, direct comparison of different model sets so that the uncertainty introduced by choice of model set can be quantified. EzGal is also capable of generating composite stellar population models (CSPs) for arbitrary input star-formation histories and reddening laws, and can be used to interpolate between metallicities for a given model set.

[ascl:2201.001] EzTao: Easier CARMA Modeling

EzTao models time series as a continuous-time autoregressive moving-average (CARMA) process. EzTao utilizes celerite (ascl:1709.008), a fast and scalable Gaussian Process Regression library, to evaluate the likelihood function. On average, EzTao is ten times faster than other tools relying on a Kalman filter for likelihood computation.

[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:2307.062] FABADA: Non-parametric noise reduction using Bayesian inference

FABADA (Fully Adaptive Bayesian Algorithm for Data Analysis) performs non-parametric noise reduction using Bayesian inference. It iteratively evaluates possible smoothed models of the data to estimate the underlying signal that is statistically compatible with the noisy measurements. Iterations stop based on the evidence E and the χ2 statistic of the last smooth model, and the expected value of the signal is computed as a weighted average of the smooth models. Though FABADA was written for astronomical data, such as spectra (1D) or images (2D), it can be used as a general noise reduction algorithm for any one- or two-dimensional data; the only requisite of the input data is an estimation of its associated variance.

[ascl:1802.001] FAC: Flexible Atomic Code

FAC calculates various atomic radiative and collisional processes, including radiative transition rates, collisional excitation and ionization by electron impact, energy levels, photoionization, and autoionization, and their inverse processes radiative recombination and dielectronic capture. The package also includes a collisional radiative model to construct synthetic spectra for plasmas under different physical conditions.

[ascl:2306.038] FacetClumps: Molecular clump detection algorithm based on Facet model

FacetClumps extracts and analyses clumpy structure in molecular clouds. Written in Python and based on the Gaussian Facet model, FacetClumps extracts signal regions using morphology, and segments the signal regions into local regions with a gradient-based method. It then applies a connectivity-based minimum distance clustering method to cluster the local regions to the clump centers. FacetClumps automatically adjusts its parameters to local situations to improve adaptability, and is optimized to detect faint and overlapping clumps.

[ascl:2210.024] Faiss: Similarity search and clustering of dense vectors library

The Faiss library performs efficient similarity search and clustering of dense vectors. It contains algorithms that search in sets of vectors of any size, up to ones that possibly do not fit in RAM. It also contains supporting code for evaluation and parameter tuning. Faiss is written in C++ with complete wrappers for Python/numpy. Some of the most useful algorithms are implemented on the GPU.

[ascl:2001.005] FAKEOBS: Model visibilities generator

The CASA (1107.013) task FAKEOBS generates model visibilities from already-existing measurement sets. This task can be used to substitute all the visibilities of the target with simulations computed from any model image. The measurement can either be with real or simulated data, the target can have been observed in mosaic mode, and there can be several sources (e.g., bandpass calibrator, flux/phase calibrator, and target).

[ascl:2304.004] FALCO: Fast Linearized Coronagraph Optimizer in MATLAB

FALCO (Fast Linearized Coronagraph Optimizer) performs coronagraphic focal plane wavefront correction. It includes routines for pair-wise probing estimation of the complex electric field and Electric Field Conjugation (EFC) control. FALCO utilizes and builds upon PROPER (ascl:1405.006) and rapidly computes the linearized response matrix for each DM, which facilitates re-linearization after each control step for faster DM-integrated coronagraph design and wavefront correction experiments. A Python 3 implementation of FALCO (ascl:2304.005) is also available.

[ascl:2304.005] FALCO: Fast Linearized Coronagraph Optimizer in Python

FALCO (Fast Linearized Coronagraph Optimizer) performs coronagraphic focal plane wavefront correction. It includes routines for pair-wise probing estimation of the complex electric field and Electric Field Conjugation (EFC) control. FALCO utilizes and builds upon PROPER (ascl:1405.006) and rapidly computes the linearized response matrix for each DM, which facilitates re-linearization after each control step for faster DM-integrated coronagraph design and wavefront correction experiments. A MATLAB implementation of FALCO (ascl:2304.004) is also available.

[ascl:2205.004] FAlCon-DNS: Framework of time schemes for direct numerical simulation of annular convection

FAlCon-DNS (Framework of time schemes for direct numerical simulation of annular convection) solves for 2-D convection in an annulus and analyzes different time integration schemes. The framework contains a suite of IMEX, IMEXRK and RK time integration schemes. The code uses a pseudospectral method for spatial discretization. The governing equations contain both numerically stiff (diffusive) and non-stiff (advective) components for time discretization. The software offers OpenMP for parallelization.

[ascl:1509.004] FalconIC: Initial conditions generator for cosmological N-body simulations in Newtonian, Relativistic and Modified theories

FalconIC generates discrete particle positions, velocities, masses and pressures based on linear Boltzmann solutions that are computed by libraries such as CLASS and CAMB. FalconIC generates these initial conditions for any species included in the selection, including Baryons, Cold Dark Matter and Dark Energy fluids. Any species can be set in Eulerian (on a fixed grid) or Lagrangian (particle motion) representation, depending on the gauge and reality chosen. That is, for relativistic initial conditions in the synchronous comoving gauge, Dark Matter can only be described in an Eulerian representation. For all other choices (Relativistic in Longitudinal gauge, Newtonian with relativistic expansion rates, Newtonian without any notion of radiation), all species can be treated in all representations. The code also computes spectra. FalconIC is useful for comparative studies on initial conditions.

[ascl:1402.016] FAMA: Fast Automatic MOOG Analysis

FAMA (Fast Automatic MOOG Analysis), written in Perl, computes the atmospheric parameters and abundances of a large number of stars using measurements of equivalent widths (EWs) automatically and independently of any subjective approach. Based on the widely-used MOOG code, it simultaneously searches for three equilibria, excitation equilibrium, ionization balance, and the relationship between logn(FeI) and the reduced EWs. FAMA also evaluates the statistical errors on individual element abundances and errors due to the uncertainties in the stellar parameters. Convergence criteria are not fixed "a priori" but instead are based on the quality of the spectra.

[ascl:2006.021] FAMED: Extraction and mode identification of oscillation frequencies for solar-like pulsators

The FAMED (Fast and AutoMated pEak bagging with Diamonds) pipeline is a multi-platform parallelized software that performs and automates extraction and mode identification of oscillation frequencies for solar-like pulsators. The pipeline can be applied to a large variety of stars, ranging from hot F-type main sequence, up to stars evolving along the red giant branch, settled into the core-Helium-burning main sequence, and even evolved beyond towards the early asymptotic giant branch. FAMED is based on DIAMONDS (ascl:1410.001), a Bayesian parameter estimation and model comparison by means of the nested sampling Monte Carlo (NSMC) algorithm.

[ascl:1209.014] FAMIAS: Frequency Analysis and Mode Identification for AsteroSeismology

FAMIAS (Frequency Analysis and Mode Identification for Asteroseismology) is a package of software tools programmed in C++ for the analysis of photometric and spectroscopic time-series data. FAMIAS provides analysis tools that are required for the steps between the data reduction and the seismic modeling. Two main sets of tools are incorporated in FAMIAS. The first set permits to search for periodicities in the data using Fourier and non-linear least-squares fitting techniques. The other set permits to carry out a mode identification for the detected pulsation frequencies to determine their harmonic degree l, and azimuthal order m. FAMIAS is applicable to main-sequence pulsators hotter than the Sun. This includes Gamma Dor, Delta Sct stars, slowly pulsating B (SPB)-stars and Beta Cep stars - basically all stars for which empirical mode identification is required to successfully carry out asteroseismology.

[ascl:1102.017] FARGO: Fast Advection in Rotating Gaseous Objects

FARGO is an efficient and simple modification of the standard transport algorithm used in explicit eulerian fixed polar grid codes, aimed at getting rid of the average azimuthal velocity when applying the Courant condition. This results in a much larger timestep than the usual procedure, and it is particularly well-suited to the description of a Keplerian disk where one is traditionally limited by the very demanding Courant condition on the fast orbital motion at the inner boundary. In this modified algorithm, the timestep is limited by the perturbed velocity and by the shear arising from the differential rotation. The speed-up resulting from the use of the FARGO algorithm is problem dependent. In the example presented in the code paper below, which shows the evolution of a Jupiter sized protoplanet embedded in a minimum mass protoplanetary nebula, the FARGO algorithm is about an order of magnitude faster than a traditional transport scheme, with a much smaller numerical diffusivity.

[ascl:1509.006] FARGO3D: Hydrodynamics/magnetohydrodynamics code

A successor of FARGO (ascl:1102.017), FARGO3D is a versatile HD/MHD code that runs on clusters of CPUs or GPUs, with special emphasis on protoplanetary disks. FARGO3D offers Cartesian, cylindrical or spherical geometry; 1-, 2- or 3-dimensional calculations; and orbital advection (aka FARGO) for HD and MHD calculations. As in FARGO, a simple Runge-Kutta N-body solver may be used to describe the orbital evolution of embedded point-like objects. There is no need to know CUDA; users can develop new functions in C and have them translated to CUDA automatically to run on GPUs.

[ascl:2311.014] FASMA: Stellar spectral analysis package

FASMA delivers the atmospheric stellar parameters (effective temperature, surface gravity, metallicity, microturbulence, macroturbulence, and rotational velocity) based on the spectral synthesis technique. This technique relies on the comparison of synthetic spectra with observations to yield the best-fit parameters under a χ2 minimization process. FASMA also delivers chemical abundances of 13 elements. Written in Python, the code is wrapped around MOOG (ascl:1202.009) which calculates the synthetic spectra. FASMA includes two grids of models in MOOG readable format, Kurucz and marcs, that cover the parameter space for both dwarf and giant stars with metallicity limit of -5.0 dex.

[ascl:1010.010] Fast WMAP Likelihood Code and GSR PC Functions

We place functional constraints on the shape of the inflaton potential from the cosmic microwave background through a variant of the generalized slow roll approximation that allows large amplitude, rapidly changing deviations from scale-free conditions. Employing a principal component decomposition of the source function G'~3(V'/V)^2 - 2V''/V and keeping only those measured to better than 10% results in 5 nearly independent Gaussian constraints that maybe used to test any single-field inflationary model where such deviations are expected. The first component implies < 3% variations at the 100 Mpc scale. One component shows a 95% CL preference for deviations around the 300 Mpc scale at the ~10% level but the global significance is reduced considering the 5 components examined. This deviation also requires a change in the cold dark matter density which in a flat LCDM model is disfavored by current supernova and Hubble constant data and can be tested with future polarization or high multipole temperature data. Its impact resembles a local running of the tilt from multipoles 30-800 but is only marginally consistent with a constant running beyond this range. For this analysis, we have implemented a ~40x faster WMAP7 likelihood method which we have made publicly available.

[ascl:1603.006] FAST-PT: Convolution integrals in cosmological perturbation theory calculator

FAST-PT calculates 1-loop corrections to the matter power spectrum in cosmology. The code utilizes Fourier methods combined with analytic expressions to reduce the computation time down to scale as N log N, where N is the number of grid point in the input linear power spectrum. FAST-PT is extremely fast, enabling mode-coupling integral computations fast enough to embed in Monte Carlo Markov Chain parameter estimation.

[ascl:1803.008] FAST: Fitting and Assessment of Synthetic Templates

FAST (Fitting and Assessment of Synthetic Templates) fits stellar population synthesis templates to broadband photometry and/or spectra. FAST is compatible with the photometric redshift code EAzY (ascl:1010.052) when fitting broadband photometry; it uses the photometric redshifts derived by EAzY, and the input files (for examply, photometric catalog and master filter file) are the same. FAST fits spectra in combination with broadband photometric data points or simultaneously fits two components, allowing for an AGN contribution in addition to the host galaxy light. Depending on the input parameters, FAST outputs the best-fit redshift, age, dust content, star formation timescale, metallicity, stellar mass, star formation rate (SFR), and their confidence intervals. Though some of FAST's functions overlap with those of HYPERZ (ascl:1108.010), it differs by fitting fluxes instead of magnitudes, allows the user to completely define the grid of input stellar population parameters and easily input photometric redshifts and their confidence intervals, and calculates calibrated confidence intervals for all parameters. Note that FAST is not a photometric redshift code, though it can be used as one.

[ascl:2301.010] Fastcc: Broadband radio telescope receiver fast color corrections

Fastcc returns color corrections for different spectra for various Cosmic Microwave Background experiments. Available in both Python and IDL, the script is easy to use when analyzing radio spectra of sources with data from multiple wide-survey CMB experiments in a consistent way across multiple experiments.

[ascl:1804.025] FastChem: An ultra-fast equilibrium chemistry

FastChem is an equilibrium chemistry code that calculates the chemical composition of the gas phase for given temperatures and pressures. Written in C++, it is based on a semi-analytic approach and is optimized for extremely fast and accurate calculations.

[ascl:1010.037] FastChi: A Fast Chi-squared Technique For Period Search of Irregularly Sampled Data

The Fast Chi-Squared Algorithm is a fast, powerful technique for detecting periodicity. It was developed for analyzing variable stars, but is applicable to many of the other applications where the Fast Fourier Transforms (FFTs) or other periodograms (such as Lomb-Scargle) are currently used. The Fast Chi-squared technique takes a data set (e.g. the brightness of a star measured at many different times during a series of observations) and finds the periodic function that has the best frequency and shape (to an arbitrary number of harmonics) to fit the data. Among its advantages are:

  • Statistical efficiency: all of the data are used, weighted by their individual error bars, giving a result with a significance calibrated in well-understood Chi-squared statistics.
  • Sensitivity to harmonic content: many conventional techniques look only at the significance (or the amplitude) of the fundamental sinusoid and discard the power of the higher harmonics.
  • Insensitivity to the sample timing: you won't find a period of 24 hours just because you take your observations at night. You do not need to window your data.
  • The frequency search is gridded more tightly than the traditional "integer number of cycles over the span of observations", eliminating power loss from peaks that fall between the grid points.
  • Computational speed: The complexity of the algorithm is O(NlogN), where N is the number of frequencies searched, due to its use of the FFT.

[ascl:1908.025] FastCSWT: Fast directional Continuous Spherical Wavelet Transform

FastCSWT performs a directional continuous wavelet transform on the sphere. The transform is based on the construction of the continuous spherical wavelet transform (CSWT) developed by Antoine and Vandergheynst (1999). A fast implementation of the CSWT (based on the fast spherical convolution developed by Wandelt and Gorski 2001) is also provided.

[ascl:2212.004] FastDF: Integrating neutrino geodesics in linear theory

FastDF (Fast Distribution Function) integrates relativistic particles along geodesics in a comoving periodic volume with forces determined by cosmological linear perturbation theory. Its main application is to set up accurate particle realizations of the linear phase-space distribution of massive relic neutrinos by starting with an analytical solution deep in radiation domination. Such particle realizations are useful for Monte Carlo experiments and provide consistent initial conditions for cosmological N-body simulations. Gravitational forces are calculated from three-dimensional potential grids, which are obtained by convolving random phases with linear transfer functions using Fast Fourier Transforms. The equations of motion are solved using a symplectic leapfrog integration scheme to conserve phase-space density and prevent the build-up of errors. Particles can be exported in different gauges and snapshots are provided in the HDF5 format, compatible with N-body codes like SWIFT (ascl:1805.020) and Gadget-4 (ascl:2204.014). The code has an interface with CLASS (ascl:1106.020) for calculating transfer functions and with monofonIC (ascl:2008.024) for setting up initial conditions with dark matter, baryons, and neutrinos.

[ascl:9910.003] FASTELL: Fast calculation of a family of elliptical mass gravitational lens models

Because of their simplicity, axisymmetric mass distributions are often used to model gravitational lenses. Since galaxies are usually observed to have elliptical light distributions, mass distributions with elliptical density contours offer more general and realistic lens models. They are difficult to use, however, since previous studies have shown that the deflection angle (and magnification) in this case can only be obtained by rather expensive numerical integrations. We present a family of lens models for which the deflection can be calculated to high relative accuracy (10-5) with a greatly reduced numerical effort, for small and large ellipticity alike. This makes it easier to use these distributions for modeling individual lenses as well as for applications requiring larger computing times, such as statistical lensing studies. FASTELL is a code to calculate quickly and accurately the lensing deflection and magnification matrix for the softened power-law elliptical mass distribution (SPEMD) lens galaxy model. The SPEMD consists of a softened power-law radial distribution with elliptical isodensity contours.

[ascl:2303.013] FastJet: Jet finding in pp and e+e− collisions

The FastJet package provides fast native implementations of many sequential recombination algorithms, including the longitudinally invariant kt longitudinally invariant inclusive Cambridge/Aachen and anti-kt jet finders. It also provides a uniform interface to external jet finders via a plugin mechanism. FastJet also includes tools for calculating jet areas and performing background (pileup/UE) subtraction and for jet substructure analyses.

[ascl:1010.041] FASTLens (FAst STatistics for weak Lensing): Fast Method for Weak Lensing Statistics and Map Making

The analysis of weak lensing data requires to account for missing data such as masking out of bright stars. To date, the majority of lensing analyses uses the two point-statistics of the cosmic shear field. These can either be studied directly using the two-point correlation function, or in Fourier space, using the power spectrum. The two-point correlation function is unbiased by missing data but its direct calculation will soon become a burden with the exponential growth of astronomical data sets. The power spectrum is fast to estimate but a mask correction should be estimated. Other statistics can be used but these are strongly sensitive to missing data. The solution that is proposed by FASTLens is to properly fill-in the gaps with only NlogN operations, leading to a complete weak lensing mass map from which one can compute straight forwardly and with a very good accuracy any kind of statistics like power spectrum or bispectrum.

[ascl:1302.008] FASTPHOT: A simple and quick IDL PSF-fitting routine

PSF fitting photometry allows a simultaneously fit of a PSF profile on the sources. Many routines use PSF fitting photometry, including IRAF/allstar, Strarfinder, and Convphot. These routines are in general complex to use and slow. FASTPHOT is optimized for prior extraction (the position of the sources is known) and is very fast and simple.

[ascl:1905.010] FastPM: Scaling N-body Particle Mesh solver

FastPM solves the gravity Possion equation with a boosted particle mesh. Arbitrary time steps can be used. The code is intended to study the formation of large scale structure and supports plain PM and Comoving-Lagranian (COLA) solvers. A broadband correction enforces the linear theory model growth factor at large scale. FastPM scales extremely well to hundred thousand MPI ranks, which is possible through the use of the PFFT Fourier Transform library. The size of mesh in FastPM can vary with time, allowing one to use coarse force mesh at high redshift with increase temporal resolution for accurate large scale modes. The code supports a variety of Greens function and differentiation kernels, though for most practical simulations the choice of kernels does not make a difference. A parameter file interpreter is provided to validate and execute the configuration files without running the simulation, allowing creative usages of the configuration files.

[ascl:2209.020] FastQSL: Quasi-separatrix Layers computation method

FastQSL calculate the squashing factor Q at the photosphere, a cross section, or a box volume, given a 3D magnetic field with Cartesian, uniform or stretched grids. It is available in IDL and in an optimized version using Fortran for calculations and field line tracing. Use of a GPU accelerates a step-size adaptive scheme for the most computationally intensive part, the field line tracing, making the code fast and efficient.

[submitted] fastrometry: Fast world coordinate solution solver

Fastrometry is a Python implementation of the fast world coordinate solution solver for the FITS standard astronomical image. When supplied with the approximate field center (+-25%) and the approximate field scale (+-10%) of the telescope and detector system the astronomical image is from, fastrometry provides WCS solutions almost instantaneously. The algorithm is also originally implemented with parallelism enabled in the Windows FITS image processor and viewer CCDLAB (ascl:2206.021).

[ascl:2211.011] fastSHT: Fast Spherical Harmonic Transforms

fastSHT performs spherical harmonic transforms on a large number of spherical maps. It converts massive SHT operations to a BLAS level 3 problem and uses the highly optimized matrix multiplication toolkit to accelerate the computation. GPU acceleration is supported and can be very effective. The core code is written in Fortran, but a Python wrapper is provided and recommended.

[ascl:2308.005] FastSpecFit: Fast spectral synthesis and emission-line fitting of DESI spectra

FastSpecFit models the observed-frame optical spectroscopy and broadband photometry of extragalactic targets using physically grounded stellar continuum and emission-line templates. The code handles data from the Dark Energy Spectroscopic Instrument (DESI) Survey, which is amassing spectrophotometry for an unprecedented 40 million extragalactic targets, although the algorithms are general enough to accommodate other upcoming, massively multiplexed spectroscopic surveys. FastSpecFit extracts nearly 800 observed- and rest-frame quantities from each target, including light-weighted ages and stellar velocity dispersions based on the underlying stellar continuum; line-widths, velocity shifts, integrated fluxes, and equivalent widths for nearly 40 rest-frame ultraviolet, optical, and near-infrared emission lines arising from both star formation and active galactic nuclear activity; and K-corrections and rest-frame absolute magnitudes and colors. Moreover, FastSpecFit is designed with speed and parallelism in mind, enabling it to deliver robust model fits to tens of millions of targets.

[ascl:1507.011] FAT: Fully Automated TiRiFiC

FAT (Fully Automated TiRiFiC) is an automated procedure that fits tilted-ring models to Hi data cubes of individual, well-resolved galaxies. The method builds on the 3D Tilted Ring Fitting Code (TiRiFiC, ascl:1208.008). FAT accurately models the kinematics and the morphologies of galaxies with an extent of eight beams across the major axis in the inclination range 20°-90° without the need for priors such as disc inclination. FAT's performance allows us to model the gas kinematics of many thousands of well-resolved galaxies, which is essential for future HI surveys, with the Square Kilometre Array and its pathfinders.

[ascl:1711.017] FATS: Feature Analysis for Time Series

FATS facilitates and standardizes feature extraction for time series data; it quickly and efficiently calculates a compilation of many existing light curve features. Users can characterize or analyze an astronomical photometric database, though this library is not necessarily restricted to the astronomical domain and can also be applied to any kind of time series data.

[ascl:2204.010] FBCTrack: Fragmentation and bulk composition tracking

The fragmentation and bulk composition tracking package contains two codes. The fragmentation code models fragmentation in collisions for the C version of REBOUND (ascl:1110.016). This code requires setting two global parameters. It automatically produces a collision report that details the time of every collision, the bodies involved, how the collision was resolved, and how many fragments were produced; collision outcomes are assigned a numerical value. The bulk composition tracking code tracks the composition change as a function of mass exchange for bodies with a homogenous composition. It is a post-processing code that works in conjunction with the fragmentation code, and requires the collision report generated by the fragmentation code.

[ascl:1712.011] FBEYE: Analyzing Kepler light curves and validating flares

FBEYE, the "Flares By-Eye" detection suite, is written in IDL and analyzes Kepler light curves and validates flares. It works on any 3-column light curve that contains time, flux, and error. The success of flare identification is highly dependent on the smoothing routine, which may not be suitable for all sources.

[ascl:2302.015] FCFC: C toolkit for computing correlation functions from pair counts

FCFC (Fast Correlation Function Calculator) computes correlation functions from pair counts. It supports the isotropic 2-point correlation function, anisotropic 2PCF, 2-D 2PCF, and 2PCF Legendre multipoles, among others. Written in C, FCFC takes advantage of three parallelisms that can be used simultaneously, distributed-memory processes via Message Passing Interface (MPI), shared-memory threads via Open Multi-Processing (OpenMP), and single instruction, multiple data (SIMD).

[ascl:1505.014] FCLC: Featureless Classification of Light Curves

FCLC (Featureless Classification of Light Curves) software describes the static behavior of a light curve in a probabilistic way. Individual data points are converted to densities and consequently probability density are compared instead of features. This gives rise to an independent classification which can corroborate the usefulness of the selected features.

[ascl:1806.027] fcmaker: Creating ESO-compliant finding charts for Observing Blocks on p2

fcmaker creates astronomical finding charts for Observing Blocks (OBs) on the p2 web server from the European Southern Observatory (ESO). It automates the creation of ESO-compliant finding charts for Service Mode and/or Visitor Mode OBs at the Very Large Telescope (VLT). The design of the fcmaker finding charts, based on an intimate knowledge of VLT observing procedures, is fine-tuned to best support night time operations. As an automated tool, fcmaker also allows observers to independently check visually, for the first time, the observing sequence coded inside an OB. This includes, for example, the signs of telescope and position angle offsets.

[ascl:1705.012] fd3: Spectral disentangling of double-lined spectroscopic binary stars

The spectral disentangling technique can be applied on a time series of observed spectra of a spectroscopic double-lined binary star (SB2) to determine the parameters of orbit and reconstruct the spectra of component stars, without the use of template spectra. fd3 disentangles the spectra of SB2 stars, capable also of resolving the possible third companion. It performs the separation of spectra in the Fourier space which is faster, but in several respects less versatile than the wavelength-space separation. (Wavelength-space separation is implemented in the twin code CRES.) fd3 is written in C and is designed as a command-line utility for a Unix-like operating system. fd3 is a new version of FDBinary (ascl:1705.011), which is now deprecated.

[ascl:1705.011] FDBinary: A tool for spectral disentangling of double-lined spectroscopic binary stars

FDBinary disentangles spectra of SB2 stars. The spectral disentangling technique can be applied on a time series of observed spectra of an SB2 to determine the parameters of orbit and reconstruct the spectra of component stars, without the use of template spectra. The code is written in C and is designed as a command-line utility for a Unix-like operating system. FDBinary uses the Fourier-space approach in separation of composite spectra. This code has been replaced with the newer fd3 (ascl:1705.012).

[ascl:1606.011] FDIPS: Finite Difference Iterative Potential-field Solver

FDIPS is a finite difference iterative potential-field solver that can generate the 3D potential magnetic field solution based on a magnetogram. It is offered as an alternative to the spherical harmonics approach, as when the number of spherical harmonics is increased, using the raw magnetogram data given on a grid that is uniform in the sine of the latitude coordinate can result in inaccurate and unreliable results, especially in the polar regions close to the Sun. FDIPS is written in Fortran 90 and uses the MPI library for parallel execution.

[ascl:1604.011] FDPS: Framework for Developing Particle Simulators

FDPS provides the necessary functions for efficient parallel execution of particle-based simulations as templates independent of the data structure of particles and the functional form of the interaction. It is used to develop particle-based simulation programs for large-scale distributed-memory parallel supercomputers. FDPS includes templates for domain decomposition, redistribution of particles, and gathering of particle information for interaction calculation. It uses algorithms such as Barnes-Hut tree method for long-range interactions; methods to limit the calculation to neighbor particles are used for short-range interactions. FDPS reduces the time and effort necessary to write a simple, sequential and unoptimized program of O(N^2) calculation cost, and produces compiled programs that will run efficiently on large-scale parallel supercomputers.

[ascl:1806.001] feets: feATURE eXTRACTOR FOR tIME sERIES

feets characterizes and analyzes light-curves from astronomical photometric databases for modelling, classification, data cleaning, outlier detection and data analysis. It uses machine learning algorithms to determine the numerical descriptors that characterize and distinguish the different variability classes of light-curves; these range from basic statistical measures such as the mean or standard deviation to complex time-series characteristics such as the autocorrelation function. The library is not restricted to the astronomical field and could also be applied to any kind of time series. This project is a derivative work of FATS (ascl:1711.017).

[ascl:2110.018] FEniCS: Computing platform for solving partial differential equations

FEniCS solves partial differential equations (PDEs) and enables users to quickly translate scientific models into efficient finite element code. With the high-level Python and C++ interfaces to FEniCS, it is easy to get started, but FEniCS offers also powerful capabilities for more experienced programmers. FEniCS runs on a multitude of platforms ranging from laptops to high-performance clusters, and each component of the FEniCS platform has been fundamentally designed for parallel processing. This framework allows for rapid prototyping of finite element formulations and solvers on laptops and workstations, and the same code may then be deployed on large high-performance computers.

[ascl:1203.004] FERENGI: Full and Efficient Redshifting of Ensembles of Nearby Galaxy Images

Bandpass shifting and the (1+z)5 surface brightness dimming (for a fixed width filter) make standard tools for the extraction of structural parameters of galaxies wavelength dependent. If only few (or one) observed high-res bands exist, this dependence has to be corrected to make unbiased statements on the evolution of structural parameters or on galaxy subsamples defined by morphology. FERENGI artificially redshifts low-redshift galaxy images to different redshifts by applying the correct cosmological corrections for size, surface brightness and bandpass shifting. A set of artificially redshifted galaxies in the range 0.1<z<1.1 using a set of ~100 SDSS low-redshift (v<7000 km s-1) images as input has been created to use as a training set of realistic images of galaxies of diverse morphologies and a large range of redshifts for the GEMS and COSMOS galaxy evolution projects. This training set allows other studies to investigate and quantify the effects of cosmological redshift on the determination of galaxy morphologies, distortions, and other galaxy properties that are potentially sensitive to resolution, surface brightness, and bandpass issues. The data sets are also available for download from the FERENGI website.

[ascl:2201.008] fermi-gce-flows: Infer the Galactic Center gamma-ray excess

fermi-gce-flows uses a machine learning-based technique to characterize the contribution of modeled components, including unresolved point sources, to the GCE. It can perform posterior parameter estimation while accounting for pixel-to-pixel spatial correlations in the gamma-ray map. On application to Fermi data, the method generically attributes a smaller fraction of the GCE flux to unresolved point source-like emission when compared to traditional approaches.

[ascl:1812.006] Fermipy: Fermi-LAT data analysis package

Fermipy facilitates analysis of data from the Large Area Telescope (LAT) with the Fermi Science Tools. It is built on the pyLikelihood interface of the Fermi Science Tools and provides a set of high-level tools for performing common analysis tasks, including data and model preparation with the gt-tools, extracting a spectral energy distribution (SED) of a source, and generating TS and residual maps for a region of interest. Fermipy also finds new source candidates and can localize a source or fit its spatial extension. The package uses a configuration-file driven workflow in which the analysis parameters (data selection, IRFs, and ROI model) are defined in a YAML configuration file. Analysis is executed through a python script that calls the methods of GTAnalysis to perform different analysis operations.

[ascl:1905.011] Fermitools: Fermi Science Tools

Fermi Science Tools is a suite of tools for the analysis of both the Large-Area Telescope (LAT) and the Gamma-ray Burst Monitor (GBM) data, including point source analysis for generating maps, spectra, and light curves, pulsar timing analysis, and source identification.

[ascl:2301.016] FERRE: Match physical models to measurements

FERRE matches physical models to observed data, taking a set of observations and identifying the model parameters that best reproduce the data, in a chi-squared sense. It solves the common problem of having numerical parametric models that are costly to evaluate and need to be used to interpret large data sets. FERRE provides flexibility to search for all model parameters, or hold constant some of them while searching for others. The code is written to be truly N-dimensional and fast. Model predictions are to be given as an array whose values are a function of the model parameters, i.e., numerically. FERRE holds this array in memory, or in a direct-access binary file, and interpolates in it. The code returns, in addition to the optimal set of parameters, their error covariance, and the corresponding model prediction. The code is written in FORTRAN90.

[ascl:2005.014] FETCH: Fast Extragalactic Transient Candidate Hunter

FETCH (Fast Extragalactic Transient Candidate Hunter) provides real-time classification of candidates from single pulse search pipelines. The package takes in a candidate file of frequency-time and DM-time data and, for each candidate and choice of model, provides the probability that the candidate is an FRB. FETCH also provides a framework for fine-tuning the models to further improve its performance for particular backends.

[ascl:1208.011] Fewbody: Numerical toolkit for simulating small-N gravitational dynamics

Fewbody is a numerical toolkit for simulating small-N gravitational dynamics. It is a general N-body dynamics code, although it was written for the purpose of performing scattering experiments, and therefore has several features that make it well-suited for this purpose. Fewbody uses the 8th-order Runge-Kutta Prince-Dormand integration method with 9th-order error estimate and adaptive timestep to advance the N-body system forward in time. It integrates the usual formulation of the N-body equations in configuration space, but allows for the option of global pairwise Kustaanheimo-Stiefel (K-S) regularization (Heggie 1974; Mikkola 1985). The code uses a binary tree algorithm to classify the N-body system into a set of independently bound hierarchies, and performs collisions between stars in the “sticky star” approximation. Fewbody contains a collection of command line utilities that can be used to perform individual scattering and N-body interactions, but is more generally a library of functions that can be used from within other codes.

[ascl:2005.006] FFANCY: Fast Folding Algorithm for pulsar searching

FFANCY uses the Fast Folding Algorithm (FFA) on a distributed-computing framework to search for pulsars in time-domain series data. This enables the algorithm to be applied to all-sky blind pulsar surveys. The package runs an implementation of the FFA on real or simulated pulsar time series data in either SIGPROC (ascl:1107.016) or PRETSO (ascl:1107.017) format with a choice of additional algorithms to be used in the evaluation of each folded profile and outputs a periodogram along with other output threads used for testing. It also contains routines that convert the periodogram output into a list of pulsar candidates with options for candidate grouping and harmonic matching, generate simulated pulsar profiles for use in testing profile evaluation algorithms independent of the FFA, provide basic statistics for the folded profiles produced by progeny, test individual profiles using profiles produced by progeny, and other complementary functions.

[ascl:2208.010] FFD: Flare Frequency Distribution

FFD (Flare Frequency Distribution) fits power-laws to FFDs. FFDs relate the frequency (i.e., occurrence rate) of flares to their energy, peak flux, photometric equivalent width, or other parameters. This module was created to handle disparate datasets between which the flare detection limit varies; in essence, the number of flares detected is treated as following a Poisson distribution while the flare energies are treated as following a power law.

[ascl:1911.022] FFTLog-and-beyond: Generalized FFTLog algorithm

FFTLog-and-beyond takes the FFTLog algorithm for single-Bessel integrals and generalizes it for integrals containing a derivative of the Bessel function to solve the non-Limber integrals. The full non-Limber angular power spectrum integral is simplified by noting the small contribution from unequal-time nonlinear terms; this significantly reduces the computation and avoids the double-Bessel integral. The original FFTLog algorithm is also extended to compute integrals containing derivatives of Bessel functions, which can be used to efficiently compute angular power spectra including redshift-space distortions (RSD) and Doppler effects. C and Python versions of the code are available.

[ascl:1512.017] FFTLog: Fast Fourier or Hankel transform

FFTLog is a set of Fortran subroutines that compute the fast Fourier or Hankel (= Fourier-Bessel) transform of a periodic sequence of logarithmically spaced points. FFTLog can be regarded as a natural analogue to the standard Fast Fourier Transform (FFT), in the sense that, just as the normal FFT gives the exact (to machine precision) Fourier transform of a linearly spaced periodic sequence, so also FFTLog gives the exact Fourier or Hankel transform, of arbitrary order m, of a logarithmically spaced periodic sequence.

[ascl:1201.015] FFTW: Fastest Fourier Transform in the West

FFTW is a C subroutine library for computing the discrete Fourier transform (DFT) in one or more dimensions, of arbitrary input size, and of both real and complex data (as well as of even/odd data, i.e. the discrete cosine/sine transforms or DCT/DST).

Benchmarks performed on a variety of platforms show that FFTW's performance is typically superior to that of other publicly available FFT software, and is even competitive with vendor-tuned codes. In contrast to vendor-tuned codes, however, FFTW's performance is portable: the same program will perform well on most architectures without modification.

The FFTW library is required by other codes such as StarCrash (ascl:1010.074) and Hammurabi (ascl:1201.014).

[ascl:2307.021] FGBuster: Parametric component separation for Cosmic Microwave Background observations

FGBuster (ForeGroundBuster) separates frequency maps into component maps and forecasts component separation both when the model is correct and when it is incorrect. FGBuster can be used for SED evaluation, intermediate component separation, multi-resolution separation, and forecasting, among other tasks.

[ascl:1909.014] fgivenx: Functional posterior plotter

fgivenx plots a predictive posterior of a function, dependent on sampled parameters, for a Bayesian posterior Post(theta|D,M) described by a set of posterior samples {theta_i}~Post. If there is a function parameterized by theta y=f(x;theta), this script produces a contour plot of the conditional posterior P(y|x,D,M) in the (x,y) plane.

[ascl:2205.014] FHD: Fast Holographic Deconvolution

FHD is an open-source imaging algorithm for radio interferometers and is written in IDL. The three main use-cases for FHD are efficient image deconvolution for general radio astronomy, fast-mode Epoch of Reionization analysis, and simulation. FHD inputs beam models, calibration files, and sky model catalogs and requires input data to be in uvfits format.

[ascl:1603.014] fibmeasure: Python/Cython module to find the center of back-illuminated optical fibers in metrology images

fibmeasure finds the precise locations of the centers of back-illuminated optical fibers in images. It was developed for astronomical fiber positioning feedback via machine vision cameras and is optimized for high-magnification images where fibers appear as resolvable circles. It was originally written during the design of the WEAVE pick-and-place fiber positioner for the William Herschel Telescope.

[ascl:1111.013] FIBRE-pac: FMOS Image-based Reduction Package

The FIBRE-pac (FMOS image-based reduction package) is an IRAF-based reduction tool for the fiber multiple-object spectrograph (FMOS) of the Subaru telescope. To reduce FMOS images, a number of special techniques are necessary because each image contains about 200 separate spectra with airglow emission lines variable in spatial and time domains, and with complicated throughput patterns for the airglow masks. In spite of these features, almost all of the reduction processes except for a few steps are carried out automatically by scripts in text format making it easy to check the commands step by step. Wavelength- and flux-calibrated images together with their noise maps are obtained using this reduction package.

[ascl:2202.012] fiducial_flare: Spectra and lightcurves of a standardized far ultraviolet flare

fiducial_flare generates a reasonable approximation of the UV emission of M dwarf stars over a single flare or a series of them. The simulated radiation is resolved in both wavelength and time. The intent is to provide consistent input for applications requiring time-dependent stellar UV radiation fields that balances simplicity with realism, namely for simulations of exoplanet atmospheres.

[ascl:1307.004] FieldInf: Field Inflation exact integration routines

FieldInf is a collection of fast modern Fortran routines for computing exactly the background evolution and primordial power spectra of any single field inflationary models. It implements reheating without any assumptions through the "reheating parameter" R allowing robust inflationary parameter estimations and inference on the reheating energy scale. The underlying perturbation code actually deals with N fields minimally-coupled and/or non-minimally coupled to gravity and works for flat FLRW only.

[ascl:1708.009] FIEStool: Automated data reduction for FIber-fed Echelle Spectrograph (FIES)

FIEStool automatically reduces data obtained with the FIber-fed Echelle Spectrograph (FIES) at the Nordic Optical Telescope, a high-resolution spectrograph available on a stand-by basis, while also allowing the basic properties of the reduction to be controlled in real time by the user. It provides a Graphical User Interface and offers bias subtraction, flat-fielding, scattered-light subtraction, and specialized reduction tasks from the external packages IRAF (ascl:9911.002) and NumArray. The core of FIEStool is instrument-independent; the software, written in Python, could with minor modifications also be used for automatic reduction of data from other instruments.

[ascl:1203.013] Figaro: Data Reduction Software

Figaro (sometimes referred to as "standalone Figaro") is a data reduction system that originated at Caltech and whose development continued at the Anglo-Australian Observatory. Although it is intended to be able to deal with any sort of data, almost all its applications to date are geared towards processing optical and infrared data. Figaro uses hierarchical data structures to provide flexibility in its data file formats. Figaro was originally written to run under DEC's VMS operating system, but is now available both for VAX/VMS (by special request) and for various flavors of UNIX including Linux and MacOS.

A variant of Figaro (ascl:1411.022) is incorporated into the Starlink package (ascl:1110.012).

[ascl:1608.009] FilFinder: Filamentary structure in molecular clouds

FilFinder extracts and analyzes filamentary structure in molecular clouds. In particular, it is capable of uniformly extracting structure over a large dynamical range in intensity. It returns the main filament properties: local amplitude and background, width, length, orientation and curvature. FilFinder offers additional tools to, for example, create a filament-only image based on the properties of the radial fits. The resulting mask and skeletons may be saved in FITS format, and property tables may be saved as a CSV, FITS or LaTeX table.

[ascl:1602.007] FilTER: Filament Trait-Evaluated Reconstruction

FilTER (Filament Trait-Evaluated Reconstruction) post-processes output from DisPerSE (ascl:1302.015 ) to produce a set of filaments that are well-defined and have measured properties (e.g. width), then cuts the profiles, fits and assesses them to reconstruct new filaments according to defined criteria.

[ascl:2202.016] Find_Orb: Orbit determination from observations

Find_Orb takes a set of observations of an asteroid, comet, or natural or artificial satellite given in the MPC (Minor Planet Center) format, the ADES astrometric format, and/or the NEODyS or AstDyS formats, and finds the corresponding orbit.

[ascl:2210.004] Finder_charts: Create finder charts from image data of various sky surveys

Finder_charts creates multi-band finder charts from image data of various partial- and all-sky surveys such as DSS, 2MASS, WISE, UKIDSS, VHS, Pan-STARRS, and DES. It also creates a WISE time series of image data acquired between 2010 and 2021. All images are reprojected so that north is up and east is to the left. The resulting finder charts can be overplotted with corresponding catalog positions. All catalog entries within the specified field of view can be saved in a variety of formats, including ipac, csv, and tex, as can the finder charts in png, pdf, eps, and other common graphics formats. Finder_charts consists of a single Python module, which depends only on well-known packages, making it easy to install.

[ascl:2004.013] Finesse: Frequency domain INterfErometer Simulation SoftwarE

Finesse is a numeric simulation for laser interferometers and models parametric instabilities, easily providing the required mechanical-to-optical transfer functions in imperfect and arbitrary interferometer configurations using Hermite-Gaussian beams. The code has been used to apply limits to the number and type of higher order modes used in simulation and investigate the potential use of higher order Laguerre-Gauss modes to reduce thermal noise in future gravitational wave detector designs. The PyKat wrapper (ascl:2004.014) helps automate complex Finesse tasks.

[ascl:1808.006] Fips: An OpenGL based FITS viewer

FIPS is a cross-platform FITS viewer with a responsive user interface. Unlike other FITS viewers, FIPS uses GPU hardware via OpenGL to provide functionality such as zooming, panning and level adjustments. OpenGL 2.1 and later is supported. FIPS supports all 2D image formats except floating point formats on OpenGL 2.1. FITS image extension has basic limited support.

[ascl:2202.006] FIRE Studio: Movie making utilities for the FIRE simulations

FIRE Studio is a Python interface for C libraries that project Smoothed Particle Hydrodynamic (SPH) datasets. These C libraries can, in principle, be applied to any SPH dataset; the Python interface is specialized to conveniently load and format Gadget-derivative datasets such as GIZMO (ascl:1410.003). FIRE Studio is fast, memory efficient, and parallelizable. In addition to producing "1-color" projection maps for SPH datasets, the interface can produce "2-color" maps, where the pixel saturation is set by one projected quantity and the hue is set by another, and "3-color" maps, where three quantities are projected simultaneously and remapped into an RGB colorspace. FIRE Studio can model stellar emission and dust extinction to produce mock Hubble images (by default) or to model surface brightness maps for thirteen of the most common bands (plus the bolometric luminosity). It produces publication quality static images of simulation datasets and provides interpolation scripts to create movies that smoothly evolve in time (provided multiple snapshots in time of the data exist), view the dataset from different perspectives (taking advantage of shared memory buffers to allow massive parallelization), or both.

[ascl:2108.010] FIREFLY: Chi-squared minimization full spectral fitting code

FIREFLY (Fitting IteRativEly For Likelihood analYsis) derives stellar population properties of stellar systems, whether observed galaxy or star cluster spectra or model spectra from simulations. The code fits combinations of single-burst stellar population models to spectroscopic data following an iterative best-fitting process controlled by the Bayesian Information Criterion without applying priors. Solutions within a statistical cut are retained with their weight, which is arbitrary. No additive or multiplicative polynomia are used to adjust the spectral shape and no regularization is imposed. This fitting freedom allows mapping of the effect of intrinsic spectral energy distribution (SED) degeneracies, such as age, metallicity, dust reddening on stellar population properties, and quantifying the effect of varying input model components on such properties.

[ascl:1810.021] Firefly: Interactive exploration of particle-based data

Firefly provides interactive exploration of particle-based data in the browser. The user can filter, display vector fields, and toggle the visibility of their customizable datasets all on-the-fly. Different Firefly visualizations, complete with preconfigured data and camera view-settings, can be shared by URL. As Firefly is written in WebGL, it can be hosted online, though Firefly can also be used locally, without an internet connection. Firefly was developed with simulations of galaxy formation in mind but is flexible enough to display any particle-based data. Other features include a stereoscopic 3D picture mode and mobile compatibility.

[ascl:1908.023] FIRST Classifier: Automated compact and extended radio sources classifier

FIRST Classifier is an on-line system for automated classification of compact and extended radio sources. It is developed based on a trained Deep Convolutional Neural Network Model to automate the morphological classification of compact and extended radio sources observed in the FIRST radio survey. FIRST Classifier is able to predict the morphological class for a single source or for a list of sources as Compact or Extended (FRI, FRII and BENT).

[ascl:1202.014] FISA: Fast Integrated Spectra Analyzer

FISA (Fast Integrated Spectra Analyzer) permits fast and reasonably accurate age and reddening determinations for small angular diameter open clusters by using their integrated spectra in the (3600-7400) AA range and currently available template spectrum libraries. This algorithm and its implementation help to achieve astrophysical results in shorter times than from other methods. FISA has successfully been applied to integrated spectroscopy of open clusters, both in the Galaxy and in the Magellanic Clouds, to determine ages and reddenings.

[ascl:1010.070] Fisher.py: Fisher Matrix Manipulation and Confidence Contour Plotting

Fisher.py allows you to combine constraints from multiple experiments (e.g., weak lensing + supernovae) and add priors (e.g., a flat universe) simply and easily. Calculate parameter uncertainties and plot confidence ellipses. Fisher matrix expectations for several experiments are included as calculated by myself (time delays) and the Dark Energy Task Force (WL/SN/BAO/CL/CMB), or provide your own.

[ascl:1201.007] Fisher4Cast: Fisher Matrix Toolbox

The Fisher4Cast suite, which requires MatLab, provides a standard, tested tool set for general Fisher Information matrix prediction and forecasting for use in both research and education. The toolbox design is robust and modular, allowing for easy additions and adaptation while keeping the user interface intuitive and easy to use. Fisher4Cast is completely general but the default is coded for cosmology. It provides parameter error forecasts for cosmological surveys providing distance, Hubble expansion and growth measurements in a general, curved FLRW background.

[ascl:2308.015] FishLSS: Fisher forecasting for Large Scale Structure surveys

FishLSS computes the Fisher information matrix for a set of observables and model parameters. It can model the redshift-space power spectrum of any biased tracer of the CDM+baryon field and the post-reconstruction galaxy power spectrum. The code also models the projected cross-correlation of galaxies with the CMB lensing convergence, the projected galaxy power spectrum, and the CMB lensing convergence power spectrum. FishLSS requires pyFFTW (ascl:2109.009), velocileptors (ascl:2308.014), and CLASS (ascl:1106.020).

[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. A modernization of FISHPACK is available as FISHPACK90 (ascl:1609.005).

[ascl:1609.005] FISHPACK90: Efficient FORTRAN Subprograms for the Solution of Separable Elliptic Partial Differential Equations

FISHPACK90 is a modernization of the original FISHPACK (ascl:1609.004), employing Fortran90 to slightly simplify and standardize the interface to some of the routines. This collection of Fortran programs and subroutines solves second- and fourth-order finite difference approximations to separable elliptic Partial Differential Equations (PDEs). These include Helmholtz equations in cartesian, polar, cylindrical, and spherical coordinates, as well as more general separable elliptic equations. The solvers use the cyclic reduction algorithm. When the problem is singular, a least-squares solution is computed. Singularities induced by the coordinate system are handled, including at the origin r=0 in cylindrical coordinates, and at the poles in spherical coordinates. Test programs are provided for the 19 solvers. Each serves two purposes: as a template to guide you in writing your own codes utilizing the FISHPACK90 solvers, and as a demonstration on your computer that you can correctly produce FISHPACK90 executables.

[ascl:1601.016] Fit Kinematic PA: Fit the global kinematic position-angle of galaxies

Fit kinematic PA measures the global kinematic position-angle (PA) from integral field observations of a galaxy stellar or gas kinematics; the code is available in IDL and Python.

[ascl:1609.015] FIT3D: Fitting optical spectra

FIT3D fits optical spectra to deblend the underlying stellar population and the ionized gas, and extract physical information from each component. FIT3D is focused on the analysis of Integral Field Spectroscopy data, but is not restricted to it, and is the basis of Pipe3D, a pipeline used in the analysis of datasets like CALIFA, MaNGA, and SAMI. It can run iteratively or in an automatic way to derive the parameters of a large set of spectra.

[ascl:1305.011] FITDisk: Cataclysmic Variable Accretion Disk Demonstration Tool

FITDisk models accretion disk phenomena using a fully three-dimensional hydrodynamics calculation, and data can either be visualized as they are computed or stored to hard drive for later playback at a fast frame rate. Simulations are visualized using OpenGL graphics and the viewing angle can be changed interactively. Pseudo light curves of simulated systems can be plotted along with the associated Fourier amplitude spectrum. It provides an easy to use graphical user interface as well as 3-D interactive graphics. The code computes the evolution of a CV accretion disk, visualizes results in real time, records and plays back simulations, and generates and plots pseudo light curves and associated power spectra. FITDisk is the Windows executable form of this software; its Fortran source code is also available as DiskSim (ascl:1811.013).

[ascl:2301.005] fitOmatic: Interferometric data modeling

The fitOmatic model-fitting prototyping tool tests multi-wavelength model-fitting and exploits VLTI data. It provides tools to define simple geometrical models and conveniently adjust the model's parameters. Written in Yorick, it takes optical interferometry FITS (oifits) files as input and allows the user to define a model of the source from a set of pre-defined models, which can be combined to make more complicated models. fitOmatic then computes the Fourier Transform of the modeled brightness distribution and synthetic observables are computed at the wavelengths and projected baselines of the observations. fitomatic's strength is its ability to define vector-parameters, i.e., parameters that may depend on wavelength and/or time. The self-cal (ascl:2301.006) component of fitOmatic is also available as a separate code.

[ascl:1206.002] FITS Liberator: Image processing software

The ESA/ESO/NASA FITS Liberator makes it possible to process and edit astronomical science data in the FITS format to produce stunning images of the universe. Formerly a plugin for Adobe Photoshop, the current version of FITS Liberator is a stand-alone application and no longer requires Photoshop. This image processing software makes it possible to create color images using raw observations from a range of telescopes; the FITS Liberator continues to support the FITS and PDS formats, preferred by astronomers and planetary scientists respectively, which enables data to be processed from a wide range of telescopes and planetary probes, including ESO’s Very Large Telescope, the NASA/ESA Hubble Space Telescope, NASA’s Spitzer Space Telescope, ESA’s XMM–Newton Telescope and Cassini–Huygens or Mars Reconnaissance Orbiter.

[ascl:1505.029] fits2hdf: FITS to HDFITS conversion

fits2hdf ports FITS files to Hierarchical Data Format (HDF5) files in the HDFITS format. HDFITS allows faster reading of data, higher compression ratios, and higher throughput. HDFITS formatted data can be presented transparently as an in-memory FITS equivalent by changing the import lines in Python-based FITS utilities. fits2hdf includes a utility to port MeasurementSets (MS) to HDF5 files.

[ascl:2309.014] fitScalingRelation: Fit galaxy cluster scaling relations using MCMC

fitScalingRelation fits galaxy cluster scaling relations using orthogonal or bisector regression and MCMC. It takes into account errors on both variables and intrinsic scatter. Although it geared for fitting galaxy cluster scaling relations of all kinds, it can be used for any kind of regression problem with errors on both variables and intrinsic scatter.

[ascl:1710.018] FITSFH: Star Formation Histories

FITSFH derives star formation histories from photometry of resolved stellar populations by populating theoretical isochrones according to a chosen stellar initial mass function (IMF) and searching for the linear combination of isochrones with different ages and metallicities that best matches the data. In comparing the synthetic and real data, observational errors and incompleteness are taken into account, and a rudimentary treatment of the effect of unresolved binaries is also implemented. The code also allows for an age-dependent range of extinction values to be included in the modelling.

[ascl:1111.014] FITSH: Software Package for Image Processing

FITSH provides a standalone environment for analysis of data acquired by imaging astronomical detectors. The package provides utilities both for the full pipeline of subsequent related data processing steps (including image calibration, astrometry, source identification, photometry, differential analysis, low-level arithmetic operations, multiple image combinations, spatial transformations and interpolations, etc.) and for aiding the interpretation of the (mainly photometric and/or astrometric) results. The package also features a consistent implementation of photometry based on image subtraction, point spread function fitting and aperture photometry and provides easy-to-use interfaces for comparisons and for picking the most suitable method for a particular problem. The utilities in the package are built on the top of the commonly used UNIX/POSIX shells (hence the name of the package), therefore both frequently used and well-documented tools for such environments can be exploited and managing massive amount of data is rather convenient.

[ascl:1107.003] FITSManager: Management of Personal Astronomical Data

With the increase of personal storage capacity, it is easy to find hundreds to thousands of FITS files in the personal computer of an astrophysicist. Because Flexible Image Transport System (FITS) is a professional data format initiated by astronomers and used mainly in the small community, data management toolkits for FITS files are very few. Astronomers need a powerful tool to help them manage their local astronomical data. Although Virtual Observatory (VO) is a network oriented astronomical research environment, its applications and related technologies provide useful solutions to enhance the management and utilization of astronomical data hosted in an astronomer's personal computer. FITSManager is such a tool to provide astronomers an efficient management and utilization of their local data, bringing VO to astronomers in a seamless and transparent way. FITSManager provides fruitful functions for FITS file management, like thumbnail, preview, type dependent icons, header keyword indexing and search, collaborated working with other tools and online services, and so on. The development of the FITSManager is an effort to fill the gap between management and analysis of astronomical data.

[ascl:2201.004] FitsMap: Interactive astronomical image and catalog data visualizer

FitsMap visualizes astronomical image and catalog data. Implemented in Python, the software is a simple, lightweight tool, requires only a simple web server, and can scale to over gigapixel images with tens of millions of sources. Further, the web-based visualizations can be viewed performantly on mobile devices.

[ascl:1905.012] Fitsverify: FITS file format-verification tool

Fitsverify rigorously checks whether a FITS (Flexible Image Transport System) data file conforms to the requirements defined in Version 3.0 of the FITS Standard document; it is a standalone version of the ftverify and fverify tasks that are distributed as part of the ftools (ascl:9912.002) software package. The source code must be compiled and linked with the CFITSIO (ascl:1010.001) library. An interactive web is also available that can verify the format of any FITS data file on a local computer or on the Web.

[submitted] fkpt: code to compute LCDM and modified gravity perturbation theory using fk-kernels

Perturbation theory for LCDM and Modified Gravity theories using "fk"-Kernels. fkpt is a code that computes the 1-loop redshift space power spectrum for tracers. Hu-Sawicky f(R) is the only modified gravity model implemented so far. It is straightforward to do it for other models.

[ascl:1709.011] FLaapLUC: Fermi-LAT automatic aperture photometry light curve

Most high energy sources detected with Fermi-LAT are blazars, which are highly variable sources. High cadence long-term monitoring simultaneously at different wavelengths being prohibitive, the study of their transient activities can help shed light on our understanding of these objects. The early detection of such potentially fast transient events is the key for triggering follow-up observations at other wavelengths. FLaapLUC (Fermi-LAT automatic aperture photometry Light C↔Urve) uses the simple aperture photometry approach to effectively detect relative flux variations in a set of predefined sources and alert potential users. Such alerts can then be used to trigger observations of these sources with other facilities. The FLaapLUC pipeline is built on top of the Science Tools provided by the Fermi-LAT collaboration and quickly generates short- or long-term Fermi-LAT light curves.

[ascl:1710.007] FLAG: Exact Fourier-Laguerre transform on the ball

FLAG is a fast implementation of the Fourier-Laguerre Transform, a novel 3D transform exploiting an exact quadrature rule of the ball to construct an exact harmonic transform in 3D spherical coordinates. The angular part of the Fourier-Laguerre transform uses the MW sampling theorem and the exact spherical harmonic transform implemented in the SSHT code (ascl:2207.034). The radial sampling scheme arises from an exact quadrature of the radial half-line using damped Laguerre polynomials. The radial transform can in fact be used to compute the spherical Bessel transform exactly, and the Fourier-Laguerre transform is thus closely related to the Fourier-Bessel transform.

[ascl:1112.007] FLAGCAL: FLAGging and CALlibration Pipeline for GMRT Data

FLAGging and CALlibration (FLAGCAL) is a software pipeline developed for automatic flagging and calibration of the GMRT data. This pipeline can be used for preprocessing (before importing the data in AIPS) any other interferromteric data also (given that the data file is in FITS format and contains multiple channels & scans).There are also a few GUI based tools which can be used for quick visualization of the data.

[ascl:2305.010] FLAGLET: Fast and exact wavelet transform on the ball

FLAGLET computes flaglet transforms with arbitrary spin direction, probing the angular features of this generic wavelet transform for rapid analysis of signals from wavelet coefficients. The code enables the decomposition of a band-limited signal into a set of flaglet maps that capture all information contained in the initial band-limited map, and it can reconstruct the individual flaglets at varying resolutions. FLAGLET relies upon the SSHT (ascl:2207.034), S2LET (ascl:1211.001), and SO3 codes to provide angular transforms and sampling theorems, as well as the FFTW (ascl:1201.015) code to compute Fourier transforms.

[ascl:1811.007] Flame: Near-infrared and optical spectroscopy data reduction pipeline

Flame reduces near-infrared and optical multi-object spectroscopic data. Although the pipeline was created for the LUCI instrument at the Large Binocular Telescope, Flame, written in IDL, is modular and can be adapted to work with data from other instruments. The software uses 2D transformations, thus using one interpolation step to wavelength calibrate and rectify the data. The γ(x, y) transformation also includes the spatial misalignment between frames, which can be measured from a reference star observed simultaneously with the science targets; sky subtraction can be performed via nodding and/or modelling of the sky spectrum.

[submitted] FLARE: Synthetic Fast Radio Burst catalog generator

FLARE, a parallel code written in Python, generates 100,000 Fast Radio Bursts (FRB) using the Monte Carlo method. The FRB population is diverse and includes sporadic FRBs, repeaters, and periodic repeaters. However, less than 200 FRBs have been detected to date, which makes understanding the FRB population difficult. To tackle this problem, FLARE uses a Monte Carlo method to generate 100,000 realistic FRBs, which can be analyzed later on for further research. It has the capability to simulate FRB distances (based on the observed FRB distance range), energies (based on the "flaring magnetar model" of FRBs), fluences, multi-wavelength counterparts (based on x-ray to radio fluence ratio of FRB 200428), and other properties. It analyzes the resulting synthetic FRB catalog and displays the distribution of their properties. It is fast (as a result of parallel code) and requires minimal human interaction. FLARE is, therefore, able to give a broad picture of the FRB population.

[ascl:1010.082] FLASH: Adaptive Mesh Hydrodynamics Code for Modeling Astrophysical Thermonuclear Flashes

The FLASH code, currently in its 4th version, is a publicly available high performance application code which has evolved into a modular, extensible software system from a collection of unconnected legacy codes. FLASH consists of inter-operable modules that can be combined to generate different applications. The FLASH architecture allows arbitrarily many alternative implementations of its components to co-exist and interchange with each other. A simple and elegant mechanism exists for customization of code functionality without the need to modify the core implementation of the source. A built-in unit test framework combined with regression tests that run nightly on multiple platforms verify the code.

[ascl:1606.015] FLASK: Full-sky Lognormal Astro-fields Simulation Kit

FLASK (Full-sky Lognormal Astro-fields Simulation Kit) makes tomographic realizations on the sphere of an arbitrary number of correlated lognormal or Gaussian random fields; it can create joint simulations of clustering and lensing with sub-per-cent accuracy over relevant angular scales and redshift ranges. It is C++ code parallelized with OpenMP; FLASK generates fast full-sky simulations of cosmological large-scale structure observables such as multiple matter density tracers (galaxies, quasars, dark matter haloes), CMB temperature anisotropies and weak lensing convergence and shear fields. The mutiple fields can be generated tomographically in an arbitrary number of redshift slices and all their statistical properties (including cross-correlations) are determined by the angular power spectra supplied as input and the multivariate lognormal (or Gaussian) distribution assumed for the fields. Effects like redshift space distortions, doppler distortions, magnification biases, evolution and intrinsic aligments can be introduced in the simulations via the input power spectra which must be supplied by the user.

[ascl:2111.012] flatstar: Make 2d intensity maps of limb-darkened stars

flatstar is an open-source Python tool for drawing stellar disks as numpy.ndarray objects with scientifically-rigorous limb darkening. Each pixel has an accurate fractional intensity in relation to the total stellar intensity of 1.0. It is ideal for ray-tracing simulations of stars and planetary transits. The code is fast, has the most well-known limb-darkening laws, including linear, quadratic, square-root, logarithmic, and exponential, and allows the user to implement custom limb-darkening laws. flatstar also offers supersampling for situations where both coarse arrays and precision in stellar disk intensity (i.e., no hard pixel boundaries) is desired, and upscaling to save on computation time when high-resolution intensity maps are needed, though there is some precision loss in intensities.

[ascl:2308.002] FLATW'RM: Finding flares in Kepler data using machine-learning tools

FLATW'RM (FLAre deTection With Ransac Method) detects stellar flares in light curves using a classical machine-learning method. The code tries to find a rotation period in the light curve and splits the data to detection windows. The light curve sections are fit with the robust fitting algorithm RANSAC (Random sample consensus); outlier points (flare candidates) above the pre-set detection level are marked for each section. For the given detection window, only those flare candidates that have at least a given number of consecutive points (three by default) are kept and marked as flares. When using FLATW’RM, the code's output should be checked to determine whether changes to the default settings are needed to account for light curve noise, data sampling frequency, and scientific needs.

[ascl:2203.009] fleck: Fast starspot rotational modulation light curves

fleck simulates rotational modulation of stars due to starspots and is used to overcome the degeneracies and determine starspot coverages accurately for a sample of young stars. The code simulates starspots as circular dark regions on the surfaces of rotating stars, accounting for foreshortening towards the limb, and limb darkening. Supplied with the latitudes, longitudes, and radii of spots and the stellar inclinations from which each star is viewed, fleck takes advantage of efficient array broadcasting with numpy to return approximate light curves. For example, the code can compute rotational modulation curves sampled at ten points throughout the rotation of each star for one million stars, with two unique spots each, all viewed at unique inclinations, in about 10 seconds on a 2.5 GHz Intel Core i7 processor. This rapid computation of light curves en masse makes it possible to measure starspot distributions with techniques such as Approximate Bayesian Computation.

[ascl:2007.011] FleCSPH: Parallel and distributed SPH implementation based on the FleCSI

FleCSPH is a multi-physics compact application that exercises FleCSI parallel data structures for tree-based particle methods. In particular, the software implements a smoothed-particle hydrodynamics (SPH) solver for the solution of Lagrangian problems in astrophysics and cosmology. FleCSPH includes support for gravitational forces using the fast multipole method (FMM). Particle affinity and gravitation is handled using the parallel implementation of the octree data structure provided by FleCSI.

[ascl:2009.019] FLEET: Finding Luminous and Exotic Extragalactic Transients

FLEET (Finding Luminous and Exotic Extragalactic Transients) is a machine-learning pipeline that predicts the probability of a transient to be a superluminous supernova. With light curve and contextual host galaxy information, it uses a random forest algorithm to rapidly identify SLSN-I without the need for redshift information.

[ascl:1612.006] flexCE: Flexible one-zone chemical evolution code

flexCE (flexible Chemical Evolution) computes the evolution of a one-zone chemical evolution model with inflow and outflow in which gas is instantaneously and completely mixed. It can be used to demonstrate the sensitivity of chemical evolution models to parameter variations, show the effect of CCSN yields on chemical evolution models, and reproduce the 2D distribution in [O/Fe]{[Fe/H] by mixing models with a range of inflow and outflow histories. It can also post-process cosmological simulations to predict element distributions.

[ascl:1107.004] Flexible DM-NRG

This code combines the spectral sum-conserving methods of Weichselbaum and von Delft and of Peters, Pruschke and Anders (both relying upon the complete basis set construction of Anders and Schiller) with the use of non-Abelian symmetries in a flexible manner: Essentially any non-Abelian symmetry can be taught to the code, and any number of such symmetries can be used throughout the computation for any density of states, and to compute any local operators' correlation function's real and imaginary parts or any thermodynamical expectation value. The code works both at zero and finite temperatures.

[ascl:1205.006] Flexion: IDL code for calculating gravitational flexion

Gravitational flexion is a technique for measuring 2nd order gravitational lensing signals in background galaxies and radio lobes. Unlike shear, flexion directly probes variations of the potential field. Moreover, the information contained in flexion is orthogonal to what is found in the shear. Thus, we get the information "for free."

[ascl:1411.016] Flicker: Mean stellar densities from flicker

Flicker calculates the mean stellar density of a star by inputting the flicker observed in a photometric time series. Written in Fortran90, its output may be used as an informative prior on stellar density when fitting transit light curves.

[ascl:1210.007] FLUKA: Fully integrated particle physics Monte Carlo simulation package

FLUKA (FLUktuierende KAskade) is a general-purpose tool for calculations of particle transport and interactions with matter. FLUKA can simulate with high accuracy the interaction and propagation in matter of about 60 different particles, including photons and electrons from 1 keV to thousands of TeV, neutrinos, muons of any energy, hadrons of energies up to 20 TeV (up to 10 PeV by linking FLUKA with the DPMJET code) and all the corresponding antiparticles, neutrons down to thermal energies and heavy ions. The program, written in Fortran, can also transport polarised photons (e.g., synchrotron radiation) and optical photons. Time evolution and tracking of emitted radiation from unstable residual nuclei can be performed online.

[ascl:1105.008] Flux Tube Model

This Fortran code computes magnetohydrostatic flux tubes and sheets according to the method of Steiner, Pneuman, & Stenflo (1986) A&A 170, 126-137. The code has many parameters contained in one input file that are easily modified. Extensive documentation is provided in README files.

[ascl:1712.010] Flux Tube: Solar model

Flux Tube is a nonlinear, two-dimensional, numerical simulation of magneto-acoustic wave propagation in the photosphere and chromosphere of small-scale flux tubes with internal structure. Waves with realistic periods of three to five minutes are studied, after horizontal and vertical oscillatory perturbations are applied to the equilibrium model. Spurious reflections of shock waves from the upper boundary are minimized by a special boundary condition.

[ascl:2110.015] Flux: Julia machine learning library

Flux provides an elegant approach to machine learning. Written in Julia, it provides lightweight abstractions on top of Julia's native GPU and AD support. It has many useful tools built in, but also lets you use the full power of the Julia language where you need it. Flux has relatively few explicit APIs for features like regularization or embeddings; instead, writing down the mathematical form works and is fast. The package works well with Julia libraries from data frames and images to differential equation solvers, so building complex data processing pipelines that integrate Flux models is straightforward.

[ascl:1405.010] FLUXES: Position and flux density of planets

FLUXES calculates approximate topocentric positions of the planets and also integrated flux densities of five of them at several wavelengths. These provide calibration information at the effective frequencies and beam-sizes employed by the UKT14, SCUBA and SCUBA-2 receivers on the JCMT telescope based on Mauna Kea, Hawaii. FLUXES is part of the bundle that comprises the Starlink multi-purpose astronomy software package (ascl:1110.012).

[ascl:1011.019] FLY: MPI-2 High Resolution code for LSS Cosmological Simulations

Cosmological simulations of structures and galaxies formations have played a fundamental role in the study of the origin, formation and evolution of the Universe. These studies improved enormously with the use of supercomputers and parallel systems and, recently, grid based systems and Linux clusters. Now we present the new version of the tree N-body parallel code FLY that runs on a PC Linux Cluster using the one side communication paradigm MPI-2 and we show the performances obtained. FLY is included in the Computer Physics Communication Program Library. This new version was developed using the Linux Cluster of CINECA, an IBM Cluster with 1024 Intel Xeon Pentium IV 3.0 Ghz. The results show that it is possible to run a 64 Million particle simulation in less than 15 minutes for each timestep, and the code scalability with the number of processors is achieved. This lead us to propose FLY as a code to run very large N-Body simulations with more than $10^{9}$ particles with the higher resolution of a pure tree code.

[ascl:2107.004] FoF-Halo-finder: Halo location and size

FoF-Halo-finder identifies the location and size of collapsed objects (halos) within a cosmological simulation box. These halos are the host for the luminous objects in the Universe. Written in C, it is based on the friends-of-friends (FoF) algorithm, and is designed to work with PMN-body (ascl:2107.003).

[ascl:2312.010] FORECAST: Realistic astronomical image and galaxy survey generator

FORECAST generates realistic astronomical images and galaxy surveys by forward modeling the output snapshot of any hydrodynamical cosmological simulation. It exploits the snapshot by constructing a lightcone centered on the observer's position; the code computes the observed fluxes of each simulated stellar element, modeled as a Single Stellar Population (SSP), in any chosen set of pass-band filters, including k-correction, IGM absorption, and dust attenuation. These fluxes are then used to create an image on a grid of pixels, to which observational features such as background noise and PSF blurring can be added. FORECAST provides customizable options for filters, size of the field of view, and survey parameters, thus allowing the synthetic images to be tailored for specific research requirements.

[submitted] forecaster-plus

An internally overhauled but fundamentally similar version of Forecaster by Jingjing Chen and David Kipping, originally presented in arXiv:1603.08614 and hosted at https://github.com/chenjj2/forecaster.

The model itself has not changed- no new data was included and the hyperparameter file was not regenerated. All functions were rewritten to take advantage of Numpy vectorization and some additional user features were added. Now able to be installed via pip.

[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:1912.009] FORSTAND: Flexible ORbit Superposition Toolbox for ANalyzing Dynamical models

FORSTAND constructs dynamical models of galaxies using the Schwarzschild orbit-superposition method; the method is available as part of the AGAMA (ascl:1805.008) framework. The models created are constrained by line-of-sight kinematic observations and are applicable to galaxies of all morphological types, including disks and triaxial rotating bars.

[ascl:1904.011] FortesFit: Flexible spectral energy distribution modelling with a Bayesian backbone

FortesFit efficiently explores and discriminates between various spectral energy distributions (SED) models of astronomical sources. The Python package adds Bayesian inference to a framework that is designed for the easy incorporation and relative assessment of SED models, various fitting engines, and a powerful treatment of priors, especially those that may arise from non-traditional wave-bands such as the X-ray or radio emission, or from spectroscopic measurements. It has been designed with particular emphasis for its scalability to large datasets and surveys.

[ascl:1405.007] FORWARD: Forward modeling of coronal observables

FORWARD forward models various coronal observables and can access and compare existing data. Given a coronal model, it can produce many different synthetic observables (including Stokes polarimetry), as well as plots of model plasma properties (density, magnetic field, etc.). It uses the CHIANTI database (ascl:9911.004) and CLE polarimetry synthesis code, works with numerical model datacubes, interfaces with the PFSS module of SolarSoft (ascl:1208.013), includes several analytic models, and connects to the Virtual Solar Observatory for downloading data in a format directly comparable to model predictions.

[ascl:2102.015] ForwardDiff: Forward mode automatic differentiation for Julia

ForwardDiff implements methods to take derivatives, gradients, Jacobians, Hessians, and higher-order derivatives of native Julia functions (or any callable object, really) using forward mode automatic differentiation (AD).While performance can vary depending on the functions you evaluate, the algorithms implemented by ForwardDiff generally outperform non-AD algorithms in both speed and accuracy.

[ascl:1204.004] Fosite: 2D advection problem solver

Fosite implements a method for the solution of hyperbolic conservation laws in curvilinear orthogonal coordinates. It is written in Fortran 90/95 integrating object-oriented (OO) design patterns, incorporating the flexibility of OO-programming into Fortran 90/95 while preserving the efficiency of the numerical computation. Although mainly intended for CFD simulations, Fosite's modular design allows its application to other advection problems as well. Unlike other two-dimensional implementations of finite volume methods, it accounts for local conservation of specific angular momentum. This feature turns the program into a perfect tool for astrophysical simulations where angular momentum transport is crucial. Angular momentum transport is not only implemented for standard coordinate systems with rotational symmetry (i.e. cylindrical, spherical) but also for a general set of orthogonal coordinate systems allowing the use of exotic curvilinear meshes (e.g. oblate-spheroidal). As in the case of the advection problem, this part of the software is also kept modular, therefore new geometries may be incorporated into the framework in a straightforward manner.

[ascl:1610.012] Fourierdimredn: Fourier dimensionality reduction model for interferometric imaging

Fourierdimredn (Fourier dimensionality reduction) implements Fourier-based dimensionality reduction of interferometric data. Written in Matlab, it derives the theoretically optimal dimensionality reduction operator from a singular value decomposition perspective of the measurement operator. Fourierdimredn ensures a fast implementation of the full measurement operator and also preserves the i.i.d. Gaussian properties of the original measurement noise.

[ascl:1806.030] foxi: Forecast Observations and their eXpected Information

Using information theory and Bayesian inference, the foxi Python package computes a suite of expected utilities given futuristic observations in a flexible and user-friendly way. foxi requires a set of n-dim prior samples for each model and one set of n-dim samples from the current data, and can calculate the expected ln-Bayes factor between models, decisiveness between models and its maximum-likelihood averaged equivalent, the decisivity, and the expected Kullback-Leibler divergence (i.e., the expected information gain of the futuristic dataset). The package offers flexible inputs and is designed for all-in-one script calculation or an initial cluster run then local machine post-processing, which should make large jobs quite manageable subject to resources and includes features such as LaTeX tables and plot-making for post-data analysis visuals and convenience of presentation.

[ascl:1010.002] fpack: FITS Image Compression Program

fpack is a utility program for optimally compressing images in the FITS data format. The associated funpack program will restore the compressed file back to its original state. These programs may be run from the host operating system command line and are analogous to the gzip and gunzip utility programs, except that they are specifically optimized for FITS format images and offer a wider choice of compression options.

fpack uses the tiled image compression convention for storing the compressed images. This convention can in principle support any number of of different compression algorithms; currently GZIP, Rice, Hcompress, and the IRAF pixel list compression algorithms have been implemented.

The main advantages of fpack compared to the commonly used technique of externally compressing the whole FITS file with gzip are:

- It is generally faster and offers better compression than gzip.
- The FITS header keywords remain uncompressed for fast access.
- Each HDU of a multi-extension FITS file is compressed separately, so it is not necessary to uncompress the entire file to read a single image in a multi-extension file.
- Dividing the image into tiles before compression enables faster access to small subsections of the image.
- The compressed image is itself a valid FITS file and can be manipulated by other general FITS utility software.
- Lossy compression can be used for much higher compression in cases where it is not necessary to exactly preserve the original image.
- The CHECKSUM keywords are automatically updated to help verify the integrity of the files.
- Software that supports the tiled image compression technique can directly read and write the FITS images in their compressed form.

[ascl:2311.010] FPFS: Fourier Power Function Shaplets

FPFS (Fourier Power Function Shaplets) is a fast, accurate shear estimator for the shear responses of galaxy shape, flux, and detection. Utilizing leading-order perturbations of shear (a vector perturbation) and image noise (a tensor perturbation), the code determines shear and noise responses for both measurements and detections. Unlike methods that distort each observed galaxy repeatedly, the software employs analytical shear responses of select basis functions, including Shapelets basis and peak basis. FPFS is efficient and can process approximately 1,000 galaxies within a single CPU second, and maintains a multiplicative shear estimation bias below 0.5% even amidst blending challenges.

[ascl:2001.004] FragMent: Fragmentation techniques for studying filaments

FragMent studies fragmentation in filaments by collating a number of different techniques, including nearest neighbour separations, minimum spanning tree, two-point correlation function, and Fourier power spectrum. It also performs model selection using a frequentist and Bayesian approach to find the best descriptor of a filament's fragmentation. While the code was designed to investigate filament fragmentation, the functions are general and may be used for any set of 2D points to study more general cases of fragmentation.

[ascl:2109.010] Frankenstein: Flux reconstructor

Frankenstein (frank) fits the 1D radial brightness profile of an interferometric source given a set of visibilities. It uses a Gaussian process that performs the fit in <1 minute for a typical protoplanetary disc continuum dataset. Frankenstein can perform a fit in 2 ways, by running the code directly from the terminal or using the code as a Python module.

[ascl:2306.018] FRB: Fast Radio Burst calculations, estimations, and analysis

FRB performs calculations, estimations, analysis, and Bayesian inferences for Fast Radio Bursts, including dispersion measure and emission measure calculations, derived properties and spectrums, and Galactic RM.

[ascl:2011.011] frbcat: Fast Radio Burst CATalog querying package

frbcat queries and downloads Fast Radio Burst (FRB) data from the FRBCAT Catalogue web page, the CHIME-REPEATERS web page and the Transient Name Server (TNS). It is written in Python and can be installed using pip.

[submitted] frbmclust: Model-independent classification of events from the first CHIME/FRB Fast Radio Burst catalog

CHIME/FRB instrument has recently published a catalog containing about half of thousand fast radio bursts (FRB) including their spectra and several reconstructed properties, like signal widths, amplitudes, etc. We have developed a model-independent approach for the classification of these bursts using cross-correlation and clustering algorithms applied to one-dimensional intensity profiles, i.e. to amplitudes as a function of time averaged over the frequency. This approach is implemented in frbmclust package, which is used for classification of bursts featuring different waveform morphology.

[ascl:1911.009] frbpoppy: Fast radio burst population synthesis in Python

frbpoppy conducts fast radio burst population synthesis and continues the work of PSRPOP (ascl:1107.019) and PsrPopPy (ascl:1501.006) in the realm of FRBs. The code replicates observed FRB detection rates and FRB distributions in three steps. It first simulates a cosmic population of one-off FRBs and allows the user to select options such as models for source number density, cosmology, DM host/IGM/Milky Way, luminosity functions, and emission bands as well as maximum redshift and size of the FRB population. The code then generates a survey by adopting a beam pattern using various survey parameters, among them telescope gain, sampling time, receiver temperature, central frequency, channel bandwidth, number of polarizations, and survey region limits. Finally, frbpoppy convolves the generated intrinsic population with the generated survey to simulate an observed FRB population.

[ascl:2106.028] FRBSTATS: A web-based platform for visualization of fast radio burst properties

FRBSTATS provides a user-friendly web interface to an open-access catalog of fast radio bursts (FRBs) published up to date, along with a highly accurate statistical overview of the observed events. The platform supports the retrieval of fundamental FRB data either directly through the FRBSTATS API, or in the form of a CSV/JSON-parsed database, while enabling the plotting of parameter distributions for a variety of visualizations. These features allow researchers to conduct more thorough population studies while narrowing down the list of astrophysical models describing the origins and emission mechanisms behind these sources. Lastly, the platform provides a visualization tool that illustrates associations between primary bursts and repeaters, complementing basic repeater information provided by the Transient Name Server.

[ascl:1906.003] FREDDA: A fast, real-time engine for de-dispersing amplitudes

FREDDA detects Fast Radio Bursts (FRBs) in power data. It is optimized for use at ASKAP, namely GHz frequencies with 10s of beams, 100s of channels and millisecond integration times. The code is written in CUDA for NVIDIA Graphics Processing Units.

[ascl:1610.014] Freddi: Fast Rise Exponential Decay accretion Disk model Implementation

Freddi (Fast Rise Exponential Decay: accretion Disk model Implementation) solves 1-D evolution equations of the Shakura-Sunyaev accretion disk. It simulates fast rise exponential decay (FRED) light curves of low mass X-ray binaries (LMXBs). The basic equation of the viscous evolution relates the surface density and viscous stresses and is of diffusion type; evolution of the accretion rate can be found on solving the equation. The distribution of viscous stresses defines the emission from the source. The standard model for the accretion disk is implied; the inner boundary of the disk is at the ISCO or can be explicitely set. The boundary conditions in the disk are the zero stress at the inner boundary and the zero accretion rate at the outer boundary. The conditions are suitable during the outbursts in X-ray binary transients with black holes. In a binary system, the accretion disk is radially confined. In Freddi, the outer radius of the disk can be set explicitely or calculated as the position of the tidal truncation radius.

[ascl:1211.002] FreeEOS: Equation of State for stellar interiors calculations

FreeEOS is a Fortran library for rapidly calculating the equation of state using an efficient free-energy minimization technique that is suitable for physical conditions in stellar interiors. Converged FreeEOS solutions can be reliably determined for the first time for physical conditions occurring in stellar models with masses between 0.1 M and the hydrogen-burning limit near 0.07 M and hot brown-dwarf models just below that limit. However, an initial survey of results for those conditions showed EOS discontinuities (plasma phase transitions) and other problems which will need to be addressed in future work by adjusting the interaction radii characterizing the pressure ionization used for the FreeEOS calculations.

[ascl:2104.011] Freeture: Free software to capTure meteors

FreeTure monitors images from GigE all-sky cameras to detect and record falling stars and fireball. Originally, it was developed for the FRIPON (Fireball Recovery and InterPlanetary Observation Network) project, which sought to cover all of France with 100 fish eyes cameras, but can be used by any station that has a GigE camera.

[ascl:1508.004] FRELLED: FITS Realtime Explorer of Low Latency in Every Dimension

FRELLED (FITS Realtime Explorer of Low Latency in Every Dimension) creates 3D images in real time from 3D FITS files and is written in Python for the 3D graphics suite Blender. Users can interactively generate masks around regions of arbitrary geometry and use them to catalog sources, hide regions, and perform basic analysis (e.g., image statistics within the selected region, generate contour plots, query NED and the SDSS). World coordinates are supported and multi-volume rendering is possible. FRELLED is designed for viewing HI data cubes and provides a number of tasks to commonly-used MIRIAD (ascl:1106.007) tasks (e.g. mbspect); however, many of its features are suitable for any type of data set. It also includes an n-body particle viewer with the ability to display 3D vector information as well as the ability to render time series movies of multiple FITS files and setup simple turntable rotation movies for single files.

[ascl:2305.001] FRIDDA: Fisher foRecast code for combIned reDshift Drift and Alpha

FRIDDA forecasts the cosmological impact of measurements of the redshift drift and the fine-structure constant (alpha) as well as their combination. The code is based on Fisher Matrix Analysis techniques and works for various fiducial cosmological models. Though designed for the ArmazoNes high Dispersion Echelle Spectrograph (ANDES), it is easily adaptable to other fiducial cosmological models and to other instruments with similar scientific goals.

[ascl:2309.019] FRISBHEE: FRIedmann Solver for Black Hole Evaporation in the Early-universe

FRISBHEE (FRIedmann Solver for Black Hole Evaporation in the Early-universe solves the Friedmann - Boltzmann equations for Primordial Black Holes + SM radiation + BSM Models. Considering the collapse of density fluctuations as the PBH formation mechanism, the code handles monochromatic and extended mass and spin distributions. FRISBHEE can return the full evolution of the PBH, SM and Dark Radiation comoving energy densities, together with the evolution of the PBH mass and spin as a function of the log10 at scale factor, and can determine the relic abundance in the case of Dark Matter produced from BH evaporation for monochromatic and extended distributions.

[ascl:1406.006] FROG: Time-series analysis

FROG performs time series analysis and display. It provides a simple user interface for astronomers wanting to do time-domain astrophysics but still offers the powerful features found in packages such as PERIOD (ascl:1406.005). FROG includes a number of tools for manipulation of time series. Among other things, the user can combine individual time series, detrend series (multiple methods) and perform basic arithmetic functions. The data can also be exported directly into the TOPCAT (ascl:1101.010) application for further manipulation if needed.

[ascl:1911.010] Fruitbat: Fast radio burst redshift estimation

Fruitbat estimates the redshift of Fast Radio Bursts (FRB) from their dispersion measure. The code combines various dispersion measure (DM) and redshift relations with the YMW16 galactic dispersion measure model into a single easy to use API.

[ascl:1506.006] fsclean: Faraday Synthesis CLEAN imager

Fsclean produces 3D Faraday spectra using the Faraday synthesis method, transforming directly from multi-frequency visibility data to the Faraday depth-sky plane space. Deconvolution is accomplished using the CLEAN algorithm, and the package includes Clark and Högbom style CLEAN algorithms. Fsclean reads in MeasurementSet visibility data and produces HDF5 formatted images; it handles images and data of arbitrary size, using scratch HDF5 files as buffers for data that is not being immediately processed, and is limited only by available disk space.

[ascl:1710.012] FSFE: Fake Spectra Flux Extractor

The fake spectra flux extractor generates simulated quasar absorption spectra from a particle or adaptive mesh-based hydrodynamic simulation. It is implemented as a python module. It can produce both hydrogen and metal line spectra, if the simulation includes metals. The cloudy table for metal ionization fractions is included. Unlike earlier spectral generation codes, it produces absorption from each particle close to the sight-line individually, rather than first producing an average density in each spectral pixel, thus substantially preserving more of the small-scale velocity structure of the gas. The code supports both Gadget (ascl:0003.001) and AREPO (ascl:1909.010).

[ascl:1010.043] FSPS: Flexible Stellar Population Synthesis

FSPS is a flexible SPS package that allows the user to compute simple stellar populations (SSPs) for a range of IMFs and metallicities, and for a variety of assumptions regarding the morphology of the horizontal branch, the blue straggler population, the post--AGB phase, and the location in the HR diagram of the TP-AGB phase. From these SSPs the user may then generate composite stellar populations (CSPs) for a variety of star formation histories (SFHs) and dust attenuation prescriptions. Outputs include the "observed" spectra and magnitudes of the SSPs and CSPs at arbitrary redshift. In addition to these fortran routines, several IDL routines are provided that allow easy manipulation of the output. FSPS was designed with the intention that the user would make full use of the provided fortran routines. However, the full FSPS package is quite large, and requires some time for the user to become familiar with all of the options and syntax. Some users may only need SSPs for a range of metallicities and IMFs. For such users, standard SSP sets for several IMFs, evolutionary tracks, and spectral libraries are available here.

[ascl:1711.003] FTbg: Background removal using Fourier Transform

FTbg performs Fourier transforms on FITS images and separates low- and high-spatial frequency components by a user-specified cut. Both components are then inverse Fourier transformed back to image domain. FTbg can remove large-scale background/foreground emission in many astrophysical applications. FTbg has been designed to identify and remove Galactic background emission in Herschel/Hi-GAL continuum images, but it is applicable to any other (e.g., Planck) images when background/foreground emission is a concern.

[ascl:9912.002] FTOOLS: A general package of software to manipulate FITS files

FTOOLS, a highly modular collection of utilities for processing and analyzing data in the FITS (Flexible Image Transport System) format, has been developed in support of the HEASARC (High Energy Astrophysics Research Archive Center) at NASA's Goddard Space Flight Center. The FTOOLS package contains many utility programs which perform modular tasks on any FITS image or table, as well as higher-level analysis programs designed specifically for data from current and past high energy astrophysics missions. The utility programs for FITS tables are especially rich and powerful, and provide functions for presentation of file contents, extraction of specific rows or columns, appending or merging tables, binning values in a column or selecting subsets of rows based on a boolean expression. Individual FTOOLS programs can easily be chained together in scripts to achieve more complex operations such as the generation and displaying of spectra or light curves. FTOOLS development began in 1991 and has produced the main set of data analysis software for the current ASCA and RXTE space missions and for other archival sets of X-ray and gamma-ray data. The FTOOLS software package is supported on most UNIX platforms and on Windows machines. The user interface is controlled by standard parameter files that are very similar to those used by IRAF. The package is self documenting through a stand alone help task called fhelp. Software is written in ANSI C and FORTRAN to provide portability across most computer systems. The data format dependencies between hardware platforms are isolated through the FITSIO library package.

[ascl:2112.025] FTP: 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:2004.011] FUNDPAR: Deriving FUNDamental PARameters from equivalent widths

FUNDPAR determines fundamental parameters of solar-type stars, by using as input the Equivalent Widths of Fe I,II lines. The code uses solar-scaled ATLAS9 model atmospheres with NEWODF opacities, together with the 2009 version of the MOOG (ascl:1202.009) program. Parameter files control different details, such as the mixing-length parameter, the overshooting, and the damping of the lines. FUNDPAR also derives the uncertainties of the parameters.

[ascl:1112.002] Funtools: FITS Users Need Tools

Funtools is a "minimal buy-in" FITS library and utility package developed at the the High Energy Astrophysics Division of SAO. The Funtools library provides simplified access to a wide array of file types: standard astronomical FITS images and binary tables, raw arrays and binary event lists, and even tables of ASCII column data. A sophisticated region filtering library (compatible with ds9) filters images and tables using boolean operations between geometric shapes, support world coordinates, etc. Funtools also supports advanced capabilities such as optimized data searching using index files.

Because Funtools consists of a library and a set of user programs, it is most appropriately built from source. Funtools has been ported to Solaris, Linux, LinuxPPC, SGI, Alpha OSF1, Mac OSX (darwin) and Windows 98/NT/2000/XP. Once the source code tar file is retrieved, Funtools can be built and installed easily using standard commands.

[ascl:1205.005] Fv: Interactive FITS file editor

Fv is an easy-to-use graphical program for viewing and editing any FITS format image or table. The Fv software is small, completely self-contained and runs on Windows PCs, most Unix platforms and Mac OS-X. Fv also provides a portal into the Hera data analysis service from the HEASARC.

[ascl:1010.015] Fyris Alpha: Computational Fluid Dynamics Code

Fyris Alpha is a high resolution, shock capturing, multi-phase, up-wind Godunov method hydrodynamics code that includes a variable equation of state and optional microphysics such as cooling, gravity and multiple tracer variables. The code has been designed and developed for use primarily in astrophysical applications, such as galactic and interstellar bubbles, hypersonic shocks, and a range of jet phenomena. Fyris Alpha boasts both higher performance and more detailed microphysics than its predecessors, with the aim of producing output that is closer to the observational domain, such as emission line fluxes, and eventually, detailed spectral synthesis. Fyris Alpha is approximately 75,000 lines of C code; it encapsulates the split sweep semi-lagrangian remap PPM method used by ppmlr (in turn developed from VH1, Blondin et al. 1998) but with an improved Riemann solver, which is derived from the exact solver of Gottlieb and Groth (1988), a significantly faster solution than previous solvers. It has a number of optimisations that have improved the speed so that additional calculations neeed for multi-phase simulations become practical.

[ascl:2202.001] GA Galaxy: Interacting galaxies model fitter

GA Galaxy fits models of interacting galaxies to synthetic data using a genetic algorithm and custom fitness function. The genetic algorithm is real-coded and uses a mixed Gaussian kernel for mutation. The fitness function incorporates 1.) a direct pixel-to-pixel comparison between the target and model images and 2.) a comparison of the degree of tidal distortion present in the target and model image such that target-model pairs which are similarly distorted will have a higher relative fitness. The genetic algorithm is written in Python 2.7 while the simulation code (SPAM: Stellar Particle Animation Module) is written in Fortran 90.

[ascl:1801.011] GABE: Grid And Bubble Evolver

GABE (Grid And Bubble Evolver) evolves scalar fields (as well as other purposes) on an expanding background for non-canonical and non-linear classical field theory. GABE is based on the Runge-Kutta method.

[ascl:0003.001] GADGET-2: A Code for Cosmological Simulations of Structure Formation

The cosmological simulation code GADGET-2, a new massively parallel TreeSPH code, is capable of following a collisionless fluid with the N-body method, and an ideal gas by means of smoothed particle hydrodynamics (SPH). The implementation of SPH manifestly conserves energy and entropy in regions free of dissipation, while allowing for fully adaptive smoothing lengths. Gravitational forces are computed with a hierarchical multipole expansion, which can optionally be applied in the form of a TreePM algorithm, where only short-range forces are computed with the `tree'-method while long-range forces are determined with Fourier techniques. Time integration is based on a quasi-symplectic scheme where long-range and short-range forces can be integrated with different timesteps. Individual and adaptive short-range timesteps may also be employed. The domain decomposition used in the parallelisation algorithm is based on a space-filling curve, resulting in high flexibility and tree force errors that do not depend on the way the domains are cut. The code is efficient in terms of memory consumption and required communication bandwidth. It has been used to compute the first cosmological N-body simulation with more than 10^10 dark matter particles, reaching a homogeneous spatial dynamic range of 10^5 per dimension in a 3D box. It has also been used to carry out very large cosmological SPH simulations that account for radiative cooling and star formation, reaching total particle numbers of more than 250 million. GADGET-2 is publicly released to the research community.

[ascl:2204.014] GADGET-4: Parallel cosmological N-body and SPH code

GADGET-4 (GAlaxies with Dark matter and Gas intEracT) is a parallel cosmological N-body and SPH code that simulates cosmic structure formation and calculations relevant for galaxy evolution and galactic dynamics. It is massively parallel and flexible, and can be applied to a variety of different types of simulations, offering a number of sophisticated simulation algorithms. GADGET-4 supports collisionless simulations and smoothed particle hydrodynamics on massively parallel computers.

The code can be used for plain Newtonian dynamics, or for cosmological integrations in arbitrary cosmologies, both with or without periodic boundary conditions. Stretched periodic boxes, and special cases such as simulations with two periodic dimensions and one non-periodic dimension are supported as well. The modeling of hydrodynamics is optional. The code is adaptive both in space and in time, and its Lagrangian character makes it particularly suitable for simulations of cosmic structure formation. Several post-processing options such as group- and substructure finding, or power spectrum estimation are built in and can be carried out on the fly or applied to existing snapshots. Through a built-in cosmological initial conditions generator, it is also particularly easy to carry out cosmological simulations. In addition, merger trees can be determined directly by the code.

[ascl:1108.005] Gaepsi: Gadget Visualization Toolkit

Gaepsi is a PYTHON extension for visualizing cosmology simulations produced by Gadget. Visualization is the most important facet of Gaepsi, but it also allows data analysis on GADGET simulations with its growing number of physics related subroutines and constants. Unlike mesh based scheme, SPH simulations are directly visible in the sense that a splatting process is required to produce raster images from the simulations. Gaepsi produces images of 2-dimensional line-of-sight projections of the simulation. Scalar fields and vector fields are both supported.

Besides the traditional way of slicing a simulation, Gaepsi also has built-in support of 'Survey-like' domain transformation proposed by Carlson & White. An improved implementation is used in Gaepsi. Gaepsi both implements an interactive shell for plotting and exposes its API for batch processing. When complied with OpenMP, Gaepsi automatically takes the advantage of the multi-core computers. In interactive mode, Gaepsi is capable of producing images of size up to 32000 x 32000 pixels. The user can zoom, pan and rotate the field with a command in on the finger tip. The interactive mode takes full advantages of matplotlib's rich annotating, labeling and image composition facilities. There are also built-in commands to add objects that are commonly used in cosmology simulations to the figures.

[ascl:2312.032] gaia_tools: Tools for working with Gaia and related data sets

gaia_tools contains codes for working with the ESA/Gaia data and related data sets (APOGEE, GALAH, LAMOST DR2, and RAVE). Written in Python, it includes tools to read catalogs, perform cross-matching, read RVS or XP spectra, and query the Gaia archive. gaia_tools also contains various matching recipes, such as matching APOGEE or APOGEE-RC to Gaia DR2, and RAVE to TGAS (taking into account the epoch difference).

[ascl:1403.024] GAIA: Graphical Astronomy and Image Analysis Tool

GAIA is an image and data-cube display and analysis tool for astronomy. It provides the usual facilities of image display tools, plus more astronomically useful ones such as aperture and optimal photometry, contouring, source detection, surface photometry, arbitrary region analysis, celestial coordinate readout, calibration and modification, grid overlays, blink comparison, defect patching and the ability to query on-line catalogues and image servers. It can also display slices from data-cubes, extract and visualize spectra as well as perform full 3D rendering. GAIA uses the Starlink software environment (ascl:1110.012) and is derived from the ESO SkyCat tool (ascl:1109.019).

[ascl:1707.006] Gala: Galactic astronomy and gravitational dynamics

Gala is a Python package (and Astropy affiliated package) for Galactic astronomy and gravitational dynamics. The bulk of the package centers around implementations of gravitational potentials, numerical integration, nonlinear dynamics, and astronomical velocity transformations (i.e. proper motions). Gala uses the Astropy units and coordinates subpackages extensively to provide a clean, pythonic interface to these features but does any heavy-lifting in C and Cython for speed.
20221218 aa: Updated ADS links to new ADS format; updated site links from http: to https:

[ascl:1302.011] GALA: Stellar atmospheric parameters and chemical abundances

GALA is a freely distributed Fortran code to derive the atmospheric parameters (temperature, gravity, microturbulent velocity and overall metallicity) and abundances for individual species of stellar spectra using the classical method based on the equivalent widths of metallic lines. The abundances of individual spectral lines are derived by using the WIDTH9 code developed by R. L. Kurucz. GALA is designed to obtain the best model atmosphere, by optimizing temperature, surface gravity, microturbulent velocity and metallicity, after rejecting the discrepant lines. Finally, it computes accurate internal errors for each atmospheric parameter and abundance. The code obtains chemical abundances and atmospheric parameters for large stellar samples quickly, thus making GALA an useful tool in the epoch of the multi-object spectrographs and large surveys.

[ascl:2103.018] GalacticDNSMass: Bayesian inference determination of mass distribution of Galactic double neutron stars

GalacticDNSMass performs Bayesian inference on Galactic double neutron stars (DNS) to investigate their mass distribution. Each DNS is comprised of two neutron stars (NS), a recycled NS and a non-recycled (slow) NS. It compares two hypotheses: A - recycled NS and non-recycled NS follow an identical mass distribution, and B - they are drawn from two distinct populations. Within each hypothesis it also explore three possible functional models: Gaussian, two-Gaussian (mixture model), and uniform mass distributions.

[ascl:1109.011] GalactICS: Galaxy Model Building Package

GalactICS generates N-body realizations of axisymmetric galaxy models consisting of disk, bulge and halo. Some of the code is in Fortran 77, using lines longer than 72 characters in some cases. The -e flag in the makefile allow for this for a Solaris f77 compiler. Other programs are written in C. Again, the linking between these routines works on Solaris systems, but may need to be adjusted for other architectures. We have found that linking using f77 instead of ld will often automatically load the appropriate libraries.

The graphics output by some of the programs (dbh, plotforce, diskdf, plothalo) uses the PGPLOT library. Alternatively, remove all calls to routines with names starting with "PG", as well as the -lpgplot flag in the Makefile, and the programs should still run fine.

[ascl:1108.004] Galacticus: A Semi-Analytic Model of Galaxy Formation

Galacticus is designed to solve the physics involved in the formation of galaxies within the current standard cosmological framework. It is of a type of model known as “semi-analytic” in which the numerous complex non-linear physics involved are solved using a combination of analytic approximations and empirical calibrations from more detailed, numerical solutions. Models of this type aim to begin with the initial state of the Universe (specified shortly after the Big Bang) and apply physical principles to determine the properties of galaxies in the Universe at later times, including the present day. Typical properties computed include the mass of stars and gas in each galaxy, broad structural properties (e.g. radii, rotation speeds, geometrical shape etc.), dark matter and black hole contents, and observable quantities such as luminosities, chemical composition etc.

[ascl:1303.018] Galactus: Modeling and fitting of galaxies from neutral hydrogen (HI) cubes

Galactus, written in python, is an astronomical software tool for the modeling and fitting of galaxies from neutral hydrogen (HI) cubes. Galactus uses a uniform medium to generate a cube. Galactus can perform the full-radiative transfer for the HI, so can model self-absorption in the galaxy.

[ascl:1408.011] GALAPAGOS-C: Galaxy Analysis over Large Areas

GALAPAGOS-C is a C implementation of the IDL code GALAPAGOS (ascl:1203.002). It processes a complete set of survey images through automation of source detection via SExtractor (ascl:1010.064), postage stamp cutting, object mask preparation, sky background estimation and complex two-dimensional light profile Sérsic modelling via GALFIT (ascl:1104.010). GALAPAGOS-C uses MPI-parallelization, thus allowing quick processing of large data sets. The code can fit multiple Sérsic profiles to each galaxy, each representing distinct galaxy components (e.g. bulge, disc, bar), and optionally can fit asymmetric Fourier mode distortions.

[ascl:1203.002] GALAPAGOS: Galaxy Analysis over Large Areas: Parameter Assessment by GALFITting Objects from SExtractor

GALAPAGOS, Galaxy Analysis over Large Areas: Parameter Assessment by GALFITting Objects from SExtractor (ascl:1010.064), automates source detection, two-dimensional light-profile Sersic modelling and catalogue compilation in large survey applications. Based on a single setup, GALAPAGOS can process a complete set of survey images. It detects sources in the data, estimates a local sky background, cuts postage stamp images for all sources, prepares object masks, performs Sersic fitting including neighbours and compiles all objects in a final output catalogue. For the initial source detection GALAPAGOS applies SExtractor, while GALFIT (ascl:1104.010) is incorporated for modelling Sersic profiles. It measures the background sky involved in the Sersic fitting by means of a flux growth curve. GALAPAGOS determines postage stamp sizes based on SExtractor shape parameters. In order to obtain precise model parameters GALAPAGOS incorporates a complex sorting mechanism and makes use of multiplexing capabilities. It combines SExtractor and GALFIT data in a single output table. When incorporating information from overlapping tiles, GALAPAGOS automatically removes multiple entries from identical sources.

GALAPAGOS is programmed in the Interactive Data Language, IDL. A C implementation of the software, GALAPAGOS-C (ascl:1408.011), is available, and a multi-band Galapagos version is also available.

[ascl:1710.022] galario: Gpu Accelerated Library for Analyzing Radio Interferometer Observations

The galario library exploits the computing power of modern graphic cards (GPUs) to accelerate the comparison of model predictions to radio interferometer observations. It speeds up the computation of the synthetic visibilities given a model image (or an axisymmetric brightness profile) and their comparison to the observations.

[ascl:1503.002] Galax2d: 2D isothermal Euler equations solver

Galax2d computes the 2D stationary solution of the isothermal Euler equations of gas dynamics in a rotating galaxy with a weak bar. The gravitational potential represents a weak bar and controls the flow. A damped Newton method solves the second-order upwind discretization of the equations for a steady-state solution, using a consistent linearization and a direct solver. The code can be applied as a tool for generating flow models if used on not too fine meshes, up to 256 by 256 cells for half a disk in polar coordinates.

[ascl:1104.005] GALAXEV: Evolutionary Stellar Population Synthesis Models

GALAXEV is a library of evolutionary stellar population synthesis models computed using the new isochrone synthesis code of Bruzual & Charlot (2003). This code allows one to computes the spectral evolution of stellar populations in wide ranges of ages and metallicities at a resolution of 3 Å across the whole wavelength range from 3200 Å to 9500 Å, and at lower resolution outside this range.

[ascl:1901.005] Galaxia_wrap: Galaxia wrapper for generating mock stellar surveys

Galaxia_wrap is a python wrap around the popular Galaxia tool (ascl:1101.007) for generating mock stellar surveys, such as a magnitude limited survey, using a built-in Galaxy model or directly from n-body data. It also offers n-body functionality and has been used to infer the age distribution of a specific stellar tracer population.

[ascl:1101.007] Galaxia: A Code to Generate a Synthetic Survey of the Milky Way

We present here a fast code for creating a synthetic survey of the Milky Way. Given one or more color-magnitude bounds, a survey size and geometry, the code returns a catalog of stars in accordance with a given model of the Milky Way. The model can be specified by a set of density distributions or as an N-body realization. We provide fast and efficient algorithms for sampling both types of models. As compared to earlier sampling schemes which generate stars at specified locations along a line of sight, our scheme can generate a continuous and smooth distribution of stars over any given volume. The code is quite general and flexible and can accept input in the form of a star formation rate, age metallicity relation, age velocity dispersion relation and analytic density distribution functions. Theoretical isochrones are then used to generate a catalog of stars and support is available for a wide range of photometric bands. As a concrete example we implement the Besancon Milky Way model for the disc. For the stellar halo we employ the simulated stellar halo N-body models of Bullock & Johnston (2005). In order to sample N-body models, we present a scheme that disperses the stars spawned by an N-body particle, in such a way that the phase space density of the spawned stars is consistent with that of the N-body particles. The code is ideally suited to generating synthetic data sets that mimic near future wide area surveys such as GAIA, LSST and HERMES. As an application we study the prospect of identifying structures in the stellar halo with a simulated GAIA survey.

[submitted] GalaXimView

GalaXimView (for Galaxies Simulations Viewer) is a python3+matplotlib tool designed to visualise simulations which use particles, providing notably a rotatable 3D view and corresponding projections in 2D, together with a way of navigating through snapshots of a simulation keeping the same projection.

[ascl:1904.002] GALAXY: N-body simulation software for isolated, collisionless stellar systems

GALAXY evolves (almost) isolated, collisionless stellar systems, both disk-like and ellipsoidal. In addition to the N-body code galaxy, which offers eleven different methods to compute the gravitational accelerations, the package also includes sophisticated set-up and analysis software. While not as versatile as tree codes, for certain restricted applications the particle-mesh methods in GALAXY are 50 to 200 times faster than a widely-used tree code. After reading in data providing the initial positions, velocities, and (optionally) masses of the particles, GALAXY compute the gravitational accelerations acting on each particle and integrates forward the velocities and positions of the particles for a short time step, repeating these two steps as desired. Intermediate results can be saved, as can the final moment in a state from which the integration could be resumed. Particles can have individual masses and their motion can be integrated using a range of time steps for greater efficiency; message-passing-interface (MPI) calls are available to enable GALAXY's use on parallel machines with high efficiency.

[ascl:1312.010] GalaxyCount: Galaxy counts and variance calculator

GalaxyCount calculates the number and standard deviation of galaxies in a magnitude limited observation of a given area. The methods to calculate both the number and standard deviation may be selected from different options. Variances may be computed for circular, elliptical and rectangular window functions.

[ascl:1702.006] GalaxyGAN: Generative Adversarial Networks for recovery of galaxy features

GalaxyGAN uses Generative Adversarial Networks to reliably recover features in images of galaxies. The package uses machine learning to train on higher quality data and learns to recover detailed features such as galaxy morphology by effectively building priors. This method opens up the possibility of recovering more information from existing and future imaging data.

[ascl:2301.022] GalCEM: GALactic Chemical Evolution Model

GalCEM (GALactic Chemical Evolution Model) tracks isotope masses as a function of time in a given galaxy. The list of tracked isotopes automatically adapts to the complete set provided by the input yields. The prescription includes massive stars, low-to-intermediate mass stars, and Type Ia supernovae as enrichment channels. Multi-dimensional interpolation curves are extracted from the input yield tables with a preprocessing tool; these interpolation curves improve the computation speeds of the full convolution integrals, which are computed for each isotope and for each enrichment channel. GalCEM also provides tools to track the mass rate change of individual isotopes on a typical spiral galaxy with a final baryonic mass of 5×1010M⊙.

[ascl:2312.027] galclaim: GALaxy Chance of Local Alignment algorIthM

galclaim identifies association between astrophysical transient sources and host galaxy. This association is made by estimating the chance alignment between a given transient sky localization and nearby galaxies. The code can be used with various catalogs, including Pan-STARRS, HSC, AllWISE and GLADE. galclaim also pre-checks for nearby bright galaxy using the RC3 catalog (https://heasarc.gsfc.nasa.gov/w3browse/all/rc3.html). When a nearby galaxy is found, a warning is raised and the properties of the galaxy are saved in a dedicated output file. The package can create plots displaying the computed pval for the found objects for each transient and each catalog; plots are stored in the result/plots directory.

[ascl:1812.009] galclassify: Stellar classifications using a galactic population synthesis model

The stellar classification code galclassify is a stand-alone version of Galaxia (ascl:1101.007). It classifies and generates a synthetic population for each star using input containing observables in a fixed format rather than using a precomputed population over a large field. It is suitable for individual stellar classifications, but slow if you want to classify large samples of stars.

[ascl:1010.033] GALEV Evolutionary Synthesis Models

GALEV evolutionary synthesis models describe the evolution of stellar populations in general, of star clusters as well as of galaxies, both in terms of resolved stellar populations and of integrated light properties over cosmological timescales of > 13 Gyr from the onset of star formation shortly after the Big Bang until today.

For galaxies, GALEV includes a simultaneous treatment of the chemical evolution of the gas and the spectral evolution of the stellar content, allowing for a chemically consistent treatment using input physics (stellar evolutionary tracks, stellar yields and model atmospheres) for a large range of metallicities and consistently account for the increasing initial abundances of successive stellar generations.

[ascl:1810.001] galfast: Milky Way mock catalog generator

galfast generates catalogs for arbitrary, user-supplied Milky Way models, including empirically derived ones. The built-in model set is based on fits to SDSS stellar observations over 8000 deg2 of the sky and includes a three-dimensional dust distribution map. Because of the capability to use empirically derived models, galfast typically produces closer matches to the actual observed counts and color-magnitude diagrams. In particular, galfast-generated catalogs are used to derive the stellar component of “Universe Model” catalogs used by the LSST Project. A key distinguishing characteristic of galfast is its speed. Galfast uses the GPU (with kernels written in NVIDIA C/C++ for CUDA) to offload compute intensive model sampling computations to the GPU, enabling the generation of realistic catalogs to full LSST depth in hours (instead of days or weeks), making it possible to study proposed science cases with high precision.

[ascl:1104.010] GALFIT: Detailed Structural Decomposition of Galaxy Images

GALFIT is a two-dimensional (2-D) fitting algorithm designed to extract structural components from galaxy images, with emphasis on closely modeling light profiles of spatially well-resolved, nearby galaxies observed with the Hubble Space Telescope. The algorithm improves on previous techniques in two areas: 1.) by being able to simultaneously fit a galaxy with an arbitrary number of components, and 2.) with optimization in computation speed, suited for working on large galaxy images. 2-D models such as the "Nuker'' law, the Sersic (de Vaucouleurs) profile, an exponential disk, and Gaussian or Moffat functions are used. The azimuthal shapes are generalized ellipses that can fit disky and boxy components. Many galaxies with complex isophotes, ellipticity changes, and position-angle twists can be modeled accurately in 2-D. When examined in detail, even simple-looking galaxies generally require at least three components to be modeled accurately rather than the one or two components more often employed. This is illustrated by way of seven case studies, which include regular and barred spiral galaxies, highly disky lenticular galaxies, and elliptical galaxies displaying various levels of complexities. A useful extension of this algorithm is to accurately extract nuclear point sources in galaxies.

[ascl:1510.005] GALFORM: Galactic modeling

GALFORM is a semi-analytic model for calculating the formation and evolution of galaxies in hierarchical clustering cosmologies. Using a Monte Carlo algorithm to follow the merging evolution of dark matter haloes with arbitrary mass resolution, it incorporates realistic descriptions of the density profiles of dark matter haloes and the gas they contain. It follows the chemical evolution of gas and stars, and the associated production of dust and includes a detailed calculation of the sizes of discs and spheroids.

[ascl:1408.008] GALIC: Galaxy initial conditions construction

GalIC (GALaxy Initial Conditions) is an implementation of an iterative method to construct steady state composite halo-disk-bulge galaxy models with prescribed density distribution and velocity anisotropy that can be used as initial conditions for N-body simulations. The code is parallelized for distributed memory based on MPI. While running, GalIC produces "snapshot files" that can be used as initial conditions files. GalIC supports the three file formats ('type1' format, the slightly improved 'type2' format, and an HDF5 format) of the GADGET (ascl:0003.001) code for its output snapshot files.

[ascl:2209.011] GaLight: 2D modeling of galaxy images

GaLight (Galaxy shapes of Light) performs two-dimensional model fitting of optical and near-infrared images to characterize the light distribution of galaxies with components including a disk, bulge, bar and quasar. Light is decomposes into PSF and Sersic, and the fitting is based on lenstronomy (ascl:1804.01). GaLight's automated features including searching PSF stars in the FOV, automatically estimating the background noise level, and cutting out the target object galaxies (QSOs) and preparing the materials to model the data. It can also detect objects in the cutout stamp and quickly create Sersic keywords to model them, and model QSOs and galaxies using 2D Sersic profile and scaled point source.

[ascl:1511.010] Galileon-Solver: N-body code

Galileon-Solver adds an extra force to PMCode (ascl:9909.001) using a modified Poisson equation to provide a non-linearly transformed density field, with the operations all performed in real space. The code's implicit spherical top-hat assumption only works over fairly long distance averaging scales, where the coarse-grained picture it relies on is a good approximation of reality; it uses discrete Fourier transforms and cyclic reduction in the usual way.

[ascl:1903.010] GalIMF: Galaxy-wide Initial Mass Function

GalIMF (Galaxy-wide Initial Mass Function) computes the galaxy-wide initial stellar mass function by integrating over a whole galaxy, parameterized by star formation rate and metallicity. The generated stellar mass distribution depends on the galaxy-wide star formation rate (SFR, which is related to the total mass of a galalxy) and the galaxy-wide metallicity. The code can generate a galaxy-wide IMF (IGIMF) and can also generate all the stellar masses within a galaxy with optimal sampling (OSGIMF). To compute the IGIMF or the OSGIMF, the GalIMF module contains all local IMF properties (e.g. the dependence of the stellar IMF on the metallicity, on the density of the star-cluster forming molecular cloud cores), and this software module can, therefore, be also used to obtain only the stellar IMF with various prescriptions, or to investigate other features of the stellar population such as what is the most massive star that can be formed in a star cluster.

[ascl:1711.011] galkin: Milky Way rotation curve data handler

galkin is a compilation of kinematic measurements tracing the rotation curve of our Galaxy, together with a tool to treat the data. The compilation is optimized to Galactocentric radii between 3 and 20 kpc and includes the kinematics of gas, stars and masers in a total of 2780 measurements collected from almost four decades of literature. The user-friendly software provided selects, treats and retrieves the data of all source references considered. This tool is especially designed to facilitate the use of kinematic data in dynamical studies of the Milky Way with various applications ranging from dark matter constraints to tests of modified gravity.

[ascl:2103.027] GalLenspy: Reconstruction of mass profile in disc-like galaxies from the gravitational lensing effect

Gallenspy uses the gravitational lensing effect (GLE) to reconstruct mass profiles in disc-like galaxies. The algorithm inverts the lens equation for gravitational potentials with spherical symmetry, in addition to the estimation in the position of the source, given the positions of the images produced by the lens. Gallenspy also computes critical and caustic curves and the Einstein ring.

[ascl:2202.017] GALLUMI: GALaxy LUMInosity function pipeline

GALLUMI (GALaxy LUMInosity) is a likelihood code that extracts cosmological and astrophysical parameters from the UV galaxy luminosity function. The code is implemented in the MCMC sampler MontePython (ascl:1307.002) and can be readily run in conjunction with other likelihood codes.

[ascl:1903.005] Galmag: Computation of realistic galactic magnetic fields

Galmag computes galactic magnetic fields based on mean field dynamo theory. Written in Python, Galmag allows quick exploration of solutions to the mean field dynamo equation based on galaxy parameters specified by the user, such as the scale height profile and the galaxy rotation curves. The magnetic fields are solenoidal by construction and can be helical.

[submitted] GalMOSS: A package for GPU-accelerated Galaxy Profile Fitting

We introduce GalMOSS, a Python-based, Torch-powered tool for two-dimensional fitting of galaxy profiles. By seamlessly enabling GPU parallelization, GalMOSS meets the high computational demands of large-scale galaxy surveys, placing galaxy profile fitting in the LSST-era. It incorporates widely used profiles such as the Sérsic, Exponential disk, Ferrer, King, Gaussian, and Moffat profiles, and allows for the easy integration of more complex models. Tested on 8,289 galaxies from the Sloan Digital Sky Survey (SDSS) g-band with a single NVIDIA A100 GPU, GalMOSS completed classical Sérsic profile fitting in about 10 minutes. Benchmark tests show that GalMOSS achieves computational speeds that are 6 $\times$ faster than those of default implementations.

[ascl:1501.014] GalPaK 3D: Galaxy parameters and kinematics extraction from 3D data

GalPaK 3D extracts the intrinsic (i.e. deconvolved) galaxy parameters and kinematics from any 3-dimensional data. The algorithm uses a disk parametric model with 10 free parameters (which can also be fixed independently) and a MCMC approach with non-traditional sampling laws in order to efficiently probe the parameter space. More importantly, it uses the knowledge of the 3-dimensional spread-function to return the intrinsic galaxy properties and the intrinsic data-cube. The 3D spread-function class is flexible enough to handle any instrument.

GalPaK 3D can simultaneously constrain the kinematics and morphological parameters of (non-merging, i.e. regular) galaxies observed in non-optimal seeing conditions and can also be used on AO data or on high-quality, high-SNR data to look for non-axisymmetric structures in the residuals.

[ascl:1611.006] GalPot: Galaxy potential code

GalPot finds the gravitational potential associated with axisymmetric density profiles. The package includes code that performs transformations between commonly used coordinate systems for both positions and velocities (the class OmniCoords), and that integrates orbits in the potentials. GalPot is a stand-alone version of Walter Dehnen's GalaxyPotential C++ code taken from the falcON code in the NEMO Stellar Dynamics Toolbox (ascl:1010.051).

[ascl:1010.028] GALPROP: Code for Cosmic-ray Transport and Diffuse Emission Production

GALPROP is a numerical code for calculating the propagation of relativistic charged particles and the diffuse emissions produced during their propagation. The GALPROP code incorporates as much realistic astrophysical input as possible together with latest theoretical developments. The code calculates the propagation of cosmic-ray nuclei, antiprotons, electrons and positrons, and computes diffuse γ-rays and synchrotron emission in the same framework. Each run of the code is governed by a configuration file allowing the user to specify and control many details of the calculation. Thus, each run of the code corresponds to a potentially different "model." The code continues to be developed and is available to the scientific community.

[ascl:1411.008] galpy: Galactic dynamics package

galpy is a python package for galactic dynamics. It supports orbit integration in a variety of potentials, evaluating and sampling various distribution functions, and the calculation of action-angle coordinates for all static potentials.

[ascl:2102.013] GalRotpy: Parametrize the rotation curve and gravitational potential of disk-like galaxies

GalRotpy models the dynamical mass of disk-like galaxies and makes a parametric fit of the rotation curve by means of the composed gravitational potential of the galaxy. It can be used to check the presence of an assumed mass type component in a observed rotation curve, to determine quantitatively the main mass contribution in a galaxy by means of the mass ratios of a given set of five potentials, and to bound the contribution of each mass component given its gravitational potential parameters.

[ascl:1402.009] GalSim: Modular galaxy image simulation toolkit

GalSim is a fast, modular software package for simulation of astronomical images. Though its primary purpose is for tests of weak lensing analysis methods, it can be used for other purposes. GalSim allows galaxies and PSFs to be represented in a variety of ways, and can apply shear, magnification, dilation, or rotation to a galaxy profile including lensing-based models from a power spectrum or NFW halo profile. It can write images in regular FITS files, FITS data cubes, or multi-extension FITS files. It can also compress the output files using various compressions including gzip, bzip2, and rice. The user interface is in python or via configuration scripts, and the computations are done in C++ for speed.

[ascl:1711.007] galstep: Initial conditions for spiral galaxy simulations

galstep generates initial conditions for disk galaxy simulations with GADGET-2 (ascl:0003.001), RAMSES (ascl:1011.007) and GIZMO (ascl:1410.003), including a stellar disk, a gaseous disk, a dark matter halo and a stellar bulge. The first two components follow an exponential density profile, and the last two a Dehnen density profile with gamma=1 by default, corresponding to a Hernquist profile.

[ascl:1711.010] galstreams: Milky Way streams footprint library and toolkit

galstreams provides a compilation of spatial information for known stellar streams and overdensities in the Milky Way and includes Python tools for visualizing them. ASCII tables are also provided for quick viewing of the stream's footprints using TOPCAT (ascl:1101.010). As of 2022, the library provides celestial, distance, proper motion and radial velocity tracks for each stream (pm/vrad when available) stored as AstroPy (ascl:1304.002) SkyCoord objects and a stream's (heliocentric) coordinate frame is realized as an AstroPy reference frame. The code offers polygon footprints and pole (at mid point) and pole tracks in the heliocentric and Galactocentric (GSR) frames. It also offers angular momentum tracks in a heliocentric reference frame at rest with respect to the Galactic center, and provides uniformly reported stream length, end points and mid-point, heliocentric and Galactocentric mid-pole, track and discovery references and information flag denoting which of the 6D attributes (sky, distance, proper motions and radial velocity) are available in the track object.

[ascl:1304.003] GALSVM: Automated Morphology Classification

GALSVM is IDL software for automated morphology classification. It was specially designed for high redshift data but can be used at low redshift as well. It analyzes morphologies of galaxies based on a particular family of learning machines called support vector machines. The method can be seen as a generalization of the classical CAS classification but with an unlimited number of dimensions and non-linear boundaries between decision regions. It is fully automated and consequently well adapted to large cosmological surveys.

[ascl:1708.030] GAMBIT: Global And Modular BSM Inference Tool

GAMBIT (Global And Modular BSM Inference Tool) performs statistical global fits of generic physics models using a wide range of particle physics and astrophysics data. Modules provide native simulations of collider and astrophysics experiments, a flexible system for interfacing external codes (the backend system), a fully featured statistical and parameter scanning framework, and additional tools for implementing and using hierarchical models.

[ascl:1912.012] GAME: GAlaxy Machine learning for Emission lines

GAME infers different ISM physical properties by analyzing the emission line intensities in a galaxy spectrum. The code is trained with a large library of synthetic spectra spanning many different ISM phases, including HII (ionized) regions, PDRs, and neutral regions. GAME is based on a Supervised Machine Learning algorithm called AdaBoost with Decision Trees as base learner. Given a set of input lines in a spectrum, the code performs a training on the library and then evaluates the line intensities to give a determination of the physical properties. The errors on the input emission line intensities and the uncertainties on the physical properties determinations are also taken into account. GAME infers gas density, column density, far-ultraviolet (FUV, 6–13.6 eV) flux, ionization parameter, metallicity, escape fraction, and visual extinction. A web interface for using the code is available.

[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:2203.007] GAMERA: Source modeling in gamma astronomy

GAMERA handles spectral modeling of non-thermally emitting astrophysical sources in a simple and modular way. It allows the user to devise time-dependent models of leptonic and hadronic particle populations in a general astrophysical context (including SNRs, PWNs and AGNs) and to compute their subsequent photon emission. GAMERA can calculate the spectral evolution of a particle population in the presence of time-dependent or constant injection, energy losses and particle escape; it also calculates the radiation spectrum from a parent particle population.

[ascl:2104.024] GAMMA: Relativistic hydro and local cooling on a moving mesh

GAMMA models relativistic hydrodynamics and non-thermal emission on a moving mesh. It uses an arbitrary Lagrangian-Eulerian approach only in the dominant direction of fluid motion to avoid mesh entanglement and associated computational costs. Shock detection, particle injection and local calculation of their evolution including radiative cooling are done at runtime. The package is modular; though it was designed with GRB physics applications in mind, new solvers and geometries can be implemented easily, making GAMMA suitable for a wide range of applications.

[ascl:2109.001] gammaALPs: Conversion probability between photons and axions/axionlike particles

gammaALPs calculates the conversion probability between photons and axions/axion-like particles in various astrophysical magnetic fields. Though focused on environments relevant to mixing between gamma rays and ALPs, this suite, written in Python, can also be used for broader applications. The code also implements various models of astrophysical magnetic fields, which can be useful for applications beyond ALP searches.

[ascl:1110.007] GammaLib: Toolbox for High-level Analysis of Astronomical Gamma-ray Data

The GammaLib is a versatile toolbox for the high-level analysis of astronomical gamma-ray data. It is implemented as a C++ library that is fully scriptable in the Python scripting language. The library provides core functionalities such as data input and output, interfaces for parameter specifications, and a reporting and logging interface. It implements instruments specific functionalities such as instrument response functions and data formats. Instrument specific functionalities share a common interface to allow for extension of the GammaLib to include new gamma-ray instruments. The GammaLib provides an abstract data analysis framework that enables simultaneous multi-mission analysis.

[ascl:1711.014] Gammapy: Python toolbox for gamma-ray astronomy

Gammapy analyzes gamma-ray data and creates sky images, spectra and lightcurves, from event lists and instrument response information; it can also determine the position, morphology and spectra of gamma-ray sources. It is used to analyze data from H.E.S.S., Fermi-LAT, and the Cherenkov Telescope Array (CTA).

[ascl:1105.011] Ganalyzer: A tool for automatic galaxy image analysis

Ganalyzer is a model-based tool that automatically analyzes and classifies galaxy images. Ganalyzer works by separating the galaxy pixels from the background pixels, finding the center and radius of the galaxy, generating the radial intensity plot, and then computing the slopes of the peaks detected in the radial intensity plot to measure the spirality of the galaxy and determine its morphological class. Unlike algorithms that are based on machine learning, Ganalyzer is based on measuring the spirality of the galaxy, a task that is difficult to perform manually, and in many cases can provide a more accurate analysis compared to manual observation. Ganalyzer is simple to use, and can be easily embedded into other image analysis applications. Another advantage is its speed, which allows it to analyze ~10,000,000 galaxy images in five days using a standard modern desktop computer. These capabilities can make Ganalyzer a useful tool in analyzing large datasets of galaxy images collected by autonomous sky surveys such as SDSS, LSST or DES.

[ascl:1708.012] GANDALF: Gas AND Absorption Line Fitting

GANDALF (Gas AND Absorption Line Fitting) accurately separates the stellar and emission-line contributions to observed spectra. The IDL code includes reddening by interstellar dust and also returns formal errors on the position, width, amplitude and flux of the emission lines. Example wrappers that make use of pPXF (ascl:1210.002) to derive the stellar kinematics are included.

[ascl:1602.015] GANDALF: Graphical Astrophysics code for N-body Dynamics And Lagrangian Fluids

GANDALF, a successor to SEREN (ascl:1102.010), is a hybrid self-gravitating fluid dynamics and collisional N-body code primarily designed for investigating star formation and planet formation problems. GANDALF uses various implementations of Smoothed Particle Hydrodynamics (SPH) to perform hydrodynamical simulations of gas clouds undergoing gravitational collapse to form new stars (or other objects), and can perform simulations of pure N-body dynamics using high accuracy N-body integrators, model the intermediate phase of cluster evolution, and provide visualizations via its python interface as well as interactive simulations. Although based on many of the SEREN routines, GANDALF has been largely re-written from scratch in C++ using more optimal algorithms and data structures.

[ascl:1303.027] GaPP: Gaussian Processes in Python

The algorithm Gaussian processes can reconstruct a function from a sample of data without assuming a parameterization of the function. The GaPP code can be used on any dataset to reconstruct a function. It handles individual error bars on the data and can be used to determine the derivatives of the reconstructed function. The data sample can consist of observations of the function and of its first derivative.

[ascl:1010.049] Gas-momentum-kinetic SZ cross-correlations

We present a new method for detecting the missing baryons by generating a template for the kinematic Sunyaev-Zel'dovich effect. The template is computed from the product of a reconstructed velocity field with a galaxy field. We provide maps of such templates constructed from SDSS Data Release 7 spectroscopic data (SDSS VAGC sample) along side with their expected two point correlation functions with CMB temperature anisotropies. Codes of generating such coefficients of the two point correlation function are also released to provide users of the gas-momentum map a way to change the parameters such as cosmological parameters, reionization history, ionization parameters, etc.

[ascl:1210.020] GASGANO: Data File Organizer

GASGANO is a GUI software tool for managing and viewing data files produced by VLT Control System (VCS) and the Data Flow System (DFS). It is developed and maintained by ESO to help its user community manage and organize astronomical data observed and produced by all VLT compliant telescopes in a systematic way. The software understands FITS, PAF, and ASCII files, and Reduction Blocks, and can group, sort, classify, filter, and search data in addition to allowing the user to browse, view, and manage them.

[ascl:1710.019] GASOLINE: Smoothed Particle Hydrodynamics (SPH) code

Gasoline solves the equations of gravity and hydrodynamics in astrophysical problems, including simulations of planets, stars, and galaxies. It uses an SPH method that features correct mixing behavior in multiphase fluids and minimal artificial viscosity. This method is identical to the SPH method used in the ChaNGa code (ascl:1105.005), allowing users to extend results to problems requiring >100,000 cores. Gasoline uses a fast, memory-efficient O(N log N) KD-Tree to solve Poisson's Equation for gravity and avoids artificial viscosity in non-shocking compressive flows.

[ascl:1610.007] gatspy: General tools for Astronomical Time Series in Python

Gatspy contains efficient, well-documented implementations of several common routines for Astronomical time series analysis, including the Lomb-Scargle periodogram, the Supersmoother method, and others.

[ascl:1406.018] GAUSSCLUMPS: Gaussian-shaped clumping from a spectral map

GAUSSCLUMPS decomposes a spectral map into Gaussian-shape clumps. The clump-finding algorithm decomposes a spectral data cube by iteratively removing 3-D Gaussians as representative clumps. GAUSSCLUMPS was originally a separate code distribution but is now a contributed package in GILDAS (ascl:1305.010). A reimplementation can also be found in CUPID (ascl:1311.007).

[ascl:1305.009] GaussFit: Solving least squares and robust estimation problems

GaussFit solves least squares and robust estimation problems; written originally for reduction of NASA Hubble Space Telescope data, it includes a complete programming language designed especially to formulate estimation problems, a built-in compiler and interpreter to support the programming language, and a built-in algebraic manipulator for calculating the required partial derivatives analytically. The code can handle nonlinear models, exact constraints, correlated observations, and models where the equations of condition contain more than one observed quantity. Written in C, GaussFit includes an experimental robust estimation capability so data sets contaminated by outliers can be handled simply and efficiently.

[ascl:1907.019] GaussPy: Python implementation of the Autonomous Gaussian Decomposition algorithm

GaussPy implements the Autonomous Gaussian Decomposition (AGD) algorithm, which uses computer vision and machine learning techniques to provide optimized initial guesses for the parameters of a multi-component Gaussian model automatically and efficiently. The speed and adaptability of AGD allow it to interpret large volumes of spectral data efficiently. Although it was initially designed for applications in radio astrophysics, AGD can be used to search for one-dimensional Gaussian (or any other single-peaked spectral profile)-shaped components in any data set. To determine how many Gaussian functions to include in a model and what their parameters are, AGD uses a technique called derivative spectroscopy. The derivatives of a spectrum can efficiently identify shapes within that spectrum corresponding to the underlying model, including gradients, curvature and edges.

[ascl:1907.020] GaussPy+: Gaussian decomposition package for emission line spectra

GaussPy+ is a fully automated Gaussian decomposition package for emission line spectra. It is based on GaussPy (ascl:1907.019) and offers several improvements, including automating preparatory steps and providing an accurate noise estimation, improving the fitting routine, and providing a routine to refit spectra based on neighboring fit solutions. GaussPy+ handles complex emission and low to moderate signal-to-noise values.

[ascl:1710.014] GBART: Determination of the orbital elements of spectroscopic binaries

GBART is an improved version of the code for determining the orbital elements for spectroscopic binaries originally written by Bertiau & Grobben (1968).

[ascl:2210.011] gbdes: DECam instrumental signature fitting and processing programs

gbdes derives photometric and astrometric calibration solutions for complex multi-detector astronomical imagers. The package includes routines to filter catalogs down to useful stellar objects, collect metadata from the catalogs and create a config file holding FITS binary tables describing exposures, instruments, fields, and other available information in the data, and uses a friends-of-friends matching algorithm to link together all detections of common objects found in distinct exposures. gbdes also calculates airmasses and parallactic angles for each exposure, calculates and saves the expected differential chromatic refraction (DCR) needed for precision astrometry, optimizes the parameters of a photometric model to maximize agreement between magnitudes measured in different exposures of the same source, and optimizing the parameters of an astrometric model to maximize agreement among the exposures and any reference catalogs, and performs other tasks. The solutions derived and used by gbdes are stored in YAML format; gbdes uses the Python code pixmappy (ascl:2210.012) to read the astrometric solution files and execute specified transformations.

[ascl:1908.006] GBKFIT: Galaxy kinematic modeling

GBKFIT performs galaxy kinematic modeling. It can be used to extract morphological and kinematical properties of galaxies by fitting models to spatially resolved kinematic data. The software can also take beam smearing into account by using the knowledge of the line and point spread functions. GBKFIT can take advantage of many-core and massively parallel architectures such as multi-core CPUs and Graphics Processing Units (GPUs), making it suitable for modeling large-scale surveys of thousands of galaxies within a very seasonable time frame. GBKFIT features an extensible object-oriented architecture that supports arbitrary models and optimization techniques in the form of modules; users can write custom modules without modifying GBKFIT’s source code. The software is written in C++ and conforms to the latest ISO standards.

[ascl:1303.019] GBTIDL: Reduction and Analysis of GBT Spectral Line Data

GBTIDL is an interactive package for reduction and analysis of spectral line data taken with the Robert C. Byrd Green Bank Telescope (GBT). The package, written entirely in IDL, consists of straightforward yet flexible calibration, averaging, and analysis procedures (the "GUIDE layer") modeled after the UniPOPS and CLASS data reduction philosophies, a customized plotter with many built-in visualization features, and Data I/O and toolbox functionality that can be used for more advanced tasks. GBTIDL makes use of data structures which can also be used to store intermediate results. The package consumes and produces data in GBT SDFITS format. GBTIDL can be run online and have access to the most recent data coming off the telescope, or can be run offline on preprocessed SDFITS files.

[ascl:2111.015] gCMCRT: 3D Monte Carlo Radiative Transfer for exoplanet atmospheres using GPUs

gCMCRT globally processes 3D atmospheric data, and as a fully 3D model, it avoids the biases and assumptions present when using 1D models to process 3D structures. It is well suited to performing the post-processing of large parameter GCM model grids, and provides simple pipelines that convert the 3D GCM structures from many well used GCMs in the community to the gCMCRT format, interpolating chemical abundances (if needed) and performing the required spectra calculation. The high-resolution spectra modes of gCMCRT provide an additional highly useful capability for 3D modellers to directly compare output to high-resolution spectral data.

[ascl:2302.018] GCP: Automated GILDAS-CLASS Pipeline

This library of scripts provides a simple interface for running the CLASS software from GILDAS (ascl:1305.010) in a semi-automatic way. Using these scripts, one can extract and organize spectra from data files in CLASS format (for example, .30m and .40m), reduce them, and even combine or average them once they are reduced. The library contains five Python scripts and two optional Julia scripts.

[ascl:1811.018] gdr2_completeness: GaiaDR2 data retrieval and manipulation

gdr2_completeness queries Gaia DR2 TAP services and divides the queries into sub-queries chunked into arbitrary healpix bins. Downloaded data are formatted into arrays. Internal completeness is calculated by dividing the total starcount and starcounts with an applied cut (e.g., radial velocity measurement and good parallax). Independent determination of the external GDR2 completeness per healpix (level 6) and G magnitude bin (3 coarse bins: 8-12,12-15,15-18) is inferred from a crossmatch with 2MASS data. The overall completeness of a specific GDR2 sample can be approximated by multiplying the internal with the external completeness map, which is useful when data are compared to models thereof. Jupyter notebooks showcasing both utilities enable the user to easily construct the overall completeness for arbitrary samples of the GDR2 catalogue.

[ascl:1010.079] Geant4: A Simulation Toolkit for the Passage of Particles through Matter

Geant4 is a toolkit for simulating the passage of particles through matter. It includes a complete range of functionality including tracking, geometry, physics models and hits. The physics processes offered cover a comprehensive range, including electromagnetic, hadronic and optical processes, a large set of long-lived particles, materials and elements, over a wide energy range starting, in some cases, from 250eV and extending in others to the TeV energy range. It has been designed and constructed to expose the physics models utilised, to handle complex geometries, and to enable its easy adaptation for optimal use in different sets of applications. The toolkit is the result of a worldwide collaboration of physicists and software engineers. It has been created exploiting software engineering and object-oriented technology and implemented in the C++ programming language. It has been used in applications in particle physics, nuclear physics, accelerator design, space engineering and medical physics.

[ascl:1608.006] Gemini IRAF: Data reduction software for the Gemini telescopes

The Gemini IRAF package processes observational data obtained with the Gemini telescopes. It is an external package layered upon IRAF and supports data from numerous instruments, including FLAMINGOS-2, GMOS-N, GMOS-S, GNIRS, GSAOI, NIFS, and NIRI. The Gemini IRAF package is organized into sub-packages; it contains a generic tools package, "gemtools", along with instrument-specific packages. The raw data from the Gemini facility instruments are stored as Multi-Extension FITS (MEF) files. Therefore, all the tasks in the Gemini IRAF package, intended for processing data from the Gemini facility instruments, are capable of handling MEF files.

[ascl:1007.003] GEMINI: A toolkit for analytical models of two-point correlations and inhomogeneous structure formation

Gemini is a toolkit for analytical models of two-point correlations and inhomogeneous structure formation. It extends standard Press-Schechter theory to inhomogeneous situations, allowing a realistic, analytical calculation of halo correlations and bias.

[ascl:1212.005] General complex polynomial root solver

This general complex polynomial root solver, implemented in Fortran and further optimized for binary microlenses, uses a new algorithm to solve polynomial equations and is 1.6-3 times faster than the ZROOTS subroutine that is commercially available from Numerical Recipes, depending on application. The largest improvement, when compared to naive solvers, comes from a fail-safe procedure that permits skipping the majority of the calculations in the great majority of cases, without risking catastrophic failure in the few cases that these are actually required.

[ascl:2006.020] GenetIC: Initial conditions generator for cosmological simulations

GenetIC generates initial conditions for cosmological simulations, especially for zoom simulations of galaxies. It provides support for "genetic modifications" of specific attributes of simulations to allow study of the impact of such modifications on the outcomes; the code can also produce constrained initial conditions.

[ascl:1812.014] GENGA: Gravitational ENcounters with Gpu Acceleration

GENGA (Gravitational ENcounters with Gpu Acceleration) integrates planet and planetesimal dynamics in the late stage of planet formation and stability analyses of planetary systems. It uses mixed variable integration when the motion is a perturbed Kepler orbit and combines this with a direct N-body Bulirsch-Stoer method during close encounters. It supports three simulation modes: 1.) integration of up to 2048 massive bodies; 2.) integration with up to a million test particles; and 3.) parallel integration of a large number of individual planetary systems.

[ascl:1706.006] GenPK: Power spectrum generator

GenPK generates the 3D matter power spectra for each particle species from a Gadget snapshot. Written in C++, it requires both FFTW3 and GadgetReader.

[ascl:1011.015] Geokerr: Computing Photon Orbits in a Kerr Spacetime

Relativistic radiative transfer problems require the calculation of photon trajectories in curved spacetime. Programmed in Fortran, Geokerr uses a novel technique for rapid and accurate calculation of null geodesics in the Kerr metric. The equations of motion from the Hamilton-Jacobi equation are reduced directly to Carlson's elliptic integrals, simplifying algebraic manipulations and allowing all coordinates to be computed semi-analytically for the first time.

[ascl:1511.015] George: Gaussian Process regression

George is a fast and flexible library, implemented in C++ with Python bindings, for Gaussian Process regression useful for accounting for correlated noise in astronomical datasets, including those for transiting exoplanet discovery and characterization and stellar population modeling.

[ascl:1412.012] GeoTOA: Geocentric TOA tools

GeoTOA computes the pulse times of arrival (TOAs) at an observatory (or spacecraft) from unbinned Fermi LAT data. Written in Python, the software requires NumPy, matplotlib, SciPy, Fermitools (ascl:1905.011), and Tempo2 (ascl:1210.015).

[ascl:2306.058] GER: Global Extinction Reduction

The Global Extinction Reduction IDL codes compare optical photometry from the twin Gemini North and South Multi-Object Spectrographs (GMOS-N and GMOS-S) against the expected worsening of atmospheric transparency due to global climate change. Data from the Gemini instruments are first reduced by DRAGONS (ascl:1811.002). GER then calibrates them against the Sloan Digital Sky Survey (SDSS) and Gaia G-band catalogs; image rotation and alignment is accomplished via identification of sufficiently-bright stars in Gaia. A simple model of Gemini and their site characteristics is generated, including meteorology, cloudy-fractions, number of reflections, dates of re-coatings modulated by rate of efficiency decay, together with response of detectors and associated zeropoints, and can be compared with the decline of transparency due to rising temperature and associated humidity increase.

[ascl:1512.002] GetData: A filesystem-based, column-oriented database format for time-ordered binary data

The GetData Project is the reference implementation of the Dirfile Standards, a filesystem-based, column-oriented database format for time-ordered binary data. Dirfiles provide a fast, simple format for storing and reading data, suitable for both quicklook and analysis pipelines. GetData provides a C API and bindings exist for various other languages. GetData is distributed under the terms of the GNU Lesser General Public License.

[ascl:1910.018] GetDist: Monte Carlo sample analyzer

GetDist analyzes Monte Carlo samples, including correlated samples from Markov Chain Monte Carlo (MCMC). It offers a point and click GUI for selecting chain files, viewing plots, marginalized constraints, and LaTeX tables, and includes a plotting library for making custom publication-ready 1D, 2D, 3D-scatter, triangle and other plots. Its convergence diagnostics include correlation length and diagonalized Gelman-Rubin statistics, and the optimized kernel density estimation provides an automated optimal bandwidth choice for 1D and 2D densities with boundary and bias correction. It is available as a standalong package and with CosmoMC (ascl:1106.025).

[ascl:1705.007] getimages: Background derivation and image flattening method

getimages performs background derivation and image flattening for high-resolution images obtained with space observatories. It is based on median filtering with sliding windows corresponding to a range of spatial scales from the observational beam size up to a maximum structure width X. The latter is a single free parameter of getimages that can be evaluated manually from the observed image. The median filtering algorithm provides a background image for structures of all widths below X. The same median filtering procedure applied to an image of standard deviations derived from a background-subtracted image results in a flattening image. Finally, a flattened image is computed by dividing the background-subtracted by the flattening image. Standard deviations in the flattened image are now uniform outside sources and filaments. Detecting structures in such radically simplified images results in much cleaner extractions that are more complete and reliable. getimages also reduces various observational and map-making artifacts and equalizes noise levels between independent tiles of mosaicked images. The code (a Bash script) uses FORTRAN utilities from getsources (ascl:1507.014), which must be installed.

[ascl:2012.001] getsf: Multi-scale, multi-wavelength sources and filaments extraction

getsf extracts sources and filaments in astronomical images by separating their structural components, and is designed to handle multi-wavelength sets of images and very complex filamentary backgrounds. The method spatially decomposes the original images and separates the structural components of sources and filaments from each other and from their backgrounds, flattening their resulting images. It spatially decomposes the flattened components, combines them over wavelengths, and detects the positions of sources and skeletons of filaments. Finally, getsf measures the detected sources and filaments and creates the output catalogs and images. This universal and fully automated method has a single user-definable free parameter, which reduces to a minimum dependence of its results on the human factor.

[ascl:1507.014] getsources: Multi-scale, multi-wavelength source extraction

getsources is a powerful multi-scale, multi-wavelength source extraction algorithm. It analyzes fine spatial decompositions of original images across a wide range of scales and across all wavebands, cleans those single-scale images of noise and background, and constructs wavelength-independent single-scale detection images that preserve information in both spatial and wavelength dimensions. getsources offers several advantages over other existing methods of source extraction, including the filtering out of irrelevant spatial scales to improve detectability, especially in the crowded regions and for extended sources, the ability to combine data over all wavebands, and the full automation of the extraction process.

[ascl:1608.014] gevolution: General Relativity Cosmological N-body code for evolution of large scale structures

The N-body code gevolution complies with general relativity principles at every step; it calculates all six metric degrees of freedom in Poisson gauge. N-body particles are evolved by solving the geodesic equation written in terms of a canonical momentum to remain valid for relativistic particles. gevolution can be extended to include different kinds of dark energy or modified gravity models, going beyond the usually adopted quasi-static approximation. A weak field expansion is the central element of gevolution; this permits the code to treat settings in which no strong gravitational fields appear, including arbitrary scenarios with relativistic sources as long as gravitational fields are not very strong. The framework is well suited for cosmology, but may also be useful for astrophysical applications with moderate gravitational fields where a Newtonian treatment is insufficient.

[ascl:1509.008] GFARGO: FARGO for GPU

GFARGO is a GPU version of FARGO (ascl:1102.017). It is written in C and C for CUDA and runs only on NVIDIA’s graphics cards. Though it corresponds to the standard, isothermal version of FARGO, not all functionalities of the CPU version have been translated to CUDA. The code is available in single and double precision versions, the latter compatible with FERMI architectures. GFARGO can run on a graphics card connected to the display, allowing the user to see in real time how the fields evolve.

[ascl:1510.001] GGADT: Generalized Geometry Anomalous Diffraction Theory

GGADT uses anomalous diffraction theory (ADT) to compute the differential scattering cross section (or the total cross sections as a function of energy) for a specified grain of arbitrary geometry (natively supports spheres, ellipsoids, and clusters of spherical monomers). It is written in Fortran 95. ADT is valid when the grain is large compared to the wavelength of incident light. GGADT can calculate either the integrated cross sections (absorption, scattering, extinction) as a function of energy, or it can calculate the differential scattering cross section as a function of scattering angle.

[ascl:2104.018] GGchem: Fast thermo-chemical equilibrium code

GGchem is a fast thermo-chemical equilibrium code with or without equilibrium condensation down to 100K. It can handle up to 40 elements (H, ..., Zr, and W), up to 1155 molecules, and up to 200 condensates (solids and liquids) from NIST-JANAF and SUPCRTBL. It offers a customized selection of elements, molecules, and condensates. The Fortran-90 code is very fast, and has a stable iterative solution scheme based on Newton-Raphson.

[ascl:2110.012] GGCHEMPY: Gas-Grain CHEMical code for interstellar medium in Python3

GGCHEMPY is efficient for building 1-D, 2-D and 3-D simulations of physical parameters of Planck galactic cold clumps; it provides a graphical user interface and can also be invoked by a Python script. The code initializes the reaction network using input parameters, and then computes the reaction rate coefficients for all reactions. It uses the backward-differentiation formulas method to solve the ordinary differential equations for the integration. The modeled results are saved and can be directly passed to a Python dictionary for analysis and plotting.

[ascl:2103.006] ggm: Gaussian gradient magnitude filtering of astronomical images

Ggm contains useful utilities for Gaussian gradient filtering of astronomical FITS images. It applies the Gaussian gradient magnitude filter to an input fits image, using a particular scale, sigma, in pixels. ggm cosmetically hides point sources in fits images by filling point sources with random values from the surrounding pixel region. It also provides an interactive tool to combine FITS images filtered on different scales.

[ascl:1112.008] GGobi: A data visualization system

GGobi is an open source visualization program for exploring high-dimensional data. It provides highly dynamic and interactive graphics such as tours, as well as familiar graphics such as the scatterplot, barchart and parallel coordinates plots. Plots are interactive and linked with brushing and identification.

[ascl:1107.002] GIBIS: Gaia Instrument and Basic Image Simulator

GIBIS is a pixel-level simulator of the Gaia mission. It is intended to simulate how the Gaia instruments will observe the sky, using realistic simulations of the astronomical sources and of the instrumental properties. It is a branch of the global Gaia Simulator under development within the Gaia DPAC CU2 Group (Data Simulations). Access is currently restricted to Gaia DPAC teams.

[ascl:1112.005] GIDGET: Gravitational Instability-Dominated Galaxy Evolution Tool

Observations of disk galaxies at z~2 have demonstrated that turbulence driven by gravitational instability can dominate the energetics of the disk. GIDGET is a 1D simulation code, which we have made publicly available, that economically evolves these galaxies from z~2 to z~0 on a single CPU in a matter of minutes, tracking column density, metallicity, and velocity dispersions of gaseous and multiple stellar components. We include an H$_2$ regulated star formation law and the effects of stellar heating by transient spiral structure. We use this code to demonstrate a possible explanation for the existence of a thin and thick disk stellar population and the age-velocity dispersion correlation of stars in the solar neighborhood: the high velocity dispersion of gas in disks at z~2 decreases along with the cosmological accretion rate, while at lower redshift, the dynamically colder gas forms the low velocity dispersion stars of the thin disk.

[ascl:1305.010] GILDAS: Grenoble Image and Line Data Analysis Software

GILDAS is a collection of software oriented toward (sub-)millimeter radioastronomical applications (either single-dish or interferometer). It has been adopted as the IRAM standard data reduction package and is jointly maintained by IRAM & CNRS. GILDAS contains many facilities, most of which are oriented towards spectral line mapping and many kinds of 3-dimensional data. The code, written in Fortran-90 with a few parts in C/C++ (mainly keyboard interaction, plotting, widgets), is easily extensible.

[ascl:1004.001] GIM2D: Galaxy IMage 2D

GIM2D (Galaxy IMage 2D) is an IRAF/SPP package written to perform detailed bulge/disk decompositions of low signal-to-noise images of distant galaxies in a fully automated way. GIM2D takes an input image from HST or ground-based telescopes and outputs a galaxy-subtracted image as well as a catalog of structural parameters.

[ascl:1303.020] Ginga: Flexible FITS viewer

Ginga is a viewer for astronomical data FITS (Flexible Image Transport System) files; the viewer centers around a FITS display widget which supports zooming and panning, color and intensity mapping, a choice of several automatic cut levels algorithms and canvases for plotting scalable geometric forms. In addition to this widget, the FITS viewer provides a flexible plugin framework for extending the viewer with many different features. A fairly complete set of "standard" plugins are provided for expected features of a modern viewer: panning and zooming windows, star catalog access, cuts, star pick/fwhm, thumbnails, and others. This viewer was written by software engineers at Subaru Telescope, National Astronomical Observatory of Japan, and is in use at that facility.

[ascl:1109.018] GIPSY: Groningen Image Processing System

GIPSY is an acronym of Groningen Image Processing SYstem. It is a highly interactive software system for the reduction and display of astronomical data. It supports multi-tasking using a versatile user interface, it has an advanced data structure, a powerful script language and good display facilities based on the X Window system.

GIPSY consists of a number of components which can be divided into a number of classes: 1.) The user interfaces. Currently two user interfaces are available; one for interactive work and one for batch processing. 2.) The data structure. 3.) The display utilities. 4.) The application programs. These are the majority of programs.

GIPSY was designed originally for the reduction of interferometric data from the Westerbork Synthesis Radio Telescope, but in its history of more than 20 years it has grown to a system capable of handling data from many different instruments (e.g. TAURUS, IRAS etc.).

[ascl:1810.012] GiRaFFE: General relativistic force-free electrodynamics code

GiRaFFE leverages the Einstein Toolkit's (ascl:1102.014) highly-scalable infrastructure to create large-scale simulations of magnetized plasmas in strong, dynamical spacetimes on adaptive-mesh refinement (AMR) grids. It is based on IllinoisGRMHD (ascl:2004.003), a user-friendly, open-source, dynamical-spacetime GRMHD code, and is highly scalable, to tens of thousands of cores.

[ascl:1907.025] GIST: Galaxy IFU Spectroscopy Tool

GIST (Galaxy IFU Spectroscopy Tool) provides a convenient all-in-one framework for the scientific analysis of fully reduced, (integral-field) spectroscopic data, conducting all the steps from the preparation of input data to the scientific analysis and to the production of publication-quality plots. In its basic set-up, the GIST pipeline extracts stellar kinematics, performs an emission-line analysis, and derives stellar population properties from full spectral fitting and via the measurement of absorption line-strength indices by exploiting pPXF (ascl:1210.002)and GandALF routines. The pipeline is not specific to any instrument or analysis technique, and includes a dedicated visualization routine with a sophisticated graphical user interface for fully interactive plotting of all measurements, spectra, fits, and residuals, as well as star formation histories and the weight distribution of the models.

[ascl:1410.003] GIZMO: Multi-method magneto-hydrodynamics+gravity code

GIZMO is a flexible, multi-method magneto-hydrodynamics+gravity code that solves the hydrodynamic equations using a variety of different methods. It introduces new Lagrangian Godunov-type methods that allow solving the fluid equations with a moving particle distribution that is automatically adaptive in resolution and avoids the advection errors, angular momentum conservation errors, and excessive diffusion problems that seriously limit the applicability of “adaptive mesh” (AMR) codes, while simultaneously avoiding the low-order errors inherent to simpler methods like smoothed-particle hydrodynamics (SPH). GIZMO also allows the use of SPH either in “traditional” form or “modern” (more accurate) forms, or use of a mesh. Self-gravity is solved quickly with a BH-Tree (optionally a hybrid PM-Tree for periodic boundaries) and on-the-fly adaptive gravitational softenings. The code is descended from P-GADGET, itself descended from GADGET-2 (ascl:0003.001), and many of the naming conventions remain (for the sake of compatibility with the large library of GADGET work and analysis software).

[ascl:2002.015] GizmoAnalysis: Read and analyze Gizmo simulations

GizmoAnalysis reads and analyzes N-body simulations run with the Gizmo code (ascl:1410.003). Written in Python, it was developed primarily to analyze FIRE simulations, though it is usable with any Gizmo snapshot files. It offers the following functionality: reads snapshot files and converts particle data to physical units; provides a flexible dictionary class to store particle data and compute derived quantities on the fly; plots images and properties of particles; and generates region files for input to MUSIC (ascl:1311.011) to generate cosmological zoom-in initial conditions. GizmoAnalysis also computes rates of supernovae and stellar winds, including their nucleosynthetic yields, as used in FIRE simulations. The software package includes a tutorial in a Jupyter notebook.

[ascl:1805.025] GLACiAR: GaLAxy survey Completeness AlgoRithm

GLACiAR (GaLAxy survey Completeness AlgoRithm) estimates the completeness and selection functions in galaxy surveys. Tailored for multiband imaging surveys aimed at searching for high-redshift galaxies through the Lyman Break technique, the code can nevertheless be applied broadly. GLACiAR generates artificial galaxies that follow Sérsic profiles with different indexes and with customizable size, redshift and spectral energy distribution properties, adds them to input images, and measures the recovery rate.

[ascl:1812.002] GLADIS: GLobal Accretion Disk Instability Simulation

GLADIS (GLobal Accretion Disk Instability Simulation) computes the time-dependent evolution of a black hole accretion disk, in one-dimensional, axisymmetric, vertically integrated scheme. The code solves two partial-differential equations of hydrodynamics for surface density and temperature evolution, i.e., given by viscous diffusion and energy conservation. Accretion disks can be subject to radiation-pressure instability if the stress tensor is proportional to the total (gas plus radiation) pressure. In the gas-pressure dominated case there is no instability. An intermediate case is provided in the code by the square root of the gas and total pressures. GLADIS is parallelized with MPI, and sample .ini and run command files are provided with the code.

[ascl:1010.012] glafic: Software Package for Analyzing Gravitational Lensing

glafic is a public software package for analyzing gravitational lensing. It offers many features including computations of various lens properties for many mass models, solving the lens equation using an adaptive grid algorithm, simulations of lensed extended images with PSF convolved, and efficient modeling of observed strong lens systems.

[ascl:2305.023] GLASS: Cosmological simulations on the sphere

GLASS (Generator for Large Scale Structure) produces cosmological simulations on the sphere. The full, three-dimensional past light cone of the observer is discretized into a sequence of nested shells, which are further discretized in the angular dimensions into maps of the sphere. GLASS was originally designed to simulate cosmic matter, weak gravitational lensing, and galaxy positions, but its flexible design and open architecture allows it to be used for a wide range of cosmological and astrophysical simulations on the sphere.

[ascl:1806.009] GLASS: Parallel, free-form gravitational lens modeling tool and framework

GLASS models strong gravitational lenses. It produces an ensemble of possible models that fit the observed input data and conform to certain constraints specified by the user. GLASS makes heavy use of the numerical routines provided by the numpy and scipy packages as well as the linear programming package GLPK. This latter package, and its Python interface, is provided with GLASS and installs automatically in the GLASS build directory.

[ascl:2102.030] GLEAM: Galaxy Line Emission and Absorption Modeling

GLEAM (Galaxy Line Emission and Absorption Modeling) fits Gaussian models to emission and absorption lines in large samples of 1D galaxy spectra. The code is tailored to work well without much human interaction on optical and infrared spectra in a wide range of instrument setups and signal-to-noise regimes. gleam will create a fits table with Gaussian line measurements, including central wavelength, width, height and amplitude, as well as estimates for the continuum under the line and the line flux, luminosity, equivalent width and velocity width. gleam will also, optionally, make plots of the spectrum with fitted lines overlaid.

[ascl:2106.019] GLEMuR: GPU-based Lagrangian mimEtic Magnetic Relaxation

GLEMuR (Gpu-based Lagrangian mimEtic Magnetic Relaxation) is a finite difference Lagrangian code which uses mimetic differential operators and runs on Nvidia GPUs. Its main purpose is to study the relaxation of magnetic relaxation in environments of zero resistivity and viscosity; it preserves the magnetic flux and the topology of magnetic field lines. The use of mimetic operators for the spatial derivatives improve accuracy for high distortions of the grid, and the final state of the simulation approximates a force-free state with a significantly higher accuracy. Note, however, that GLEMuR is not a general purpose equation solver and the full magnetohydrodynamics equations are not implemented.

[ascl:1103.006] GLESP 2.0: Gauss-Legendre Sky Pixelization for CMB Analysis

GLESP is a pixelization scheme for the cosmic microwave background (CMB) radiation maps. This scheme is based on the Gauss-Legendre polynomials zeros and allows one to create strict orthogonal expansion of the map.

[ascl:1802.010] Glimpse: Sparsity based weak lensing mass-mapping tool

Glimpse, also known as Glimpse2D, is a weak lensing mass-mapping tool that relies on a robust sparsity-based regularization scheme to recover high resolution convergence from either gravitational shear alone or from a combination of shear and flexion. Including flexion allows the supplementation of the shear on small scales in order to increase the sensitivity to substructures and the overall resolution of the convergence map. To preserve all available small scale information, Glimpse avoids any binning of the irregularly sampled input shear and flexion fields and treats the mass-mapping problem as a general ill-posed inverse problem, regularized using a multi-scale wavelet sparsity prior. The resulting algorithm incorporates redshift, reduced shear, and reduced flexion measurements for individual galaxies and is made highly efficient by the use of fast Fourier estimators.

[ascl:2308.011] glmnet: Lasso and elastic-net regularized generalized linear models

glmnet efficiently fits the entire lasso or elastic-net regularization path for linear regression (gaussian), multi-task gaussian, logistic and multinomial regression models (grouped or not), Poisson regression and the Cox model. The algorithm uses cyclical coordinate descent in a path-wise fashion.

[ascl:1110.008] Glnemo2: Interactive Visualization 3D Program

Glnemo2 is an interactive 3D visualization program developed in C++ using the OpenGL library and Nokia QT 4.X API. It displays in 3D the particles positions of the different components of an nbody snapshot. It quickly gives a lot of information about the data (shape, density area, formation of structures such as spirals, bars, or peanuts). It allows for in/out zooms, rotations, changes of scale, translations, selection of different groups of particles and plots in different blending colors. It can color particles according to their density or temperature, play with the density threshold, trace orbits, display different time steps, take automatic screenshots to make movies, select particles using the mouse, and fly over a simulation using a given camera path. All these features are accessible from a very intuitive graphic user interface.

Glnemo2 supports a wide range of input file formats (Nemo, Gadget 1 and 2, phiGrape, Ramses, list of files, realtime gyrfalcON simulation) which are automatically detected at loading time without user intervention. Glnemo2 uses a plugin mechanism to load the data, so that it is easy to add a new file reader. It's powered by a 3D engine which uses the latest OpenGL technology, such as shaders (glsl), vertex buffer object, frame buffer object, and takes in account the power of the graphic card used in order to accelerate the rendering. With a fast GPU, millions of particles can be rendered in real time. Glnemo2 runs on Linux, Windows (using minGW compiler), and MaxOSX, thanks to the QT4API.

[ascl:1011.010] Global Sky Model (GSM): A Model of Diffuse Galactic Radio Emission from 10 MHz to 100 GHz

Understanding diffuse Galactic radio emission is interesting both in its own right and for minimizing foreground contamination of cosmological measurements. Cosmic Microwave Background experiments have focused on frequencies > 10 GHz, whereas 21 cm tomography of the high redshift universe will mainly focus on < 0.2 GHz, for which less is currently known about Galactic emission. Motivated by this, we present a global sky model derived from all publicly available total power large-area radio surveys, digitized with optical character recognition when necessary and compiled into a uniform format, as well as the new Villa Elisa data extending the 1.4 GHz map to the entire sky. We quantify statistical and systematic uncertainties in these surveys by comparing them with various global multi-frequency model fits. We find that a principal component based model with only three components can fit the 11 most accurate data sets (at 10, 22, 45 & 408 MHz and 1.4, 2.3, 23, 33, 41, 61, 94 GHz) to an accuracy around 1%-10% depending on frequency and sky region. The data compilation and software returning a predicted all-sky map at any frequency from 10 MHz to 100 GHz are publicly available in the archive file at the link below.

[ascl:2104.028] globalemu: Global (sky-averaged) 21-cm signal emulation

globalemu emulates the Global or sky averaged 21-cm signal and the associated neutral fraction history. The code can train a network on your own Global 21-cm signal or neutral fraction simulations using the built-in globalemu pre-processing techniques. It also features a GUI that can be invoked from the command line and used to explore how the structure of the Global 21-cm signal varies with the values of the astrophysical inputs.

[ascl:2109.018] GLoBES: General Long Baseline Experiment Simulator

GLoBES simulates long baseline neutrino oscillation experiments. The package features full incorporation of correlations and degeneracies in the oscillation parameter space, advanced routines for the treatment of arbitrary systematical errors, and user-defined priors, which allowsn for the inclusion of arbitrary external physical information. Its use of AEDL, the Abstract Experiment Definition Language, provides an easy way to define experimental setups. GLoBES also provides an interface for the simulation of non-standard physics, and offers predefined setups for many experiments, including Superbeams, Beta Beams, Neutrino factories, Reactors, and various detector technologies.

[ascl:1807.019] GLS: Generalized Lomb-Scargle periodogram

The Lomb-Scargle periodogram is a common tool in the frequency analysis of unequally spaced data equivalent to least-squares fitting of sine waves. GLS is a solution for the generalization to a full sine wave fit, including an offset and weights (χ2 fitting). Compared to the Lomb-Scargle periodogram, GLS is superior as it provides more accurate frequencies, is less susceptible to aliasing, and gives a much better determination of the spectral intensity.

[ascl:1402.002] Glue: Linked data visualizations across multiple files

Glue, written in Python, links visualizations of scientific datasets across many files, allowing for interactive, linked statistical graphics of multiple files. It supports many file formats including common image formats (jpg, tiff, png), ASCII tables, astronomical image and table formats (FITS, VOT, IPAC), and HDF5. Custom data loaders can also be easily added. Glue is highly scriptable and extendable.

[ascl:1710.015] GMCALab: Generalized Morphological Component Analysis

GMCALab solves Blind Source Separation (BSS) problems from multichannel/multispectral/hyperspectral data. In essence, multichannel data provide different observations of the same physical phenomena (e.g. multiple wavelengths), which are modeled as a linear combination of unknown elementary components or sources. Written as a set of Matlab toolboxes, it provides a generic framework that can be extended to tackle different matrix factorization problems.

[ascl:1708.013] GMM: Gaussian Mixture Modeling

GMM (Gaussian Mixture Modeling) tests the existence of bimodality in globular cluster color distributions. GMM uses three indicators to distinguish unimodal and bimodal distributions: the kurtosis of the distribution, the separation of the peaks, and the probability of obtaining the same χ2 from a unimodal distribution.

[ascl:2001.015] gnm: The MCMC Jagger

gnm is an implementation of the affine-invariant sampler for Markov chain Monte Carlo (MCMC) that uses the Gauss-Newton-Metropolis (GNM) Algorithm. The GNM algorithm is specialized in sampling highly non-linear posterior probability distribution functions of the form exp(-||f(x)||^2/2). The code includes dynamic hyper-parameter optimization to increase performance of the sampling; other features include the Jacobian tester and an error bars creator.

[ascl:1801.009] Gnuastro: GNU Astronomy Utilities

Gnuastro (GNU Astronomy Utilities) manipulates and analyzes astronomical data. It is an official GNU package of a large collection of programs and C/C++ library functions. Command-line programs perform arithmetic operations on images, convert FITS images to common types like JPG or PDF, convolve an image with a given kernel or matching of kernels, perform cosmological calculations, crop parts of large images (possibly in multiple files), manipulate FITS extensions and keywords, and perform statistical operations. In addition, it contains programs to make catalogs from detection maps, add noise, make mock profiles with a variety of radial functions using monte-carlo integration for their centers, match catalogs, and detect objects in an image among many other operations. The command-line programs share the same basic command-line user interface for the comfort of both the users and developers. Gnuastro is written to comply fully with the GNU coding standards and integrates well with all Unix-like operating systems. This enables astronomers to expect a fully familiar experience in the source code, building, installing and command-line user interaction that they have seen in all the other GNU software that they use. Gnuastro's extensive library is included for users who want to build their own unique programs.

[ascl:2011.016] GoFish: Molecular line detections in protoplanetary disks

GoFish exploits the known rotation of a protoplanetary disk to shift all emission to a common line center in order to stack them, increasing the signal-to-noise of the spectrum, detecting weaker lines, or super-sampling the spectrum to better resolve the line profile.

[ascl:1210.003] GOSSIP: SED fitting code

GOSSIP fits the electro-magnetic emission of an object (the SED, Spectral Energy Distribution) against synthetic models to find the simulated one that best reproduces the observed data. It builds-up the observed SED of an object (or a large sample of objects) combining magnitudes in different bands and eventually a spectrum; then it performs a chi-square minimization fitting procedure versus a set of synthetic models. The fitting results are used to estimate a number of physical parameters like the Star Formation History, absolute magnitudes, stellar mass and their Probability Distribution Functions.

[ascl:2005.011] gotetra: Cosmic velocity fields tracking through the use of tetrahedra

gotetra uses phase-space tesselation techniques to extract information about cosmological N-body simulations. The key applications of this Go-based code are the measurement of splashback shells around halos and the generation of high resolution images of density fields. The package includes routines to generates 3D and 2D (projected) density fields from a particle snapshot generated by a cosmological N-body simulation, measure density along lines of sight from the center of halos, and compresse the position space data from cosmological N-body simulations. Included are two helper libraries with functions for calculating cosmological quantities and computing a number of useful mathematical functions.

[ascl:2011.008] GOTHIC: Double nuclei galaxy detector

GOTHIC (Graph-bOosTed iterated HIll Climbing) detects whether a given image of a galaxy has characteristic features of a double nuclei galaxy (DNG). Galaxy interactions and mergers play a crucial role in the hierarchical growth of structure in the universe; galaxy mergers can lead to the formation of elliptical galaxies and larger disk galaxies, as well as drive galaxy evolution through star formation and nuclear activity. During mergers, the nuclei of the individual galaxies come closer and finally form a double nuclei galaxy. Although mergers are common, the detection of double-nuclei galaxies (DNGs) is rare and fairly serendipitous. Their properties can help us understand the formation of supermassive black hole (SMBH) binaries, dual active galactic nuclei (DAGN) and the associated feedback effects. GOTHIC provides an automatic and systematic way to survey data for the discovery of double nuclei galaxies.

[ascl:1210.001] GP2PCF: Brute-force computation of 2-point correlation functions

The two-point correlation function is a simple statistic that quantifies the clustering of a given distribution of objects. In studies of the large scale structure of the Universe, it is an important tool containing information about the matter clustering and the evolution of the Universe at different cosmological epochs. A classical application of this statistic is the galaxy-galaxy correlation function to find constraints on the parameter Omega_m or the location of the baryonic acoustic oscillation peak. This calculation, however, is very expensive in terms of computer power and Graphics Processing Units provide one solution for efficient analysis of the increasingly larger galaxy surveys that are currently taking place.

GP2PCF is a public code in CUDA for performing this computation; with a single GPU board it is possible to achieve 120-fold speedups with respect to a standard implementation in C running on a single CPU. With respect to other solutions such as k-trees the improvement is of a factor of a few retaining full precision. The speedup is comparable to running in parallel in a cluster of O(100) cores.

[ascl:1512.006] GPC: General Polygon Clipper library

The University of Manchester GPC library is a flexible and highly robust polygon set operations library for use with C, C#, Delphi, Java, Perl, Python, Haskell, Lua, VB.Net and other applications. It supports difference, intersection, exclusive-or and union clip operations, and polygons may be comprised of multiple disjoint contours. Contour vertices may be given in any order - clockwise or anticlockwise, and contours may be convex, concave or self-intersecting, and may be nested (i.e. polygons may have holes). Output may take the form of either polygon contours or tristrips, and hole and external contours are differentiated in the result. GPC is free for non-profit and educational use; a Commercial Use License is required for commercial use.

Internet Archive link provided for archival purposes; per its website, GPC is no longer distributed or available as of August 2020.

[ascl:2011.022] GPCAL: Instrumental polarization calibration in VLBI data

GPCAL performs instrumental polarization calibration in very long baseline interferometry (VLBI) data. It enhances the calibration accuracy by enabling users to fit the model to multiple calibrators data simultaneously and to take into account the calibrators linear polarization structures instead of using the conventional similarity assumption. GPCAL is based on AIPS (ascl:9911.003) and uses ParselTongue (ascl:1208.020) to run AIPS tasks.

[ascl:2303.006] GPCC: Gaussian process cross-correlation for time delay estimation

Gaussian Process Cross-Correlation (GPCC) uses Gaussian processes to estimate time delays for reverberation mapping (RM) of Active Galactic Nuclei (AGN). This statistically principled model delivers a posterior distribution for the delay and accounts for observational noise and the non-uniform sampling of the light curves. Written in Julia, GPCC quantifies the uncertainty and propagates it to subsequent calculations of dependent physical quantities, such as black hole masses. The code delivers out-of-sample predictions, which enables model selection, and can calculate the joint posterior delay for more than two light curves. Though written for RM, the software can also be applied to other fields where cross-correlation analysis is performed.

[ascl:2109.023] gphist: Cosmological expansion history inference using Gaussian processes

gphist performs Bayesian inference on the cosmological expansion history using Gaussian process priors. It is written in Python and includes driver programs to run inference calculations and plot the results. The code infers the cosmological expansion history using a Gaussian process prior, reads these ouputs, and performs checks to ensure they are indeed compatible. gphist then generates a single combined output file to plot expansion history inferences.

[ascl:1603.004] gPhoton: Time-tagged GALEX photon events analysis tools

Written in Python, gPhoton calibrates and sky-projects the ~1.1 trillion ultraviolet photon events detected by the microchannel plates on the Galaxy Evolution Explorer Spacecraft (GALEX), archives these events in a publicly accessible database at the Mikulski Archive for Space Telescopes (MAST), and provides tools for working with the database to extract scientific results, particularly over short time domains. The software includes a re-implementation of core functionality of the GALEX mission calibration pipeline to produce photon list files from raw spacecraft data as well as a suite of command line tools to generate calibrated light curves, images, and movies from the MAST database.

[ascl:1411.018] GPI Pipeline: Gemini Planet Imager Data Pipeline

The GPI data pipeline allows users to reduce and calibrate raw GPI data into spectral and polarimetric datacubes, and to apply various PSF subtraction methods to those data. Written in IDL and available in a compiled version, the software includes an integrated calibration database to manage reference files and an interactive data viewer customized for high contrast imaging that allows exploration and manipulation of data.

[ascl:2007.001] GProtation: Measuring stellar rotation periods with Gaussian processes

GProtation measures stellar rotation periods with Gaussian processes.

This code is no longer being maintained. Please consider using celerite (ascl:1709.008) or exoplanet (ascl:1910.005) instead.

[ascl:2212.006] GPry: Bayesian inference of expensive likelihoods with Gaussian processes

GPry efficiently obtains marginal quantities from computationally expensive likelihoods. It works best with smooth (continuous) likelihoods and posteriors that are slow to converge by other methods, which is dependent on the number of dimensions and expected shape of the posterior distribution. The likelihood should be low-dimensional (d<20 as a rule of thumb), though the code may still provide considerable improvements in speed in higher dimensions, despite an increase in the computational overhead of the algorithm. GPry is an alternative to samplers such as MCMC and Nested Sampling with a goal of speeding up inference in cosmology, though the software will work with any likelihood that can be called as a python function. It uses Cobaya's (ascl:1910.019) model framework so all of Cobaya's inbuilt likelihoods work, too.

[ascl:1403.001] GPU-D: Generating cosmological microlensing magnification maps

GPU-D is a GPU-accelerated implementation of the inverse ray-shooting technique used to generate cosmological microlensing magnification maps. These maps approximate the source plane magnification patterns created by an ensemble of stellar-mass compact objects within a foreground macrolens galaxy. Unlike other implementations, GPU-D solves the gravitational lens equation without any approximation. Due to the high computational intensity and high degree of parallelization inherent in the algorithm, it is ideal for brute-force implementation on GPUs. GPU-D uses CUDA for GPU acceleration and require NVIDIA devices to run.

[ascl:1906.014] GPUVMEM: Maximum Entropy Method (MEM) GPU algorithm for radio astronomical image synthesis

The maximum entropy method (MEM) is a well known deconvolution technique in radio-interferometry. This method solves a non-linear optimization problem with an entropy regularization term. Other heuristics such as CLEAN are faster but highly user dependent. Nevertheless, MEM has the following advantages: it is unsupervised, it has a statistical basis, it has a better resolution and better image quality under certain conditions. GPUVMEM presents a high performance GPU version of non-gridding MEM.

[ascl:1010.022] GR1D: Open-Source Code for Spherically-Symmetric Stellar Collapse to Neutron Stars and Black Holes

GR1D is based on the Eulerian formulation of GR hydrodynamics (GRHD) put forth by Romero-Ibanez-Gourgoulhon and employs radial-gauge, polar-slicing coordinates in which the 3+1 equations simplify substantially. GR1D is intended for the simulation of stellar collapse to neutron stars and black holes and will also serve as a testbed for modeling technology to be incorporated in multi-D GR codes. Its GRHD part is coupled to various finite-temperature microphysical equations of state in tabulated form that we make available with GR1D.

[ascl:1612.020] Grackle: Chemistry and radiative cooling library for astrophysical simulations

The chemistry and radiative cooling library Grackle provides options for primordial chemistry and cooling, photo-heating and photo-ionization from UV backgrounds, and support for user-provided arrays of volumetric and specific heating rates for astrophysical simulations and models. The library provides functions to update chemistry species; solve radiative cooling and update internal energy; and calculate cooling time, temperature, pressure, and ratio of specific heats (gamma), and has interfaces for C, C++, Fortran, and Python codes.

[ascl:1010.080] GRACOS: Scalable and Load Balanced P3M Cosmological N-body Code

The GRACOS (GRAvitational COSmology) code, a parallel implementation of the particle-particle/particle-mesh (P3M) algorithm for distributed memory clusters, uses a hybrid method for both computation and domain decomposition. Long-range forces are computed using a Fourier transform gravity solver on a regular mesh; the mesh is distributed across parallel processes using a static one-dimensional slab domain decomposition. Short-range forces are computed by direct summation of close pairs; particles are distributed using a dynamic domain decomposition based on a space-filling Hilbert curve. A nearly-optimal method was devised to dynamically repartition the particle distribution so as to maintain load balance even for extremely inhomogeneous mass distributions. Tests using $800^3$ simulations on a 40-processor beowulf cluster showed good load balance and scalability up to 80 processes. There are limits on scalability imposed by communication and extreme clustering which may be removed by extending the algorithm to include adaptive mesh refinement.

[ascl:1106.008] GRAFIC-2: Multiscale Gaussian Random Fields for Cosmological Simulations

This paper describes the generation of initial conditions for numerical simulations in cosmology with multiple levels of resolution, or multiscale simulations. We present the theory of adaptive mesh refinement of Gaussian random fields followed by the implementation and testing of a computer code package performing this refinement called GRAFIC-2.

[ascl:1011.021] GRALE: A genetic algorithm for the non-parametric inversion of strong lensing systems

We present a non-parametric technique to infer the projected-mass distribution of a gravitational lens system with multiple strong-lensed images. The technique involves a dynamic grid in the lens plane on which the mass distribution of the lens is approximated by a sum of basis functions, one per grid cell. We used the projected mass densities of Plummer spheres as basis functions. A genetic algorithm then determines the mass distribution of the lens by forcing images of a single source, projected back onto the source plane, to coincide as well as possible. Averaging several tens of solutions removes the random fluctuations that are introduced by the reproduction process of genomes in the genetic algorithm and highlights those features common to all solutions. Given the positions of the images and the redshifts of the sources and the lens, we show that the mass of a gravitational lens can be retrieved with an accuracy of a few percent and that, if the sources sufficiently cover the caustics, the mass distribution of the gravitational lens can also be reliably retrieved. A major advantage of the algorithm is that it makes full use of the information contained in the radial images, unlike methods that minimise the residuals of the lens equation, and is thus able to accurately reconstruct also the inner parts of the lens.

[ascl:1908.004] Gramsci: GRAph Made Statistics for Cosmological Information

Gramsci (GRAph Made Statistics for Cosmological Information) computes the general N-point spatial correlation functions of any discrete point set embedded within an Euclidean space of ℝ^n. It uses kd-trees and graph databases to count all possible N-tuples in binned configurations within a given length scale, e.g. all pairs of points or all triplets of points with side lengths. Gramsci can run in serial, OpenMP, MPI and hybrid parallel schemes. It is useful for performing domain decomposition of input catalogs, especially if the catalogs are large or the Rmax value is too large.

[ascl:1812.011] GRAND-HOD: GeneRalized ANd Differentiable Halo Occupation Distribution

GRAND-HOD (GeneRalized ANd Differentiable Halo Occupation Distribution) takes a generalized Halo Occupation Distribution (HOD) prescription as input and outputs the corresponding mock galaxy catalogs in binary files. The code is differentiable and incorporates various generalizations to the standard HOD. It is written for the Abacus simulations, but the main functionalities can be easily adapted for other halo catalogs with the appropriate properties.

[ascl:2010.005] GRAPUS: GRAvitational instability PopUlation Synthesis

GRAPUS (GRAvitational instability PopUlation Synthesis) executes population synthesis modeling of self-gravitating disc fragmentation and tidal downsizing in protostellar discs. It reads in pre-run 1D viscous disc models of self-gravitating discs and computes where fragmentation will occur and the initial fragment mass. GRAPUS then allows these fragment embryos to evolve under various forces, including quasistatic collapse of the embryo, growth and sedimentation of the dust inside the embryo, and the formation of solid cores. The software also evolves migration due to embryo-disc interactions and tidal disruption of the embryo, and can optionally determine gravitational interactions with neighboring embryos.

[ascl:1204.006] GRASIL: Spectral evolution of stellar systems with dust

GRASIL (which stands for GRAphite and SILicate) computes the spectral evolution of stellar systems taking into account the effects of dust, which absorbs and scatters optical and UV photons and emits in the IR-submm region. It may be used as well to do “standard” no-dust stellar spectral synthesis. The code is very well calibrated and applied to interpret galaxies at different redshifts. GRASIL can be downloaded or run online using the GALSYNTH WEB interface.

[ascl:1609.008] GRASP: General-purpose Relativistic Atomic Structure Package

GRASP (General-purpose Relativistic Atomic Structure Package) calculates atomic structure, including energy levels, radiative rates (A-values) and lifetimes; it is a fully relativistic code based on the jj coupling scheme. This code has been superseded by GRASP2K (ascl:1611.007).

[ascl:1611.007] GRASP2K: Relativistic Atomic Structure Package

GRASP2K is a revised and greatly expanded version of GRASP (ascl:1609.008) and is adapted for 64-bit computer architecture. It includes new angular libraries, can transform from jj- to LSJ-coupling, and coefficients of fractional parentage have been extended to j=9/2, making calculations feasible for the lanthanides and actinides. GRASP2K identifies each atomic state by the total energy and a label for the configuration state function with the largest expansion coefficient in LSJLSJ intermediate coupling.

[ascl:2110.011] GRASS: GRanulation and Spectrum Simulator

The Julia library GRASS produces realistic stellar spectra with time-variable granulation signatures. It is based on real observations of the Sun, and does not rely on magnetohydrodynamic simulations to produce its spectra. GRASS can also compute bisectors for absorption lines or CCF profiles, and provides two methods for calculating bisectors.

[ascl:1902.004] GraviDy: Gravitational Dynamics

GraviDy performs N-body 3D visualizations; it is a GPU, direct-summation N-body integrator based on the Hermite scheme and includes relativistic corrections for sources of gravitational radiation. The software is modular, allowing users to readily introduce new physics, and exploits available computational resources. The software can be used in parallel on multiple CPUs and GPUs, with a considerable speed-up benefit. The single-GPU version is between one and two orders of magnitude faster than the single-CPU version.

[ascl:1102.003] GRAVLENS: Computational Methods for Gravitational Lensing

Modern applications of strong gravitational lensing require the ability to use precise and varied observational data to constrain complex lens models. Two sets of computational methods for lensing calculations are discussed. The first is a new algorithm for solving the lens equation for general mass distributions. This algorithm makes it possible to apply arbitrarily complicated models to observed lenses. The second is an evaluation of techniques for using observational data including positions, fluxes, and time delays of point-like images, as well as maps of extended images, to constrain models of strong lenses. The techniques presented here are implemented in a flexible and user-friendly software package called gravlens, which is made available to the community.

[ascl:2312.009] GravSphere: Jeans modeling code

The non-parametric Jeans code GravSphere models discrete data and can be used to model dark matter distributions in galaxies. It can also recover the density ρ(r) and velocity anisotropy β(r) of spherical stellar systems, assuming only that they are in a steady state. Real or mock data are prepared by using the included binulator.py code; the repository also includes many examples for exploring the GravSphere's capabilities.

[ascl:1403.005] GRay: Massive parallel ODE integrator

GRay is a massive parallel ordinary differential equation integrator that employs the "stream processing paradigm." It is designed to efficiently integrate billions of photons in curved spacetime according to Einstein's general theory of relativity. The code is implemented in CUDA C/C++.

[ascl:2306.039] GRChombo: Numerical relativity simulator

GRChombo performs numerical relativity simulations. It uses Chombo (ascl:1202.008) for adaptive mesh refinement and can evolve standard spacetimes such as binary black hole mergers and scalar collapses into black holes. The code supports non-trivial many-boxes-in-many-boxes mesh hierarchies and massive parallelism and evolves the Einstein equation using the standard BSSN formalism. GRChombo is written in C++14 and uses hybrid MPI/OpenMP parallelism and vector intrinsics to achieve good performance.

[submitted] Green Bank Observatory Gridder

A stand-alone spectral gridder and imager for the Green Bank Telescope, as well as functionality for any diameter telescope. Based around the cygrid package from Benjamin Winkel and Daniel Lenz

[ascl:2312.014] GRFolres: Extension to GRChombo for modified gravity simulations

GRFolres performs simulations in modified theories of gravity. It is based on GRChombo (ascl:2306.039) and inherits all of the capabilities of the main GRChombo code, which makes use of the Chombo library (ascl:1202.008) for adaptive mesh refinement. The code implements the 4∂ST theory of modified gravity and the cubic Horndeski theory in (3+1)-dimensional numerical relativity. GRFolres can be used for stable gauge evolution, solving the modified energy and momentum constraints for initial conditions, and monitoring the constraint violation and calculating the energy densities associated with the different scalar terms in the action. It can also extract data for the tensor and scalar gravitational waveforms.

[ascl:2305.022] GrGadget: Evolve metric perturbations in the weak field limit

GrGadget merges the Particle-Mesh (PM) relativistic GEVOLUTION code (ascl:1608.014) with the TreePM GADGET-4 code (ascl:2204.014) to create a TreePM simulation code that represents metric perturbations at the scales where they are relevant while resolving non-linear structures. The better resolution of the highly non-linear regime improves the representation of the relativistic fields sampled on the mesh with respect to PM-only simulations.

[ascl:1302.007] GRID-core: Gravitational Potential Identification of Cores

GRID-core is a core-finding method using the contours of the local gravitational potential to identify core boundaries. The GRID-core method applied to 2D surface density and 3D volume density are in good agreement for bound cores. We have implemented a version of the GRID-core algorithm in IDL, suitable for core-finding in observed maps. The required input is a two-dimensional FITS file containing a map of the column density in a region of a cloud.

[ascl:1702.012] GRIM: General Relativistic Implicit Magnetohydrodynamics

GRIM (General Relativistic Implicit Magnetohydrodynamics) evolves a covariant extended magnetohydrodynamics model derived by treating non-ideal effects as a perturbation of ideal magnetohydrodynamics. Non-ideal effects are modeled through heat conduction along magnetic field lines and a difference between the pressure parallel and perpendicular to the field lines. The model relies on an effective collisionality in the disc from wave-particle scattering and velocity-space (mirror and firehose) instabilities. GRIM, which runs on CPUs as well as on GPUs, combines time evolution and primitive variable inversion needed for conservative schemes into a single step using only the residuals of the governing equations as inputs. This enables the code to be physics agnostic as well as flexible regarding time-stepping schemes.

[ascl:1912.013] GriSPy: Fixed-radius nearest neighbors grid search in Python

GriSPy (Grid Search in Python) uses a regular grid search algorithm for quick fixed-radius nearest-neighbor lookup. It indexes a set of k-dimensional points in a regular grid providing a fast approach for nearest neighbors queries. Optional periodic boundary conditions can be provided for each axis individually. GriSPy implements three types of queries: bubble, shell and the nth-nearest, and offers three different metrics of interest in astronomy: the Euclidean and two distance functions in spherical coordinates of varying precision, haversine and Vincenty. It also provides a custom distance function. GriSPy is particularly useful for large datasets where a brute-force search is not practical.

[ascl:2112.021] GRIT: Gravitational Rigid-body InTegrators for simulating coupled dynamics

GRIT (Gravitational Rigid-body InTegrators) simulaties the coupled dynamics of both spin and orbit of N gravitationally interacting rigid bodies. The code supports tidal forces and general relativity correction are supported, and multiple schemes with different orders of convergences and splitting strategies are available. Multiscale splittings boost the simulation speed, and force evaluations can be parallelized. In addition, each body can be set to be a rigid body or just a point mass, and the floating-point format can be customized as float, double, or long double globally.

[ascl:1905.001] Grizli: Grism redshift and line analysis software

Grizli produces quantitative and comprehensive modeling and fitting of slitless spectroscopic observations, which typically involve overlapping spectra of hundreds or thousands of objects in exposures taken with one or more separate grisms and at multiple dispersion position angles. This type of analysis provides complete and uniform characterization of the spectral properties (e.g., continuum shape, redshifts, line fluxes) of all objects in a given exposure taken in the slitless spectroscopic mode.

[ascl:2310.012] GRIZZLY: 1D radiative transfer code

GRIZZLY simulates reionization using a 1D radiative transfer scheme. The code enables the efficient exploration of the parameter space for evaluating 21cm brightness temperature fluctuations near the cosmic dawn. GRIZZLY builds upon the BEARS algorithm for generating simulated reionization maps with density and velocity fields, which are useful for profiling dark matter halos and cosmological density fields.

[ascl:1306.002] grmonty: Relativistic radiative transport Monte Carlo code

grmonty is a Monte Carlo radiative transport code intended for calculating spectra of hot, optically thin plasmas in full general relativity. The code models hot accretion flows in the Kerr metric, it incorporates synchrotron emission and absorption and Compton scattering. grmonty can be readily generalized to account for other radiative processes and an arbitrary spacetime.

[ascl:1512.018] growl: Growth factor and growth rate of expanding universes

Growl calculates the linear growth factor Da and its logarithmic derivative dln D/dln a in expanding Friedmann-Robertson-Walker universes with arbitrary matter and vacuum densities. It permits rapid and stable numerical evaluation.

[ascl:1605.013] grtrans: Polarized general relativistic radiative transfer via ray tracing

grtrans calculates ray tracing radiative transfer in the Kerr metric, including the full treatment of polarised radiative transfer and parallel transport along geodesics, for comparing theoretical models of black hole accretion flows and jets with observations. The code is written in Fortran 90 and parallelizes with OpenMP; the full code and several components have Python interfaces. grtrans includes Geokerr (ascl:1011.015) and requires cfitsio (ascl:1010.001) and pyfits (ascl:1207.009).

[ascl:2209.009] GRUMPY: Galaxy formation with RegUlator Model in PYthon

GRUMPY (Galaxy formation with RegUlator Model in PYthon) models the formation of dwarf galaxies. When coupled with realistic mass accretion histories of halos from simulations and reasonable choices for model parameter values, this simple regulator-type framework reproduces a broad range of observed properties of dwarf galaxies over seven orders of magnitude in stellar mass. GRUMPY matches observational constraints on the stellar mass--halo mass relation and observed relations between stellar mass and gas phase and stellar metallicities, gas mass, size, and star formation rate. It also models the general form and diversity of star formation histories (SFHs) of observed dwarf galaxies. The software can be used to predict photometric properties of dwarf galaxies hosted by dark matter haloes in N-body simulations, such as colors, surface brightnesses, and mass-to-light ratios and to forward model observations of dwarf galaxies.

[ascl:1503.009] GSD: Global Section Datafile access library

The GSD library reads data written in the James Clerk Maxwell Telescope GSD format. This format uses the General Single-Dish Data model and was used at the JCMT until 2005. The library provides an API to open GSD files and read their contents. The content of the data files is self-describing and the library can return the type and name of any component. The library is used by SPECX (ascl:1310.008), JCMTDR (ascl:1406.019) and COADD (ascl:1411.020). The SMURF (ascl:1310.007) package can convert GSD heterodyne data files to ACSIS format using this library.

[ascl:1806.008] gsf: galactic structure finder

gsf applies Gaussian Mixture Models in the stellar kinematic space of normalized angular momentum and binding energy on NIHAO high resolution galaxies to separate the stars into multiple components. The gsf analysis package assumes that the simulation snapshot has been pre-processed with a halo finder. It is based on pynbody (ascl:1305.002) and the scikit-learnpython package for Machine Learning; after loading, orienting, and transforming a simulation snapshot to physical units, it runs the clustering algorithm and performs the direct N-body gravity force using all the particles in the given halo.

[ascl:2211.012] gsf: Grism SED Fitting package

gsf fits photometric data points, simultaneously with grism spectra if provided, to get posterior probability of galaxy physical properties, such as stellar mass, dust attenuation, metallicity, as well as star formation and metallicity enrichment histories. Designed for extra-galactic science, this flexible, python-based SED fitting code involves a Markov-Chain Monte-Carlo (MCMC) process, and may take more time (depending on the number of parameters and length of MCMC chains) than other SED fitting codes based on chi-square minimization.

[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:2010.002] GSpec: Gamma-ray Burst Monitor analyzer

GSpec analyzes the Fermi mission's Gamma-ray Burst Monitor (GBM) data via a user-interactive GUI. The software provides a seamless interface to XSPEC (ascl:9910.005). It allows users to create their own Python scripts using the included libraries, and to define additional data reduction techniques, such as background fitting/estimation and data binning, as Python-based plugins. It is part of a larger effort to produce a set of GBM data tools to allow the broader community to analyze all aspects of GBM data, including the continuous data that GBM produces. GSpec is similar to RMfit (ascl:1409.011), a GUI-based spectral analysis code that specializes in the analysis of GBM trigger data, and is intended to eventually replace that IDL package.

[ascl:2208.021] GSSP: Grid Search in Stellar Parameters

GSSP (Grid Search in Stellar Parameters) is based on a grid search in the fundamental atmospheric parameters and (optionally) individual chemical abundances of the star (or binary stellar components) in question. It uses atmosphere models and spectrum synthesis, which assumes a comparison of the observations with each theoretical spectrum from the grid. The code can optimize five stellar parameters at a time (effective temperature, surface gravity, metallicity, microturbulent velocity, and projected rotational velocity of the star) and synthetic spectra can be computed in any number of wavelength ranges. GSSP builds the grid of theoretical spectra from all possible combinations of the above mentioned parameters, and delivers the set of best fit parameters, the corresponding synthetic spectrum, and the ASCII file containing the individual parameter values for all grid points and the corresponding chi-square values.

[ascl:2208.020] GStokes: Magnetic field structure and line profiles calculator

GStokes performs simple multipolar fits to circular polarization data to provide information about the field strength and geometry. It provides forward calculation of the disc-integrated Stokes parameter profiles as well as magnetic inversions under several widely used simplifying approximations of the polarized line formation. GStokes implements the Unno–Rachkovsky analytical solution of the polarized radiative transfer equation and the weak-field approximation with the Gaussian local profiles. The magnetic field geometry is described with one of the common low-order multipolar field parametrizations. Written in IDL, GStokes provides a user-friendly graphical front-end.

[ascl:2307.034] Guacho: 3D uniform mesh parallel HD/MHD code for astrophysics

Guacho is a 3D hydrodynamical/magnetohydrodynamical code suited for astrophysical fluids. The hydrodynamic equations are evolved with a number of approximate Riemann solvers. Gaucho includes various modules to deal with different cooling regimes, and a radiation transfer module based on a Monte Carlo ray tracing method. The code can run sequentially or in parallel with MPI.

[ascl:2107.013] GUBAS: General Use Binary Asteroid Simulator

GUBAS (General Use Binary Asteroid Simulator) predicts binary asteroid system behaviors by implementing the Hou 2016 realization of the full two-body problem (F2BP). The F2BP models binary asteroid systems as two arbitrary mass distributions whose mass elements interact gravitationally and result in both gravity forces and torques. To account for these mass distributions and model the mutual gravity of the F2BP, GUBAS computes the inertia integrals of each body up to a user defined expansion order. This approach provides a recursive expression of the mutual gravity potential and represents a significant decrease in the computational burden of the F2BP when compared to other methods of representing the mutual potential.

[ascl:2305.016] gw_pta_emulator: Gravitational Waves via Pulsar Timing Arrays

The gw_pta_emulator reads in gravitational wave (GW) characteristic strain spectra from black-hole population simulations, re-bins for the user's observing baseline, and constructs new spectra. The user can train a Gaussian process to emulate the spectral behavior at all frequencies across the astrophysical parameter space of supermassive black-hole binary environments.

[ascl:2307.047] GWDALI: Gravitational wave parameter estimation

GWDALI focuses on parameter estimations of gravitational waves generated by compact object coalescence (CBC). This software employs both Gaussian (Fisher Matrix) and Beyond-Gaussian methods to approximate the likelihood of gravitational wave events. GWDALI also addresses the challenges posed by Fisher Matrices with zero determinants. Additionally, the Beyond-Gaussian approach incorporates the Derivative Approximation for Likelihoods (DALI) algorithm, enabling a more reliable estimation process.

[ascl:2207.032] gwdet: Detectability of gravitational-wave signals from compact binary coalescences

gwdet computes the probability of detecting a gravitational-wave signal from compact binaries averaging over sky-location and source inclination. The code has two classes, averageangles and detectability. averageangles computes the detection probability, averaged over all angles (such as sky location, polarization, and inclination), as a function of the projection parameter. detectability computes the detection probability of a non-spinning compact binary.

[ascl:2002.013] GWecc: Calculator for pulsar timing array signals due to eccentric supermassive binaries

GWecc computes the pulsar timing array (PTA) signals induced by eccentric supermassive binaries. Written in C++, it computes the plus/cross polarizations as well as Earth and pulsar terms of the PTA signal given the binary parameters and the sky locations of the binary and the pulsar. A python wrapper is included through which GWecc can be used to simulate, search for and constrain gravitational wave-emitting eccentric supermassive binaries using packages such as ENTERPRISE (ascl:1912.015) and libstempo (ascl:2002.017).

[ascl:2212.001] GWFAST: Fisher information matrix python package for gravitational-wave detectors

GWFAST forecasts the signal-to-noise ratios and parameter estimation capabilities of networks of gravitational-wave detectors, based on the Fisher information matrix approximation. It is designed for applications to third-generation gravitational-wave detectors. It is based on Automatic Differentiation, which makes use of the library JAX (ascl:2111.002). This allows efficient parallelization and numerical accuracy. The code includes a module for parallel computation on clusters.

[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:1912.016] GWpy: Python package for studying data from gravitational-wave detectors

The Python package GWpy analyzes and characterizes gravitational wave data. It provides a user-friendly, intuitive interface to the common time-domain and frequency-domain data produced by the LIGO and Virgo observatories and their analyses. The core Python infrastructure is influenced by, and extends the functionality of, the Astropy (ascl:1304.002) package, and its methodology has been derived from, and augmented by, the LIGO Algorithm Library Suite (LALSuite), a large collection of primarily C99 routines for analysis and manipulation of data from gravitational-wave detectors. These packages use the SWIG program to produce Python wrappings for all C modules, allowing the GWpy package to leverage both the completeness, and the speed, of these libraries.

[ascl:2309.004] GWSim: Mock gravitational waves event generator

GWSim generates mock gravitational waves (GW) events corresponding to different binary black holes (BBHs) population models. It can incorporate scenarios of GW mass models, GW spin distributions, the merger rate, and the cosmological parameters. GWSim generates samples of binary compact objects for a fixed amount of observation time, duty cycle, and configurations of the detector network; the universe created by the code is uniform in comobile volume.

[ascl:2305.018] GWSurrogate: Gravitational wave surrogate models

GWSurrogate provides an easy to use interface to gravitational wave surrogate models. Surrogates provide a fast and accurate evaluation mechanism for gravitational waveforms which would otherwise be found through solving differential equations. These equations must be solved in the “building” phase, which was performed using other codes.

[ascl:2111.018] GWToolbox: Gravitational wave observation simulator

GWToolbox simulates gravitational wave observations for various detectors. The package is composed of three modules, namely the ground-based detectors (and their targets), the space-borne detectors (and their targets) and pulsar timing arrays (PTA). These three modules work independently and have different dependencies on other packages and libraries; failed dependencies met in one module will not influence the usage of another module. GWToolbox can accessed with a web interface (gw-universe.org) or as a python package (https://bitbucket.org/radboudradiolab/gwtoolbox).

[ascl:1203.005] Gyoto: General relativitY Orbit Tracer of Observatoire de Paris

GYOTO, a general relativistic ray-tracing code, aims at computing images of astronomical bodies in the vicinity of compact objects, as well as trajectories of massive bodies in relativistic environments. This code is capable of integrating the null and timelike geodesic equations not only in the Kerr metric, but also in any metric computed numerically within the 3+1 formalism of general relativity. Simulated images and spectra have been computed for a variety of astronomical targets, such as a moving star or a toroidal accretion structure. The underlying code is open source and freely available. It is user-friendly, quickly handled and very modular so that extensions are easy to integrate. Custom analytical metrics and astronomical targets can be implemented in C++ plug-in extensions independent from the main code.

[ascl:1308.010] GYRE: Stellar oscillation code

GYRE is an oscillation code that solves the stellar pulsation equations (both adiabatic and non-adiabatic) using a novel Magnus Multiple Shooting numerical scheme devised to overcome certain weaknesses of the usual relaxation and shooting schemes. The code is accurate (up to 6th order in the number of grid points), robust, and makes efficient use of multiple processor cores and/or nodes.

[ascl:1402.031] gyrfalcON: N-body code

gyrfalcON (GalaxY simulatoR using falcON) is a full-fledged N-body code using Dehnen’s force algorithm of complexity O(N) (falcON); this algorithm is approximately 10 times faster than an optimally coded tree code. The code features individual adaptive time steps and individual (but fixed) softening lengths. gyrfalcON is included in and requires NEMO to run.

[ascl:2307.026] gyrointerp: Gyrochronology via interpolation of open cluster rotation sequences

gyrointerp calculates gyrochronal ages by interpolating between open cluster rotation sequences. The framework, written in Python, can be used to find the gyrochronological age posterior of single or many stars. It can also produce a visual interpolation for a star’s age to determine where the star falls in the rotation-temperature plane in comparison to known reference clusters. gyrointerp models the ensemble evolution of rotation periods for main-sequence stars with temperatures of 3800-6200 K (masses of 0.5-1.2 solar) and is not applicable for subgiant or giant stars, and should be used cautiously with binary stars, as they can observationally bias temperature and rotation period measurements.

[ascl:2211.015] H-FISTA: Phase retrieval for pulsar spectroscopy

H-FISTA (Hierarchical Fast Iterative Shrinkage Thresholding Algorithm) retrieves the phases of the wavefield from intensity measurements for pulsar spectroscopy. The code accepts input data in ASCII format as produced by PSRchive's (ascl:1105.014) psrflux function, a FITS file, or a pickle. If using a notebook, any custom reader can be used as long as the data ends up in a NumPy array. H-FISTA obtains sparse models of the wavefield in a hierarchical approach with progressively increasing depth. Once the tail of the noise distribution is reached, the hierarchy terminates with a final unregularized optimization, resulting in a fully dense model of the complex wavefield that permits the discovery of faint signals by appropriate averaging.

[ascl:1909.005] HADES: Hexadecapolar Analysis for Dust Estimation in Simulations (of CMB B-mode thermal dust emission)

HADES analyzse dust levels in simulated CMB galactic dust maps with realistic experimental noise and lensing configurations. It allows detection of dust via its anisotropy properties in CMB B-modes. It also includes techniques for computing null-tests and a rudimentary technique for dedusting.

[ascl:2306.001] HAFFET: Supernovae photometric and spectroscopic data analyzer

HAFFET (Hybrid Analytic Flux FittEr for Transients) analyzes supernovae photometric and spectroscopic data. It handles observational data for a set of targets, estimates their physical parameters, and visualizes the population of inferred parameters. HAFFET defines two classes, snobject for data and fittings for one specific object, and snelist to organize the overall running for a list of objects. The HAFFET package includes utilities for downloading SN data from online sources, intepolating multi band lightcurves, characterizing the first light and rising of SNe with power law fits, and matching epochs of different bands. It can also calculate colors, and/or construct the spectral energy distribution (SED), estimate bolometric LCs and host galaxy extinction, fit the constructed bolometric lightcurves to different models, and identify and fit the absorption minima of spectral lines, in addition to performing other tasks. In addition to utilizing the built-in models, users can add their own models or import models from other python packages.

[ascl:2002.014] HaloAnalysis: Read and analyze halo catalogs and merger trees

HaloAnalysis reads and analyzes halo/galaxy catalogs, generated from Rockstar (ascl:1210.008) or AHF (ascl:1102.009), and merger trees generated from Consistent Trees (ascl:1210.011). Written in Python, it offers the following functionalities: reads halo/galaxy/tree catalogs from multiple file formats; assigns baryonic particles and galaxy properties to dark-matter halos; combines and re-generates halo/galaxy/tree files in hdf5 format; analyzes properties of halos/galaxies; and selects halos to generate zoom-in initial conditions. The code includes a tutorial in the form of a Jupyter notebook.

[ascl:1402.032] HALOFIT: Nonlinear distribution of cosmological mass and galaxies

HALOFIT provides an explanatory framework for galaxy bias and clustering and has been incorporated into CMB packages such as CMBFAST (ascl:9909.004) and CAMB (ascl:1102.026). It attains a reasonable level of precision, though the halo model does not match N-body data perfectly. The code is written in Fortran 77. HALOFIT tends to underpredict the power on the smallest scales in standard LCDM universes (although HALOFIT was designed to work for a much wider range of power spectra); its accuracy can be improved by using a supplied correction.

[ascl:1010.053] Halofitting codes for DGP and Degravitation

We perform N-body simulations of theories with infinite-volume extra dimensions, such as the Dvali-Gabadadze-Porrati (DGP) model and its higher-dimensional generalizations, where 4D gravity is mediated by massive gravitons. The longitudinal mode of these gravitons mediates an extra scalar force, which we model as a density-dependent modification to the Poisson equation. This enhances gravitational clustering, particularly on scales that have undergone mild nonlinear processing. While the standard non-linear fitting algorithm of Smith et al. overestimates this power enhancement on non-linear scales, we present a modified fitting formula that offers a remarkably good fit to our power spectra. Due to the uncertainty in galaxy bias, our results are consistent with precision power spectrum determinations from galaxy redshift surveys, even for graviton Compton wavelengths as small as 300 Mpc. Our model is sufficiently general that we expect it to capture the phenomenology of a wide class of related higher-dimensional gravity scenarios.

[ascl:1505.017] HALOGEN: Approximate synthetic halo catalog generator

HALOGEN generates approximate synthetic halo catalogs. Written in C, it decomposes the problem of generating cosmological tracer distributions (eg. halos) into four steps: generating an approximate density field, generating the required number of tracers from a CDF over mass, placing the tracers on field particles according to a bias scheme dependent on local density, and assigning velocities to the tracers based on velocities of local particles. It also implements a default set of four models for these steps. HALOGEN uses 2LPTic (ascl:1201.005) and CUTE (ascl:1505.016); the software is flexible and can be adapted to varying cosmologies and simulation specifications.

[ascl:2011.009] HaloGen: Modular halo model code

HaloGen computes all auto and cross spectra and halo model trispectrum in simple configurations. This modular halo model code computes 3d power spectra, and the corresponding projected 2d power spectra in the Limber and flat sky approximations. The observables include matter density, galaxy lensing, CMB lensing, thermal Sunyaev-Zel'dovich, cosmic infrared background, tracers with any dn/dz, b(z) and HOD.

[ascl:1407.020] Halogen: Multimass spherical structure models for N-body simulations

Halogen, written in C, generates multimass spherically symmetric initial conditions for N-body simulations. A large family of radial density profiles is supported. The initial conditions are sampled from the full distribution function.

[ascl:2303.020] HaloGraphNet: Predict halo masses from simulations

HaloGraphNet predicts halo masses from simulations using Graph Neural Networks. Given a dark matter halo and its galaxies, this software creates a graph with information about the 3D position, stellar mass and other properties. It then trains a Graph Neural Network to predict the mass of the host halo. Data are taken from the CAMELS hydrodynamic simulations.

[ascl:2009.016] halomod: Flexible interface for the halo model of dark matter halos

halomod calculates cosmological halo model and HOD quantities. It is built on HMF (ascl:1412.006); it retains that code's features and provides extended components for the halo model, including numerous halo bias models, including scale-dependent bias, basic concentration-mass-redshift relations, and several plug-and-play halo-exclusion models. halomod includes built-in HOD parameterizations and halo profiles, support for WDM models, and all basic quantities such as 3D correlations and power spectra, and also several derived quantities such as effective bias and satellite fraction. In addition, it offers a simple routine for populating a halo catalog with galaxies via a HOD. halomod is flexible and modular, making it easily extendable.

[ascl:1604.005] Halotools: Galaxy-Halo connection models

Halotools builds and tests models of the galaxy-halo connection and analyzes catalogs of dark matter halos. The core functions of the package include fast generation of synthetic galaxy populations using HODs, abundance matching, and related methods; efficient algorithms for calculating galaxy clustering, lensing, z-space distortions, and other astronomical statistics; a modular, object-oriented framework for designing galaxy evolution models; and end-to-end support for reducing halo catalogs and caching them as hdf5 files.

[ascl:1210.022] HAM2D: 2D Shearing Box Model

HAM solves non-relativistic hyperbolic partial differential equations in conservative form using high-resolution shock-capturing techniques. This version of HAM has been configured to solve the magnetohydrodynamic equations of motion in axisymmetry to evolve a shearing box model.

[ascl:1201.014] Hammurabi: Simulating polarized Galactic synchrotron emission

The Hammurabi code is a publicly available C++ code for generating mock polarized observations of Galactic synchrotron emission with telescopes such as LOFAR, SKA, Planck, and WMAP, based on model inputs for the Galactic magnetic field (GMF), the cosmic-ray density distribution, and the thermal electron density. The Hammurabi code allows one to perform simulations of several different data sets simultaneously, providing a more reliable constraint of the magnetized ISM.

[ascl:2112.022] hankl: Python implementation of the FFTLog algorithm for cosmology

hankl implements the FFTLog algorithm in lightweight Python code. The FFTLog algorithm can be thought of as the Fast Fourier Transform (FFT) of a logarithmically spaced periodic sequence (= Hankel Transform). hankl consists of two modules, the General FFTLog module and the Cosmology one. The latter is suited for modern cosmological application and relies heavily on the former to perform the Hankel transforms. The accuracy of the method usually improves as the range of integration is enlarged; FFTlog prefers an interval that spans many orders of magnitude. Resolution is important, as low resolution introduces sharp features which in turn causes ringing.

[ascl:1905.009] HAOS-DIPER: HAO Spectral Diagnostic Package For Emitted Radiation

HAOS-DIPER works with and manipulates data for neutral atoms and atomic ions to understand radiation emitted by some space plasmas, notably the solar atmosphere and stellar atmospheres. HAOS-DIPER works with quantum numbers for atomic levels, enabling it to perform tasks otherwise difficult or very tedious, including a variety of data checks, calculations based upon the atomic numbers, and searching and manipulating data based upon these quantum numbers. HAOS-DIPER handles conditions from LTE to coronal-like conditions, in a manner controlled by one system variable !REGIME, and has some capability for estimating data for which no accurate parameters are available and for accounting for the effects of missing atomic levels.

[ascl:2102.010] hardCORE: Exoplanet core radius fractions calculator

hardCORE calculates the minimum, maximum, and marginal core radius fractions (CRFmin, CRFmax, CRFmarg) for a solid exoplanet using only its mass and radius. Written in Python, the code is an efficient tool that is extremely fast to execute and perform inversions.

[ascl:1209.005] HARM: A Numerical Scheme for General Relativistic Magnetohydrodynamics

HARM uses a conservative, shock-capturing scheme for evolving the equations of general relativistic magnetohydrodynamics. The fluxes are calculated using the Harten, Lax, & van Leer scheme. A variant of constrained transport, proposed earlier by Tóth, is used to maintain a divergence-free magnetic field. Only the covariant form of the metric in a coordinate basis is required to specify the geometry. On smooth flows HARM converges at second order.

[ascl:2009.022] Harmonia: Hybrid-basis inference for large-scale galaxy clustering

Harmonia combines clustering statistics decomposed in spherical and Cartesian Fourier bases for large-scale galaxy clustering likelihood analysis. Optimal weighting schemes for spherical Fourier analysis can also be readily implemented using the code.

[ascl:2401.009] Harmonic: Learnt harmonic mean estimator

harmonic learns an approximate harmonic mean estimator (referred to as a "learnt harmonic mean estimator") from posterior distribution samples to compute the marginal likelihood required for Bayesian model selection. Using a large number of independent Markov chain Monte Carlo (MCMC) chains from another package such as emcee (ascl:1303.002), harmonic uses importance sampling to learn a new target distribution in order to optimize an approximate harmonic estimator while minimizing its variance.

[ascl:1306.003] Harmony: Synchrotron Emission Coefficients

Harmony is a general numerical scheme for evaluating MBS emission and absorption coefficients for both polarized and unpolarized light in a plasma with a general distribution function.

[ascl:1912.014] HARMPI: 3D massively parallel general relativictic MHD code

HARMPI is a parallel, 3D version of HARM (ascl:1209.005), which solves hyperbolic partial differential equations in conservative form using high-resolution shock-capturing techniques. The code is parallelized using MPI and is fully operational in 3D. HARMPI, like HARM, is capable of using non-uniform grids and solves the relativistic magnetohydrodynamic equations of motion on a stationary black hole spacetime in Kerr-Schild coordinates to evolve an accretion disk model.

[ascl:2302.008] HawkingNet: Finding Hawking points in the Cosmic Microwave Background

HawkingNet searches for Hawking points in large Cosmic Microwave Background (CMB) data sets. It is based on the deep residual network ResNet18 and consists of eighteen neural layers. Written in Paython, HawkingNet inputs the CMB data, processes the data through its internal network trained for data classification, and outputs the result in a form of a classification score that indicates how confident it is that a Hawking point is contained in the image patch.

[ascl:2307.046] HAYASHI: Halo-level AnalYsis of the Absorption Signal in HI

HAYASHI (Halo-level AnalYsis of the Absorption Signal in HI) computes the number of absorption features of the 21cm forest using a semianalytic formalism. It includes the enhancement of the signal due to the presence of substructures within minihalos and supports non-standard cosmologies with impact in the large scale structure, such as warm dark matter and primordial black holes. HAYASHI is written in Python3 and uses the cosmological computations package Colossus (ascl:1501.016).

[ascl:1109.004] HAZEL: HAnle and ZEeman Light

A big challenge in solar and stellar physics in the coming years will be to decipher the magnetism of the solar outer atmosphere (chromosphere and corona) along with its dynamic coupling with the magnetic fields of the underlying photosphere. To this end, it is important to develop rigorous diagnostic tools for the physical interpretation of spectropolarimetric observations in suitably chosen spectral lines. HAZEL is a computer program for the synthesis and inversion of Stokes profiles caused by the joint action of atomic level polarization and the Hanle and Zeeman effects in some spectral lines of diagnostic interest, such as those of the He I 1083.0 nm and 587.6 nm (or D3) multiplets. It is based on the quantum theory of spectral line polarization, which takes into account in a rigorous way all the relevant physical mechanisms and ingredients (optical pumping, atomic level polarization, level crossings and repulsions, Zeeman, Paschen-Back and Hanle effects). The influence of radiative transfer on the emergent spectral line radiation is taken into account through a suitable slab model. The user can either calculate the emergent intensity and polarization for any given magnetic field vector or infer the dynamical and magnetic properties from the observed Stokes profiles via an efficient inversion algorithm based on global optimization methods.

[ascl:2212.009] Hazma: Compute indirect detection constraints on sub-GeV dark matter

Hazma enables indirect detection of sub-GeV dark matter. It computes gamma-ray and electron/positron spectra from dark matter annihilations, sets limits on sub-GeV dark matter using existing gamma-ray data, and determines the discovery reach of future gamma-ray detectors. The code also derives accurate CMB constraints. Hazma comes with several sub-GeV dark matter models, for which it provides functions to compute dark matter annihilation cross sections and mediator decay widths. A variety of low-level tools are provided to make it straightforward to define new models.

[ascl:1711.022] HBT: Hierarchical Bound-Tracing

HBT is a Hierarchical Bound-Tracing subhalo finder and merger tree builder, for numerical simulations in cosmology. It tracks haloes from birth and continues to track them after mergers, finding self-bound structures as subhaloes and recording their merger histories as merger trees.

[ascl:1711.023] HBT+: Subhalo finder and merger tree builder

HBT+ is a hybrid subhalo finder and merger tree builder for cosmological simulations. It comes as an MPI edition that can be run on distributed clusters or shared memory machines and is MPI/OpenMP parallelized, and also as an OpenMP edition that can be run on shared memory machines and is only OpenMP parallelized. This version is more memory efficient than the MPI branch on shared memory machines, and is more suitable for analyzing zoomed-in simulations that are difficult to balance on distributed clusters. Both editions support hydro simulations with gas/stars.

[ascl:2012.023] HCGrid: Mapping non-uniform radio astronomy data onto a uniformly distributed grid

HCGrid maps non-uniform radio astronomy data onto a uniformly distributed grid using a convolution-based algorithm on CPU-GPU heterogeneous platforms. The package has three modules; the initialization module initializes parameters needed for the calculation process, such as setting the size of the sampling space and output resolution. The gridding module uses a parallel ordering algorithm to pre-order the sampling points based on HEALPix on the CPU platform and uses an efficient two-level lookup table to speed up the acquisition of sampling points; it then accelerates convolution by using the high parallelism of GPU and through related performance optimization strategies based on CUDA architecture to further improve the gridding performance. The third module processes the results; it visualizes the gridding and exports the final products as FITS files.

[ascl:2302.026] HDMSpectra: Dark Matter Spectra from the electroweak to the Planck scale

HDMSpectra computes the decay spectrum for dark matter with masses above the scale of electroweak symmetry breaking, down to Planck scale and including all relevant electroweak interactions. The code determines the distribution of stable states for photons, neutrinos, positrons, and antiprotons.

[ascl:1502.009] HDS: Hierarchical Data System

The Hierarchical Data System (HDS) is a file-based hierarchical data system designed for the storage of a wide variety of information. It is particularly suited to the storage of large multi-dimensional arrays (with their ancillary data) where efficient access is needed. It is a key component of the Starlink software collection (ascl:1110.012) and is used by the Starlink N-Dimensional Data Format (NDF) library (ascl:1411.023).

HDS organizes data into hierarchies, broadly similar to the directory structure of a hierarchical filing system, but contained within a single HDS container file. The structures stored in these files are self-describing and flexible; HDS supports modification and extension of structures previously created, as well as functions such as deletion, copying, and renaming. All information stored in HDS files is portable between the machines on which HDS is implemented. Thus, there are no format conversion problems when moving between machines. HDS can write files in a private binary format (version 4), or be layered on top of HDF5 (version 5).

[ascl:2301.004] HEADSS: HiErArchical Data Splitting and Stitching for non-distributed clustering algorithms

HEADSS (HiErArchical Data Splitting and Stitching) facilitates clustering at scale, unlike clustering algorithms that scale poorly with increased data volume or that are intrinsically non-distributed. HEADSS automates data splitting and stitching, allowing repeatable handling, and removal, of edge effects. Implemented in conjunction with scikit's HDBSCAN, the code achieves orders of magnitude reduction in single node memory requirements for both non-distributed and distributed implementations, with the latter offering similar order of magnitude reductions in total run times while recovering analogous accuracy. HEADSS also establishes a hierarchy of features by using a subset of clustering features to split the data.

[ascl:1107.018] HEALPix: Hierarchical Equal Area isoLatitude Pixelization of a sphere

HEALPix is an acronym for Hierarchical Equal Area isoLatitude Pixelization of a sphere. As suggested in the name, this pixelization produces a subdivision of a spherical surface in which each pixel covers the same surface area as every other pixel. Another property of the HEALPix grid is that the pixel centers occur on a discrete number of rings of constant latitude, the number of constant-latitude rings is dependent on the resolution of the HEALPix grid.

[ascl:2109.028] Healpix.jl: Julia-only port of the HEALPix library

Healpix.jl is a Julia-only port of the C/C++/Fortran/Python HEALPix library (ascl:1107.018), which implements a hierarchical pixelization of the sphere in equal-area pixels. Much like the original library, Healpix.jl supports two enumeration schemes for the pixels (RING and NESTED) and implements an optimized computation of the generalized Fourier transform using spherical harmonics, binding libsharp2 (ascl:1402.033). In addition, Healpix.jl provides four additional features: 1.) it fully supports Windows systems, alongside the usual Linux and MAC OS X machines; 2.) it uses Julia's strong typesystem to prevent several bugs related to mismatches in map ordering (e.g., combining a RING map with a NESTED map); 3.) it uses a versatile memory layout so that map bytes can be stored in shared memory objects or on GPUs; and 4.) it implements an elegant and general way to signal missing values in maps.

[ascl:2008.022] healpy: Python wrapper for HEALPix

healpy handles pixelated data on the sphere. It is based on the Hierarchical Equal Area isoLatitude Pixelization (HEALPix) scheme and bundles the HEALPix (ascl:1107.018) C++ library. healpy provides utilities to convert between sky coordinates and pixel indices in HEALPix nested and ring schemes and find pixels within a disk, a polygon or a strip in the sky. It can apply coordinate transformations between Galactic, Ecliptic and Equatorial reference frames, apply custom rotations either to vectors or full maps, and read and write HEALPix maps to disk in FITS format. healpy also includes utilities to upgrade and downgrade the resolution of existing HEALPix maps and transform maps to Spherical Harmonics space and back using multi-threaded C++ routines, among other utilities.

[ascl:1907.002] healvis: Radio interferometric visibility simulator based on HEALpix maps

Healvis simulates radio interferometric visibility off of HEALPix shells. It generates a flat-spectrum and a GSM model and computes visibilities, and can simulates visibilities given an Observation Parameter YAML file. Healvis can perform partial frequency simulations in serial to minimize instantaneous memory loads.

[ascl:2006.001] HEARSAY: Simulations for the probability of alien contact

HEARSAY computes simulations of the causal contacts between emitters in the Galaxy. It implements the Stochastic Constrained Causal Contact Network (SC3Net) model and explores the parameter space of the model for the emergence of communicating nodes through Monte Carlo simulations and analyzes their causal connections. This model for the abundance and duration of civilizations is based on minimal assumptions and three free parameters, with focus on the statistical properties of empirical models instead of an interpretable model with variables to be determined by observation.

[ascl:1408.004] HEAsoft: Unified Release of FTOOLS and XANADU

HEASOFT combines XANADU, high-level, multi-mission software for X-ray astronomical spectral, timing, and imaging data analysis tasks, and FTOOLS (ascl:9912.002), general and mission-specific software to manipulate FITS files, into one package. It also contains contains the NuSTAR subpackage of tasks, NuSTAR Data Analysis Software (NuSTARDAS). The source code for the software can be downloaded; precompiled executables for the most widely used computer platforms are also available for download. As an additional service, HEAsoft tasks can be directly from a web browser via WebHera.

[ascl:1506.009] HEATCVB: Coronal heating rate approximations

HEATCVB is a stand-alone Fortran 77 subroutine that estimates the local volumetric coronal heating rate with four required inputs: the radial distance r, the wind speed u, the mass density ρ, and the magnetic field strength |B0|. The primary output is the heating rate Qturb at the location defined by the input parameters. HEATCVB also computes the local turbulent dissipation rate of the waves, γ = Qturb/(2UA).

[ascl:1911.008] HeatingRate: Radioactive heating rate and macronova (kilonova) light curve

HeatingRate calculates the nuclear heating rates [erg/s/g] of beta-decay, alpha-decay, and spontaneous fission of r-process nuclei, taking into account for thermalization of gamma-rays and charged decay products in r-process ejecta. It uses the half-lives and injection energy spectra from an evaluated nuclear data library (ENDF/B-VII.1). Each heating rate is computed for given abundances, ejecta mass, velocity, and density profile. HeatingRate also computes the bolometric light curve and the evolution of the effective temperature for given abundances, ejecta mass, velocity, and density profile assuming opacities independent of the wavelength.

[ascl:2307.056] HELA: Random Forest retrieval for exoplanet atmospheres

HELA performs atmospheric retrieval on exoplanet atmospheres using a Random Forest algorithm. The code has two stages: training (which includes testing), and predicting. It requires a training set that matches the format of the data to be analyzed, with the same number of points and a sample spectrum for each parameter. The number of trees used and the number of jobs are editable. The HELA package includes a training set and data as examples.

[ascl:1903.017] HelioPy: Heliospheric and planetary physics library

HelioPy provides a set of tools to download and read in data, and carry out other common data processing tasks for heliospheric and planetary physics. It handles a wide variety of solar and satellite data and builds upon the SpiceyPy package (ascl:1903.016) to provide an accessible interface for performing orbital calculations. It has also implemented a framework to perform transformations between some common coordinate systems.

[ascl:1503.004] HELIOS-K: Opacity Calculator for Radiative Transfer

HELIOS-K is an opacity calculator for exoplanetary atmospheres. It takes a line list as an input and computes the line shapes of an arbitrary number of spectral lines (~millions to billions). HELIOS-K is capable of computing 100,000 spectral lines in 1 second; it is written in CUDA, is optimized for graphics processing units (GPUs), and can be used with the HELIOS radiative transfer code (ascl:1807.009).

[ascl:2207.010] Helios-r2: Bayesian nested-sampling retrieval code

Helios-r2 performs atmospheric retrieval of brown dwarf and exoplanet spectra. It uses a Bayesian statistics approach by employing a nested sampling method to generate posterior distributions and calculate the Bayesian evidence. The nested sampling itself is done by Multinest (ascl:1109.006). The computationally most demanding parts of the model have been written in NVIDIA's CUDA language for an increase in computational speed. Successful applications include retrieval of brown dwarf emission spectra and secondary eclipse measurements of exoplanets.

[ascl:1807.009] HELIOS: Radiative transfer code for exoplanetary atmospheres

HELIOS, a radiative transfer code, is constructed for studying exoplanetary atmospheres. The model atmospheres of HELIOS are one-dimensional and plane-parallel, and the equation of radiative transfer is solved in the two-stream approximation with non-isotropic scattering. Though HELIOS can be used alone, the opacity calculator HELIOS-K (ascl:1503.004) can be used with it to provide the molecular opacities.

[ascl:1805.019] HENDRICS: High ENergy Data Reduction Interface from the Command Shell

HENDRICS, a rewrite and update to MaLTPyNT (ascl:1502.021), contains command-line scripts based on Stingray (ascl:1608.001) to perform a quick-look (spectral-)timing analysis of X-ray data, treating the gaps in the data due, e.g., to occultation from the Earth or passages through the SAA, properly. Despite its original main focus on NuSTAR, HENDRICS can perform standard aperiodic timing analysis on X-ray data from, in principle, any other satellite, and its features include power density and cross spectra, time lags, pulsar searches with the Epoch folding and the Z_n^2 statistics, color-color and color-intensity diagrams. The periodograms produced by HENDRICS (such as a power density spectrum or a cospectrum) can be saved in a format compatible with XSPEC (ascl:9910.005) or ISIS (ascl:1302.002).

[ascl:2104.001] hera_opm: The HERA Online Processing Module

The hera_opm package provides a convenient and flexible framework for developing data analysis pipelines for operating on a sequence of input files. Though developed for application to the Hydrogen Epoch of Reionization Array (HERA), it is a general package that can be applied to any workflow designed to apply a series of analysis steps to any type of files. It is also portable, operating both on a diversity of computer clusters with batch submission systems and local machines.

[ascl:1102.016] HERACLES: 3D Hydrodynamical Code to Simulate Astrophysical Fluid Flows

HERACLES is a 3D hydrodynamical code used to simulate astrophysical fluid flows. It uses a finite volume method on fixed grids to solve the equations of hydrodynamics, MHD, radiative transfer and gravity. This software is developed at the Service d'Astrophysique, CEA/Saclay as part of the COAST project and is registered under the CeCILL license. HERACLES simulates astrophysical fluid flows using a grid based Eulerian finite volume Godunov method. It is capable of simulating pure hydrodynamical flows, magneto-hydrodynamic flows, radiation hydrodynamic flows (using either flux limited diffusion or the M1 moment method), self-gravitating flows using a Poisson solver or all of the above. HERACLES uses cartesian, spherical and cylindrical grids.

[ascl:2209.002] Herculens: Differentiable gravitational lensing

Herculens models imaging data of strong gravitational lenses. The package supports various degrees of model complexity, ranging from standard smooth analytical profiles to pixelated models and machine learning approaches. In particular, it implements multiscale pixelated models regularized with sparsity constraints and wavelet decomposition, for modeling both the source light distribution and the lens potential. The code is fully differentiable - based on JAX (ascl:2111.002) - which enables fast convergence to the solution, access to the parameters covariance matrix, efficient exploration of the parameter space including the sampling of posterior distributions using variational inference or Hamiltonian Monte-Carlo methods.

[ascl:2107.030] HERMES: High-Energy Radiative MESsengers

The HERMES (High-Energy Radiative MESsengers) computational framework for line of sight integration creates sky maps in the HEALPix-compatibile format of various galactic radiative processes, including Faraday rotation, synchrotron and free-free radio emission, gamma-ray emission from pion-decay, bremsstrahlung and inverse-Compton. The code is written in C++ and provides numerous integrators, including dispersion measure, rotation measure, and Gamma-ray emissions from Dark Matter annihilation, among others.

[ascl:1808.005] hfof: Friends-of-Friends via spatial hashing

hfof is a 3-d friends-of-friends (FoF) cluster finder with Python bindings based on a fast spatial hashing algorithm that identifies connected sets of points where the point-wise connections are determined by a fixed spatial distance. This technique sorts particles into fine cells sufficiently compact to guarantee their cohabitants are linked, and uses locality sensitive hashing to search for neighboring (blocks of) cells. Tests on N-body simulations of up to a billion particles exhibit speed increases of factors up to 20x compared with FOF via trees, and is consistently complete in less than the time of a k-d tree construction, giving it an intrinsic advantage over tree-based methods.

[ascl:2103.002] hfs_fit: Atomic emission spectral line hyperfine structure fitting

hfs_fit performs parameter optimization in the analysis of emission line hyperfine structure (HFS). The code uses a simulated annealing algorithm to optimize the magnetic dipole interaction constants, electric quadrupole interaction constants, Voigt profile widths and the center of gravity wavenumber for a given emission line profile. The fit can be changed visually with sliders for parameters, which is useful when HFS constants are unknown.

[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:1801.004] hh0: Hierarchical Hubble Constant Inference

hh0 is a Bayesian hierarchical model (BHM) that describes the full distance ladder, from nearby geometric-distance anchors through Cepheids to SNe in the Hubble flow. It does not rely on any of the underlying distributions being Gaussian, allowing outliers to be modeled and obviating the need for any arbitrary data cuts.

[submitted] HHTpywrapper: Python Wrapper for Hilbert–Huang Transform MATLAB Package

HHTpywrapper is a python interface to call the Hilbert–Huang Transform (HHT) MATLAB package. HHT is a time-frequency analysis method to adaptively decompose a signal, that could be generated by non-stationary and/or nonlinear processes, into basis components at different timescales, and then Hilbert transform these components into instantaneous phases, frequencies and amplitudes as functions of time. HHT has been successfully applied to analyzing X-ray quasi-periodic oscillations (QPOs) from the active galactic nucleus RE J1034+396 (Hu et al. 2014) and two black hole X-ray binaries, XTE J1550–564 (Su et al. 2015) and GX 339-4 (Su et al. 2017). HHTpywrapper provides examples of reproducing HHT analysis results in Su et al. (2015) and Su et al. (2017). This project is originated from the Astro Hack Week 2015.

[ascl:1808.010] hi_class: Horndeski in the Cosmic Linear Anisotropy Solving System

hi_class implements Horndeski's theory of gravity in the modern Cosmic Linear Anisotropy Solving System (ascl:1106.020). It can be used to compute any cosmological observable at the level of background or linear perturbations, such as cosmological distances, cosmic microwave background, matter power and number count spectra (including relativistic effects). hi_class can be readily interfaced with Monte Python (ascl:1307.002) to test Gravity and Dark Energy models.

[ascl:2311.009] Hi-COLA: Cosmological large-scale structure simulator for Horndeski theories

Hi-COLA runs fast approximate N-body simulations of non-linear structure formation in reduced Horndeski gravity (Horndeski theories with luminal gravitational waves). It is generic with respect to the reduced Horndeski class. Given an input Lagrangian, Hi-COLA's front-end dynamically constructs the appropriate field equations and consistently solves for the cosmological background, linear growth, and screened fifth force of that theory. This is passed to the back-end, which runs a hybrid N-body simulation at significantly reduced computational and temporal cost compared to traditional N-body codes. By analyzing the particle snapshots, one can study the formation of structure through statistics such as the matter power spectrum.

[ascl:1606.004] HIBAYES: Global 21-cm Bayesian Monte-Carlo Model Fitting

HIBAYES implements fully-Bayesian extraction of the sky-averaged (global) 21-cm signal from the Cosmic Dawn and Epoch of Reionization in the presence of foreground emission. User-defined likelihood and prior functions are called by the sampler PyMultiNest (ascl:1606.005) in order to jointly explore the full (signal plus foreground) posterior probability distribution and evaluate the Bayesian evidence for a given model. Implemented models, for simulation and fitting, include gaussians (HI signal) and polynomials (foregrounds). Some simple plotting and analysis tools are supplied. The code can be extended to other models (physical or empirical), to incorporate data from other experiments, or to use alternative Monte-Carlo sampling engines as required.

[ascl:1607.019] HIDE: HI Data Emulator

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:2007.002] hierArc: Hierarchical analysis of strong gravitational lenses

hierArc hierarchically infers strong lensing mass density profiles and the cosmological parameters, in particular the Hubble constant. The software supports lenses with imaging data and kinematics, and optionally time delays. The kinematics modeling is performed in conjunction with lenstronomy (ascl:1804.012).

[ascl:2005.008] HiFLEx: Echelle data reduction pipeline

HiFLEx reduces echelle data taken with a single or bifurcated fiber input. It takes a FITS image file (i.e., a CCD image) and runs data reduction steps, extracts out orders from an Echelle spectrograph (regardless of separation and curvature, as long as orders are distinguishable from one-another), applies the wavelength correction, measures the radial velocity, and performs further calibration steps.

[ascl:1802.007] HiGal_SED_Fitter: SED fitting tools for Herschel Hi-Gal data

HiGal SED Fitter fits modified blackbody SEDs to Herschel data, specifically targeted at Herschel Hi-Gal data.

[ascl:1207.002] HiGPUs: Hermite's N-body integrator running on Graphic Processing Units

HiGPUs is an implementation of the numerical integration of the classical, gravitational, N-body problem, based on a 6th order Hermite’s integration scheme with block time steps, with a direct evaluation of the particle-particle forces. The main innovation of this code is its full parallelization, exploiting both OpenMP and MPI in the use of the multicore Central Processing Units as well as either Compute Unified Device Architecture (CUDA) or OpenCL for the hosted Graphic Processing Units. We tested both performance and accuracy of the code using up to 256 GPUs in the supercomputer IBM iDataPlex DX360M3 Linux Infiniband Cluster provided by the italian supercomputing consortium CINECA, for values of N ≤ 8 millions. We were able to follow the evolution of a system of 8 million bodies for few crossing times, task previously unreached by direct summation codes.

HiGPUs is also available as part of the AMUSE project.

[ascl:1807.008] HII-CHI-mistry_UV: Oxygen abundance and ionizionation parameters for ultraviolet emission lines

HII-CHI-mistry_UV derives oxygen and carbon abundances using the ultraviolet (UV) lines emitted by the gas phase ionized by massive stars. The code first fixes C/O using ratios of appropriate emission lines and, in a second step, calculates O/H and the ionization parameter from carbon lines in the UV. An optical version of this Python code, HII-CHI-mistry (ascl:1807.007), is also available.

[ascl:1807.007] HII-CHI-mistry: Oxygen abundance and ionizionation parameters for optical emission lines

HII-CHI-mistry calculates the oxygen abundance for gaseous nebulae ionized by massive stars using optical collisionally excited emission lines. This code takes the extinction-corrected emission line fluxes and, based on a Χ2 minimization on a photoionization models grid, determines chemical-abundances (O/H, N/O) and ionization parameters. An ultraviolet version of this Python code, HII-CHI-mistry-UV (ascl:1807.008), is also available.

[ascl:1603.017] HIIexplorer: Detect and extract integrated spectra of HII regions

HIIexplorer detects and extracts the integrated spectra of HII regions from IFS datacubes. The procedure assumes H ii regions are peaky/isolated structures with a strong ionized gas emission, clearly above the continuum emission and the average ionized gas emission across the galaxy and that H ii regions have a typical physical size of about a hundred or a few hundreds of parsecs, which corresponds to a typical projected size at the distance of the galaxies of a few arcsec for galaxies at z~0.016. All input parameters can be derived from either a visual inspection and/or a statistical analysis of the Hα emission line map. The algorithm produces a segmentation FITS file describing the pixels associated to each H ii region. A newer version of this code, pyHIIexplorer (ascl:2206.010), is available.

[ascl:1405.005] HIIPHOT: Automated Photometry of H II Regions

HIIPHOT enables accurate photometric characterization of H II regions while permitting genuine adaptivity to irregular source morphology. It makes a first guess at the shapes of all sources through object recognition techniques; it then allows for departure from such idealized "seeds" through an iterative growing procedure and derives photometric corrections for spatially coincident diffuse emission from a low-order surface fit to the background after exclusion of all detected sources.

[ascl:2104.003] Hilal-Obs: Authentication agorithm for new moon visibility report

Hilal-Obs authenticates lunar crescent first visibility reports. The code, written in Python, uses PyEphem (ascl:1112.014) for astrometrics, and takes into account all the factors that affect lunar crescent visibility, including atmospheric extinction, observer physiology, sky and lunar brightness, contrast threshold, and the type of observation.

[ascl:2307.031] HilalPy: Analysis tool for lunar crescent visibility criterion

HilalPy analyzes lunar crescent visibility criteria. Written in Python, the code uses more than 8000 lunar crescent visibility records extracted from literature and websites of lunar crescent observation, descriptive statistics, contradiction rate percentage, and regression analysis in its analysis to predict the visibility of a lunar crescent.

[ascl:2301.008] HiLLiPoP: High-L Likelihood Polarized for Planck

HiLLiPoP is a multifrequency CMB likelihood for Planck data. The likelihood is a spectrum-based Gaussian approximation for cross-correlation spectra from Planck 100, 143 and 217GHz split-frequency maps, with semi-analytic estimates of the Cl covariance matrix based on the data. The cross-spectra are debiased from the effects of the mask and the beam leakage using Xpol (ascl:2301.009) before being compared to the model, which includes CMB and foreground residuals. They cover the multipoles from ℓ=30 to ℓ=2500. HiLLiPoP is interfaced with the Cobaya (ascl:1910.019) MCMC sampler.

[ascl:1111.001] HIPE: Herschel Interactive Processing Environment

The Herschel Space Observatory is the fourth cornerstone mission in the ESA science programme and performs photometry and spectroscopy in the 55 - 672 micron range. The development of the Herschel Data Processing System started in 2002 to support the data analysis for Instrument Level Tests. The Herschel Data Processing System was used for the pre-flight characterisation of the instruments, and during various ground segment test campaigns. Following the successful launch of Herschel 14th of May 2009 the Herschel Data Processing System demonstrated its maturity when the first PACS preview observation of M51 was processed within 30 minutes of reception of the first science data after launch. Also the first HIFI observations on DR21 were successfully reduced to high quality spectra, followed by SPIRE observations on M66 and M74. A fast turn-around cycle between data retrieval and the production of science-ready products was demonstrated during the Herschel Science Demonstration Phase Initial Results Workshop held 7 months after launch, which is a clear proof that the system has reached a good level of maturity.

[ascl:2301.030] HIPP: HIgh-Performance Package for scientific computation

HIPP (HIgh-Performance Package for scientific computation) provides elegant interfaces for some well-known HPC libraries. Some libraries are wrapped with full-OOP interfaces, and many new extensions based on those raw-interfaces are also provided. This C++ toolkit for HPC can significantly reduce the length of your code, making programming more productive.

[ascl:2005.020] HIPSTER: HIgh-k Power Spectrum EstimatoR

HIPSTER (HIgh-k Power Spectrum EstimatoR) computes small-scale power spectra and isotropic bispectra for cosmological simulations and galaxy surveys of arbitrary shape. The code computes the Legendre multipoles of the power spectrum, P(k), or bispectrum B(k1,k2), by computing weighted pair counts over the simulation box or survey, truncated at some maximum radius. The code can be run either in 'aperiodic' or 'periodic' mode for galaxy surveys or cosmological simulations respectively. HIPSTER also supports weighted spectra, for example when tracer particles are weighted by their mass in a multi-species simulation. Generalization to anisotropic bispectra is straightforward (and requires no additional computing time) and can be added on request.

[ascl:1909.012] HISS: HI spectra stacker

HISS stacks HI (emission and absorption) spectra in a consistent and reliable manner to enable statistical analysis of average HI properties. It provides plots of the stacked spectrum and reference spectrum with any fitted function, of the stacked noise response, and of the distribution of the integrated fluxes when calculating the uncertainties. It also produces a table containing the integrated flux calculated from the fitted functions and the stacked spectrum, among other output files.

[ascl:2306.051] Hitomi: Cosmological analysis of anisotropic galaxy distributions

Hitomi provides a comprehensive set of codes for cosmological analysis of anisotropic galaxy distributions using two- and three-point statistics: two-point correlation function (2PCF), power spectrum, three-point correlation function (3PCF), and bispectrum. The code can measure the Legendre-expanded 2PCF and power spectrum from an observed sample of galaxies, and can measure the 3PCF and bispectrum expanded using the Tripolar spherical harmonic (TripoSH) function. Hitomi is basically a serial code, but can also implement MPI parallelization. Hitomi uses MPI to read multiple different input parameters simultaneously.

[ascl:1911.017] HLattice: Scalar fields and gravity simulator for the early universe

HLattice simulates scalar fields and gravity in the early universe. The code allows the user to select between symplectic integrators, descretization schemes, and metrics such as Minkowski or FRW backgrounds and adaptice schemes in an "all-in-one" configuration file.

[ascl:1507.008] HLINOP: Hydrogen LINe OPacity in stellar atmospheres

HLINOP is a collection of codes for computing hydrogen line profiles and opacities in the conditions typical of stellar atmospheres. It includes HLINOP for approximate quick calculation of any line of neutral hydrogen (suitable for model atmosphere calculations), based on the Fortran code of Kurucz and Peterson found in ATLAS9. It also includes HLINPROF, for detailed, accurate calculation of lower Balmer line profiles (suitable for detailed analysis of Balmer lines) and HBOP, to implement the occupation probability formalism of Daeppen, Anderson and Milhalas (1987) and thus account for the merging of bound-bound and bound-free opacity (used often as a wrapper to HLINOP for model atmosphere calculations).

[ascl:1508.001] HMcode: Halo-model matter power spectrum computation

HMcode computes the halo-model matter power spectrum. It is written in Fortran90 and has been designed to quickly (~0.5s for 200 k-values across 16 redshifts on a single core) produce matter spectra for a wide range of cosmological models. In testing it was shown to match spectra produced by the 'Coyote Emulator' to an accuracy of 5 per cent for k less than 10h Mpc^-1. However, it can also produce spectra well outside of the parameter space of the emulator.

[ascl:1412.006] HMF: Halo Mass Function calculator

HMF calculates the Halo Mass Function (HMF) given any set of cosmological parameters and fitting function and serves as the backend for the web application HMFcalc. Written in Python, it allows for dynamic accurate calculation of the transfer function with CAMB (ascl:1102.026) and efficient and self-consistent parameter updates. HMF offers exploration of the effects of cosmological parameters, redshift and fitting function on the predicted HMF.

[ascl:1201.010] HNBody: Hierarchical N-Body Symplectic Integration Package

HNBody is a new set of software utilities geared to the integration of hierarchical (nearly-Keplerian) N-body systems. Our focus is on symplectic methods, and we have included explicit support for three classes of particles (heavy, light, and massless), second and fourth order methods, post-Newtonian corrections, and the use of a symplectic corrector (among other things). For testing purposes, we also provide support for more general integration schemes (Bulirsch-Stoer & Runge-Kutta). Configuration files employing an intuitive syntax allow for easy problem setup, and many simple simulations can be done without the user compiling any code. Low-level interfaces are also available, enabling extensive customization.

[ascl:1711.013] HO-CHUNK: Radiation Transfer code

HO-CHUNK calculates radiative equilibrium temperature solution, thermal and PAH/vsg emission, scattering and polarization in protostellar geometries. It is useful for computing spectral energy distributions (SEDs), polarization spectra, and images.

[ascl:2208.017] HOCHUNK3D: Dust radiative transfer in 3D

HOCHUNK3D is an updated version of the HOCHUNK radiative equilibrium code (ascl:1711.013); the code has been converted to Fortran 95, which allows a specification of one-dimensional (1D), 2D, or 3D grids at runtime. The code is parallelized so it can be run on multiple processors on one machine, or on multiple machines in a network. It includes 3-D functionality and several other additional geometries and features. The code calculates radiative equilibrium temperature solution, thermal and PAH/vsg emission, scattering and polarization in protostellar geometries. HOCHUNK3D also computes spectral energy distributions (SEDs), polarization spectra, and images.

[ascl:2112.026] HoloSim-ML: Analyzing radio holography measurements of complex optical systems

HoloSim-ML performs beam simulation and analysis of radio holography data from complex optical systems. The code uses machine learning to efficiently determine the position of hundreds of mirror adjusters on multiple mirrors with few micron accuracy.

[ascl:2003.011] HOMER: A Bayesian inverse modeling code

HOMER (Helper Of My Eternal Retrievals) is a machine-learning-accelerated Bayesian inverse modeling code. Given some data and uncertainties, the code determines the posterior distribution of a model. HOMER uses MC3 (ascl:1610.013) for its MCMC; its forward model is a neural network surrogate model trained by MARGE (ascl:2003.010). The code produces plots of the 1D marginalized posteriors, 2D pairwise posteriors, and parameter history traces, and can also overplot the 1D and 2D posteriors for comparison with another posterior. HOMER computes the Bhattacharyya coefficient to compare the similarity of two 1D marginalized posteriors.

[ascl:1102.019] HOP: A Group-finding Algorithm for N-body Simulations

We describe a new method (HOP) for identifying groups of particles in N-body simulations. Having assigned to every particle an estimate of its local density, we associate each particle with the densest of the Nh particles nearest to it. Repeating this process allows us to trace a path, within the particle set itself, from each particle in the direction of increasing density. The path ends when it reaches a particle that is its own densest neighbor; all particles reaching the same such particle are identified as a group. Combined with an adaptive smoothing kernel for finding the densities, this method is spatially adaptive, coordinate-free, and numerically straight-forward. One can proceed to process the output by truncating groups at a particular density contour and combining groups that share a (possibly different) density contour. While the resulting algorithm has several user-chosen parameters, we show that the results are insensitive to most of these, the exception being the outer density cutoff of the groups.

[ascl:1411.005] HOPE: Just-in-time Python compiler for astrophysical computations

HOPE is a specialized Python just-in-time (JIT) compiler designed for numerical astrophysical applications. HOPE focuses on a subset of the language and is able to translate Python code into C++ while performing numerical optimization on mathematical expressions at runtime. To enable the JIT compilation, the user only needs to add a decorator to the function definition. By using HOPE, the user benefits from being able to write common numerical code in Python while getting the performance of compiled implementation.

[ascl:2205.019] HOPS: Haystack Observatory Postprocessing System

HOPS (Haystack Observatory Postprocessing System) analyzes the data generated by DiFX VLBI correlators. It is written in C for Linux computers, and emphasizes quality-control aspects of data processing. It sits between the correlator and an image-processing and/or geodetic-processing package, and performs basic fringe-fitting, data editing, problem diagnosis, and correlator support functions.

[ascl:2008.027] HorizonGRound: Relativistic effects in ultra-large-scale clustering

HorizonGRound forward models general relativistic effects from the tracer luminosity function. It also compares relativistic corrections with the local primordial non-Gaussianity signature in ultra-large-scale clustering statistics. The package includes several recipes along with the data required to run them.

[ascl:1504.004] HOTPANTS: High Order Transform of PSF ANd Template Subtraction

HOTPANTS (High Order Transform of PSF ANd Template Subtraction) implements the Alard 1999 algorithm for image subtraction. It photometrically aligns one input image with another after they have been astrometrically aligned.

[ascl:1702.008] HOURS: Simulation and analysis software for the KM3NeT

The Hellenic Open University Reconstruction & Simulation (HOURS) software package contains a realistic simulation package of the detector response of very large (km3-scale) underwater neutrino telescopes, including an accurate description of all the relevant physical processes, the production of signal and background as well as several analysis strategies for triggering and pattern recognition, event reconstruction, tracking and energy estimation. HOURS also provides tools for simulating calibration techniques and other studies for estimating the detector sensitivity to several neutrino sources.

[ascl:2108.001] HRK: HII Region Kinematics

Generate simulated radio recombination line observations of HII regions with various internal kinematic structure. Fit single Gaussians to each pixel of the simulated observations and generate images of the fitted Gaussian center and full-width half-maximum (FWHM) linewidth.

[ascl:1707.001] HRM: HII Region Models

HII Region Models fits HII region models to observed radio recombination line and radio continuum data. The algorithm includes the calculations of departure coefficients to correct for non-LTE effects. HII Region Models has been used to model star formation in the nucleus of IC 342.

[ascl:1412.008] Hrothgar: MCMC model fitting toolkit

Hrothgar is a parallel minimizer and Markov Chain Monte Carlo generator. It has been used to solve optimization problems in astrophysics (galaxy cluster mass profiles) as well as in experimental particle physics (hadronic tau decays).

[ascl:1912.006] HSIM: HARMONI simulation pipeline

HSIM simulates observations with HARMONI on the Extremely Large Telescope. HSIM takes high spectral and spatial resolution input data cubes, encoding physical descriptions of astrophysical sources, and generates mock observed data cubes. The simulations incorporate detailed models of the sky, telescope, instrument, and detectors to produce realistic mock data. HSIM performs in-depth simulations for several key science cases as part of the design and development of the HARMONI integral field spectrograph, including the ELT AO performance, atmospheric effects and realistic detector statistics.

[ascl:2109.014] HSS: The Hough Stream Spotter

The Hough Stream Spotter (HSS) is a stream finding code which transforms individual positions of stars to search for linear structure in discrete data sets. The code requires only the two-dimensional plane of galactic longitude and latitude as input.

[ascl:2011.021] HSTCosmicrays: Analyzing cosmic rays in HST calibration data

HSTCosmicrays finds and characterizes cosmic rays found in dark frames (exposures taken with the shutter closed) taken with instruments on the Hubble Space Telescope (HST). Dark exposures are obtained routinely by all the Hubble Space Telescope instruments for calibration. The main processing pipeline runs locally or in the cloud on AWS utilizing the HST Public Dataset.

[ascl:2109.017] HTOF: Astrometric solutions for Hipparcos and Gaia intermediate data

HTOF parses the intermediate data from Hipparcos and Gaia and fits astrometric solutions to those data. It computes likelihoods and parameter errors in line with the catalog and can reproduce five, seven, and nine (or higher) parameter fits to their astrometry.

[ascl:2102.019] HUAYNO: Hierarchically split-Up AstrophYsical N-body sOlver N-body code

HUAYNO implements integrators derived from second order Hamiltonian splitting for N-body dynamics. This integration scheme conserves energy and momentum with little or no systematic drift. The code uses an explicit but approximate formula for the time symmetrization that is compatible with the use of individual time steps, making an iterative scheme unnecessary. HUAYNO is available as part of the AMUSE package (ascl:1107.007).

[ascl:1511.014] HumVI: Human Viewable Image creation

HumVI creates a composite color image from sets of input FITS files, following the Lupton et al (2004, ascl:1511.013) composition algorithm. Written in Python, it takes three FITS files as input and returns a color composite, color-saturated png image with an arcsinh stretch. HumVI reads the zero points out of the FITS headers and uses them to put all the images on the same flux scale; photometrically calibrated images produce the best results.

[ascl:1103.010] Hydra: A Parallel Adaptive Grid Code

We describe the first parallel implementation of an adaptive particle-particle, particle-mesh code with smoothed particle hydrodynamics. Parallelisation of the serial code, "Hydra," is achieved by using CRAFT, a Cray proprietary language which allows rapid implementation of a serial code on a parallel machine by allowing global addressing of distributed memory.

The collisionless variant of the code has already completed several 16.8 million particle cosmological simulations on a 128 processor Cray T3D whilst the full hydrodynamic code has completed several 4.2 million particle combined gas and dark matter runs. The efficiency of the code now allows parameter-space explorations to be performed routinely using $64^3$ particles of each species. A complete run including gas cooling, from high redshift to the present epoch requires approximately 10 hours on 64 processors.

[ascl:1402.023] HydraLens: Gravitational lens model generator

HydraLens generates gravitational lens model files for Lenstool (ascl:1102.004), PixeLens (ascl:1102.007), glafic (ascl:1010.012) and Lensmodel and can also translate lens model files among these four lens model codes. Through a GUI, the user enters a new model by specifying the type of model and is then led through screens to collect the data. Written in MS Visual Basic, the code can also translate an existing model from any of the four supported codes to any of the other three.

[ascl:2012.009] HydroCode1D: 1D finite volume code

HydroCode1D is a 1D finite volume code that can run any problem with 1D or 2D/3D spherical symmetry including external gravity or self-gravity. The program provides, depending on the configuration, output files that contain the midpoint position, density, velocity and pressure for each cell in the grid (in SI units). The program will by default use all available threads (as given by the environment variable OMP_NUM_THREADS). This can be overwritten by giving the desired number of threads as a command line argument to the program.

[ascl:1601.002] Hyper-Fit: Fitting routines for multidimensional data with multivariate Gaussian uncertainties

The R package Hyper-Fit fits hyperplanes (hyper.fit) and creates 2D/3D visualizations (hyper.plot2d / hyper.plot3d) to produce robust 1D linear fits for 2D x vs y type data, and robust 2D plane fits to 3D x vs y vs z type data. This hyperplane fitting works generically for any N-1 hyperplane model being fit to a N dimensional dataset. All fits include intrinsic scatter in the generative model orthogonal to the hyperplane. A web interface for online fitting is also available at http://hyperfit.icrar.org.

[ascl:2205.009] hyperas: Keras + Hyperopt

Hyperas is a convenience wrapper around hyperopt (ascl:2205.008) for fast prototyping with keras models (ascl:1806.022). Hyperas lets you use the power of hyperopt without having to learn the syntax of it. Instead, just define your keras model as you are used to, but use a simple template notation to define hyper-parameter ranges to tune.

[ascl:1207.004] Hyperion: Parallelized 3D Dust Continuum Radiative Transfer Code

Hyperion is a three-dimensional dust continuum Monte-Carlo radiative transfer code that is designed to be as generic as possible, allowing radiative transfer to be computed through a variety of three-dimensional grids. The main part of the code is problem-independent, and only requires an arbitrary three-dimensional density structure, dust properties, the position and properties of the illuminating sources, and parameters controlling the running and output of the code. Hyperion is parallelized, and is shown to scale well to thousands of processes. Two common benchmark models for protoplanetary disks were computed, and the results are found to be in excellent agreement with those from other codes. Finally, to demonstrate the capabilities of the code, dust temperatures, SEDs, and synthetic multi-wavelength images were computed for a dynamical simulation of a low-mass star formation region.

[ascl:2205.008] Hyperopt: Distributed asynchronous hyper-parameter optimization

The Python library Hyperopt performs serial and parallel optimization over awkward search spaces, which may include real-valued, discrete, and conditional dimensions. Three algorithms are implemented in hyperopt: Random Search, Tree of Parzen Estimators (TPE), and Adaptive TPE. Algorithms can be parallelized in two ways, using either Apache Spark or MongoDB. To use Hyperopt, the objective function to minimize and the space over which to search, and the database in which to store all the point evaluations of the search have to be described, and the search algorithm to use has to be specified.

[ascl:1108.010] Hyperz: Photometric Redshift Code

From a photometric catalogue, hyperz finds the redshift of each object by means of a standard SED fitting procedure, i.e. comparing the observed magnitudes with the expected ones, computed from template Spectral Energy Distributions. The set of templates used in the minimization procedure (age, metallicity, reddening, absorption in the Lyman forest, ...) is studied in detail, through both real and simulated data. The expected accuracy of photometric redshifts, as well as the fraction of catastrophic identifications and wrong detections, is given as a function of the redshift range, the set of filters considered, and the photometric accuracy. Special attention is paid to the results expected from real data.

[ascl:2209.010] HyPhy: Hydrodynamical Physics via Deep Generative Painting

HyPhy maps from dark matter only simulations to full hydrodynamical physics models. It uses a fully convolutional variational auto-encoder (VAE) to synthesize hydrodynamic fields conditioned on dark matter fields from N-body simulations. After training, HyPhy can probabilistically map new dark matter only simulations to corresponding full hydrodynamical outputs and generate posterior samples for studying the variance of the mapping. This conditional deep generative model is implemented in TensorFlow.

[ascl:1011.023] HyRec: A Fast and Highly Accurate Primordial Hydrogen and Helium Recombination Code

We present a state-of-the-art primordial recombination code, HyRec, including all the physical effects that have been shown to significantly affect recombination. The computation of helium recombination includes simple analytic treatments of hydrogen continuum opacity in the He I 2 1P - 1 1S line, the He I] 2 3P - 1 1S line, and treats feedback between these lines within the on-the-spot approximation. Hydrogen recombination is computed using the effective multilevel atom method, virtually accounting for an infinite number of excited states. We account for two-photon transitions from 2s and higher levels as well as frequency diffusion in Lyman-alpha with a full radiative transfer calculation. We present a new method to evolve the radiation field simultaneously with the level populations and the free electron fraction. These computations are sped up by taking advantage of the particular sparseness pattern of the equations describing the radiative transfer. The computation time for a full recombination history is ~2 seconds. This makes our code well suited for inclusion in Monte Carlo Markov chains for cosmological parameter estimation from upcoming high-precision cosmic microwave background anisotropy measurements.

[ascl:1302.009] IAS Stacking Library in IDL

This IDL library is designed to be used on astronomical images. Its main aim is to stack data to allow a statistical detection of faint signal, using a prior. For instance, you can stack 160um data using the positions of galaxies detected at 24um or 3.6um, or use WMAP sources to stack Planck data. It can estimate error bars using bootstrap, and it can perform photometry (aperture photometry, or PSF fitting, or other that you can plug). The IAS Stacking Library works with gnomonic projections (RA---TAN), and also with HEALPIX projection.

[ascl:1611.018] Icarus: Stellar binary light curve synthesis tool

Icarus is a stellar binary light curve synthesis tool that generates a star, given some basic binary parameters, by solving the gravitational potential equation, creating a discretized stellar grid, and populating the stellar grid with physical parameters, including temperature and surface gravity. Icarus also evaluates the outcoming flux from the star given an observer's point of view (i.e., orbital phase and orbital orientation).

[ascl:1703.012] ICICLE: Initial Conditions for Isolated CoLlisionless systEms

ICICLE (Initial Conditions for Isolated CoLlisionless systEms) generates stable initial conditions for isolated collisionless systems that can then be used in NBody simulations. It supports the Navarro-Frenk-White, Hernquist, King and Einasto density profiles.

[ascl:1302.010] ICORE: Image Co-addition with Optional Resolution Enhancement

ICORE is a command-line driven co-addition, mosaicking, and resolution enhancement (HiRes) tool for creating science quality products from image data in FITS format and with World Coordinate System information following the FITS-WCS standard. It includes preparatory steps such as image background matching, photometric gain-matching, and pixel-outlier rejection. Co-addition and/or HiRes'ing can be performed in either the inertial WCS or in the rest frame of a moving object. Three interpolation methods are supported: overlap-area weighting, drizzle, and weighting by the detector Point Response Function (PRF). The latter enables the creation of matched-filtered products for optimal point-source detection, but most importantly allows for resolution enhancement using a spatially-dependent deconvolution method. This is a variant of the classic Richardson-Lucy algorithm with the added benefit to simultaneously register and co-add multiple images to optimize signal-to-noise and sampling of the instrumental PSF. It can assume real (or otherwise "flat") image priors, mitigate "ringing" artifacts, and assess the quality of image solutions using statistically-motivated convergence criteria. Uncertainties are also estimated and internally validated for all products. The software supports multithreading that can be configured for different architectures. Numerous example scripts are included (with test data) to co-add and/or HiRes image data from Spitzer-IRAC/MIPS, WISE, and Herschel-SPIRE.

[ascl:9905.002] ICOSAHEDRON: A package for pixelizing the sphere

What is the best way to pixelize a sphere? This question occurs in many practical applications, for instance when making maps (of the earth or the celestial sphere) and when doing numerical integrals over the sphere. This package consists of source code and documentation for a method which involves inscribing the sphere in a regular icosahedron and then equalizing the pixel areas.

[ascl:1010.034] iCosmo: An Interactive Cosmology Package

iCosmo is a software package to perform interactive cosmological calculations for the low redshift universe. The computation of distance measures, the matter power spectrum, and the growth factor is supported for any values of the cosmological parameters. It also performs the computation of observables for several cosmological probes such as weak gravitational lensing, baryon acoustic oscillations and supernovae. The associated errors for these observables can be derived for customised surveys, or for pre-set values corresponding to current or planned instruments. The code also allows for the calculation of cosmological forecasts with Fisher matrices which can be manipulated to combine different surveys and cosmological probes. The code is written in the IDL language and thus benefits from the convenient interactive features and scientific library available in this language. iCosmo can also be used as an engine to perform cosmological calculations in batch mode, and forms a convenient evolutive platform for the development of further cosmological modules. With its extensive documentation, it may also serve as a useful resource for teaching and for newcomers in the field of cosmology.

[ascl:1903.007] ICSF: Intensity Conserving Spectral Fitting

ICSF (Intensity Conserving Spectral Fitting) "corrects" (x,y) data in which the ordinate represents the average of a quantity over a finite interval in the abscissa. A typical example is spectral data, where the average intensity over a wavelength bin (the measured quantity) is assigned to the center of the bin. If the profile is curved, the average will be different from the discrete value at the bin center location. ICSF, written in IDL and available separately and as part of SolarSoft (ascl:1208.013), corrects the intensity using an iterative procedure and cubic spline. The corrected intensity equals the "true" intensity at bin center, rather than the average over the bin. Unlike other methods that are restricted to a single fitting function, typically a spline, ICSF can be used with any function, such as a cubic spline or a Gaussian, with slight changes to the code.

[ascl:1411.009] iDealCam: Interactive Data Reduction and Analysis for CanariCam

iDealCam is an IDL GUI toolkit for processing multi-extension FITS file produced by CanariCam, the facility mid-IR instrument of Gran Telescopio CANARIAS (GTC). iDealCam is optimized for CanariCam data, but is also compatible with data generated by other instruments using similar detectors and data format (e.g., Michelle and T-ReCS at Gemini). iDealCam provides essential capabilities to examine, reduce, and analyze data obtained in the standard imaging or polarimetric imaging mode of CanariCam.

[ascl:2306.036] IDEFIX: Astrophysical fluid dynamics

Idefix solves non-relativistic HD and MHD equations on various grid geometries. Based on a Godunov finite-volume method, this astrophysical flows code includes a wide choice of solvers and several modules, including constrained transport, orbital advection, and non-ideal MHD, to address complex astrophysical and fluid dynamics applications. Written in C++, Idefix relies on the Kokkos meta-programming library to guarantee performance portability on a wide variety of architectures.

[ascl:1011.001] Identikit 1: A Modeling Tool for Interacting Disk Galaxies

By combining test-particle and self-consistent techniques, we have developed a method to rapidly explore the parameter space of galactic encounters. Our method, implemented in an interactive graphics program, can be used to find the parameters required to reproduce the observed morphology and kinematics of interacting disk galaxies. We test this system on an artificial data-set of 36 equal-mass merging encounters, and show that it is usually possible to reproduce the morphology and kinematics of these encounters and that a good match strongly constrains the encounter parameters. An update to this software with additional capabilities, Identikit 2 (ascl:1102.011), is available.

[ascl:1102.011] Identikit 2: An Algorithm for Reconstructing Galactic Collisions

Using a combination of self-consistent and test-particle techniques, Identikit 1 (ascl:1011.001) provided a way to vary the initial geometry of a galactic collision and instantly visualize the outcome. Identikit 2 uses the same techniques to define a mapping from the current morphology and kinematics of a tidal encounter back to the initial conditions. By requiring that various regions along a tidal feature all originate from a single disc with a unique orientation, this mapping can be used to derive the initial collision geometry. In addition, Identikit 2 offers a robust way to measure how well a particular model reproduces the morphology and kinematics of a pair of interacting galaxies. A set of eight self-consistent simulations is used to demonstrate the algorithm's ability to search a ten-dimensional parameter space and find near-optimal matches; all eight systems are successfully reconstructed.

[ascl:1911.011] IDG: Image Domain Gridding

IDG (Image Domain Gridding) is an imager that makes w-term corrections and a-term corrections computationally very cheap. It works with WSClean (ascl:1408.023) and supports the same cleaning and data selections options that WSClean offers in normal mode (such as cotton-schwab, multi-frequency multi-scale cleaning, and auto-masking). IDG also allows gridding with a time-variable beam including the LOFAR, AARTFAAC and MWA beam and can perform full beam or differential correction. The code requires measurement sets with four polarizations (e.g. XX/XY/YX/YY), can apply a spatially varying time-variable TEC term that can additionally be different for different antennas and output channels, and performs extremely well on GPUs.

[ascl:1303.013] idistort: CMB spectral distortions templates and code

Spectrum created by energy release in the early Universe, before recombination, creates distortions which are a superposition of μ-type, y-type and intermediate-type distortions. The final spectrum can thus be constructed from the templates, once energy injection rate as a function of redshift is known. This package contains the templates spaced at dy=0.001 for y<1 and dy=0.01 for y>1 covering a range 0.001 < y < 10. Also included is a Mathematica code which can combine these templates for user-defined rate of energy injection as a function of redshift. Silk damping, particle decay and annihilation examples are also included.

[ascl:1507.020] IEHI: Ionization Equilibrium for Heavy Ions

IEHI, written in Fortran, outputs a simple "coronal" ionization equilibrium (i.e., collisional ionization and auto-ionization balanced by radiative and dielectronic recombination) for a plasma at a given electron temperature.

[ascl:2008.019] iFIT: 1D surface photometry code

iFIT determines the Sérsic law model for galaxies with imperfect Sérsic law profiles by searching for the best match between the observationally determined and theoretically expected radial variation of the mean surface brightness and light growth curve. The technique ensures quick convergence to a unique solution for both perfect and imperfect Sérsic profiles, even shallow and resolution-degraded SBPs. iFIT allows for correction of PSF convolution effects, offering the user the option of choosing between a Moffat, Gaussian, or user-supplied PSF, and is an efficient tool for the non-supervised structural characterization of large galaxy samples, such as those expected to become available with Euclid and LSST.

[ascl:1304.019] IFrIT: Ionization FRont Interactive Tool

IFrIT (Ionization FRont Interactive Tool) is a powerful general purpose visualization tool that can be used to visualize 3-dimensional data sets. IFrIT is written in C++ and is based on the Visualization ToolKit (VTK) and, optionally, uses a GUI toolkit Qt. IFrIT can visualize scalar, vector field, tensor, and particle data. Several visualization windows can exist at the same time, each one having a full set of visualization objects. Some visualization windows can share the data between them, while other windows can be fully independent. Images from several visualization windows can be combined into one image file on the disk, tiling some windows together, and inserting reduced versions of some windows into larger other windows. A large array of features is also available, including highly advanced animation capabilities, a complex set of lights, markers to label various points in space, and a capability to "pick" a point in the scene and retrieve information about the data at this location.

[ascl:2206.011] IFSCube: Analyze and process integral field spectroscopy data cubes

IFSCube performs analysis tasks in data cubes of integral field spectroscopy. It contains routines for fitting spectral features in 1D spectra and data cubes and rotation models to velocity fields; it also contains a routine that inspects the fit results. Though originally intended to make user scripts more concise, analysis can also be performed on the fly by using an interactive interpreter such as ipython. By default, IFSCube assumes data are in the Flexible Image Transport System (FITS) standard, but the package can be modified easily to allow use of other data formats.

[ascl:1409.005] IFSFIT: Spectral Fitting for Integral Field Spectrographs

IFSFIT is a general-purpose IDL library for fitting the continuum, emission lines, and absorption lines in integral field spectra. It uses PPXF (ascl:1210.002) to find the best fit stellar continuum (using a user-defined library of stellar templates and including additive polynomials), or optionally a user-defined method to find the best fit continuum. It uses MPFIT (ascl:1208.019) to simultaneously fit Gaussians to any number of emission lines and emission line velocity components. It will also fit the NaI D feature using analytic absorption and/or emission-line profiles.

[ascl:1409.004] IFSRED: Data Reduction for Integral Field Spectrographs

IFSRED is a general-purpose library for reducing data from integral field spectrographs (IFSs). For a general IFS data cube, it contains IDL routines to: (1) find and apply a zero-point shift in a wavelength solution on a spaxel-by-spaxel basis, using sky lines; (2) find the spatial coordinates of a flux peak; (3) empirically correct for differential atmospheric refraction; (4) mosaic dithered exposures; (5) (integer) rebin; and (6) apply a telluric correction. A sky-subtraction routine for data from the Gemini Multi-Object Spectrograph and Imager (GMOS) that can be easily modified for any instrument is also included. IFSRED also contains additional software specific to reducing data from GMOS and the Gemini Near-Infrared Integral Field Spectrograph (NIFS).

[ascl:1110.003] iGalFit: An Interactive Tool for GalFit

The iGalFit suite of IDL routines interactively runs GALFIT whereby the various surface brightness profiles (and their associated parameters) are represented by regions, which the user is expected to place. The regions may be saved and/or loaded from the ASCII format used by ds9 or in the Hierarchical Data Format (version 5). The software has been tested to run stably on Mac OS X and Linux with IDL 7.0.4. In addition to its primary purpose of modeling galaxy images with GALFIT, this package has several ancillary uses, including a flexible image display routines, several basic photometry functions, and qualitatively assessing Source Extractor.

[ascl:1101.003] IGMtransfer: Intergalactic Radiative Transfer Code

This document describes the publically available numerical code "IGMtransfer", capable of performing intergalactic radiative transfer (RT) of light in the vicinity of the Lyman alpha (Lya) line. Calculating the RT in a (possibly adaptively refined) grid of cells resulting from a cosmological simulation, the code returns 1) a "transmission function", showing how the intergalactic medium (IGM) affects the Lya line at a given redshift, and 2) the "average transmission" of the IGM, making it useful for studying the results of reionization simulations.

[ascl:1504.015] IGMtransmission: Transmission curve computation

IGMtransmission is a Java graphical user interface that implements Monte Carlo simulations to compute the corrections to colors of high-redshift galaxies due to intergalactic attenuation based on current models of the Intergalactic Medium. The effects of absorption due to neutral hydrogen are considered, with particular attention to the stochastic effects of Lyman Limit Systems. Attenuation curves are produced, as well as colors for a wide range of filter responses and model galaxy spectra. Photometric filters are included for the Hubble Space Telescope, the Keck telescope, the Mt. Palomar 200-inch, the SUBARU telescope and UKIRT; alternative filter response curves and spectra may be readily uploaded.

[ascl:2210.013] iharm3D: Hybrid MPI/OpenMP 3D HARM with vectorization

iharm3D implements the HARM algorithm (ascl:1209.005) with modifications and enables a second-order, conservative, shock-capturing scheme for general-relativistic magnetohydrodynamics (GRMHD). Written in C, it simulates black hole accretion systems in arbitrary stationary spacetimes.

[ascl:1408.009] IIPImage: Large-image visualization

IIPImage is an advanced high-performance feature-rich image server system that enables online access to full resolution floating point (as well as other bit depth) images at terabyte scales. Paired with the VisiOmatic (ascl:1408.010) celestial image viewer, the system can comfortably handle gigapixel size images as well as advanced image features such as both 8, 16 and 32 bit depths, CIELAB colorimetric images and scientific imagery such as multispectral images. Streaming is tile-based, which enables viewing, navigating and zooming in real-time around gigapixel size images. Source images can be in either TIFF or JPEG2000 format. Whole images or regions within images can also be rapidly and dynamically resized and exported by the server from a single source image without the need to store multiple files in various sizes.

[ascl:2004.003] IllinoisGRMHD: GRMHD code for dynamical spacetimes

IllinoisGRMHD is an open-source, highly-extensible rewrite of the original closed-source general relativistic (ideal) magnetohydrodynamics (GRMHD) code of the Illinois Numerical Relativity (ILNR) Group. Reducing the learning curve was the primary focus of this rewrite, with the goal of facilitating community involvement in the code's use and development, as well as reducing the human effort necessary to generate new science. IllinoisGRMHD also saves computer time, generating roundoff-precision identical output to the original code on adaptive-mesh grids while being nearly twice as fast at scales of hundreds to thousands of cores.

[ascl:1307.006] im2shape: Bayesian Galaxy Shape Estimation

im2shape is a Bayesian approach to the problem of accurate measurement of galaxy ellipticities for weak lensing studies, in particular cosmic shear. im2shape parameterizes galaxies as sums of Gaussians, convolved with a psf which is also a sum of Gaussians. The uncertainties in the output parameters are calculated using a Markov Chain Monte Carlo approach.

[ascl:1409.013] IM3SHAPE: Maximum likelihood galaxy shear measurement code for cosmic gravitational lensing

Im3shape forward-fits a galaxy model to each data image it is supplied with and reports the parameters of the best fitting model, including the ellipticity components. It uses the Discrete Fourier Transform (DFT) to render images of convolved galaxy profiles, calculates the maximum likelihood parameter values, and corrects for noise bias. IM3SHAPE is a modular C code with a significant amount of Python glue code to enable setting up new models and their options automatically.

[ascl:1206.014] ImageHealth: Quality Assurance for Large FITS Images

ImageHealth (IH) is a c program that makes use of standard CFITSIO routines to examine, in an automated fashion, .FITS images with any number of extensions, find objects within those images, and determine basic parameters of those images (stellar flux, background counts, FWHM, and ellipticity, along with sky background counts) in order to provide a snapshot of the quality of those images. A variety of python wrappers have also been written to test large numbers of such images and compare the results of ImageHealth to other image analysis programs, such as SourceExtractor. Additional IH-related tools will be made available in the future.

[ascl:1206.013] ImageJ: Image processing and analysis in Java

ImageJ is a public domain Java image processing program inspired by NIH Image. It can display, edit, analyze, process, save and print 8-bit, 16-bit and 32-bit images. It can read many image formats including TIFF, GIF, JPEG, BMP, DICOM, FITS and "raw". It supports "stacks", a series of images that share a single window. It is multithreaded, so time-consuming operations such as image file reading can be performed in parallel with other operations.

[ascl:1803.007] IMAGINE: Interstellar MAGnetic field INference Engine

IMAGINE (Interstellar MAGnetic field INference Engine) performs inference on generic parametric models of the Galaxy. The modular open source framework uses highly optimized tools and technology such as the MultiNest sampler (ascl:1109.006) and the information field theory framework NIFTy (ascl:1302.013) to create an instance of the Milky Way based on a set of parameters for physical observables, using Bayesian statistics to judge the mismatch between measured data and model prediction. The flexibility of the IMAGINE framework allows for simple refitting for newly available data sets and makes state-of-the-art Bayesian methods easily accessible particularly for random components of the Galactic magnetic field.

[ascl:2307.033] Imber: Doppler imaging tool for modeling stellar and substellar surfaces

Imber simulates spectroscopic and photometric observations with both a gridded numerical simulation and analytical model. Written in Python, it is specifically designed to predict Extremely Large Telescope instrument (such as ELT/METIS and TMT/MODHIS) Doppler imaging performance, and has also been applied to existing, archival observations of spectroscopy and photometry.

[ascl:1108.001] IMCAT: Image and Catalogue Manipulation Software

The IMCAT software was developed initially to do faint galaxy photometry for weak lensing studies, and provides a fairly complete set of tools for this kind of work. Unlike most packages for doing data analysis, the tools are standalone unix commands which you can invoke from the shell, via shell scripts or from perl scripts. The tools are arranges in a tree of directories. One main branch is the ’imtools’. These deal only with fits files. The most important imtool is the ’image calculator’ ’ic’ which allows one to do rather general operations on fits images. A second branch is the ’catools’ which operate only on catalogues. The key cattool is ’lc’; this effectively defines the format of IMCAT catalogues, and allows one to do very general operations on and filtering of such catalogues. A third branch is the ’imcattools’. These tend to be much more specialised than the cattools and imcattools and are focussed on faint galaxy photometry.

[ascl:1312.003] IMCOM: IMage COMbination

IMCOM allows for careful treatment of aliasing in undersampled imaging data and can be used to test the feasibility of multi-exposure observing strategies for space-based survey missions. IMCOM can also been used to explore focal plane undersampling for an optical space mission such as Euclid.

[ascl:2203.004] imexam: IMage EXAMination and plotting

imexam performs simple image examination and plotting, with similar functionality to IRAF's (ascl:9911.002) imexamine. It is a lightweight library that enables users to explore data from a command line interface, through a Jupyter notebook, or through a Jupyter console. imexam can be used with multiple viewers, such as DS9 (scl:0003.002) or Ginga (ascl:1303.020), or without a viewer as a simple library to make plots and grab quick photometry information. It has been designed so that other viewers may be easily attached in the future.

[ascl:1408.001] Imfit: A Fast, Flexible Program for Astronomical Image Fitting

Imfit is an open-source astronomical image-fitting program specialized for galaxies but potentially useful for other sources, which is fast, flexible, and highly extensible. Its object-oriented design allows new types of image components (2D surface-brightness functions) to be easily written and added to the program. Image functions provided with Imfit include Sersic, exponential, and Gaussian galaxy decompositions along with Core-Sersic and broken-exponential profiles, elliptical rings, and three components that perform line-of-sight integration through 3D luminosity-density models of disks and rings seen at arbitrary inclinations.

Available minimization algorithms include Levenberg-Marquardt, Nelder-Mead simplex, and Differential Evolution, allowing trade-offs between speed and decreased sensitivity to local minima in the fit landscape. Minimization can be done using the standard chi^2 statistic (using either data or model values to estimate per-pixel Gaussian errors, or else user-supplied error images) or the Cash statistic; the latter is particularly appropriate for cases of Poisson data in the low-count regime.

The C++ source code for Imfit is available under the GNU Public License.

[ascl:2108.024] iminuit: Jupyter-friendly Python interface for C++ MINUIT2

iminuit is a Jupyter-friendly Python interface for the Minuit2 C++ library maintained by CERN's ROOT team. It can be used as a general robust function minimization method, but is most commonly used for likelihood fits of models to data, and to get model parameter error estimates from likelihood profile analysis.

[ascl:1804.014] IMNN: Information Maximizing Neural Networks

This software trains artificial neural networks to find non-linear functionals of data that maximize Fisher information: information maximizing neural networks (IMNNs). As compressing large data sets vastly simplifies both frequentist and Bayesian inference, important information may be inadvertently missed. Likelihood-free inference based on automatically derived IMNN summaries produces summaries that are good approximations to sufficient statistics. IMNNs are robustly capable of automatically finding optimal, non-linear summaries of the data even in cases where linear compression fails: inferring the variance of Gaussian signal in the presence of noise, inferring cosmological parameters from mock simulations of the Lyman-α forest in quasar spectra, and inferring frequency-domain parameters from LISA-like detections of gravitational waveforms. In this final case, the IMNN summary outperforms linear data compression by avoiding the introduction of spurious likelihood maxima.

[ascl:1601.013] ImpactModel: Black Hole Accretion Disk Impact Model

ImpactModel, written in Cython, computes the accretion disc impact spectrum at given frequencies and can compute other model quantities as a function of time.

[ascl:1808.004] ImPlaneIA: Image Plane Approach to Interferometric Analysis

Aperture masking interferometric data analysis involves measuring phases and amplitudes of fringes formed by interference between holes in the pupil mask. These fringe observables can be measured by computing an analytic model of the point spread function and fitting the relevant set of spatial frequencies directly in the image plane, without recourse to numerical Fourier transforms. The ImPlaneIA pipeline converts aperture masking images to fringe observables by fitting fringes in the image plane, calibrates data from a target of interest with one or more point source calibrators, and contains some basic model-fitting routines. The pipeline can accept different mask geometries, instruments, and observing modes.

[ascl:2307.018] IMRIpy: Intermediate Mass Ratio Inspirals simulator

IMRIpy simulates an Intermediate Mass Ratio Inspiral (IMRI) by gravitational wave emission with a Dark Matter(DM) halo or a (baryonic) Accretion Disk around the central Intermediate Mass Black Hole(IMBH). It can use different density profiles (such as DM spikes), and different interactions, such as dynamical friction with and without HaloFeedback models or accretion, to produce the simulation.

[ascl:2307.019] IMRPhenomD: Phenomenological waveform model

The IMRPhenomD model generates gravitational wave signals for merging black hole binaries with non-precessing spins. The waveforms are produced in the frequency domain and include the inspiral, merger and ringdown parts for the dominant spherical harmonic mode of the signal. Part of LALSuite (ascl:2012.021) and also available as an independent code, IMRPhenomD is written in C and is calibrated against data from numerical relativity simulations. A re-implementation of IMRPhenomD in Python, PyIMRPhenomD (ascl:2307.023), is available.

[ascl:1010.046] indexf: Line-strength Indices in Fully Calibrated FITS Spectra

This program measures line-strength indices in fully calibrated FITS spectra. By "fully calibrated" one should understand wavelength and relative flux-calibrated data. Note that the different types of line-strength indices that can be measured with indexf (see below) do not require absolute flux calibration. If even a relative flux-calibration is absent (or deficient), the derived indices should be transformed to an appropriate spectrophotometric system. The program can also compute index errors resulting from the propagation of random errors (e.g. photon statistics, read-out noise). This option is only available if the user provides the error spectrum as an additional input FITS file to indexf. The error spectrum must contain the unbiased standard deviation (and not the variance!) for each pixel of the data spectrum. In addition, indexf also estimates the effect of errors on radial velocity. For this purpose, the program performs Monte Carlo simulations by measuring each index using randomly drawn radial velocities (following a Gaussian distribution of a given standard deviation). If no error file is employed, the program can perform numerical simulations with synthetic error spectra, the latter generated from the original data spectra and assuming randomly generated S/N ratios.

[ascl:1806.005] Indri: Pulsar population synthesis toolset

Indri models the population of single (not in binary or hierarchical systems) neutron stars. Given a starting distribution of parameters (birth place, velocity, magnetic field, and period), the code moves a set of stars through the time (by evolving spin period and magnetic field) and the space (by propagating through the Galactic potential). Upon completion of the evolution, a set of observables is computed (radio flux, position, dispersion measure) and compared with a radio survey such as the Parkes Multibeam Survey. The models' parameters are optimised by using the Markov Chain Monte Carlo technique.

[ascl:1210.023] inf_solv: Kerr inflow solver

The efficiency of thin disk accretion onto black holes depends on the inner boundary condition, specifically the torque applied to the disk at the last stable orbit. This is usually assumed to vanish. This code estimates the torque on a magnetized disk using a steady magnetohydrodynamic inflow model originally developed by Takahashi et al. The efficiency e can depart significantly from the classical thin disk value. In some cases e > 1, i.e., energy is extracted from the black hole.

[ascl:1007.002] INFALL: A code for calculating the mean initial and final density profiles around a virialized dark matter halo

Infall is a code for calculating the mean initial and final density profiles around a virialized dark matter halo. The initial profile is derived from the statistics of the initial Gaussian random field, accounting for the problem of peaks within peaks using the extended Press-Schechter model. Spherical collapse then yields the typical density and velocity profiles of the gas and dark matter that surrounds the final, virialized halo. In additional to the mean profile, ±1-σ profiles are calculated and can be used as an estimate of the scatter.

[ascl:2212.021] Infinity: Calculate accretion disk radiation forces onto moving particles

Infinity sets an observer in a black hole - accretion disk system. The black hole can be either Schwarzschild (nonrotating) or Kerr (rotating) by choice of the user. This observer can be on the surface of the disk, in its exterior or its interior (if the disk is not opaque). Infinity then scans the entire sky around the observer and investigates whether photons emitted by the hot accretion disk material can reach them. After recording the incoming radiation, the program calculates the stress-energy tensor of the radiation. Afterwards, the program calculates the radiation flux and hence, the radiation force exerted on target particles of various velocity profiles.

[ascl:1201.017] Inflation: Monte-Carlo Code for Slow-Roll Inflation

Inflation is a numerical code to generate power spectra and other observables through numerical solutions to flow equations. The code generates tensor and scalar power spectra as a function of wavenumber and various other parameters at specific wavenumbers of interest (such as for CMB, scalar perturbations at smaller scales, gravitational wave detection at direct detection frequencies). The output can be easily ported to publicly available Markov Chain codes to constrain cosmological parameters with data.

[ascl:1711.002] inhomog: Biscale kinematical backreaction analytical evolution

The inhomog library provides Raychaudhuri integration of cosmological domain-wise average scale factor evolution using an analytical formula for kinematical backreaction Q_D evolution. The inhomog main program illustrates biscale examples. The library routine lib/Omega_D_precalc.c is callable by RAMSES (ascl:1011.007) using the RAMSES extension ramses-scalav.

[ascl:1801.005] InitialConditions: Initial series solutions for perturbations in our Universe

InitialConditions finds the initial series solutions for perturbations in our Universe. This includes all scalar (1 adiabatic, 4 isocurvature and 2 magnetic modes), vector (1 vorticity mode, 1 magnetic mode), and tensor (1 gravitational wave mode and 1 magnetic mode) perturbations including terms up to second order in the neutrino mass. It can handle the standard species (cdm, baryons, photons), and two neutrino mass eigenstates (1 light, 1 heavy).

[ascl:2202.025] INSANE: INflationary potential Simulator and ANalysis Engine

INSANE (INflationary potential Simulator and ANalysis Engine) takes either a numeric inflationary potential or a symbolic one, calculates the background evolution and then, using the Mukhanov-Sasaki equations, calculates the primordial power spectrum it yields. The package can analyze the results to extract the spectral index n_s, the index running alpha, the running of running and possibly higher moments. The package contains two main modules: BackgroundSolver solves the background equations, and the MsSolver module solves and analyses the MS equations.

[submitted] INSPECTA: INtegrated SDHDF Processing Engine in C for Telescope data Analysis

INSPECTA (formerly sdhdfProc) is a software package to read, manipulate and process radio astronomy data in Spectral-Domain Hierarchical Data Format (SDHDF). It is available as part of the 'sdhdf_tools' repository.

[ascl:1907.027] intensitypower: Spectrum multipoles modeler

intensitypower measures and models the auto- and cross-power spectrum multipoles of galaxy catalogs and radio intensity maps presented in spherical coordinates. It can also convert the multipoles to power spectrum wedges P(k,mu) and 2D power spectra P(k_perp,k_par). The code assumes the galaxy catalog is a set of discrete points and the radio intensity map is a pixelized continuous field which includes angular pixelization using healpix, binning in redshift channels, smoothing by a Gaussian telescope beam, and the addition of a Gaussian noise in each cell. The galaxy catalog and radio intensity map are transferred onto an FFT grid, and power spectrum multipoles are measured including curved-sky effects. Both maps include redshift-space distortions.

[ascl:2112.005] Interferopy: Analyzing datacubes from radio-to-submm observations

Interferopy analyzes datacubes from radio-to-submm observations. It provides a homogenous interface to common tasks, making it easy to go from reduced datacubes to essential measurements and publication-quality plots. Its core functionalities are widely applicable and have been successfully tested on (but are not limited to) ALMA, NOEMA, VLA and JCMT data.

[ascl:1101.004] InterpMC: Caching and Interpolated Likelihoods -- Accelerating Cosmological Monte Carlo Markov Chains

We describe a novel approach to accelerating Monte Carlo Markov Chains. Our focus is cosmological parameter estimation, but the algorithm is applicable to any problem for which the likelihood surface is a smooth function of the free parameters and computationally expensive to evaluate. We generate a high-order interpolating polynomial for the log-likelihood using the first points gathered by the Markov chains as a training set. This polynomial then accurately computes the majority of the likelihoods needed in the latter parts of the chains. We implement a simple version of this algorithm as a patch (InterpMC) to CosmoMC and show that it accelerates parameter estimatation by a factor of between two and four for well-converged chains. The current code is primarily intended as a "proof of concept", and we argue that there is considerable room for further performance gains. Unlike other approaches to accelerating parameter fits, we make no use of precomputed training sets or special choices of variables, and InterpMC is almost entirely transparent to the user.

[ascl:1403.010] Inverse Beta: Inverse cumulative density function (CDF) of a Beta distribution

The Beta Inverse code solves the inverse cumulative density function (CDF) of a Beta distribution, allowing one to sample from the Beta prior directly. The Beta distribution is well suited as a prior for the distribution of the orbital eccentricities of extrasolar planets; imposing a Beta prior on orbital eccentricity is valuable for any type of observation of an exoplanet where eccentricity can affect the model parameters (e.g. transits, radial velocities, microlensing, direct imaging). The Beta prior is an excellent description of the current, empirically determined distribution of orbital eccentricities and thus employing it naturally incorporates an observer’s prior experience of what types of orbits are probable or improbable. The default parameters in the code are currently set to the Beta distribution which best describes the entire population of exoplanets with well-constrained orbits.

[ascl:1612.013] InversionKit: Linear inversions from frequency data

InversionKit is an interactive Java program that performs rotational and structural linear inversions from frequency data.

[ascl:1303.022] ionFR: Ionospheric Faraday rotation

ionFR calculates the amount of ionospheric Faraday rotation for a specific epoch, geographic location, and line-of-sight. The code uses a number of publicly available, GPS-derived total electron content maps and the most recent release of the International Geomagnetic Reference Field. ionFR can be used for the calibration of radio polarimetric observations; its accuracy had been demonstrated using LOFAR pulsar observations.

[ascl:1804.002] ipole: Semianalytic scheme for relativistic polarized radiative transport

ipole is a ray-tracing code for covariant, polarized radiative transport particularly useful for modeling Event Horizon Telescope sources, though may also be used for other relativistic transport problems. The code extends the ibothros scheme for covariant, unpolarized transport using two representations of the polarized radiation field: in the coordinate frame, it parallel transports the coherency tensor, and in the frame of the plasma, it evolves the Stokes parameters under emission, absorption, and Faraday conversion. The transport step is as spacetime- and coordinate- independent as possible; the emission, absorption, and Faraday conversion step is implemented using an analytic solution to the polarized transport equation with constant coefficients. As a result, ipole is stable, efficient, and produces a physically reasonable solution even for a step with high optical depth and Faraday depth.

[ascl:2310.009] IQRM-APOLLO: Clean narrow-band RFI using Inter-Quartile Range Mitigation (IQRM) algorithm

IQRM-APOLLO cleans narrow-band radio frequency interference (RFI) using the Inter-Quartile Range Mitigation (IQRM) algorithm. By masking this interference, the code reduces the number of false positive pulsar candidates and increases sensitivity for pulsar detection. The IQRM algorithm is an outlier detection algorithm that is both non-parametric and robust to the presences of trends in time series data. Using short-duration data blocks, IQRM-APOLLO computes a spectral statistic that correlates with the presence of RFI, removing high outliers from the input signal.

[ascl:2311.008] IQRM: IQRM interference flagging algorithm for radio pulsar and transient searches

IQRM implements the Inter-Quartile Range Mitigation (IQRM) interference flagging algorithm for radio pulsar and transient searches. This module provides only the algorithm that infers a channel mask from some spectral statistic that measures the level of RFI contamination in a time-frequency data block. It should be useful as a reference implementation to developers who wish to integrate IQRM into an existing pipeline or search code.

[ascl:1512.001] IRACpm: Distortion correction for IRAC astrometric data

The IRACpm R package applies a 7-8 order distortion correction to IRAC astrometric data from the Spitzer Space Telescope and includes a function for measuring apparent proper motions between different Epochs. These corrections are applicable only to positions measured by APEX; cryogenic images benefit from a correction for varying intra-pixel sensitivity prior to the application of the distortion.

[ascl:1209.013] IRACproc: IRAC Post-BCD Processing

IRACproc is a software suite that facilitates the co-addition of dithered or mapped Spitzer/IRAC data to make them ready for further analysis with application to a wide variety of IRAC observing programs. The software runs within PDL, a numeric extension for Perl available from pdl.perl.org, and as stand alone perl scripts. In acting as a wrapper for the Spitzer Science Center's MOPEX software, IRACproc improves the rejection of cosmic rays and other transients in the co-added data. In addition, IRACproc performs (optional) Point Spread Function (PSF) fitting, subtraction, and masking of saturated stars.

[ascl:9911.002] IRAF: Image Reduction and Analysis Facility

IRAF includes a broad selection of programs for general image processing and graphics, plus a large number of programs for the reduction and analysis of optical and IR astronomy data. Other external or layered packages are available for applications such as data acquisition or handling data from other observatories and wavelength regimes such as the Hubble Space Telescope (optical), EUVE (extreme ultra-violet), or ROSAT and AXAF (X-ray). These external packages are distributed separately from the main IRAF distribution but can be easily installed. The IRAF system also includes a complete programming environment for scientific applications, which includes a programmable Command Language scripting facility, the IMFORT Fortran/C programming interface, and the full SPP/VOS programming environment in which the portable IRAF system and all applications are written.

[ascl:2106.040] IRAGNSEP: Spectral energy distribution fitting code

iragnsep performs IR SED fits separated into AGN and galaxy contributions, and measures host galaxy properties free of AGN contamination. The advantage of iragnsep is that, in addition to fitting observed broadband photometric fluxes, it also incorporates IR spectra in the fits which, if available, improves the robustness of the galaxy-AGN separation. For the galaxy component, iragnsep uses a library of galaxy templates. In terms of the AGN contribution, if the input dataset is a mixture of spectral and photometric data, iragnsep uses a combination of power-laws for the AGN continuum, and some broad features for the silicate emission. If instead the dataset contains photometric data alone, the AGN contribution is accounted for by using a library of AGN templates. The advanced fitting techniques used by iragnsep combined with the powerful model comparison tests allows iragnsep to provide a statistically robust interpretation of IR SEDs in terms of AGN-galaxy contributions, even when the AGN contribution is highly diluted by the host galaxy emission.

[ascl:1406.014] IRAS90: IRAS Data Processing

IRAS90 is a suite of programs for processing IRAS data. It takes advantage of Starlink's (ascl:1110.012) ADAM environment, which provides multi-platform availability of both data and the programs to process it, and the user friendly interface of the parameter entry system. The suite can determine positions in astrometric coordinates, draw grids, and offers other functions for standard astronomical measurement and standard projections.

[ascl:1406.015] IRCAMDR: IRCAM3 Data Reduction Software

The UKIRT IRCAM3 data reduction and analysis software package, IRCAMDR (formerly ircam_clred) analyzes and displays any 2D data image stored in the standard Starlink (ascl:1110.012) NDF data format. It reduces and analyzes IRCAM1/2 data images of 62x58 pixels and IRCAM3 images of 256x256 size. Most of the applications will work on NDF images of any physical (pixel) dimensions, for example, 1024x1024 CCD images can be processed.

[ascl:2004.015] IRDAP: SPHERE-IRDIS polarimetric data reduction pipeline

IRDAP (IRDIS Data reduction for Accurate Polarimetry) accurately reduces SPHERE-IRDIS polarimetric data. It is a highly-automated end-to-end pipeline; its core feature is model-based correction of the instrumental polarization effects. IRDAP handles data taken both in field- and pupil-tracking mode and using the broadband filters Y, J, H and Ks. Data taken with the narrowband filters can be reduced as well, although with a somewhat worse accuracy. For pupil-tracking observations IRDAP can additionally apply angular differential imaging.

[ascl:1109.017] IRDR: InfraRed Data Reduction

We describe the InfraRed Data Reduction (IRDR) software package, a small ANSI C library of fast image processing routines for automated pipeline reduction of infrared (dithered) observations. We developed the software to satisfy certain design requirements not met in existing packages (e.g., full weight map handling) and to optimize the software for large data sets (non-interactive tasks that are CPU and disk efficient). The software includes stand-alone C programs for tasks such as running sky frame subtraction with object masking, image registration and coaddition with weight maps, dither offset measurement using cross-correlation, and object mask dilation. Although we currently use the software to process data taken with CIRSI (a near-IR mosaic imager), the software is modular and concise and should be easy to adapt/reuse for other work.

[ascl:1205.007] Iris: The VAO SED Application

Iris is a downloadable Graphical User Interface (GUI) application which allows the astronomer to build and analyze wide-band Spectral Energy Distributions (SEDs). The components of Iris have been contributed by members of the VAO. Specview, contributed by STScI, provides a GUI for reading, editing, and displaying SEDs, as well as defining models and parameter values. Sherpa, contributed by the Chandra project at SAO, provides a library of models, fit statistics, and optimization methods; the underlying I/O library, SEDLib, is a VAO product written by SAO to current IVOA (International Virtual Observatory Alliance) data model standards. NED is a service provided by IPAC for easy location of data for a given extragalactic source, including SEDs. SedImporter converts non-standard SED data files into a format supported by Iris.

[ascl:1602.016] IRSFRINGE: Interactive tool for fringe removal from Spitzer IRS spectra

IRSFRINGE is an IDL-based GUI package that allows observers to interactively remove fringes from IRS spectra. Fringes that originate from the detector subtrates are observed in the IRS Short-High (SH) and Long-High (LH) modules. In the Long-Low (LL) module, another fringe component is seen as a result of the pre-launch change in one of the LL filters. The fringes in the Short-Low (SL) module are not spectrally resolved. the fringes are already largely removed in the pipeline processing when the flat field is applied. However, this correction is not perfect and remaining fringes can be removed with IRSFRINGE from data in each module. IRSFRINGE is available as a stand-alone package and is also part of the Spectroscopic Modeling, Analysis and Reduction Tool (SMART, ascl:1210.021).

[ascl:1303.029] iSAP: Interactive Sparse Astronomical Data Analysis Packages

iSAP consists of three programs, written in IDL, which together are useful for spherical data analysis. MR/S (MultiResolution on the Sphere) contains routines for wavelet, ridgelet and curvelet transform on the sphere, and applications such denoising on the sphere using wavelets and/or curvelets, Gaussianity tests and Independent Component Analysis on the Sphere. MR/S has been designed for the PLANCK project, but can be used for many other applications. SparsePol (Polarized Spherical Wavelets and Curvelets) has routines for polarized wavelet, polarized ridgelet and polarized curvelet transform on the sphere, and applications such denoising on the sphere using wavelets and/or curvelets, Gaussianity tests and blind source separation on the Sphere. SparsePol has been designed for the PLANCK project. MS-VSTS (Multi-Scale Variance Stabilizing Transform on the Sphere), designed initially for the FERMI project, is useful for spherical mono-channel and multi-channel data analysis when the data are contaminated by a Poisson noise. It contains routines for wavelet/curvelet denoising, wavelet deconvolution, multichannel wavelet denoising and deconvolution.

[ascl:1403.009] ISAP: ISO Spectral Analysis Package

ISAP, written in IDL, simplifies the process of visualizing, subsetting, shifting, rebinning, masking, combining scans with weighted means or medians, filtering, and smoothing Auto Analysis Results (AARs) from post-pipeline processing of the Infrared Space Observatory's (ISO) Short Wavelength Spectrometer (SWS) and Long Wavelength Spectrometer (LWS) data. It can also be applied to PHOT-S and CAM-CVF data, and data from practically any spectrometer. The result of a typical ISAP session is expected to be a "simple spectrum" (single-valued spectrum which may be resampled to a uniform wavelength separation if desired) that can be further analyzed and measured either with other ISAP functions, native IDL functions, or exported to other analysis package (e.g., IRAF, MIDAS) if desired. ISAP provides many tools for further analysis, line-fitting, and continuum measurements, such as routines for unit conversions, conversions from wavelength space to frequency space, line and continuum fitting, flux measurement, synthetic photometry and models such as a zodiacal light model to predict and subtract the dominant foreground at some wavelengths.

[ascl:1809.010] Isca: Idealized global circulation modeling

Isca provides a framework for the idealized modeling of the global circulation of planetary atmospheres at varying levels of complexity and realism. Though Isca is an outgrowth of models designed for Earth's atmosphere, it may readily be extended into other planetary regimes. Various forcing and radiation options are available. At the simple end of the spectrum a Held-Suarez case is available. An idealized grey radiation scheme, a grey scheme with moisture feedback, a two-band scheme and a multi-band scheme are also available, all with simple moist effects and astronomically-based solar forcing. At the complex end of the spectrum the framework provides a direct connection to comprehensive atmospheric general circulation models.

[ascl:1708.029] iSEDfit: Bayesian spectral energy distribution modeling of galaxies

iSEDfit uses Bayesian inference to extract the physical properties of galaxies from their observed broadband photometric spectral energy distribution (SED). In its default mode, the inputs to iSEDfit are the measured photometry (fluxes and corresponding inverse variances) and a measurement of the galaxy redshift. Alternatively, iSEDfit can be used to estimate photometric redshifts from the input photometry alone.

After the priors have been specified, iSEDfit calculates the marginalized posterior probability distributions for the physical parameters of interest, including the stellar mass, star-formation rate, dust content, star formation history, and stellar metallicity. iSEDfit also optionally computes K-corrections and produces multiple "quality assurance" (QA) plots at each stage of the modeling procedure to aid in the interpretation of the prior parameter choices and subsequent fitting results. The software is distributed as part of the impro IDL suite.

[ascl:9909.003] ISIS: A method for optimal image subtraction

ISIS is a complete package to process CCD images using the image Optimal subtraction method (Alard & Lupton 1998, Alard 1999). The ISIS package can find the best kernel solution even in case of kernel variations as a function of position in the image. The relevant computing time is minimal in this case and is only slightly different from finding constant kernel solutions. ISIS includes as well a number of facilities to compute the light curves of variables objects from the subtracted images. The basic routines required to build the reference frame and make the image registration are also provided in the package.

[ascl:1302.002] ISIS: Interactive Spectral Interpretation System for High Resolution X-Ray Spectroscopy

ISIS, the Interactive Spectral Interpretation System, is designed to facilitate the interpretation and analysis of high resolution X-ray spectra. It is being developed as a programmable, interactive tool for studying the physics of X-ray spectrum formation, supporting measurement and identification of spectral features, and interaction with a database of atomic structure parameters and plasma emission models.

[ascl:1601.021] ISO: Isochrone construction

ISO transforms MESA history files into a uniform basis for interpolation and then constructs new stellar evolution tracks and isochrones from that basis. It is written in Fortran and requires MESA (ascl:1010.083), primarily for interpolation. Though designed to ingest MESA star history files, tracks from other stellar evolution codes can be incorporated by loading the tracks into the data structures used in the codes.

[ascl:1503.010] isochrones: Stellar model grid package

Isochrones, written in Python, simplifies common tasks often done with stellar model grids, such as simulating synthetic stellar populations, plotting evolution tracks or isochrones, or estimating the physical properties of a star given photometric and/or spectroscopic observations.

[ascl:1409.006] iSpec: Stellar atmospheric parameters and chemical abundances

iSpec is an integrated software framework written in Python for the treatment and analysis of stellar spectra and abundances. Spectra treatment functions include cosmic rays removal, continuum normalization, resolution degradation, and telluric lines identification. It can also perform radial velocity determination and correction and resampling. iSpec can also determine atmospheric parameters (i.e effective temperature, surface gravity, metallicity, micro/macroturbulence, rotation) and individual chemical abundances by using either the synthetic spectra fitting technique or equivalent widths method. The synthesis is performed with SPECTRUM (ascl:9910.002).

[ascl:2009.004] ISPy3: Integrated-light Spectroscopy for Python3

The ISPy3 suite of Python routines models and analyzes integrated-light spectra of stars and stellar populations. The actual spectral modeling and related tasks such as setting up model atmospheres is done via external codes. Currently, the Kurucz codes (ATLAS/SYNTHE) and MARCS/TurboSpectrum are supported, though implementing other similar codes should be relatively straight forward.

[ascl:1010.047] ISW and Weak Lensing Likelihood Code

ISW and Weak Lensing Likelihood code is the likelihood code that calculates the likelihood of Integrated Sachs Wolfe and Weak Lensing of Cosmic Microwave Background using the WMAP 3year CMB maps with mass tracers such as 2MASS (2-Micron All Sky Survey), SDSS LRG (Sloan Digital Sky Survey Luminous Red Galaxies), SDSS QSOs (Sloan Digital Sky Survey Quasars) and NVSS (NRAO VLA All Sky Survey) radio sources. The details of the analysis (*thus the likelihood code) can be understood by reading the papers ISW paper and Weak lensing paper. The code does brute force theoretical matter power spectrum and calculations with CAMB. See the paper for an introduction, descriptions, and typical results from some pre-WMAP data. The code is designed to be integrated into CosmoMC. For further information concerning the integration, see Code Modification for integration into COSMOMC.

[ascl:1307.012] ITERA: IDL Tool for Emission-line Ratio Analysis

ITERA, the IDL Tool for Emission-line Ratio Analysis, is an IDL widget tool that allows you to plot ratios of any strong atomic and ionized emission lines as determined by standard photoionization and shock models. These "line ratio diagrams" can then be used to determine diagnostics for nebulae excitation mechanisms or nebulae parameters such as density, temperature, metallicity, etc. ITERA can also be used to determine line sensitivities to such parameters, compare observations with the models, or even estimate unobserved line fluxes.

[ascl:1406.016] IUEDR: IUE Data Reduction package

IUEDR reduces IUE data. It addresses the problem of working from the IUE Guest Observer tape or disk file through to a calibrated spectrum that can be used in scientific analysis and is a complete system for IUE data reduction. IUEDR was distributed as part of the Starlink software collection (ascl:1110.012).

[ascl:1801.002] iWander: Dynamics of interstellar wanderers

iWander assesses the origin of interstellar small bodies such as asteroids and comets. It includes a series of databases and tools that can be used in general for studying the dynamics of an interstellar vagabond object (small−body, interstellar spaceship and even stars).

[ascl:2210.020] ixpeobssim: Imaging X-ray Polarimetry Explorer simulator and analyzer

The simulation and analysis framework ixpeobssim was specifically developed for the Imaging X-ray Polarimetry Explorer (IXPE). It produces realistic simulated observations, in the form of event lists in FITS format, that also contain a strict superset of the information included in the publicly released IXPE data products. The framework's core simulation capabilities are complemented by post-processing applications that support the spatial, spectral, and temporal models needed for analysis of typical polarized X-ray sources, allowing implementation of complex, polarization-aware analysis pipelines. Where applicable, the data formats are consistent with the common display and analysis tools used by the community, e.g., the binned count spectra can be fed into XSPEC (ascl:9910.005), along with the corresponding response functions, for doing standard spectral analysis. All ixpeobssim simulation and analysis tools are fully configurable via the command line.

[ascl:2009.007] J plots: Tool for characterizing 2D and 3D structures in the interstellar medium

J plots classifies and quantifies a pixelated structure, based on its principal moments of inertia, thus enabling automatic detection and objective comparisons of centrally concentrated structures (cores), elongated structures (filaments) and hollow circular structures (bubbles) from the main population of slightly irregular blobs that make up most astronomical images. Examples of how to analyze 2D or 3D datasets, enabling an unbiased analysis and comparison of simulated and observed structures are provided along with the Python code.

[ascl:2208.015] J-comb: Combine high-resolution and low-resolution data

J-comb combines high-resolution data with large-scale missing information with low-resolution data containing the short spacing. Based on uvcombine (ascl:2208.014), it takes as input FITS files of low- and high-resolution images, the angular resolution of the input images, and the pixel size of the input images, and outputs a FITS file of the combined image.

[ascl:1209.002] JAGS: Just Another Gibbs Sampler

JAGS analyzes Bayesian hierarchical models using Markov Chain Monte Carlo (MCMC) simulation not wholly unlike BUGS. JAGS has three aims:

  • to have a cross-platform engine for the BUGS language;
  • to be extensible, allowing users to write their own functions, distributions and samplers; and
  • to be a platform for experimentation with ideas in Bayesian modeling.

[ascl:1403.018] JAM: Jeans Anisotropic MGE modeling method

The Jeans Anisotropic MGE (JAM) modeling method uses the Multi-Gaussian Expansion parameterization for the galaxy surface brightness. The code allows for orbital anisotropy (three-integrals distribution function) and also provides the full second moment tensor, including proper motions and radial velocities.

[ascl:1010.007] JAVELIN: Just Another Vehicle for Estimating Lags In Nuclei

JAVELIN (formerly known as SPEAR) is an approach to reverberation mapping that computes the lags between the AGN continuum and emission line light curves and their statistical confidence limits. It uses a damped random walk model to describe the quasar continuum variability and the ansatz that emission line variability is a scaled, smoothed and displaced version of the continuum. While currently configured only to simultaneously fit light curve means, it includes a general linear parameters formalism to fit more complex trends or calibration offsets. The noise matrix can be modified to allow for correlated errors, and the correlation matrix can be modified to use a different stochastic process. The transfer function model is presently a tophat, but this can be altered by changing the line-continuum covariance matrices. It is also able to cope with some problems in traditional reverberation mapping, such as irregular sampling, correlated errors and seasonal gaps.

[ascl:2111.002] JAX: Autograd and XLA

JAX brings Autograd and XLA together for high-performance machine learning research. It can automatically differentiate native Python and NumPy functions. The code can differentiate through loops, branches, recursion, and closures, and it can take derivatives of derivatives of derivatives. JAX supports reverse-mode differentiation (a.k.a. backpropagation) via grad as well as forward-mode differentiation, and the two can be composed arbitrarily to any order.

[ascl:2007.021] JB2008: Empirical Thermospheric Density Model

JB2008 (Jacchia-Bowman 2008) is an empirical thermospheric density model developed as an improved revision to the Jacchia-Bowman 2006 model, based on Jacchia’s diffusion equations. Driving solar indices are computed from on-orbit sensor data, which are used for the solar irradiances in the extreme through far ultraviolet, including x-ray and Lyman-α wavelengths. Exospheric temperature equations are developed to represent the thermospheric EUV and FUV heating. Semiannual density equations based on multiple 81-day average solar indices are used to represent the variations in the semiannual density cycle that result from EUV heating, and geomagnetic storm effects are modeled using the Dst index as the driver of global density changes.

[ascl:1411.020] JCMT COADD: UKT14 continuum and photometry data reduction

COADD was used to reduce photometry and continuum data from the UKT14 instrument on the James Clerk Maxwell Telescope in the 1990s. The software can co-add multiple observations and perform sigma clipping and Kolmogorov-Smirnov statistical analysis. Additional information on the software is available in the JCMT Spring 1993 newsletter (large PDF).

[ascl:1406.019] JCMTDR: Applications for reducing JCMT continuum data in GSD format

JCMTDR reduces continuum on-the-fly mapping data obtained with UKT14 or the heterodyne instruments using the IFD on the James Clerk Maxwell Telescope. This program reduces archive data and heterodyne beam maps and was distributed as part of the Starlink software collection (ascl:1110.012).

[ascl:2307.001] Jdaviz: JWST astronomical data analysis tools in the Jupyter platform

Jdaviz provides data viewers and analysis plugins that can be flexibly combined as desired to create interactive applications. It offers Specviz (ascl:1902.011) for visualization and quick-look analysis of 1D astronomical spectra; Mosviz for visualization of astronomical spectra, including 1D and 2D spectra as well as contextual information, and Cubeviz for visualization of spectroscopic data cubes (such as those produced by JWST MIRI). Imviz, which provides visualization and quick-look analysis for 2D astronomical images, is also included. Jdaviz is designed with instrument modes from the James Webb Space Telescope (JWST) in mind, but the tool is flexible enough to read in data from many astronomical telescopes, and the documentation provides a complete table of all supported modes.

[ascl:2305.020] JEDI: James's EVE Dimming Index

JEDI searches for and characterizes coronal dimming in light curves produced from the Solar Dynamics Observatory (SDO) Extreme Ultraviolet (EUV) Variability Experiment (EVE). The suite has a wrapper script that calls other functions, which can also be run independently assuming needed inputs from prior functions are provided. JEDI's functions fit light curves and return the best fit, compute precision for iron light curves, and find the biggest dimming depth and its time in a given light curve. JEDI also includes functions for finding the duration of the dimming, minimum, maximum, and mean slope of dimming of a light curve, and for identifying the biggest peak in two light curves, time shifting them so the peaks are concurrent, scaling them so the peaks are the same magnitude, and then subtracting them, among other useful functions.

[ascl:2304.006] JET: JWST Exoplanet Targeting

JET (JWST Exoplanet Targeting) optimizes lists of exoplanet targets for atmospheric characterization by the James Webb Space Telescope (JWST). The software uses catalogs of planet detections, either simulated, or actual and categorizes targets by radius and equilibrium temperature; it also estimates planet masses and generates model spectra and simulated instrument spectra. JET then performs a statistical analysis to determine if the instrument spectra can confirm an atmospheric detection and finally ranks the targets within each category by observation time required for detection.

[ascl:1702.005] JetCurry: Modeling 3D geometry of AGN jets from 2D images

Written in Python, JetCurry models the 3D geometry of jets from 2-D images. JetCurry requires NumPy and SciPy and incorporates emcee (ascl:1303.002) and AstroPy (ascl:1304.002), and optionally uses VPython. From a defined initial part of the jet that serves as a reference point, JetCurry finds the position of highest flux within a bin of data in the image matrix and fits along the x axis for the general location of the bends in the jet. A spline fitting is used to smooth out the resulted jet stream.

[ascl:1810.003] JETGET: Hydrodynamic jet simulation visualization and analysis

JETGET accesses, visualizes, and analyses (magnetized-)fluid dynamics data stored in Hierarchical Data Format (HDF) and ASCII files. Although JETGET has been optimized to handle data output from jet simulations using the Zeus code (ascl:1306.014) from NCSA, it is also capable of analyzing other data output from simulations using other codes. JETGET can select variables from the data files, render both two- and three-dimensional graphics and analyze and plot important physical quantities. Graphics can be saved in encapsulated Postscript, JPEG, VRML, or saved into an MPEG for later visualization and/or presentations. The strength of JETGET in extracting the physics underlying such phenomena is demonstrated as well as its capabilities in visualizing the 3-dimensional features of the simulated magneto-hydrodynamic jets. The JETGET tool is written in Interactive Data Language (IDL) and uses a graphical user interface to manipulate the data. The tool was developed on a LINUX platform and can be run on any platform that supports IDL.

[ascl:2009.001] JetSeT: Numerical modeling and SED fitting tool for relativistic jets

JetSeT reproduces radiative and accelerative processes acting in relativistic jets and fits the numerical models to observed data. This C/Python framework re-bins observed data, can define data sets, and binds to astropy tables and quantities. It can use Synchrotron Self-Compton (SSC), external Compton (EC) and EC against the CMB when defining complex numerical radiative scenarios. JetSeT can constrain the model in the pre-fitting stage based on accurate and already published phenomenological trends starting from parameters such as spectral indices, peak fluxes and frequencies, and spectral curvatures. The package fits multiwavelength SEDs using both frequentist approach and Bayesian MCMC sampling, and also provides self-consistent temporal evolution of the plasma under the effect of radiative and accelerative processes for both first order and second order (stochastic acceleration) processes.

[ascl:2112.027] JexoSim 2.0: JWST Exoplanet Observation Simulator

JexoSim 2.0 (JWST Exoplanet Observation Simulator) simulates exoplanet transit observations using all four instruments of the James Webb Space Telescope, and is designed for the planning and validation of science cases for JWST. The code generates synthetic spectra that capture the full impact of complex noise sources and systematic trends, allowing for assessment of both accuracy and precision in the final spectrum. JexoSim does not contain all known systematics for the various instruments, but is a good starting point to investigate the effects of systematics, and has the framework to incorporate more systematics in the future.

[ascl:1308.016] JHelioviewer: Visualization software for solar physics data

JHelioview is open source visualization software for solar physics data. The JHelioviewer client application enables users to browse petabyte-scale image archives; the JHelioviewer server integrates a JPIP server, metadata catalog, and an event server. JHelioview uses the JPEG 2000 image compression standard, which provides efficient access to petabyte-scale image archives; JHelioviewer also allows users to locate and manipulate specific data sets.

[ascl:1207.013] JKTEBOP: Analyzing light curves of detached eclipsing binaries

The JKTEBOP code is used to fit a model to the light curves of detached eclipsing binary stars in order to derive the radii of the stars as well as various other quantities. It is very stable and includes extensive Monte Carlo or bootstrapping error analysis algorithms. It is also excellent for transiting extrasolar planetary systems. All input and output is done by text files; JKTEBOP is written in almost-standard FORTRAN 77 using first the g77 compiler and now the ifort compiler.

[ascl:1511.016] JKTLD: Limb darkening coefficients

JKTLD outputs theoretically-calculated limb darkening (LD) strengths for equations (LD laws) which predict the amount of LD as a function of the part of the star being observed. The coefficients of these laws are obtained by bilinear interpolation (in effective temperature and surface gravity) in published tables of coefficients calculated from stellar model atmospheres by several researchers. Many observations of stars require the strength of limb darkening (LD) to be estimated, which can be done using theoretical models of stellar atmospheres; JKTLD can help in these circumstances.

[ascl:2006.013] JoXSZ: Joint X-ray and SZ fitting for galaxy clusters in Python

JoXSZ jointly fits the thermodynamic profiles of galaxy clusters from both SZ and X-ray data using a Markov chain Monte Carlo fitting algorithm. It is an enhanced version of preprofit (ascl:1910.002), which fits only SZ data. JoXSZ parameterizes the pressure and electron density profile of a galaxy cluster with a given center and derives the temperature profile as the ratio of these quantities through the ideal gas law. The X-ray and SZ-based temperatures can be similar or different, which allows study of the cluster elongation along line of sight, gas clumping, or calibration uncertainties.

[submitted] JPFITS (C# .Net FITS File Interaction)

FITS File interaction written in Visual Studio C# .Net.

JPFITS is not based upon any other implementation and is written from the ground-up, consistent with the FITS standard, designed to interact with FITS files as object-oriented structures.

JPFITS provides functionality to interact with FITS images and binary table extensions, as well as providing common mathematical methods for the manipulation of data, data reductions, profile fitting, photometry, etc.

JPFITS also implements object-oriented classes for Point Source Extraction, World Coordinate Solutions (WCS), WCS automated field solving, FITS Headers and Header Keys, etc.

The automatic world coordinate solver is based on the trigonometric algorithm as described here:

https://iopscience.iop.org/article/10.1088/1538-3873/ab7ee8

All function parameters, methods, properties, etc., are coded with XML descriptions which will function with Visual Studio. Other code editors may or may not read the XML files.

Everything which is reasonable to parallelize in order to benefit from the computation speed increase for multi-threaded systems has been done so. In all such cases function options are given in order to specify the use of parallelism or not. Generally, most image manipulation functions are highly amenable to parallelism. No parallelism is forced, i.e., any code which may execute parallelized is given a user option to do so or not.

[ascl:1908.017] JPLephem: Jet Propulsion Lab ephemerides package

JPLephem loads and uses standard Jet Propulsion Laboratory (JPL) ephemerides for predicting the position and velocity of a planet or other Solar System body. It is one of the foundations of the Skyfield (ascl:1907.024) astronomy library for Python, and can also be used as a standalone package to generate raw vectors.

[ascl:1511.002] JSPAM: Interacting galaxies modeller

JSPAM models galaxy collisions using a restricted n-body approach to speed up computation. Instead of using a softened point-mass potential, the software supports a modified version of the three component potential created by Hernquist (1994, ApJS 86, 389). Although spherically symmetric gravitationally potentials and a Gaussian model for the bulge are used to increase computational efficiency, the potential mimics that of a fully consistent n-body model of a galaxy. Dynamical friction has been implemented in the code to improve the accuracy of close approaches between galaxies. Simulations using this code using thousands of particles over the typical interaction times of a galaxy interaction take a few seconds on modern desktop workstations, making it ideal for rapidly prototyping the dynamics of colliding galaxies. Extensive testing of the code has shown that it produces nearly identical tidal features to those from hierarchical tree codes such as Gadget but using a fraction of the computational resources. This code was used in the Galaxy Zoo: Mergers project and is very well suited for automated fitting of galaxy mergers with automated pattern fitting approaches such as genetic algorithms. Java and Fortran versions of the code are available.

[ascl:1607.007] JUDE: An Utraviolet Imaging Telescope pipeline

JUDE (Jayant's UVIT Data Explorer) converts the Level 1 data (FITS binary table) from the Ultraviolet Imaging Telescope (UVIT) on ASTROSAT into three output files: a photon event list as a function of frame number (FITS binary table); a FITS image file with two extensions; and a PNG file created from the FITS image file with an automated scaling.

[ascl:1812.016] Juliet: Transiting and non-transiting exoplanetary systems modelling tool

Juliet essentially serves as a wrapper of other tools, including Batman (ascl:1510.002), George (ascl:1511.015), Dynesty (ascl:1809.013) and AstroPy (ascl:1304.002), to analyze and model transits, radial-velocities, or both from multiple instruments at the same time. Using nested sampling algorithms, it performs a thorough sampling of the parameter space and a model comparison via Bayesian evidences. Juliet also fits transiting and non-transiting multi-planetary systems, and Gaussian Processes (GPs) which might share hyperparameters between the photometry and radial-velocities simultaneously (e.g., stellar rotation periods).

[ascl:1109.024] Jupiter: Multidimensional Astrophysical Hydrocode

Jupiter is a multidimensional astrophysical hydrocode. It is based on a Godunov method, and it is parallelized with MPI. The mesh geometry can either be cartesian, cylindrical or spherical. It allows mesh refinement and includes special features adapted to the description of planets embedded in disks and nearly steady states.

[ascl:1702.003] juwvid: Julia code for time-frequency analysis

Juwvid performs time-frequency analysis. Written in Julia, it uses a modified version of the Wigner distribution, the pseudo Wigner distribution, and the short-time Fourier transform from MATLAB GPL programs, tftb-0.2. The modification includes the zero-padding FFT, the non-uniform FFT, the adaptive algorithm by Stankovic, Dakovic, Thayaparan 2013, the S-method, the L-Wigner distribution, and the polynomial Wigner-Ville distribution.

[ascl:1904.029] JVarStar: Variable Star Analysis Library

JVarStar (Java Variable Star Analysis) performs pattern classification by analyzing variable star data. This all-in-one library package includes machine learning techniques, fundamental mathematical methods, and digital signal processing functions that can be externally referenced (i.e., from Python), or can be used for further Java development. This library has dependencies on several open source packages that, along with the developed functionality, provides a developer with an easily accessible library from which to construct stable variable star analysis and classification code.

[ascl:1504.017] JWFront: Wavefronts and Light Cones for Kerr Spacetimes

JWFront visualizes wavefronts and light cones in general relativity. The interactive front-end allows users to enter the initial position values and choose the values for mass and angular momentum per unit mass. The wavefront animations are available in 2D and 3D; the light cones are visualized using the coordinate systems (t, x, y) or (t, z, x). JWFront can be easily modified to simulate wavefronts and light cones for other spacetime by providing the Christoffel symbols in the program.

[ascl:2110.001] JWSTSim: Geometric-Focused JWST Deep Field Image Simulation

JWST_Simulation generates a novel geometric-focused deep field simulation of the expected JWST future deep field image. Galaxies are represented by ellipses with randomly-generated positions and orientations. Three scripts are included: a deterministic simulation, an ensemble simulation, and a more-realistic monochrome image simulation. The following initial conditions can be perturbed in these codes: H0, Ωm, ΩΛ, the dark energy equation of state parameter, the number of unseen galaxies in the Hubble Ultra Deep Field Image (HUDF), the increase in effective radius due to the JWST’s higher sensitivity, the anisotropy of dark energy, and the maximum redshift reached by the JWST. Galaxy number densities are estimated using integration over comoving volume with an integration constant calibrated with the Hubble Ultra Deep Field. A galaxy coverage percentage is calculated for each image to determine the percentage of the background occupied by galaxies.

[ascl:1507.013] K-Inpainting: Inpainting for Kepler

Inpainting is a technique for dealing with gaps in time series data, as frequently occurs in asteroseismology data, that may generate spurious peaks in the power spectrum, thus limiting the analysis of the data. The inpainting method, based on a sparsity prior, judiciously fills in gaps in the data, preserving the asteroseismic signal as far as possible. This method can be applied both on ground and space-based data. The inpainting technique improves the oscillation modes detection and estimation, the impact of the observational window function is reduced, and the interpretation of the power spectrum is simplified. K-Inpainting can be used to study very long time series of many stars because its computation is very fast.

[ascl:2107.024] K2-CPM: Causal Pixel Model for K2 data

K2-CPM captures variability while preserving transit signals in Kepler data. Working at the pixel level, the model captures very fine-grained information about the variation of the spacecraft. The CPM models the systematic effects in the time series of a pixel using the pixels of many other stars and the assumption that any shared signal in these causally disconnected light curves is caused by instrumental effects. The target star's future and past are used and the data points are separated into training and test sets to ensure that information about any transit is perfectly isolated from the model. The method has four tuning parameters, the number of predictor stars or pixels, the autoregressive window size, and two L2-regularization amplitudes for model components, and consistently produces low-noise light curves.

[submitted] K2CE: Kepler-K2 Cadence Events

Since early 2018, the Kepler/K2 project has been performing a uniform global reprocessing of data from K2 Campaigns 0 through 14. Subsequent K2 campaigns (C15-C19) are being processed using the same processing pipeline. One of the major benefits of the reprocessing effort is that, for the first time, short-cadence (1-min) light curves are produced in addition to the standard long-cadence (30-min) light curves. Users have been cautioned that the Kepler pipeline detrending module (PDC), developed for use on original Kepler data, has not been tailored for use on short-cadence K2 observations. Systematics due to events on fast timescales, such as thruster firings, are sometimes poorly corrected for many short-cadence targets. A Python data visualization and manipulation tool, called Kepler-K2 Cadence Events, has been developed that identifies and removes cadences associated with problematic thruster events, thus producing better light curves. Kepler-K2 Cadence Events can be used to visualize and manipulate light curve files and target pixel files from the Kepler, K2, and TESS missions. This software is available at the following NASA GitHub repository https://github.com/nasa/K2CE .

[ascl:1503.001] K2flix: Kepler pixel data visualizer

K2flix makes it easy to inspect the CCD pixel data obtained by NASA's Kepler space telescope. The two-wheeled extended Kepler mission, K2, is affected by new sources of systematics, including pointing jitter and foreground asteroids, that are easier to spot by eye than by algorithm. The code takes Kepler's Target Pixel Files (TPF) as input and turns them into contrast-stretched animated gifs or MPEG-4 movies. K2flix can be used both as a command-line tool or using its Python API.

[ascl:1601.009] K2fov: Field of view software for NASA's K2 mission

K2fov allows users to transform celestial coordinates into K2's pixel coordinate system for the purpose of preparing target proposals and field of view visualizations. In particular, the package, written in Python, adds the "K2onSilicon" and "K2findCampaigns" tools to the command line, allowing the visibility of targets to be checked in a user-friendly way.

[ascl:2107.026] K2mosaic: Mosaic Kepler pixel data

K2mosaic stitches the postage stamp-sized pixel masks obtained by NASA's Kepler and K2 missions together into CCD-sized mosaics and movies. The command-line tool's principal use is to take a set of Target Pixel Files (TPF) and turn them into more traditional FITS image files -- one per CCD channel and per cadence. K2mosaic can also be used to create animations from these mosaics. The mosaics produced by K2mosaic also makes the analysis of certain Kepler/K2 targets, such as clusters and asteroids, easier. Moreover such mosaics are useful to reveal the context of single-star observations, e.g., they enable users to check for the presence of instrumental noise or nearby bright objects.

[ascl:1602.014] k2photometry: Read, reduce and detrend K2 photometry

k2photometry reads, reduces and detrends K2 photometry and searches for transiting planets. MAST database pixel files are used as input; the output includes raw lightcurves, detrended lightcurves and a transit search can be performed as well. Stellar variability is not typically well-preserved but parameters can be tweaked to change that. The BLS algorithm used to detect periodic events is a Python implementation by Ruth Angus and Dan Foreman-Mackey (https://github.com/dfm/python-bls).

[ascl:1607.010] K2PS: K2 Planet search

K2PS is an Oxford K2 planet search pipeline. Written in Python, it searches for transit-like signals from the k2sc-detrended light curves.

[ascl:1605.012] K2SC: K2 Systematics Correction

K2SC (K2 Systematics Correction) models instrumental systematics and astrophysical variability in light curves from the K2 mission. It enables the user to remove both position-dependent systematics and time-dependent variability (e.g., for transit searches) or to remove systematics while preserving variability (for variability studies). K2SC automatically computes estimates of the period, amplitude and evolution timescale of the variability for periodic variables and can be run on ASCII and FITS light curve files. Written in Python, this pipeline requires NumPy, SciPy, MPI4Py, Astropy (ascl:1304.002), and George (ascl:1511.015).

[ascl:1307.003] K3Match: Point matching in 3D space

K3Match is a C library with Python bindings for fast matching of points in 3D space. It uses an implementation of three dimensional binary trees to efficiently find matches between points in 3D space. Two lists of points are compared and match indices as well as distances are given. K3Match can find either the nearest neighbour or all matches within a given search distance in 3D Cartesian space or on the surface of the 2D unit sphere in standard spherical or celestial coordinates.

[ascl:2106.013] Kadath: Spectral solver

The Kadath library implements spectral methods in the context of theoretical physics. It is fully parallel; a sequential version can be installed. The library is written in C++, and solves a wide variety of problems. Several coordinates systems are implemented and additional geometries can be easily encoded. Partial differential equations of various types are discretized by means of spectral methods. The resulting system is solved using a Newton-Raphson iteration, allowing KADATH to deal with strongly non-linear situations. An optimized version of Kadath is available that improves memory management (reducing the number of uses of new and delete), inlines several member functions, and provides better management of the accessors for the arrays.

[ascl:1803.005] Kadenza: Kepler/K2 Raw Cadence Data Reader

Kadenza enables time-critical data analyses to be carried out using NASA's Kepler Space Telescope. It enables users to convert Kepler's raw data files into user-friendly Target Pixel Files upon downlink from the spacecraft. The primary motivation for this tool is to enable the microlensing, supernova, and exoplanet communities to create quicklook lightcurves for transient events which require rapid follow-up.

[ascl:1607.013] Kālī: Time series data modeler

The fully parallelized and vectorized software package Kālī models time series data using various stochastic processes such as continuous-time ARMA (C-ARMA) processes and uses Bayesian Markov Chain Monte-Carlo (MCMC) for inferencing a stochastic light curve. Kālī is written in c++ with Python language bindings for ease of use. Kālī is named jointly after the Hindu goddess of time, change, and power and also as an acronym for KArma LIbrary.

[ascl:2011.003] Kalkayotl: Inferring distances to stellar clusters from Gaia parallaxes

Kalkayotl obtains samples of the joint posterior distribution of cluster parameters and distances to the cluster stars from Gaia parallaxes using Bayesian inference. The code is designed to deal with the parallax spatial correlations of Gaia data, and can accommodate different values of parallax zero point and spatial correlation functions.

[ascl:1906.005] Kalman: Forecasts and interpolations for ALMA calibrator variability

Kalman models an inhomogeneous time series of measurements at different frequencies as noisy sampling from a finite mixture of Gaussian Ornstein-Uhlenbeck processes to try to reproduce the variability of the fluxes and of the spectral indices of the quasars used as calibrators in the Atacama Large Millimeter/Sub-millimeter Array (ALMA), assuming sensible parameters are provided to the model (obtained, for example, from maximum likelihood estimation). One routine in the Kalman Perl module calculates best forecast estimations based on a state space representation of the stochastic model using Kalman recursions, and another routine calculates the smoothed estimation (or interpolations) of the measurements and of the state space also using Kalman recursions. The code does not include optimization routines to calculate best fit parameters for the stochastic processes.

[ascl:1403.022] KAPPA: Kernel Applications Package

KAPPA comprising about 180 general-purpose commands for image processing, data visualization, and manipulation of the standard Starlink data format--the NDF. It works with Starlink's various specialized packages; in addition to the NDF, KAPPA can also process data in other formats by using the "on-the-fly" conversion scheme. Many commands can process data arrays of arbitrary dimension, and others work on both spectra and images. KAPPA operates from both the UNIX C-shell and the ICL command language. KAPPA uses the Starlink environment (ascl:1110.012).

[ascl:1502.008] KAPPA: Optically thin spectra synthesis for non-Maxwellian kappa-distributions

Based on the freely available CHIANTI (ascl:9911.004) database and software, KAPPA synthesizes line and continuum spectra from the optically thin spectra that arise from collisionally dominated astrophysical plasmas that are the result of non-Maxwellian κ-distributions detected in the solar transition region and flares. Ionization and recombination rates together with the ionization equilibria are provided for a range of κ values. Distribution-averaged collision strengths for excitation are obtained by an approximate method for all transitions in all ions available within CHIANTI; KAPPA also offers tools for calculating synthetic line and continuum intensities.

[ascl:1611.010] Kapteyn Package: Tools for developing astronomical applications

The Kapteyn Package provides tools for the development of astronomical applications with Python. It handles spatial and spectral coordinates, WCS projections and transformations between different sky systems; spectral translations (e.g., between frequencies and velocities) and mixed coordinates are also supported. Kapteyn offers versatile tools for writing small and dedicated applications for the inspection of FITS headers, the extraction and display of (FITS) data, interactive inspection of this data (color editing) and for the creation of plots with world coordinate information. It includes utilities for use with matplotlib such as obtaining coordinate information from plots, interactively modifiable colormaps and timer events (module mplutil); tools for parsing and interpreting coordinate information entered by the user (module positions); a function to search for gaussian components in a profile (module profiles); and a class for non-linear least squares fitting (module kmpfit).

[ascl:1102.018] Karma: Visualisation Test-Bed Toolkit

Karma is a toolkit for interprocess communications, authentication, encryption, graphics display, user interface and manipulating the Karma network data structure. It contains KarmaLib (the structured libraries and API) and a large number of modules (applications) to perform many standard tasks. A suite of visualisation tools are distributed with the library.

[ascl:2209.006] KaRMMa: Curved-sky mass map reconstruction

KaRMMa (Kappa Reconstruction for Mass MApping) performs curved-sky mass map reconstruction using a lognormal prior from weak-lensing surveys. It uses a fully Bayesian approach with a physically motivated lognormal prior to sample from the posterior distribution of convergence maps. The posterior distribution of KaRMMa maps are nearly unbiased in one-point and two-point functions and peak/void counts. KaRMMa successfully captures the non-Gaussian nature of the distribution of κ values in the simulated maps, and KaRMMa posteriors correctly characterize the uncertainty in summary statistics.

[ascl:2305.004] katdal: MeerKAT Data Access Library

katdal interacts with the chunk stores and HDF5 files produced by the MeerKAT radio telescope and its predecessors (KAT-7 and Fringe Finder), which are collectively known as MeerKAT Visibility Format (MVF) data sets. The library uses memory carefully, allowing data sets to be inspected and partially loaded into memory. Data sets may be concatenated and split via a flexible selection mechanism. In addition, katdal provides a script to convert these data sets to CASA MeasurementSets.

[ascl:2106.026] Katu: Interaction of particles in plasma simulator

Katu evolves the interaction of particles (photons, protons, neutrons, leptons, pions and neutrinos) in plasma. The package comes with wrappers for emcee (ascl:1303.002) and pymultinest (ascl:1606.005) for Bayesian analysis, making the software applicable to blazars and able to extract relevant statistical information from their electromagnetic (and neutrino, if applicable) flux. The code is optimized for fast performance, and can be easily modified and extended.

[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:2211.002] KC: Analytical propagator with collision detection for Keplerian systems

The analytic propagator Kepler-Collisions calculates collisions for Keplerian systems. The algorithm maintains a list of collision possibilities and jumps from one collision to the next; since collisions are rare in astronomical scales, jumping from collision to collision and calculating each one is more efficient than calculating all the time steps that are between collisions.

[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:2301.019] KCWI_DRP: Keck Cosmic Web Imager Data Reduction Pipeline in Python

KCWI_DRP, written in Python and based on kderp (ascl:2301.018), is the official DRP for the Keck Cosmic Web Imager at the W. M. Keck Observatory. It provides all of the functionality of the older pipeline and has three execution modes: multi-threading for CPU intensive tasks such as wavelength calibration, and multi-processing for large datasets. It offers vacuum to air and heliocentric or barycentric correction and the ability to use KOA file names or original file names. KCWI_DRP also improves the provenance and traceability of DRP versions and execution steps in the headers over kderp, and has versatile sky subtraction modes including using external sky frames and ability of masking regions.

[submitted] KCWIKit: KCWI Post-Processing and Improvements

KCWIKit extends the official KCWI DRP (ascl:2301.019) with a variety of stacking tools and DRP improvements. The software offers masking and median filtering scripts to be used while running the KCWI DRP, and a step-by-step KCWI_DRP implementation for finer control over the reduction process. Once the DRP has finished, KCWIKit can be used to stack the output cubes via the Montage package. Various functions cross-correlate and mosaic the constituent cubes and the final stacked cubes are WCS corrected. Helper functions can then be used to deproject the stacked cube into lower-dimensional representations should the user desire.

[ascl:2107.022] Kd-match: Correspondences of objects between two catalogs through pattern matching

Kd-match matches stellar catalogs for which the transformation between the coordinate systems of the two catalogs is unknown and might include shearing. The code uses the ratio of sides as the invariant under a coordinate transformation and searches for several triangles with similar transformations by building quadrilaterals from sets of four objects in each catalog and calculating the ratio of areas of the triangles that comprise the quadrilaterals. The k-d tree accelerates this quadrilateral search dramatically and is significantly faster than the customary direct search over triangles.

[ascl:2301.018] kderp: Keck Cosmic Web Imager Data Extraction and Reduction Pipeline in IDL

kderp (KCWI Data Extraction and Reduction Pipeline) reduces data for the Keck Cosmic Web Imager. Written in IDL, it performs basic CCD reduction on raw images to produce bias and overscan subtracted, gain-corrected, trimmed and cosmic ray removed images; it can also subtract the sky. It defines the geometric transformations required to map each pixel in the 2d image into slice, postion, and wavelength, and performs flat field and illumination corrections. It generates cubes, applying the transformations previously solved to the object intensity, variance and mask images output from any of the previous stages, and uses a standard star observation to generate an inverse sensitivity curve which is applied to the corresponding observations to flux calibrate them.

This pipeline has been superseded by KCWI_DRP (ascl:2301.019).

[ascl:1712.001] KDUtils: Kinematic Distance Utilities

The Kinematic Distance utilities (KDUtils) calculate kinematic distances and kinematic distance uncertainties. The package includes methods to calculate "traditional" kinematic distances as well as a Monte Carlo method to calculate kinematic distances and uncertainties.

[ascl:1702.007] KEPLER: General purpose 1D multizone hydrodynamics code

KEPLER is a general purpose stellar evolution/explosion code that incorporates implicit hydrodynamics and a detailed treatment of nuclear burning processes. It has been used to study the complete evolution of massive and supermassive stars, all major classes of supernovae, hydrostatic and explosive nucleosynthesis, and x- and gamma-ray bursts on neutron stars and white dwarfs.

[ascl:2105.021] Kepler's Goat Herd: Solving Kepler's equation via contour integration

Kepler's Goat Herd solves Kepler's equation using contour integration to solve the "geometric goat problem". The C++ code implements a variety of solution: 1.) Newton-Raphson: The quadratic Newton-Raphson root finder; 2.) Danby: The quartic root; 3.) Series: An elliptical series method; and 4.) Contour: A new method based on contour integration. Given an array of mean anomalies, an eccentricity and a desired precision, the code estimates the eccentric anomaly using each method. The accuracy of each approach is increased until the desired precision is reached, and timing is performed using the C++ chrono package.

[ascl:2308.012] KeplerFit: Keplerian velocity distribution model fitter

KeplerFit fits a Keplerian velocity distribution model to position-velocity (PV) data to obtain an estimate of the enclosed mass. The code extracts the scales of the pixels in both directions, spatial and spectral, then extracts the most extreme velocity at each position; this returns two arrays of positions and velocities. KeplerFit then models the extracted PV data and returns a set of the best-fit parameters, the standard deviations in each of the parameters, and the total residual of the fit.

[ascl:2107.027] KeplerPORTS: Kepler Planet Occurrence Rate Tools

KeplerPORTS calculates the detection efficiency of the DR25 Kepler Pipeline. It uses a detection contour model to quantify the recoverability of transiting planet signals due to the Kepler pipeline, and accurately portrays the ability of the Kepler pipeline to generate a Threshold Crossing Event (TCE) for a given hypothetical planet.

[ascl:1706.012] KeplerSolver: Kepler equation solver

KeplerSolver solves Kepler's equation for arbitrary epoch and eccentricity, using continued fractions. It is written in C and its speed is nearly the same as the SWIFT routines, while achieving machine precision. It comes with a test program to demonstrate usage.

[ascl:1806.022] Keras: The Python Deep Learning library

Keras is a high-level neural networks API written in Python and capable of running on top of TensorFlow, CNTK, or Theano. It focuses on enabling fast experimentation.

[ascl:2305.012] KERN: Radio telescope toolkit

KERN contains most of the standard tools needed to work with radio telescope data. The suite saves time and reduces frustration in setting up of scientific pipelines, and also improves scientific reproducibility. It includes a wide variety of packages, including 21cmfast (ascl:1102.023), BRATS (ascl:1806.025), CARTA (ascl:2103.031), casacore (ascl:1912.002), CubiCal (ascl:1805.031), DDFacet (ascl:2305.008), PyBDSF (ascl:1502.007),TiRiFiC (ascl:1208.008), WSClean (ascl:1408.023), and many others. KERN can be run on a supported platform such as Ubuntu, with Docker and Singularity, or in a virtual machine.

[ascl:1708.021] KERTAP: Strong lensing effects of Kerr black holes

KERTAP computes the strong lensing effects of Kerr black holes, including the effects on polarization. The key ingredients of KERTAP are a graphic user interface, a backward ray-tracing algorithm, a polarization propagator dealing with gravitational Faraday rotation, and algorithms computing observables such as flux magnification and polarization angles.

[ascl:1502.020] ketu: Exoplanet candidate search code

ketu, written in Python, searches K2 light curves for evidence of exoplanets; the code simultaneously fits for systematic effects caused by small (few-pixel) drifts in the telescope pointing and other spacecraft issues and the transit signals of interest. Though more computationally expensive than standard search algorithms, it can be efficiently implemented and used to discover transit signals.

[ascl:2011.027] kiauhoku: Stellar model grid interpolation

Kiauhoku interacts with, manipulates, and interpolates between stellar evolutionary tracks in a model grid. It was built for interacting with YREC models, but other stellar evolution model grids, including MIST, Dartmouth, and GARSTEC, are also available.

[ascl:2305.005] killMS: Direction-dependent radio interferometric calibration package

killMS implements two very efficient algorithms for solving the Direction-Dependent calibration problem (also known as third generation calibration). This problem naturally arises in the Radio Interferometry Measurement Equation (RIME), but only became overwhelmingly problematic with the construction of the SKA precursors and pathfinders. Solving for the DDE calibration problem basically consists in inverting a number of non-linear equations, while the system is very large and often subject to ill conditioning. The two algorithms killMS uses are based on complex optimization techniques and exploit algorithmic shortcuts; killMS also runs an extended Kalman filter.

[ascl:2306.052] kilopop: Binary neutron star population of optical kilonovae

kilopop produces binary neutron star kilonovae in the grey-body approximation. It can also create populations of these objects useful for forecasting detection and testing observing scenarios. Additionally, it uses an emulator for the grey-opacity of the material calibrated against a suite of numerical radiation transport simulations with the code SuperNu (ascl:2103.019).

[ascl:2302.014] kima: Exoplanet detection in RVs with DNest4 and GPs

kima fits Keplerian curves to a set of RV measurements, using the Diffusive Nested Sampling (ascl:1010.029) algorithm to sample the posterior distribution for the model parameters. Additionally, the code can calculate the fully marginalized likelihood of a model with a given number of Keplerians and also infer the number of Keplerian signals detected in a given dataset. kima implements dedicated models for different analyses of a given dataset. The models share a common organization, but each has its own parameters (and thus priors) and settings.

[ascl:2403.003] kinematic_scaleheight: Infer the vertical distribution of clouds in the solar neighborhood

kinematic_scaleheight uses MCMC methods to kinematically estimate the vertical distribution of clouds in the Galactic plane, including the least squares analysis of Crovisier (1978), an updated least squares analysis using a modern Galactic rotation model, and a Bayesian model sampled via MCMC as described in Wenger et al. (2024).

[ascl:1403.019] KINEMETRY: Analysis of 2D maps of kinematic moments of LOSVD

KINEMETRY, written in IDL, analyzes 2D maps of the moments of the line-of-sight velocity distribution (LOSVD). It generalizes the surface photometry to all moments of the LOSVD. It performs harmonic expansion of 2D maps of observed moments (surface brightness, velocity, velocity dispersion, h3, h4, etc.) along the best fitting ellipses (either fixed or free to change along the radii) to robustly quantify maps of the LOSVD moments, describe trends in structures, and detect morphological and kinematic sub-components.

[ascl:2008.001] kinesis: Kinematic modeling of clusters

Kinesis fits the internal kinematics of a star cluster with astrometry and (incomplete) radial velocity data of its members. In the most general model, the stars can be a mixture of background (contamination) and the cluster, for which the (3,3) velocity dispersion matrix and velocity gradient (i.e., dv_x/dx and dv_y/dx) are included. There are also simpler versions of the most general model and utilities to generate mock clusters and mock observations.

[ascl:2006.003] KinMS: Three-dimensional kinematic modeling of arbitrary gas distributions

The KinMS (KINematic Molecular Simulation) package simulates observations of arbitrary molecular/atomic cold gas distributions from interferometers and line observations from integral field units. This modeling tool is optimized for situations where one has analytic forms for e.g. the rotation curve and/or surface brightness profiles (and may want to fit the parameters of these parametric models). It can, however, also be used as a tilted-ring modelling code. The routines are flexible and have been used in various different applications, including investigating the kinematics of molecular gas in early-type galaxies and determining supermassive black-hole masses from CO interferometric observations. They are also useful for creating mock observations from hydrodynamic simulations, and input data-cubes for further simulation in, for example, CASA's (ascl:1107.013) sim_observe tool. Interactive Data Language (IDL) and Python versions of the code are available.

[ascl:1401.001] Kirin: N-body simulation library for GPUs

The use of graphics processing units offers an attractive alternative to specialized hardware, like GRAPE. The Kirin library mimics the behavior of the GRAPE hardware and uses the GPU to execute the force calculations. It is compatible with the GRAPE6 library; existing code that uses the GRAPE6 library can be recompiled and relinked to use the GPU equivalents of the GRAPE6 functions. All functions in the GRAPE6 library have an equivalent GPU implementation. Kirin can be used for direct N-body simulations as well as for treecodes; it can be run with shared-time steps or with block time-steps and allows non-softened potentials. As Kirin makes use of CUDA, it works only on NVIDIA GPUs.

[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.

[ascl:2008.003] KLLR: Kernel Localized Linear Regression

KLLR (Kernel Localized Linear Regression) generates estimates of conditional statistics in terms of the local slope, normalization, and covariance. This method provides a more nuanced description of population statistics appropriate for very large samples with non-linear trends. The code uses a bootstrap re-sampling technique to estimate the uncertainties and also provides tools to seamlessly generate visualizations of the model parameters.

[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:2106.001] KOBE: Kepler Observes Bern Exoplanets

KOBE (Kepler Observes Bern Exoplanets) adds the geometrical limitations and the physical detection biases of the transit method to a given population of theoretical planets. In addition, it also adds the completeness and reliability of a transit survey.

[ascl:2004.010] kombine: Kernel-density-based parallel ensemble sampler

kombine is an ensemble sampler built for efficiently exploring multimodal distributions. By using estimates of ensemble’s instantaneous distribution as a proposal, it achieves very fast burnin, followed by sampling with very short autocorrelation times.

[ascl:2211.016] Korg: 1D local thermodynamic equilibrium stellar spectral synthesis

Korg computes stellar spectra from 1D model atmospheres and linelists assuming local thermodynamic equilibrium and implements both plane-parallel and spherical radiative transfer. The code is generally faster than other codes, and is compatible with automatic differentiation libraries and easily extensible, making it ideal for statistical inference and parameter estimation applied to large data sets.

[ascl:1504.013] kozai: Hierarchical triple systems evolution

The kozai Python package evolves hierarchical triple systems in the secular approximation. As its name implies, the kozai package is useful for studying Kozai-Lidov oscillations. The kozai package can represent and evolve hierarchical triples using either the Delaunay orbital elements or the angular momentum and eccentricity vectors. kozai contains functions to calculate the period of Kozai-Lidov oscillations and the maximum eccentricity reached; it also contains a module to study octupole order effects by averaging over individual Kozai-Lidov oscillations.

[ascl:1807.027] kplr: Tools for working with Kepler data using Python

kplr provides a lightweight Pythonic interface to the catalog of planet candidates (Kepler Objects of Interest [KOIs]) in the NASA Exoplanet Archive and the data stored in the Barbara A. Mikulski Archive for Space Telescopes (MAST). kplr automatically supports loading Kepler data using pyfits (ascl:1207.009) and supports two types of data: light curves and target pixel files.

[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:1402.011] KROME: Chemistry package for astrophysical simulations

KROME, given a chemical network (in CSV format), automatically generates all the routines needed to solve the kinetics of the system modeled as a system of coupled Ordinary Differential Equations. It provides a large set of physical processes connected to chemistry, including photochemistry, cooling, heating, dust treatment, and reverse kinetics. KROME is flexible and can be used for a wide range of astrophysical simulations. The package contains a network for primordial chemistry, a small metal network appropriate for the modeling of low metallicities environments, a detailed network for the modeling of molecular clouds, and a network for planetary atmospheres as well as a framework for the modelling of the dust grain population.

[ascl:1505.004] KS Integration: Kelvin-Stokes integration

KS Intergration solves for mutual photometric effects produced by planets and spots allowing for analysis of planetary occultations of spots and spots regions. It proceeds by identifying integrable and non integrable arcs on the objects profiles and analytically calculates the solution exploiting the power of Kelvin-Stokes theorem. It provides the solution up to the second degree of the limb darkening law.

[ascl:1804.026] KSTAT: KD-tree Statistics Package

KSTAT calculates the 2 and 3-point correlation functions in discreet point data. These include the two-point correlation function in 2 and 3-dimensions, the anisotripic 2PCF decomposed in either sigma-pi or Kazin's dist. mu projection. The 3-point correlation function can also work in anisotropic coordinates. The code is based on kd-tree structures and is parallelized using a mixture of MPI and OpenMP.

[ascl:1807.028] ktransit: Exoplanet transit modeling tool in python

The routines in ktransit create and fit a transiting planet model. The underlying model is a Fortran implementation of the Mandel & Agol (2002) limb darkened transit model. The code calculates a full orbital model and eccentricity can be allowed to vary; radial velocity data can also be calculated via the model and included in the fit.

[ascl:1407.011] kungifu: Calibration and reduction of fiber-fed IFU astronomical spectroscopy

kungifu is a set of IDL software routines designed for the calibration and reduction of fiber-fed integral-field unit (IFU) astronomical spectroscopy. These routines can perform optimal extraction of IFU data and allow relative and absolute wavelength calibration to within a few hundredths of a pixel (for unbinned data) across 1200-2000 fibers. kungifu does nearly Poisson-limited sky subtraction, even in the I band, and can rebin in wavelength. The Princeton IDLUTILS and IDLSPEC2D packages must be installed for kungifu to run.

[ascl:2311.004] KvW: Modified Kwee–Van Woerden method for eclipse minimum timing with reliable error estimates

The KvW code applies the Kwee Van Woerden (KvW) method for eclipse or transit minimum timing, with an improved error calculation that avoids underestimated errors in minimum times that may appear in the original method. This is particularly the case for low-noise eclipse or transit lightcurves from space or from modern ground instrumentation. The code requires an input light curve of near-equidistant points that contains only the eclipse, without any off-eclipse points, and is available in python and IDL. Both implementaitons return an eclipse minimum time with its error and provide optional text output and plots, as well as several levels of debug information.

[ascl:1507.004] L-PICOLA: Fast dark matter simulation code

L-PICOLA generates and evolves a set of initial conditions into a dark matter field and can include primordial non-Gaussianity in the simulation and simulate the past lightcone at run-time, with optional replication of the simulation volume. It is a fast, distributed-memory, planar-parallel code. L-PICOLA is extremely useful for both current and next generation large-scale structure surveys.

[ascl:1207.005] L.A.Cosmic: Laplacian Cosmic Ray Identification

Conventional algorithms for rejecting cosmic rays in single CCD exposures rely on the contrast between cosmic rays and their surroundings and may produce erroneous results if the point-spread function is smaller than the largest cosmic rays. This code uses a robust algorithm for cosmic-ray rejection, based on a variation of Laplacian edge detection. The algorithm identifies cosmic rays of arbitrary shapes and sizes by the sharpness of their edges and reliably discriminates between poorly sampled point sources and cosmic rays. Examples of its performance are given for spectroscopic and imaging data, including Hubble Space Telescope Wide Field Planetary Camera 2 images, in the code paper.

[ascl:2112.024] l1p: Python implementation of the l1 periodogram

The l1 periodogram searches for periodicities in unevenly sampled time series. It can be used similarly as a Lomb-Scargle periodogram, and retrieves a figure which has a similar aspect but has fewer peaks due to aliasing. It is primarily designed for the search of exoplanets in radial velocity data, but can be also used for other purposes. The principle of the algorithm is to search for a representation of the input signal as a sum of a small number of sinusoidal components, that is a representation which is sparse in the frequency domain. Here, "small number" means small compared to the number of observations.

[ascl:1601.011] LACEwING: LocAting Constituent mEmbers In Nearby Groups

LACEwING (LocAting Constituent mEmbers In Nearby Groups) uses the kinematics (positions and motions) of stars to determine if they are members of one of 10 nearby young moving groups or 4 nearby open clusters within 100 parsecs. It is written for Python 2.7 and depends upon Numpy, Scipy, and Astropy (ascl:1304.002) modules. LACEwING can be used as a stand-alone code or as a module in other code. Additional python programs are present in the repository for the purpose of recalibrating the code and producing other analyses, including a traceback analysis.

[ascl:2104.008] LaFuLi: NASA Langley Fu-Liou radiative transfer code

The NASA Langley Fu-Liou radiative transfer code (also known as Ed4 LaRC Fu-Liou) computes broadband solar shortwave and thermal long wave profiles of down-welling and up-welling flux accounting for gas absorption by H2O, CO2, O3, O2, CH4, N2O and CFCs and absorption and scattering by clouds and aerosols. Longwave has options of a four-stream or 2/4 stream solver, while shortwave has options for two-stream, four-stream or Gamma weighted two-stream (GWTSA) which treats the inhomogeniety of cloud optical depth. A delta-Eddington approximation is used to treat the forward scattering peak. Water cloud properties are based on Mie calculations and ice cloud properties or the ice particle aspect ratio. Aerosol properties are given for 25 types.

[ascl:2012.021] LALSuite: LIGO Scientific Collaboration Algorithm Library Suite

LALSuite contains numerous gravitational wave analysis libraries. Written primarily in C, the libraries include math and signal analysis packages such as for vector manipulation, FFT, statistics, time-domain filtering, and numerical and signal injection routines. The libraries also include date and time and datatype factory routines, in addition to general and support tools and a variety of Python packages. Also included are packages for gravitational waveform and noise generation, burst gravitational wave data analysis, inspiral and ringdown CBC gravitational wave data analysis, pulsar and continuous wave gravitational wave data analysis, and Bayesian inference data analysis. Various wrappers and other tools are also included.

[ascl:1604.003] LAMBDAR: Lambda Adaptive Multi-Band Deblending Algorithm in R

LAMBDAR measures galaxy fluxes from an arbitrary FITS image, covering an arbitrary photometric wave-band, when provided all parameters needed to construct galactic apertures at the required locations for multi-band matched aperture galactic photometry. Through sophisticated matched aperture photometry, the package develops robust Spectral Energy Distributions (SEDs) and accurately establishes the physical properties of galactic objects. LAMBDAR was based on a package detailed in Bourne et al. (2012) that determined galactic fluxes in low resolution Herschel images.

[ascl:1010.077] LAMDA: Leiden Atomic and Molecular Database

LAMDA provides users of radiative transfer codes with the basic atomic and molecular data needed for the excitation calculation. Line data of a number of astrophysically interesting species are summarized, including energy levels, statistical weights, Einstein A-coefficients and collisional rate coefficients. Available collisional data from quantum chemical calculations and experiments are in some cases extrapolated to higher energies. Currently the database contains atomic data for 3 species and molecular data for 28 different species. In addition, several isotopomers and deuterated versions are available. This database should form an important tool in analyzing observations from current and future infrared and (sub)millimetre telescopes. Databases such as these rely heavily on the efforts by the chemical physics community to provide the relevant atomic and molecular data. Further efforts in this direction are strongly encouraged so that the current extrapolations of collisional rate coefficients can be replaced by actual calculations in future releases.

RADEX (ascl:1010.075), a computer program for performing statistical equilibrium calculations, is made publicly available as part of the data base.

[ascl:1409.003] LANL*: Radiation belt drift shell modeling

LANL* calculates the magnetic drift invariant L*, used for modeling radiation belt dynamics and other space weather applications, six orders of magnitude (~ one million times) faster than convectional approaches that require global numerical field lines tracing and integration. It is based on a modern machine learning technique (feed-forward artificial neural network) by supervising a large data pool obtained from the IRBEM library, which is the traditional source for numerically calculating the L* values. The pool consists of about 100,000 samples randomly distributed within the magnetosphere (r: [1.03, 11.5] Re) and within a whole solar cycle from 1/1/1994 to 1/1/2005. There are seven LANL* models, each corresponding to its underlying magnetic field configuration that is used to create the data sample pool. This model has applications to real-time radiation belt forecasting, analysis of data sets involving tens of satellite-years of observations, and other problems in space weather.

[ascl:2104.020] LAPACK: Linear Algebra PACKage

LAPACK provides routines for solving systems of simultaneous linear equations, least-squares solutions of linear systems of equations, eigenvalue problems, and singular value problems. The associated matrix factorizations (LU, Cholesky, QR, SVD, Schur, generalized Schur) are also provided, as are related computations such as reordering of the Schur factorizations and estimating condition numbers. Dense and banded matrices are handled, but not general sparse matrices. In all areas, similar functionality is provided for real and complex matrices, in both single and double precision. The list of LAPACK Contributors is available online.

[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:1208.015] Lare3d: Lagrangian-Eulerian remap scheme for MHD

Lare3d is a Lagrangian-remap code for solving the non-linear MHD equations in three spatial dimensions.

[ascl:1806.021] LASR: Linear Algorithm for Significance Reduction

LASR removes stellar variability in the light curves of δ-Scuti and similar stars. It subtracts oscillations from a time series by minimizing their statistical significance in frequency space.

[ascl:2010.006] LaSSI: Large-Scale Structure Information

LaSSI produces forecasts for the LSST 3x2 point functions analysis, or the LSSTxCMB S4 and LSSTxSO 6x2 point functions analyses using a Fisher matrix. It computes the auto and cross correlations of galaxy number density, galaxy shear and CMB lensing convergence. The software includes the effect of Gaussian and outlier photo-z errors, shear multiplicative bias, linear galaxy bias, and extensions to ΛCDM.

[ascl:2306.033] lasso_spectra: Predict properties from galaxy spectra using Lasso regression

lasso_spectra fits Lasso regression models to data, specifically galaxy spectra. It contains two classes for performing the actual model fitting. GeneralizedLasso is a tensorflow implementation of Lasso regression, which includes the ability to use link functions. SKLasso is a wrapper around the scikit-learn Lasso implementation intended to give the same syntax as GeneralizedLasso. It is much faster and more reliable, but does not support generalized linear models.

[ascl:2205.006] LATTE: Lightcurve Analysis Tool for Transiting Exoplanet

LATTE identifies, vets and characterizes signals in TESS lightcurves to weed out instrumental and astrophysical false positives. The program performs a fast in-depth analysis of targets that have already been identified as promising candidates by the main TESS pipelines or via alternative methods such as citizen science. The code automatically downloads the data products for any chosen TIC ID (short or long cadence TESS data) and produces a number of diagnostic plots that are compiled in a concise report.

[ascl:1911.015] LATTICEEASY: Lattice simulator for evolving interacting scalar fields in an expanding universe

LATTICEEASY creates lattice simulations of the evolution of interacting scalar fields in an expanding universe. The program can do runs with different parameters and new models can be easily introduced for evaluation. Simulations can be done in one, two, or three dimensions by resetting a single variable. Mathematica notebooks for plotting the output and a range of models are also available for download; a parallel processing version of LATTICEEASY called CLUSTEREASY (ascl:1911.016) is also available.

[ascl:1202.011] Lattimer-Swesty Equation of State Code

The Lattimer-Swesty Equation of State code is rapid enough to use directly in hydrodynamical simulations such as stellar collapse calculations. It contains an adjustable nuclear force that accurately models both potential and mean-field interactions and allows for the input of various nuclear parameters, including the bulk incompressibility parameter, the bulk and surface symmetry energies, the symmetric matter surface tension, and the nucleon effective masses. This permits parametric studies of the equation of state in astrophysical situations. The equation of state is modeled after the Lattimer, Lamb, Pethick, and Ravenhall (LLPR) compressible liquid drop model for nuclei, and includes the effects of interactions and degeneracy of the nucleon outside nuclei.

[ascl:2210.018] LavAtmos: Gas-melt equilibrium calculations for a given temperature and melt composition

LavAtmos performs gas-melt equilibrium calculations for a given temperature and melt composition. The thermodynamics of the melt are modeled by the MELTS code as presented in the Thermoengine package (ascl:2208.006). In combination with atmospheric chemistry codes, LavAtmos enables the characterization of interior compositions through atmospheric signatures.

[ascl:2301.014] LBL: Line-by-line velocity measurements

LBL derives velocity measurements from high-resolution (R>50 000) datasets by accounting for outliers in the spectra data. It is tailored for fiber-fed multi-order spectrographs, both in optical and near-infrared (up to 2.5µm) domains. The domain is split into individual units (lines) and the velocity and its associated uncertainty are measured within each line and combined through a mixture model to allow for the presence of spurious values. In addition to the velocity, other quantities are also derived, the most important being a value (dW) that can be understood (for a Gaussian line) as a change in the line FWHM. These values provide useful stellar activity indicators. LBL works on data from a variety of instruments, including SPIRou, NIRPS, HARPS, and ESPRESSO. The code's output is an rdb table that can be uploaded to the online DACE pRV analysis tool.

[ascl:1405.001] LBLRTM: Line-By-Line Radiative Transfer Model

LBLRTM (Line-By-Line Radiative Transfer Model) is an accurate line-by-line model that is efficient and highly flexible. LBLRTM attributes provide spectral radiance calculations with accuracies consistent with the measurements against which they are validated and with computational times that greatly facilitate the application of the line-by-line approach to current radiative transfer applications. LBLRTM has been extensively validated against atmospheric radiance spectra from the ultra-violet to the sub-millimeter.

LBLRTM's heritage is in FASCODE [Clough et al., 1981, 1992].

[ascl:1708.017] LCC: Light Curves Classifier

Light Curves Classifier uses data mining and machine learning to obtain and classify desired objects. This task can be accomplished by attributes of light curves or any time series, including shapes, histograms, or variograms, or by other available information about the inspected objects, such as color indices, temperatures, and abundances. After specifying features which describe the objects to be searched, the software trains on a given training sample, and can then be used for unsupervised clustering for visualizing the natural separation of the sample. The package can be also used for automatic tuning parameters of used methods (for example, number of hidden neurons or binning ratio).

Trained classifiers can be used for filtering outputs from astronomical databases or data stored locally. The Light Curve Classifier can also be used for simple downloading of light curves and all available information of queried stars. It natively can connect to OgleII, OgleIII, ASAS, CoRoT, Kepler, Catalina and MACHO, and new connectors or descriptors can be implemented. In addition to direct usage of the package and command line UI, the program can be used through a web interface. Users can create jobs for ”training” methods on given objects, querying databases and filtering outputs by trained filters. Preimplemented descriptors, classifier and connectors can be picked by simple clicks and their parameters can be tuned by giving ranges of these values. All combinations are then calculated and the best one is used for creating the filter. Natural separation of the data can be visualized by unsupervised clustering.

[ascl:1805.003] lcps: Light curve pre-selection

lcps searches for transit-like features (i.e., dips) in photometric data. Its main purpose is to restrict large sets of light curves to a number of files that show interesting behavior, such as drops in flux. While lcps is adaptable to any format of time series, its I/O module is designed specifically for photometry of the Kepler spacecraft. It extracts the pre-conditioned PDCSAP data from light curves files created by the standard Kepler pipeline. It can also handle csv-formatted ascii files. lcps uses a sliding window technique to compare a section of flux time series with its surroundings. A dip is detected if the flux within the window is lower than a threshold fraction of the surrounding fluxes.

[ascl:2310.002] lcsim: Light curve simulation code

lcsim creates artificial light curves using two algorithms. The first simulates Gaussian distributed light curves following a specific power spectral density (PSD) freely selectable by the user. The second algorithm simulates light curves following a specific PSD and matching a specific probability density function (PDF). The package provides methods to resample the simulated light curves and add "observational" noise. Furthermore, the package provides an interface to a SQLite3-based database to store and access the simulations.

[ascl:2205.013] ld-exosim: Simulate biases using different limb darkening laws

ld-exosim selects the optimal (i.e. best estimator in a MSE sense) limb-darkening law for a given transiting exoplanet lightcurve and calculates the limb-darkening induced biases on various exoplanet parameters. Limb-darkening laws include linear, quadratic, logarithmic, square-root and three-parameter laws.

[ascl:1511.018] LDC3: Three-parameter limb darkening coefficient sampling

LDC3 samples physically permissible limb darkening coefficients for the Sing et al. (2009) three-parameter law. It defines the physically permissible intensity profile as being everywhere-positive, monotonically decreasing from center to limb and having a curl at the limb. The approximate sampling method is analytic and thus very fast, reproducing physically permissible samples in 97.3% of random draws (high validity) and encompassing 94.4% of the physically permissible parameter volume (high completeness).

[ascl:1507.016] Least Asymmetry: Centering Method

Least Asymmetry finds the center of a distribution of light in an image using the least asymmetry method; the code also contains center of light and fitting a Gaussian routines. All functions in Least Asymmetry are designed to take optional weights.

[ascl:1104.006] LECTOR: Line-strengths in One-dimensional ASCII Spectra

LECTOR is a Fortran 77 code that measures line-strengths in one dimensional ascii spectra. The code returns the values of the Lick indices as well as those of Vazdekis & Arimoto 1999, Vazdekis et al. 2001, Rose 1994, Jones & Worthey 1995 and Cenarro et al. 2001. The code measures as many indices as you wish if the limits of two pseudocontinua (at each side of the feature) and the feature itself (i.e. Lick-style index definition) are provided. The Lick-style indices could be either expressed in pseudo-equivalent widths or in magnitudes. If requested the program provides index error estimates on the basis of photon statistics.

[ascl:2307.054] LEFTfield: Forward modeling of cosmological density fields

LEFTfield forward models cosmological matter density fields and biased tracers of large-scale structure. The model, written in C++ code, is centered around classes encapsulating scalar, vector, and tensor grids. It includes the complete bias expansion at any order in perturbations and captures general expansion histories without relying on the EdS approximation; however, the latter is also implemented and results in substantially smaller computational demands. LEFTfield includes a subset of the nonlinear higher-derivative terms in the bias expansion of general tracers.

[ascl:2204.003] legacystamps: Retrieve DESI Legacy Imaging Surveys cutouts

The Python module legacystamps provides easy retrieval, both standalone and scripted, of FITS and JPEG cutouts from the DESI Legacy Imaging Surveys through URLs provided by the Legacy Survey viewer.

[ascl:2010.013] Legolas: Large Eigensystem Generator for One-dimensional pLASmas

Legolas (Large Eigensystem Generator for One-dimensional pLASmas) is a finite element code for MHD spectroscopy of 1D Cartesian/cylindrical equilibria with flow that balance pressure gradients, enriched with various non-adiabatic effects. The code's capabilities range from full spectrum calculations to eigenfunctions of specific modes to full-on parametric studies of various equilibrium configurations in different geometries.

[ascl:2111.007] LEGWORK: LISA Evolution and Gravitational Wave ORbit Kit

LEGWORK (LISA Evolution and Gravitational Wave ORbit Kit) is a simple package for gravitational wave calculations. It evolves binaries and computes signal-to-noise ratios for binary systems potentially observable with LISA; it also visualizes the results. LEGWORK can also compare different detector sensitivity curves, compute the horizon distance for a collection of sources, and tracks signal-to-noise evolution over time.

[ascl:1809.001] LEMON: Differential photometry pipeline

LEMON is a differential-photometry pipeline, written in Python, that determines the changes in the brightness of astronomical objects over time and compiles their measurements into light curves. This code makes it possible to completely reduce thousands of FITS images of time series in a matter of only a few hours, requiring minimal user interaction.

[ascl:2106.014] Lemon: Linear integral Equations' Monte carlo solver based On the Neumann solution

Lemon solves the radiative transfer (RT) processes that contain scattering. These processes are described by differentio-integral equations with given initial or boundary conditions; Lemon solves these differentio-integral equations, which can be converted into the second kind integral equations of Fredholm. The code then obtains the Neumman solution (a series that consists of infinite terms of multiple integrals) from the Fredholm integral equation, and uses the Monte Carlo (MC) method to evaluate these integrals. Lemon is written in Fortran; IDL programs are included for plotting the results.

[ascl:1905.016] LensCNN: Gravitational lens detector

The LensCNN (Convolutional Neural Network) identifies images containing gravitational lensing systems after being trained and tested on simulated images, recovering most systems that are identifiable by eye.

[ascl:1505.026] Lensed: Forward parametric modelling of strong lenses

Lensed performs forward parametric modelling of strong lenses. Using a provided model, Lensed renders the expected image of the lensing event for a large number of parameter settings, thereby exploring the space of possible realizations of the observation. It compares the expectation to the observed image by calculating the likelihood that the observation was indeed produced by the assumed model, thus reconstructing the probability distribution over the parameter space of the model. Written in C, the code uses a massively parallel ray-tracing kernel to perform the necessary calculations on a graphics processing unit (GPU), making the precise rendering of the background lensed sources fast and allowing the simultaneous optimization of tens of parameters for the selected model.

[ascl:1308.004] LensEnt2: Maximum-entropy weak lens reconstruction

LensEnt2 is a maximum entropy reconstructor of weak lensing mass maps. The method takes each galaxy shape as an independent estimator of the reduced shear field and incorporates an intrinsic smoothness, determined by Bayesian methods, into the reconstruction. The uncertainties from both the intrinsic distribution of galaxy shapes and galaxy shape estimation are carried through to the final mass reconstruction, and the mass within arbitrarily shaped apertures are calculated with corresponding uncertainties. The input is a galaxy ellipticity catalog with each measured galaxy shape treated as a noisy tracer of the reduced shear field, which is inferred on a fine pixel grid assuming positivity, and smoothness on scales of w arcsec where w is an input parameter. The ICF width w can be chosen by computing the evidence for it.

[ascl:2210.027] LensingETC: Lensing Exposure Time Calculator

LensingETC optimizes observing strategies for multi-filter imaging campaigns of galaxy-scale strong lensing systems. It uses the lens modelling software lenstronomy (ascl:1804.012) to simulate and model mock imaging data, forecasts the lens model parameter uncertainties, and optimizes observing strategies.

[ascl:2102.021] lensingGW: Lensing of gravitational waves

lensingGW simulates lensed gravitational waves in ground-based interferometers from arbitrary compact binaries and lens models. Its algorithm resolves strongly lensed images and microimages simultaneously, such as the images resulting from hundreds of microlenses embedded in galaxies and galaxy clusters. It is based on Lenstronomy (ascl:1804.012),

[ascl:9903.001] LENSKY: Galactic Microlensing Probability

Given a model for the Galaxy, this program computes the microlensing rate in any direction. Program features include the ability to include the brightness of the lens and to compute the probability of lens detection at any level of lensing amplification. The program limits itself to lensing by single stars of single sources. The program is currently setup to accept input from the Galactic models of Bahcall and Soniera (1982, 1986).

There are three files needed for LENSKY, the Fortran file lensky.for and two input files: galmod.dsk (15 Megs) and galmod.sph (22 Megs). The zip file available below contains all three files. The program generates output to the file lensky.out. The program is pretty self-explanatory past that.

[ascl:1010.050] LensPerfect: Gravitational Lens Massmap Reconstructions Yielding Exact Reproduction of All Multiple Images

LensPerfect is a new approach to the massmap reconstruction of strong gravitational lenses. Conventional methods iterate over possible lens models which reproduce the observed multiple image positions well but not exactly. LensPerfect only produces solutions which fit all of the data exactly. Magnifications and shears of the multiple images can also be perfectly constrained to match observations.

[ascl:1102.025] LensPix: Fast MPI full sky transforms for HEALPix

Modelling of the weak lensing of the CMB will be crucial to obtain correct cosmological parameter constraints from forthcoming precision CMB anisotropy observations. The lensing affects the power spectrum as well as inducing non-Gaussianities. We discuss the simulation of full sky CMB maps in the weak lensing approximation and describe a fast numerical code. The series expansion in the deflection angle cannot be used to simulate accurate CMB maps, so a pixel remapping must be used. For parameter estimation accounting for the change in the power spectrum but assuming Gaussianity is sufficient to obtain accurate results up to Planck sensitivity using current tools. A fuller analysis may be required to obtain accurate error estimates and for more sensitive observations. We demonstrate a simple full sky simulation and subsequent parameter estimation at Planck-like sensitivity.

[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:2010.010] lenspyx: Curved-sky python lensed CMB maps simulation package

lenspyx creates curved-sky python lensed CMB maps simulations; the software allows those familiar with healpy (ascl:2008.022) to build very easily lensed CMB simulations. Parallelization is done with openmp. The numerical cost is approximately that of an high-res harmonic transform. lenspyx provides two methods to build a simulation; one method computes a deflected spin-0 healpix map from its alm and deflection field alm, and the other computes a deflected spin-weight Healpix map from its gradient and curl modes and deflection field alm. lenspyx can be used in conjunction with the Planck 2018 CMB lensing pipeline plancklens (ascl:2010.009) to reproduce the published map and band-powers.

[ascl:1905.017] LensQuEst: CMB Lensing QUadratic Estimator

LensQuEst forecasts the signal-to-noise of CMB lensing estimators (standard, shear-only, magnification-only), generates mock maps, lenses them, and applies various lensing estimators to them. It can manipulate flat sky maps in various ways, including FFT, filtering, power spectrum, generating Gaussian random field, and applying lensing to a map, and evaluate these estimators on flat sky maps.

[ascl:1102.004] LENSTOOL: A Gravitational Lensing Software for Modeling Mass Distribution of Galaxies and Clusters (strong and weak regime)

We describe a procedure for modelling strong lensing galaxy clusters with parametric methods, and to rank models quantitatively using the Bayesian evidence. We use a publicly available Markov chain Monte-Carlo (MCMC) sampler ('Bayesys'), allowing us to avoid local minima in the likelihood functions. To illustrate the power of the MCMC technique, we simulate three clusters of galaxies, each composed of a cluster-scale halo and a set of perturbing galaxy-scale subhalos. We ray-trace three light beams through each model to produce a catalogue of multiple images, and then use the MCMC sampler to recover the model parameters in the three different lensing configurations. We find that, for typical Hubble Space Telescope (HST)-quality imaging data, the total mass in the Einstein radius is recovered with ~1-5% error according to the considered lensing configuration. However, we find that the mass of the galaxies is strongly degenerated with the cluster mass when no multiple images appear in the cluster centre. The mass of the galaxies is generally recovered with a 20% error, largely due to the poorly constrained cut-off radius. Finally, we describe how to rank models quantitatively using the Bayesian evidence. We confirm the ability of strong lensing to constrain the mass profile in the central region of galaxy clusters in this way. Ultimately, such a method applied to strong lensing clusters with a very large number of multiple images may provide unique geometrical constraints on cosmology.

[ascl:1602.009] LensTools: Weak Lensing computing tools

LensTools implements a wide range of routines frequently used in Weak Gravitational Lensing, including tools for image analysis, statistical processing and numerical theory predictions. The package offers many useful features, including complete flexibility and easy customization of input/output formats; efficient measurements of power spectrum, PDF, Minkowski functionals and peak counts of convergence maps; survey masks; artificial noise generation engines; easy to compute parameter statistical inferences; ray tracing simulations; and many others. It requires standard numpy and scipy, and depending on tools used, may require Astropy (ascl:1304.002), emcee (ascl:1303.002), matplotlib, and mpi4py.

[ascl:1804.012] Lenstronomy: Multi-purpose gravitational lens modeling software package

Lenstronomy is a multi-purpose open-source gravitational lens modeling python package. Lenstronomy reconstructs the lens mass and surface brightness distributions of strong lensing systems using forward modelling and supports a wide range of analytic lens and light models in arbitrary combination. The software is also able to reconstruct complex extended sources as well as point sources. Lenstronomy is flexible and numerically accurate, with a clear user interface that could be deployed across different platforms. Lenstronomy has been used to derive constraints on dark matter properties in strong lenses, measure the expansion history of the universe with time-delay cosmography, measure cosmic shear with Einstein rings, and decompose quasar and host galaxy light.

[ascl:1307.005] LENSVIEW: Resolved gravitational lens images modeling

Lensview models resolved gravitational lens systems based on LensMEM but using the Skilling & Bryan MEM algorithm. Though its primary purpose is to find statistically acceptable lens models for lensed images and to reconstruct the surface brightness profile of the source, LENSVIEW can also be used for more simple tasks such as projecting a given source through a lens model to generate a “true” image by conserving surface brightness. The user can specify complicated lens models based on one or more components, such as softened isothermal ellipsoids, point masses, exponential discs, and external shears; LENSVIEW generates a best-fitting source matching the observed data for each specific combination of model parameters.

[ascl:1910.011] LEO-Py: Likelihood Estimation of Observational data with Python

LEO-Py uses a novel technique to compute the likelihood function for data sets with uncertain, missing, censored, and correlated values. It uses Gaussian copulas to decouple the correlation structure of variables and their marginal distributions to compute likelihood functions, thus mitigating inconsistent parameter estimates and accounting for non-normal distributions in variables of interest or their errors.

[ascl:1108.009] LePHARE: Photometric Analysis for Redshift Estimate

LePHARE is a set of Fortran commands to compute photometric redshifts and to perform SED fitting. The latest version includes new features with FIR fitting and a more complete treatment of physical parameters and uncertainties based on PÉGASE and Bruzual & Charlot population synthesis models. The program is based on a simple chi2 fitting method between the theoretical and observed photometric catalogue. A simulation program is also available in order to generate realistic multi-colour catalogues taking into account observational effects.

[ascl:2208.009] LeXInt: Leja Exponential Integrators

LeXInt (Leja interpolation for eXponential Integrators) is a temporal exponential integration package using the method of polynomial interpolation at Leja points. Exponential Rosenbrock (EXPRB) and Exponential Propagation Iterative Runge-Kutta (EPIRK) methods use the Leja interpolation method to compute the functions. For linear PDEs, one can get the exact solution (in time) by directly computing the matrix exponential.

[ascl:1711.018] LExTeS: Link Extraction and Testing Suite

LExTeS (Link Extraction and Testing Suite) extracts hyperlinks from PDF documents, tests the extracted links to see which are broken, and tabulates the results. Though written to support a particular set of PDF documents, the dataset and scripts can be edited for use on other documents.

[ascl:1804.024] LFlGRB: Luminosity function of long gamma-ray bursts

LFlGRB models the luminosity function (LF) of long Gamma Ray Bursts (lGRBs) by using a sample of Swift and Fermi lGRBs to re-derive the parameters of the Yonetoku correlation and self-consistently estimate pseudo-redshifts of all the bursts with unknown redshifts. The GRB formation rate is modeled as the product of the cosmic star formation rate and a GRB formation efficiency for a given stellar mass.

[ascl:1804.023] LFsGRB: Binary neutron star merger rate via the luminosity function of short gamma-ray bursts

LFsGRB models the luminosity function (LF) of short Gamma Ray Bursts (sGRBs) by using the available catalog data of all short GRBs (sGRBs) detected till 2017 October, estimating the luminosities via pseudo-redshifts obtained from the Yonetoku correlation, and then assuming a standard delay distribution between the cosmic star formation rate and the production rate of their progenitors. The data are fit well both by exponential cutoff powerlaw and broken powerlaw models. Using the derived parameters of these models along with conservative values in the jet opening angles seen from afterglow observations, the true rate of short GRBs is derived. Assuming a short GRB is produced from each binary neutron star merger (BNSM), the rate of gravitational wave (GW) detections from these mergers are derived for the past, present and future configurations of the GW detector networks.

[ascl:1710.016] LGMCA: Local-Generalized Morphological Component Analysis

LGMCA (Local-Generalized Morphological Component Analysis) is an extension to GMCA (ascl:1710.015). Similarly to GMCA, it is a Blind Source Separation method which enforces sparsity. The novel aspect of LGMCA, however, is that the mixing matrix changes across pixels allowing LGMCA to deal with emissions sources which vary spatially. These IDL scripts compute the CMB map from WMAP and Planck data; running LGMCA on the WMAP9 temperature products requires the main script and a selection of mandatory files, algorithm parameters and map parameters.

[ascl:1712.016] LgrbWorldModel: Long-duration Gamma-Ray Burst World Model

LgrbWorldModel is written in Fortran 90 and attempts to model the population distribution of the Long-duration class of Gamma-Ray Bursts (LGRBs) as detected by the NASA's now-defunct Burst And Transient Source Experiment (BATSE) onboard the Compton Gamma Ray Observatory (CGRO). It is assumed that the population distribution of LGRBs is well fit by a multivariate log-normal distribution. The best-fit parameters of the distribution are then found by maximizing the likelihood of the observed data by BATSE detectors via a native built-in Adaptive Metropolis-Hastings Markov-Chain Monte Carlo (AMH-MCMC) Sampler.

[ascl:1408.002] LIA: LWS Interactive Analysis

The Long Wavelength Spectrometer (LWS) was one of two complementary spectrometers on the Infrared Space Observatory (ISO). LIA (LWS Interactive Analysis) is used for processing data from the LWS. It provides access to the different processing steps, including visualization of intermediate products and interactive manipulation of the data at each stage.

[ascl:1206.009] Libimf

Libimf provides a collection of programming functions based on the general IMF-algorithm by Pflamm-Altenburg & Kroupa (2006).

[ascl:1502.016] libnova: Celestial mechanics, astrometry and astrodynamics library

libnova is a general purpose, double precision, celestial mechanics, astrometry and astrodynamics library. Among many other calculations, it can calculate aberration, apparent position, proper motion, planetary positions, orbit velocities and lengths, angular separation of bodies, and hyperbolic motion of bodies.

[ascl:1604.002] libpolycomp: Compression/decompression library

Libpolycomp compresses and decompresses one-dimensional streams of numbers by means of several algorithms. It is well-suited for time-ordered data acquired by astronomical instruments or simulations. One of the algorithms, called "polynomial compression", combines two widely-used ideas (namely, polynomial approximation and filtering of Fourier series) to achieve substantial compression ratios for datasets characterized by smoothness and lack of noise. Notable examples are the ephemerides of astronomical objects and the pointing information of astronomical telescopes. Other algorithms implemented in this C library are well known and already widely used, e.g., RLE, quantization, deflate (via libz) and Burrows-Wheeler transform (via libbzip2). Libpolycomp can compress the timelines acquired by the Planck/LFI instrument with an overall compression ratio of ~9, while other widely known programs (gzip, bzip2) reach compression ratios less than 1.5.

[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:1010.020] Libpsht: Algorithms for Efficient Spherical Harmonic Transforms

Libpsht (or "library for Performing Spherical Harmonic Transforms") is a collection of algorithms for efficient conversion between spatial-domain and spectral-domain representations of data defined on the sphere. The package supports transforms of scalars as well as spin-1 and spin-2 quantities, and can be used for a wide range of pixelisations (including HEALPix, GLESP and ECP). It will take advantage of hardware features like multiple processor cores and floating-point vector operations, if available. Even without this additional acceleration, the employed algorithms are among the most efficient (in terms of CPU time as well as memory consumption) currently being used in the astronomical community.

The library is written in strictly standard-conforming C90, ensuring portability to many different hard- and software platforms, and allowing straightforward integration with codes written in various programming languages like C, C++, Fortran, Python etc.

Libpsht is distributed under the terms of the GNU General Public License (GPL) version 2.

Development on this project has ended; its successor is libsharp (ascl:1402.033).

[ascl:2104.002] Librarian: The HERA Librarian

The HERA Librarian system keeps track of all the primary data products for the telescope at a given site. The Librarian supports large data volumes and automated data processing capabilities. A web-based application handles human user and automatic requests and interfaces with a backing database and data storage servers. The system supports the long-term data storage of all relevant telescope data, as well as staging data to individual users' directories for processing.

[ascl:1402.033] libsharp: Library for spherical harmonic transforms

Libsharp is a collection of algorithms for efficient conversion between maps on the sphere and their spherical harmonic coefficients. It supports a wide range of pixelisations (including HEALPix, GLESP, and ECP). This library is a successor of libpsht (ascl:1010.020); it adds MPI support for distributed memory systems and SHTs of fields with arbitrary spin, and also supports new developments in CPU instruction sets like the Advanced Vector Extensions (AVX) or fused multiply-accumulate (FMA) instructions. libsharp is written in portable C99; it provides an interface accessible to other programming languages such as C++, Fortran, and Python.

[ascl:2002.017] libstempo: Python wrapper for Tempo2

libstempo uses the Tempo2 library (ascl:1210.015) to load a pulsar's tim/par files, providing Python access to the TOAs, the residuals, the timing-model parameters, the fit procedure, and more.

[ascl:2209.018] libTheSky: Compute positions of celestial bodies and events

libTheSky compute the positions of celestial bodies, such as the Moon, planets, and stars, and events, including conjunctions and eclipses, with great accuracy. Written in Fortran, libTheSky can use different reference frames (heliocentric, geocentric, topocentric) and coordinate systems (ecliptic, equatorial, galactic; spherical, rectangular), and the user can choose low- or high-accuracy calculations, depending on need.

[ascl:2012.008] LIFELINE: LIne proFiles in massivE coLliding wInd biNariEs

LIFELINE (LIne proFiles in massivE coLliding wInd biNariEs) simulates the X-ray lines profile in colliding wind binaries. The code is self-consistent and computes the distribution of the wind velocity, the characterization of the wind shock region, and the line profile. In addition to perform the overall computation, LIFELINE can use a pre-computed velocity distribution to compute the shock characteristics and the line profile, or use pre-computed shock characteristics and velocity distributions to compute only the line profile.

[ascl:2107.001] light-curve: Light curve analysis toolbox

light-curve implements the extraction of numerous light curve features suitable for processing alert and archival data for the current ZTF and future Vera Rubin Observatory LSST photometric surveys. These high-performance irregular time series processing tools are written in Rust and Python.

[ascl:2102.006] Lightbeam: Simulate light through weakly-guiding waveguides

Lightbeam simulates the 3D propagation of light through waveguides of arbitrary geometries. This code package is based off of the finite-differences beam propagation method, and employs a transverse adaptive mesh for extra computational efficiency. Also included are tools to simulate adaptive optics systems for use in conjunction with waveguides, useful in astronomical contexts for simulating coupling devices which transfer telescope light to the science instrument.

[ascl:1403.004] Lightcone: Light-cone generating script

Lightcone works with simulated galaxy data stored in a relational database to rearrange the data in a shape of a light-cone; simulated galaxy data is expected to be in a box volume. The light-cone constructing script works with output from the SAGE semi-analytic model (ascl:1601.006), but will work with any other model that has galaxy positions (and other properties) saved per snapshots of the simulation volume distributed in time. The database configuration file is set up for PostgreSQL RDBMS, but can be modified for use with any other SQL database.

[ascl:1408.012] LightcurveMC: An extensible lightcurve simulation program

LightcurveMC is a versatile and easily extended simulation suite for testing the performance of time series analysis tools under controlled conditions. It is designed to be highly modular, allowing new lightcurve types or new analysis tools to be introduced without excessive development overhead. The statistical tools are completely agnostic to how the lightcurve data is generated, and the lightcurve generators are completely agnostic to how the data will be analyzed. The use of fixed random seeds throughout guarantees that the program generates consistent results from run to run.

LightcurveMC can generate periodic light curves having a variety of shapes and stochastic light curves having a variety of correlation properties. It features two error models (Gaussian measurement and signal injection using a randomized sample of base light curves), testing of C1 shape statistic, periodograms, ΔmΔt plots, autocorrelation function plots, peak-finding plots, and Gaussian process regression. The code is written in C++ and R.

[ascl:1812.013] Lightkurve: Kepler and TESS time series analysis in Python

Lightkurve analyzes astronomical flux time series data, in particular the pixels and light curves obtained by NASA’s Kepler, K2, and TESS exoplanet missions. This community-developed Python package is designed to be user friendly to lower the barrier for students, astronomers, and citizen scientists interested in analyzing data from these missions. Lightkurve provides easy tools to download, inspect, and analyze time series data and its documentation is supported by a large syllabus of tutorials.

[ascl:1711.009] Lightning: SED Fitting Package

Lightning is a spectral energy distribution (SED) fitting procedure that quickly and reliably recovers star formation history (SFH) and extinction parameters. The SFH is modeled as discrete steps in time. The code consists of a fully vectorized inversion algorithm to determine SFH step intensities and combines this with a grid-based approach to determine three extinction parameters.

[ascl:1906.007] limb-darkening: Limb-darkening coefficients generator

Limb-darkening generates limb-darkening coefficients from ATLAS and PHOENIX model atmospheres using arbitrary response functions. The code uses PyFITS (ascl:1207.009) and has several other dependencies, and produces a folder of results with descriptions of the columns contained in each file.

[ascl:2312.017] LimberJack.jl: Auto-differentiable methods for cosmology

LimberJack.jl performs cosmological analyses of 2 point auto- and cross-correlation measurements from galaxy clustering, CMB lensing and weak lensing data. Written in Julia, it obtains gradients for its outputs faster than traditional finite difference methods, making the code greatly synergistic with gradient-based sampling methods such as Hamiltonian Monte Carlo. LimberJack.jl can efficiently exploring parameter spaces with hundreds of dimensions.

[ascl:1107.012] LIME: Flexible, Non-LTE Line Excitation and Radiation Transfer Method for Millimeter and Far-infrared Wavelengths

LIME solves the molecular and atomic excitation and radiation transfer problem in a molecular gas and predicting emergent spectra. The code works in arbitrary three dimensional geometry using unstructured Delaunay latices for the transport of photons. Various physical models can be used as input, ranging from analytical descriptions over tabulated models to SPH simulations. To generate the Delaunay grid we sample the input model randomly, but weigh the sample probability with the molecular density and other parameters, and thereby we obtain an average grid point separation that scales with the local opacity. Slow convergence of opaque models becomes traceable; when convergence between the level populations, the radiation field, and the point separation has been obtained, the grid is ray-traced to produced images that can readily be compared to observations. LIME is particularly well suited for modeling of ALMA data because of the high dynamic range in scales that can be resolved using this type of grid, and can furthermore deal with overlapping lines of multiple molecular and atomic species.

[ascl:1710.023] LIMEPY: Lowered Isothermal Model Explorer in PYthon

LIMEPY solves distribution function (DF) based lowered isothermal models. It solves Poisson's equation used on input parameters and offers fast solutions for isotropic/anisotropic, single/multi-mass models, normalized DF values, density and velocity moments, projected properties, and generates discrete samples.

[ascl:2307.042] LIMpy: Line Intensity Mapping in Python

LIMpy models and analyzes multi-line intensity maps of CII (158 µ), OIII (88 µ), and CO (1-0) to CO (13-12) transitions. It can be used as an analytic model for star formation rate, to simulate line intensity maps based on halo catalogs, and to calculate the power spectrum from simulated maps and the cross-correlated signal between two separate lines. Among other things, LIMpy can also create multi-line luminosity models and determine the multi-line intensity power spectrum.

[ascl:2303.002] line_selections: Automatic line detection for large spectroscopic surveys

The Python code line_selections reads synthetic "full" spectra and elemental spectra, automatically identifies the detectable lines at a given resolution (provided the linelist used to compute the spectra), and returns a table containing various properties of the lines (e.g., purity, central wavelength, and depth). The code then stores the information in a pandas DataFrame. line_selections demonstrates where chemical information is present in a stellar spectrum, and allows the user to optimize observational strategies, such as choosing resolution and spectra windows, as well as analysis codes with the application of high-quality masks.

[ascl:2007.012] Line-Stacker: Spectral lines stacking

Line-Stacker stacks both 3D cubes or already extracted spectra and is an extension of Stacker (ascl:1912.019). It is an ensemble of both CASA tasks and native python tasks. Line-Stacker supports image stacking and some additional tools, allowing further analysis of the stack product, are also included in the module.

[ascl:2104.027] linemake: Line list generator

linemake generates formatted and curated atomic and molecular line lists suitable for spectral synthesis work. It is lightweight and easy-to-use. The code requires that the requested beginning and ending wavelengths not bridge the divide between two files of atomic line data; in such cases, run the code twice, once on either side of the divide, to generate the desired lists.

[ascl:1504.019] LineProf: Line Profile Indicators

LineProf implements a series of line-profile analysis indicators and evaluates its correlation with RV data. It receives as input a list of Cross-Correlation Functions and an optional list of associated RV. It evaluates the line-profile according to the indicators and compares it with the computed RV if no associated RV is provided, or with the provided RV otherwise.

[ascl:1602.006] LIRA: LInear Regression in Astronomy

LIRA (LInear Regression in Astronomy) performs Bayesian linear regression that accounts for heteroscedastic errors in both the independent and the dependent variables, intrinsic scatters (in both variables), time evolution of slopes, normalization and scatters, Malmquist and Eddington bias, and break of linearity. The posterior distribution of the regression parameters is sampled with a Gibbs method exploiting the JAGS (ascl:1209.002) library.

[ascl:1601.007] LIRA: Low-counts Image Reconstruction and Analysis

LIRA (Low-counts Image Reconstruction and Analysis) deconvolves any unknown sky components, provides a fully Poisson 'goodness-of-fit' for any best-fit model, and quantifies uncertainties on the existence and shape of unknown sky. It does this without resorting to χ2 or rebinning, which can lose high-resolution information. It is written in R and requires the FITSio package.

[ascl:2205.017] LiSA: LIghtweight Source finding Algorithms for analysis of HI spectral data

The LIghtweight Source finding Algorithms (LiSA) library finds HI sources in next generation radio surveys. LiSA can analyze input data cubes of any size with pipelines that automatically decompose data into different domains for parallel distributed analysis. For source finding, the library contains python modules for wavelet denoising of 3D spatial and spectral data, and robust automatic source finding using null-hypothesis testing. The source-finding algorithms all have options to automatically choose parameters, minimizing the need for manual fine tuning. Finally, LiSA also contains neural network architectures for classification and characterization of 3D spectral data.

[ascl:1112.009] LISACode: A scientific simulator of LISA

LISACode is a simulator of the LISA mission. Its ambition is to achieve a new degree of sophistication allowing to map, as closely as possible, the impact of the different subsystems on the measurements. Its also a useful tool for generating realistic data including several kind of sources (Massive Black Hole binaries, EMRIs, cosmic string cusp, stochastic background, etc) and for preparing their analysis. It’s fully integrated to the Mock LISA Data Challenge. LISACode is not a detailed simulator at the engineering level but rather a tool whose purpose is to bridge the gap between the basic principles of LISA and a future, sophisticated end-to-end simulator.

[ascl:1902.005] LiveData: Data reduction pipeline

LiveData is a multibeam single-dish data reduction system for bandpass calibration and gridding. It is used for processing Parkes multibeam and Mopra data.

[ascl:1906.011] Lizard: An extensible Cyclomatic Complexity Analyzer

Lizard is an extensible Cyclomatic Complexity Analyzer for imperative programming languages including C/C++/C#, Python, Java, and Javascript. It counts the nloc (lines of code without comments) and CCN (cyclomatic complexity number), and takes a token count of functions and a parameter count of functions. It also does copy-paste detection (code clone detection/code duplicate detection) and many other forms of static code analysis. Lizard is often used in software-related research and calculates how complex the code looks rather than how complex the code really is; thought it's often very hard to get all the included folders and files right when they are complicated, that accuracy is not needed to determine cyclomatic complexity, which can be useful for measuring the maintainability of a software package.

[ascl:1906.020] LIZARD: Particle initial conditions for cosmological simulations

LIZARD (Lagrangian Initialization of Zeldovich Amplitudes for Resimulations of Displacements) creates particle initial conditions for cosmological simulations using the Zel'dovich approximation for the matter and velocity power spectrum.

[ascl: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: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.

[submitted] loci: Smooth Cubic Multivariate Local Interpolations

loci is a shared library for interpolations in up to 4 dimensions. It is written in C and can be used with C/C++, Python and others. In order to calculate the coefficients of the cubic polynom, only local values are used: The data itself and all combinations of first-order derivatives, i.e. in 2D f_x, f_y and f_xy. This is in contrast to splines, where the coefficients are not calculated using derivatives, but non-local data, which can lead to over-smoothing the result.

[ascl:2004.001] Locus: Optimized differential photometry

Locus implements the Locus Algorithm, which maximizes the performance of differential photometry systems by optimizing the number and quality of reference stars in the Field of View with the target.

[submitted] LOFAR H5plot

Calibration solutions for the LOFAR radio telescope are stored in a 5-dimensional (time, frequency, station, polarisation and direction in the sky) HDF5 table. H5plot is a GUI application focussing on interactive visual inspection of these calibration solutions.

[ascl:2104.030] lofti_gaiaDR2: Orbit fitting with Gaia astrometry

Lofti_gaia fits orbital parameters for one wide stellar binary relative to the other, when both objects are resolved in Gaia DR2. It takes as input only the Gaia DR2 source id of the two components, and their masses. It retrieves the relevant parameters from the Gaia archive, computes observational constraints for them, and fits orbital parameters to those measurements. It assumes the two components are bound in an elliptical orbit.

[ascl:2301.007] LoLLiPoP: Low-L Likelihood Polarized for Planck

LoLLiPoP is a Planck low-l polarization likelihood based on cross-power-spectra for which the bias is zero when the noise is uncorrelated between maps. It uses a modified approximation to apply to cross-power spectra and is interfaced with the Cobaya (ascl:1910.019) MCMC sampler. Cross-spectra are computed on the CMB maps from Commander component separation applied on each detset-split Planck frequency maps.

[ascl:2401.014] LoRD: Locate Reconnection Distribution

LoRD (Locate Reconnection Distribution) identifies the locations and structures of 3D magnetic reconnection within discrete magnetic field data. The toolkit contains three main functions; the first, ARD (Analyze Reconnection Distribution) locates the grids undergoing reconnection without null points and also recognizes the local configurations of reconnection sites. ANP (Analyze Null Points) locates and classifies the 3D null points, and APNP (Analyze Projected Null Points) analyzes the 2D neutral points projected on a plane near a cell. LoRD is written in Matlab and the toolkit contains demo scripts.

[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:2401.006] LoSoTo: LOFAR solutions tool

LoSoTo (LOFAR Solution Tool) performs a variety of operations on H5parm data, which is based on the HDF5 format; it isolates direction independent systematic effects and can therefore be transferred to the target field. Subsets of data can be selected for each operation using lists of axes values, regular expressions, or intervals. The LoSoTo package stores solutions in arrays organized in a hierarchical fashion; this provides flexibility and preserves performance. The code can, for example, extract Faraday rotation from RR/LL phase solutions or a rotation matrix, clip solutions around the median, and calculate the ionospheric structure function. LoSoTo includes an outlier flagging procedure, normalizes solutions to a given value, and offers an advanced plotting routine, and many other operations.

[ascl:1309.003] LOSP: Liège Orbital Solution Package

LOSP is a FORTRAN77 numerical package that computes the orbital parameters of spectroscopic binaries. The package deals with SB1 and SB2 systems and is able to adjust either circular or eccentric orbits through a weighted fit.

[ascl:1308.002] LOSSCONE: Capture rates of stars by a supermassive black hole

LOSSCONE computes the rates of capture of stars by supermassive black holes. It uses a stationary and time-dependent solutions for the Fokker-Planck equation describing the evolution of the distribution function of stars due to two-body relaxation, and works for arbitrary spherical and axisymmetric galactic models that are provided by the user in the form of M(r), the cumulative mass as a function of radius.

[ascl:2207.017] LOTUS: 1D Non-LTE stellar parameter determination via Equivalent Width method

LOTUS (non-LTE Optimization Tool Utilized for the derivation of atmospheric Stellar parameters) derives stellar parameters via Equivalent Width (EW) method with the assumption of 1D non-local thermodynamic equilibrium. It mainly applies on the spectroscopic data from high resolution spectral survey. It can provide extremely accurate measurement of stellar parameters compared with non-spectroscopic analysis from benchmark stars. LOTUS provides a fast optimizer for obtaining stellar parameters based on Differential Evolution algorithm, well constrained uncertainty of derived stellar parameters from slice-sampling MCMC from PyMC3 (ascl:1610.016), and can interpolate the Curve of Growth from theoretical EW grid under the assumptions of LTE and Non-LTE. It also visualizes excitation and ionization balance when at the optimal combination of stellar parameters.

[ascl:1010.038] Low Resolution Spectral Templates For AGNs and Galaxies From 0.03 -- 30 microns

We present a set of low resolution empirical SED templates for AGNs and galaxies in the wavelength range from 0.03 to 30 microns based on the multi-wavelength photometric observations of the NOAO Deep-Wide Field Survey Bootes field and the spectroscopic observations of the AGN and Galaxy Evolution Survey. Our training sample is comprised of 14448 galaxies in the redshift range 0<~z<~1 and 5347 likely AGNs in the range 0<~z<~5.58. We use our templates to determine photometric redshifts for galaxies and AGNs. While they are relatively accurate for galaxies, their accuracies for AGNs are a strong function of the luminosity ratio between the AGN and galaxy components. Somewhat surprisingly, the relative luminosities of the AGN and its host are well determined even when the photometric redshift is significantly in error. We also use our templates to study the mid-IR AGN selection criteria developed by Stern et al.(2005) and Lacy et al.(2004). We find that the Stern et al.(2005) criteria suffers from significant incompleteness when there is a strong host galaxy component and at z =~ 4.5, when the broad Halpha emission line is redshifted into the [3.6] band, but that it is little contaminated by low and intermediate redshift galaxies. The Lacy et al.(2004) criterion is not affected by incompleteness at z =~ 4.5 and is somewhat less affected by strong galaxy host components, but is heavily contaminated by low redshift star forming galaxies. Finally, we use our templates to predict the color-color distribution of sources in the upcoming WISE mission and define a color criterion to select AGNs analogous to those developed for IRAC photometry. We estimate that in between 640,000 and 1,700,000 AGNs will be identified by these criteria, but will have serious completeness problems for z >~ 3.4.

[ascl:1501.007] LP-VIcode: La Plata Variational Indicators Code

LP-VIcode computes variational chaos indicators (CIs) quickly and easily. The following CIs are included:

  • Lyapunov Indicators, also known as Lyapunov Characteristic Exponents, Lyapunov Characteristic Numbers or Finite Time Lyapunov Characteristic Numbers (LIs)
  • Mean Exponential Growth factor of Nearby Orbits (MEGNO)
  • Slope Estimation of the largest Lyapunov Characteristic Exponent (SElLCE)
  • Smaller ALignment Index (SALI)
  • Generalized ALignment Index (GALI)
  • Fast Lyapunov Indicator (FLI)
  • Orthogonal Fast Lyapunov Indicator (OFLI)
  • Spectral Distance (SD)
  • dynamical Spectra of Stretching Numbers (SSNs)
  • Relative Lyapunov Indicator (RLI)

[ascl:2103.015] LPF: Real-time detection of transient sources in radio data streams

LPF (Live Pulse Finder) provides real-time automated analysis of the radio image data stream at multiple frequencies. The fully automated GPU-based machine-learning backed pipeline performs source detection, association, flux measurement and physical parameter inference. At the end of the pipeline, an alert of a significant detection of a transient event can be sent out and the data saved for further investigation.

[ascl:1902.002] LPNN: Limited Post-Newtonian N-body code for collisionless self-gravitating systems

The Limited Post-Newtonian N-body code (LPNN) simulates post-Newtonian interactions between a massive object and many low-mass objects. The interaction between one massive object and low-mass objects is calculated by post-Newtonian approximation, and the interaction between low-mass objects is calculated by Newtonian gravity. This code is based on the sticky9 code, and can be accelerated with the use of GPU in a CUDA (version 4.2 or earlier) environment.

[ascl:1306.012] LRG DR7 Likelihood Software

This software computes likelihoods for the Luminous Red Galaxies (LRG) data from the Sloan Digital Sky Survey (SDSS). It includes a patch to the existing CAMB software (ascl:1102.026; the February 2009 release) to calculate the theoretical LRG halo power spectrum for various models. The code is written in Fortran 90 and has been tested with the Intel Fortran 90 and GFortran compilers.

[ascl:1602.005] LRGS: Linear Regression by Gibbs Sampling

LRGS (Linear Regression by Gibbs Sampling) implements a Gibbs sampler to solve the problem of multivariate linear regression with uncertainties in all measured quantities and intrinsic scatter. LRGS extends an algorithm by Kelly (2007) that used Gibbs sampling for performing linear regression in fairly general cases in two ways: generalizing the procedure for multiple response variables, and modeling the prior distribution of covariates using a Dirichlet process.

[ascl:1807.033] LSC: Supervised classification of time-series variable stars

LSC (LINEAR Supervised Classification) trains a number of classifiers, including random forest and K-nearest neighbor, to classify variable stars and compares the results to determine which classifier is most successful. Written in R, the package includes anomaly detection code for testing the application of the selected classifier to new data, thus enabling the creation of highly reliable data sets of classified variable stars.

[ascl:1209.003] LSD: Large Survey Database framework

The Large Survey Database (LSD) is a Python framework and DBMS for distributed storage, cross-matching and querying of large survey catalogs (>10^9 rows, >1 TB). The primary driver behind its development is the analysis of Pan-STARRS PS1 data. It is specifically optimized for fast queries and parallel sweeps of positionally and temporally indexed datasets. It transparently scales to more than >10^2 nodes, and can be made to function in "shared nothing" architectures.

[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:1505.012] LSSGALPY: Visualization of the large-scale environment around galaxies on the 3D space

LSSGALPY provides visualization tools to compare the 3D positions of a sample (or samples) of isolated systems with respect to the locations of the large-scale structures galaxies in their local and/or large scale environments. The interactive tools use different projections in the 3D space (right ascension, declination, and redshift) to study the relation of the galaxies with the LSS. The tools permit visualization of the locations of the galaxies for different values of redshifts and redshift ranges; the relationship of isolated galaxies, isolated pairs, and isolated triplets to the galaxies in the LSS can be visualized for different values of the declinations and declination ranges.

[ascl:1312.006] LTL: The Little Template Library

LTL provides dynamic arrays of up to 7-dimensions, subarrays and slicing, support for fixed-size vectors and matrices including basic linear algebra operations, expression templates-based evaluation, and I/O facilities for ascii and FITS format files. Utility classes for command-line processing and configuration-file processing are provided as well.

[ascl:1404.001] LTS_LINEFIT & LTS_PLANEFIT: LTS fit of lines or planes

LTS_LINEFIT and LTS_PLANEFIT are IDL programs to robustly fit lines and planes to data with intrinsic scatter. The code combines the Least Trimmed Squares (LTS) robust technique, proposed by Rousseeuw (1984) and optimized in Rousseeuw & Driessen (2006), into a least-squares fitting algorithm which allows for intrinsic scatter. This method makes the fit converge to the correct solution even in the presence of a large number of catastrophic outliers, where the much simpler σ-clipping approach can converge to the wrong solution. The code is also available in Python as ltsfit.

[ascl:1201.016] LumFunc: Luminosity Function Modeling

LumFunc is a numerical code to model the Luminosity Function based on central galaxy luminosity-halo mass and total galaxy luminosity-halo mass relations. The code can handle rest b_J-band (2dFGRS), r'-band (SDSS), and K-band luminosities, and any redshift with redshift dependences specified by the user. It separates the luminosity function (LF) to conditional luminosity functions, LF as a function of halo mass, and also to galaxy types. By specifying a narrow mass range, the code will return the conditional luminosity functions. The code returns luminosity functions for galaxy types as well (broadly divided to early-type and late-type). The code also models the cluster luminosity function, either mass averaged or for individual clusters.

[ascl:2401.003] LUNA: Forward model luna simulator

LUNA generates dynamically accurate lightcurves from a planet-moon pair, analytically accounting for shadow overlaps, stellar limb darkening, and planet-moon dynamical motion. The code takes transit timing/duration variations and ingress/egress asymmetries into consideration not only for the planet, but also the moon. LUNA was designed to be analytical and dynamical and to incorporate limb darkening (including non-linear laws) and account for all orbital elements, including eccentricity and longitude of the ascending node. Because the software is precise and analytic, LUNA is a highly potent tool for exomoon detection.

[ascl:1803.012] LWPC: Long Wavelength Propagation Capability

Long Wavelength Propagation Capability (LWPC), written as a collection of separate programs that perform unique actions, generates geographical maps of signal availability for coverage analysis. The program makes it easy to set up these displays by automating most of the required steps. The user specifies the transmitter location and frequency, the orientation of the transmitting and receiving antennae, and the boundaries of the operating area. The program automatically selects paths along geographic bearing angles to ensure that the operating area is fully covered. The diurnal conditions and other relevant geophysical parameters are then determined along each path. After the mode parameters along each path are determined, the signal strength along each path is computed. The signal strength along the paths is then interpolated onto a grid overlying the operating area. The final grid of signal strength values is used to display the signal-strength in a geographic display. The LWPC uses character strings to control programs and to specify options. The control strings have the same meaning and use among all the programs.

[ascl:2312.005] LyaCoLoRe: Generate simulated Lyman alpha forest spectra

LyaCoLoRe uses CoLoRe (ascl:2111.009) simulations to generate simulated Lyman alpha forest spectra. The code takes the output files from CoLoRe as an input, carries out several stages of processing, and produces realistic skewers of transmitted flux fraction as an output. The repository includes tools to tune the parameters within LyaCoLoRe's transformation, and to measure the 1D power spectrum of output skewers quickly.

[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:2212.019] m2mcluster: Star clusters made-to-measure modeling

m2mcluster performs made-to-measure modeling of star clusters, and can fit target observations of a Galactic globular cluster's 3D density profile and individual kinematic properties, including proper motion velocity dispersion, and line of sight velocity dispersion. The code uses AMUSE (ascl:1107.007) to model the gravitational N-body evolution of the system between time steps; GalPy (ascl:1411.008) is also required.

[ascl:1407.005] MAAT: MATLAB Astronomy and Astrophysics Toolbox

The MATLAB Astronomy and Astrophysics Toolbox (MAAT) is a collection of software tools and modular functions for astronomy and astrophysics written in the MATLAB environment. It includes over 700 MATLAB functions and a few tens of data files and astronomical catalogs. The scripts cover a wide range of subjects including: astronomical image processing, ds9 control, astronomical spectra, optics and diffraction phenomena, catalog retrieval and searches, celestial maps and projections, Solar System ephemerides, planar and spherical geometry, time and coordinates conversion and manipulation, cosmology, gravitational lensing, function fitting, general utilities, plotting utilities, statistics, and time series analysis.

[ascl:1209.006] macula: Rotational modulations in the photometry of spotted stars

Photometric rotational modulations due to starspots remain the most common and accessible way to study stellar activity. Modelling rotational modulations allows one to invert the observations into several basic parameters, such as the rotation period, spot coverage, stellar inclination and differential rotation rate. The most widely used analytic model for this inversion comes from Budding (1977) and Dorren (1987), who considered circular, grey starspots for a linearly limb darkened star. That model is extended to be more suitable in the analysis of high precision photometry such as that by Kepler. Macula, a Fortran 90 code, provides several improvements, such as non-linear limb darkening of the star and spot, a single-domain analytic function, partial derivatives for all input parameters, temporal partial derivatives, diluted light compensation, instrumental offset normalisations, differential rotation, starspot evolution and predictions of transit depth variations due to unocculted spots. The inclusion of non-linear limb darkening means macula has a maximum photometric error an order-of-magnitude less than that of Dorren (1987) for Sun-like stars observed in the Kepler-bandpass. The code executes three orders-of-magnitude faster than comparable numerical codes making it well-suited for inference problems.

[ascl:1306.010] MADCOW: Microwave Anisotropy Dataset Computational softWare

MADCOW is a set of parallelized programs written in ANSI C and Fortran 77 that perform a maximum likelihood analysis of visibility data from interferometers observing the cosmic microwave background (CMB) radiation. This software has been used to produce power spectra of the CMB with the Very Small Array (VSA) telescope.

[ascl:2302.019] MADCUBA: MAdrid Data CUBe Analysis

MADCUBA analyzes astronomical datacubes and multiple spectra from various astronomical facilities, including ALMA, Herschel, VLA, IRAM 30m, APEX, GBT, and others. These telescopes, and in particular ALMA, generate extremely large datacubes (spatial, spectral and polarization). This software combines a user-friendly interface and powerful data analysis system to derive the physical conditions of molecular gas, its chemical complexity and the kinematics from datacubes. Built using the ImageJ (ascl:1206.013) infrastructure, MADCUBA visualizes astronomical datacubes with thousands on spectral channels, and datasets with thousands of spectra; it also identifies molecular species using publicly available molecular catalogs. It can automatically derive the physical parameters of the molecular species: column density, excitation temperature, velocity and linewidths and provides the best non-linear least-squared fit using the Levenberg-Marquardt algorithm, among other tasks.

[ascl:1712.012] MadDM: Computation of dark matter relic abundance

MadDM computes dark matter relic abundance and dark matter nucleus scattering rates in a generic model. The code is based on the existing MadGraph 5 architecture and as such is easily integrable into any MadGraph collider study. A simple Python interface offers a level of user-friendliness characteristic of MadGraph 5 without sacrificing functionality. MadDM is able to calculate the dark matter relic abundance in models which include a multi-component dark sector, resonance annihilation channels and co-annihilations. The direct detection module of MadDM calculates spin independent / spin dependent dark matter-nucleon cross sections and differential recoil rates as a function of recoil energy, angle and time. The code provides a simplified simulation of detector effects for a wide range of target materials and volumes.

[ascl:2009.009] MADHAT: Gamma-ray emission analyzer

MADHAT (Model-Agnostic Dark Halo Analysis Tool) analyzes gamma-ray emission from dwarf satellite galaxies and dwarf galaxy candidates due to dark matter annihilation, dark matter decay, or other nonstandard or unknown astrophysics. The tool is data-driven and model-independent, and provides statistical upper bounds on the number of observed photons in excess of the number expected using a stacked analysis of any selected set of dwarf targets. MADHAT also calculates the resulting bounds on the properties of dark matter under any assumptions the user makes regarding dark sector particle physics or astrophysics.

[ascl:2012.010] MADLens: Differentiable lensing simulator

MADLens produces non-Gaussian cosmic shear maps at arbitrary source redshifts. A MADLens simulation with only 256^3 particles produces convergence maps whose power agree with theoretical lensing power spectra up to scales of L=10000. The code is based on a highly parallelizable particle-mesh algorithm and employs a sub-evolution scheme in the lensing projection and a machine-learning inspired sharpening step to achieve these high accuracies.

[ascl:1110.018] MADmap: Fast Parallel Maximum Likelihood CMB Map Making Code

MADmap produces maximum-likelihood images of the sky from time-ordered data which include correlated noise, such as those gathered by Cosmic Microwave Background (CMB) experiments. It works efficiently on platforms ranging from small workstations to the most massively parallel supercomputers. Map-making is a critical step in the analysis of all CMB data sets, and the maximum-likelihood approach is the most accurate and widely applicable algorithm; however, it is a computationally challenging task. This challenge will only increase with the next generation of ground-based, balloon-borne and satellite CMB polarization experiments. The faintness of the B-mode signal that these experiments seek to measure requires them to gather enormous data sets. MADmap has the ability to address problems typically encountered in the analysis of realistic CMB data sets. The massively parallel and distributed implementation is detailed and scaling complexities are given for the resources required. MADmap is capable of analyzing the largest data sets now being collected on computing resources currently available.

[ascl:2206.018] MADYS: Isochronal parameter determination for young stellar and substellar objects

MADYS (Manifold Age Determination for Young Stars) determines the age and mass of young stellar and substellar objects. The code automatically retrieves and cross-matches photometry from several catalogs, estimates interstellar extinction, and derives age and mass estimates for individual objects through isochronal fitting. MADYS harmonizes the heterogeneity of publicly-available isochrone grids and the user can choose amongst several models, some of which have customizable astrophysical parameters. Particular attention has been dedicated to the categorization of these models, labeled through a four-level taxonomical classification.

[ascl:2205.005] maelstrom: Forward modeling of pulsating stars in binaries

maelstrom models binary orbits through the phase modulation technique. This set of custom PyMC3 models and solvers fit each individual datapoint in the time series by forward modeling the time delay onto the light curve. This approach fully captures variations in a light curve caused by an orbital companion.

[ascl:1010.044] MAESTRO: An Adaptive Low Mach Number Hydrodynamics Algorithm for Stellar Flows

MAESTRO, a low Mach number stellar hydrodynamics code, simulates long-time, low-speed flows that would be prohibitively expensive to model using traditional compressible codes. MAESTRO is based on an equation set derived using low Mach number asymptotics; this equation set does not explicitly track acoustic waves and thus allows a significant increase in the time step. MAESTRO is suitable for two- and three-dimensional local atmospheric flows as well as three-dimensional full-star flows, and adaptive mesh refinement (AMR) has been incorporated into the code. The expansion of the base state for full-star flows using a novel mapping technique between the one-dimensional base state and the Cartesian grid is also available.

NOTE: MAESTRO is no longer being actively developed. Users should switch to MAESTROeX (ascl:1908.019) to take advantage of the latest capabilities.

[ascl:1908.019] MAESTROeX: Low Mach number stellar hydrodynamics code

MAESTROeX solves the equations of low Mach number hydrodynamics for stratified atmospheres or stars with a general equation of state. It includes reactions and thermal diffusion and can be used on anything from a single core to 100,000s of processor cores with MPI + OpenMP. MAESTROeX maintains the accuracy of its predecessor MAESTRO (ascl:1010.044) while taking advantage of a simplified temporal integration scheme and leveraging the AMReX software framework for block-structured adaptive mesh refinement (AMR) applications.

[ascl:2007.015] MAGI: Initial-condition generator for galactic N-body simulations

MAGI (MAny-component Galaxy Initializer) generates initial conditions for numerical simulations of galaxies that resemble observed galaxies and are dynamically stable for time-scales longer than their characteristic dynamical times, taking into account galaxy bulges, discs, and haloes. MAGI adopts a distribution-function-based method and supports various kinds of density models, including custom-tabulated inputs and the presence of more than one disc, and is fast and easy to use.

[ascl:1709.010] MagIC: Fluid dynamics in a spherical shell simulator

MagIC simulates fluid dynamics in a spherical shell. It solves for the Navier-Stokes equation including Coriolis force, optionally coupled with an induction equation for Magneto-Hydro Dynamics (MHD), a temperature (or entropy) equation and an equation for chemical composition under both the anelastic and the Boussinesq approximations. MagIC uses either Chebyshev polynomials or finite differences in the radial direction and spherical harmonic decomposition in the azimuthal and latitudinal directions. The time-stepping scheme relies on a semi-implicit Crank-Nicolson for the linear terms of the MHD equations and a Adams-Bashforth scheme for the non-linear terms and the Coriolis force.

[ascl:1604.004] magicaxis: Pretty scientific plotting with minor-tick and log minor-tick support

The R suite magicaxis makes useful and pretty plots for scientific plotting and includes functions for base plotting, with particular emphasis on pretty axis labelling in a number of circumstances that are often used in scientific plotting. It also includes functions for generating images and contours that reflect the 2D quantile levels of the data designed particularly for output of MCMC posteriors where visualizing the location of the 68% and 95% 2D quantiles for covariant parameters is a necessary part of the post MCMC analysis, can generate low and high error bars, and allows clipping of values, rejection of bad values, and log stretching.

[ascl:1303.009] MAGIX: Modeling and Analysis Generic Interface for eXternal numerical codes

MAGIX provides an interface between existing codes and an iterating engine that minimizes deviations of the model results from available observational data; it constrains the values of the model parameters and provides corresponding error estimates. Many models (and, in principle, not only astrophysical models) can be plugged into MAGIX to explore their parameter space and find the set of parameter values that best fits observational/experimental data. MAGIX complies with the data structures and reduction tools of Atacama Large Millimeter Array (ALMA), but can be used with other astronomical and with non-astronomical data.

[ascl:2003.002] MAGNETAR: Histogram of relative orientation calculator for MHD observations

MAGNETAR is a set of tools for the study of the magnetic field in simulations of MHD turbulence and polarization observations. It calculates the histogram of relative orientation between density structure in the magnetic field in data cubes from simulations of MHD turbulence and observations of polarization using the method of histogram of relative orientations (HRO).

[ascl:1010.054] MagnetiCS.c: Cosmic String Loop Evolution and Magnetogenesis

Large-scale coherent magnetic fields are observed in galaxies and clusters, but their ultimate origin remains a mystery. We reconsider the prospects for primordial magnetogenesis by a cosmic string network. We show that the magnetic flux produced by long strings has been overestimated in the past, and give improved estimates. We also compute the fields created by the loop population, and find that it gives the dominant contribution to the total magnetic field strength on present-day galactic scales. We present numerical results obtained by evolving semi-analytic models of string networks (including both one-scale and velocity-dependent one-scale models) in a Lambda-CDM cosmology, including the forces and torques on loops from Hubble redshifting, dynamical friction, and gravitational wave emission. Our predictions include the magnetic field strength as a function of correlation length, as well as the volume covered by magnetic fields. We conclude that string networks could account for magnetic fields on galactic scales, but only if coupled with an efficient dynamo amplification mechanism.

[ascl:2008.011] Magnetizer: Computing magnetic fields of evolving galaxies

Magnetizer computes time and radial dependent magnetic fields for a sample of galaxies in the output of a semi-analytic model of galaxy formation. The magnetic field is obtained by numerically solving the galactic dynamo equations throughout history of each galaxy. Stokes parameters and Faraday rotation measure can also be computed along a random line-of-sight for each galaxy.

[ascl:1502.014] Magnetron: Fitting bursts from magnetars

Magnetron, written in Python, decomposes magnetar bursts into a superposition of small spike-like features with a simple functional form, where the number of model components is itself part of the inference problem. Markov Chain Monte Carlo (MCMC) sampling and reversible jumps between models with different numbers of parameters are used to characterize the posterior distributions of the model parameters and the number of components per burst.

[ascl:1106.010] MAGPHYS: Multi-wavelength Analysis of Galaxy Physical Properties

MAGPHYS is a self-contained, user-friendly model package to interpret observed spectral energy distributions of galaxies in terms of galaxy-wide physical parameters pertaining to the stars and the interstellar medium. MAGPHYS is optimized to derive statistical constraints of fundamental parameters related to star formation activity and dust content (e.g. star formation rate, stellar mass, dust attenuation, dust temperatures) of large samples of galaxies using a wide range of multi-wavelength observations. A Bayesian approach is used to interpret the SEDs all the way from the ultraviolet/optical to the far-infrared.

[ascl:2310.006] MAGPy-RV: Gaussian Process regression pipeline with MCMC parameter searching

MAGPy-RV (Modelling stellar Activity with Gaussian Processes in Radial Velocity) models data with Gaussian Process regression and affine invariant Monte Carlo Markov Chain parameter searching. Developed to model intrinsic, quasi-periodic variations induced by the host star in radial velocity (RV) surveys for the detection of exoplanets and the accurate measurements of their orbital parameters and masses, it now includes a variety of kernels and models and can be applied to any timeseries analysis. MAGPy-RV includes publication level plotting, efficient posterior extraction, and export-ready LaTeX results tables. It also handles multiple datasets at once and can model offsets and systematics from multiple instruments. MAGPy-RV requires no external dependencies besides basic python libraries and corner (ascl:1702.002).

[ascl:2203.024] Magrathea-Pathfinder: 3D AMR ray-tracing in simulations

Magrathea-Pathfinder propagates photons within cosmological simulations to construct observables. This high-performance framework uses a 3D Adaptive-Mesh Refinement and is built on top of the MAGRATHEA metalibrary (ascl:2203.023).

[ascl:2203.023] MAGRATHEA: Multi-processor Adaptive Grid Refinement Analysis for THEoretical Astrophysics

MAGRATHEA (Multi-processor Adaptive Grid Refinement Analysis for THEoretical Astrophysics) is a foundational cosmological library and a relativistic raytracing code. Classical linear algebra libraries come with their own operations and can be difficult to leverage for new data types. Instead of providing basic types, MAGRATHEA provides tools to generate base types such as scalar quantities, points, vectors, or tensors.

[ascl:2201.012] MAGRATHEA: Planet interior structure code

MAGRATHEA solves planet interiors and considers the case of fully differentiated interiors. The code integrates the hydrostatic equation in order to determine the correct planet radius given the mass in each layer. The code returns the pressure, temperature, density, phase, and radius at steps of enclosed mass. The code support four layers: core, mantle, hydrosphere, and atmosphere. Each layer has a phase diagram with equations of state chosen for each phase.

[ascl:2012.025] Magritte: 3D radiative transfer library

Magritte performs 3D radiative transfer modeling; though focused on astrophysics and cosmology, the techniques can also be applied more generally. The code uses a deterministic ray-tracer with a formal solver that currently focuses on line radiative transfer. Magritte can either be used as a C++ library or as a Python package.

[ascl:1307.009] MAH: Minimum Atmospheric Height

MAH calculates the posterior distribution of the "minimum atmospheric height" (MAH) of an exoplanet by inputting the joint posterior distribution of the mass and radius. The code collapses the two dimensions of mass and radius into a one dimensional term that most directly speaks to whether the planet has an atmosphere or not. The joint mass-radius posteriors derived from a fit of some exoplanet data (likely using MCMC) can be used by MAH to evaluate the posterior distribution of R_MAH, from which the significance of a non-zero R_MAH (i.e. an atmosphere is present) is calculated.

[ascl:2106.011] MakeCloud: Turbulent GMC initial conditions for GIZMO

MakeCloud makes turbulent giant molecular cloud (GMC) initial conditions for GIZMO (ascl:1410.003). It generates turbulent velocity fields on the fly and stores that data in a user-specified path for efficiency. The code is flexible, allowing the user control through various parameters, including the radius of the cloud, number of gas particles, type of initial turbulent velocity (Gaussian or full), and magnetic energy as a fraction of the binding energy, among other options. With an additional file, it can also create glassy initial conditions.

[ascl:1502.021] MaLTPyNT: Quick look timing analysis for NuSTAR data

MaLTPyNT (Matteo's Libraries and Tools in Python for NuSTAR Timing) provides a quick-look timing analysis of NuSTAR data, properly treating orbital gaps and exploiting the presence of two independent detectors by using the cospectrum as a proxy for the power density spectrum. The output of the analysis is a cospectrum, or a power density spectrum, that can be fitted with XSPEC (ascl:9910.005) or ISIS (ascl:1302.002). The software also calculates time lags. Though written for NuSTAR data, MaLTPyNT can also perform standard spectral analysis on X-ray data from other satellite such as XMM-Newton and RXTE.

[submitted] MALU IFS visualisation tool

MALU visualizes integral field spectroscopy (IFS) data such as CALIFA, MANGA, SAMI or MUSE data producing fully interactive plots. The tool is not specific to any instrument. It is available in Python and no installation is required.

[ascl:2203.020] MAMPOSSt: Mass/orbit modeling of spherical systems

MAMPOSSt (Modeling Anisotropy and Mass Profiles of Observed Spherical Systems) is a Bayesian code to perform mass/orbit modeling of spherical systems. It determines marginal parameter distributions and parameter covariances of parametrized radial distributions of dark or total matter, as well as the mass of a possible central black hole, and the radial profiles of density and velocity anisotropy of one or several tracer components, all of which are jointly fit to the discrete data in projected phase space. It is based upon the MAMPOSSt likelihood function for the distribution of individual tracers in projected phase space (projected radius and line-of-sight velocity) and the CosmoMC Markov Chain Monte Carlo code (ascl:1106.025), run in generic mode. MAMPOSSt is not based on the 6D distribution function (which would require triple integrals), but on the assumption that the local 3D velocity distribution is an (anisotropic) Gaussian (requiring only a single integral).

[ascl:2106.010] Maneage: Managing data lineage

The Maneage (Managing data lineage; ending pronounced like "lineage") framework produces fully reproducible computational research. It provides full control on building the necessary software environment from a low-level C compiler, the shell and LaTeX, all the way up to the high-level science software in languages such as Python without a third-party package manager. Once the software environment is built, adding analysis steps is as easy as defining "Make" rules to allow parallelized operations, and not repeating operations that do not need to be recreated. Make provides control over data provenance. A Maneage'd project also contains the narrative description of the project in LaTeX, which helps prepare the research for publication. All results from the analysis are passed into the report through LaTeX macros, allowing immediate dynamic updates to the PDF paper when any part of the analysis has changed. All information is stored in plain text and is version-controlled in Git. Maneage itself is actually a Git branch; new projects start by defining a new Git branch over it and customizing it for a new project. Through Git merging of branches, it is possible to import infrastructure updates to projects.

[ascl:2203.017] MaNGA-DAP: MaNGA Data Analysis Pipeline

The MaNGA data analysis pipeline (MaNGA DAP) analyzes the data produced by the MaNGA data-reduction pipeline (ascl:2203.016) to produced physical properties derived from the MaNGA spectroscopy. All survey-provided properties are currently derived from the log-linear binned datacubes (i.e., the LOGCUBE files).

[ascl:2203.016] MaNGA-DRP: MaNGA Data Reduction Pipeline

The MaNGA Data Reduction Pipeline (DRP) processes the raw data to produce flux calibrated, sky subtracted, coadded data cubes from each of the individual exposures for a given galaxy. The DRP consists of two primary parts: the 2d stage that produces flux calibrated fiber spectra from raw individual exposures, and the 3d stage that combines multiple flux calibrated exposures with astrometric information to produce stacked data cubes. These science-grade data cubes are then processed by the MaNGA Data Analysis Pipeline (ascl:2203.017), which measures the shape and location of various spectral features, fits stellar population models, and performs a variety of other analyses necessary to derive astrophysically meaningful quantities from the calibrated data cubes.

[ascl:1202.005] Mangle: Angular Mask Software

Mangle deals accurately and efficiently with complex angular masks, such as occur typically in galaxy surveys. Mangle performs the following tasks: converts masks between many handy formats (including HEALPix); rapidly finds the polygons containing a given point on the sphere; rapidly decomposes a set of polygons into disjoint parts; expands masks in spherical harmonics; generates random points with weights given by the mask; and implements computations for correlation function analysis. To mangle, a mask is an arbitrary union of arbitrarily weighted angular regions bounded by arbitrary numbers of edges. The restrictions on the mask are only (1) that each edge must be part of some circle on the sphere (but not necessarily a great circle), and (2) that the weight within each subregion of the mask must be constant. Mangle is complementary to and integrated with the HEALPix package (ascl:1107.018); mangle works with vector graphics whereas HEALPix works with pixels.

[ascl:2306.015] Mangrove: Infer galaxy properties using dark matter merger trees

Mangrove uses Graph Neural Networks to regress baryonic properties directly from full dark matter merger trees to infer galaxy properties. The package includes code for preprocessing the merger tree, and training the model can be done either as single experiments or as a sweep. Mangrove provides loss functions, learning rate schedulers, models, and a script for doing the training on a GPU.

[ascl:1305.012] MapCUMBA: Multi-grid map-making algorithm for CMB experiments

The MapCUMBA package applies a multigrid fast iterative Jacobi algorithm for map-making in the context of CMB experiments.

[ascl:1308.003] MapCurvature: Map Projections

MapCurvature, written in IDL, can create map projections with Goldberg-Gott indicatrices. These indicatrices measure the flexion and skewness of a map, and are useful for determining whether features are faithfully reproduced on a particular projection.

[ascl:1306.008] MAPPINGS III: Modelling And Prediction in PhotoIonized Nebulae and Gasdynamical Shocks

MAPPINGS III is a general purpose astrophysical plasma modelling code. It is principally intended to predict emission line spectra of medium and low density plasmas subjected to different levels of photoionization and ionization by shockwaves. MAPPINGS III tracks up to 16 atomic species in all stages of ionization, over a useful range of 102 to 108 K. It treats spherical and plane parallel geometries in equilibrium and time-dependent models. MAPPINGS III is useful for computing models of HI and HII regions, planetary nebulae, novae, supernova remnants, Herbig-Haro shocks, active galaxies, the intergalactic medium and the interstellar medium in general. The present version of MAPPINGS III is a large FORTRAN program that runs with a simple TTY interface for historical and portability reasons. A newer version of this software, MAPPINGS V (ascl:1807.005), is available.

[ascl:1807.005] MAPPINGS V: Astrophysical plasma modeling code

MAPPINGS V is a update of the MAPPINGS code (ascl:1306.008) and provides new cooling function computations for optically thin plasmas based on the greatly expanded atomic data of the CHIANTI 8 database. The number of cooling and recombination lines has been expanded from ~2000 to over 80,000, and temperature-dependent spline-based collisional data have been adopted for the majority of transitions. The expanded atomic data set provides improved modeling of both thermally ionized and photoionized plasmas; the code is now capable of predicting detailed X-ray spectra of nonequilibrium plasmas over the full nonrelativistic temperature range, increasing its utility in cosmological simulations, in modeling cooling flows, and in generating accurate models for the X-ray emission from shocks in supernova remnants.

[ascl:2108.003] MAPS: Multi-frequency Angular Power Spectrum estimator

MAPS (Multi-frequency Angular Power Spectrum) extracts two-point statistical information from Epoch of Reionization (EoR) signals observed in three dimensions, with two directions on the sky and the wavelength (or frequency) constituting the third dimension. Rather than assume that the signal has the same statistical properties in all three directions, as the spherically averaged power spectrum (SAPS) does, MAPS does not make these assumptions, making it more natural for radio interferometric observations than SAPS.

[ascl:2306.011] margarine: Posterior sampling and marginal Bayesian statistics

Margarine computes marginal bayesian statistics given a set of samples from an MCMC or nested sampling run. Specifically, the code calculates marginal Kullback-Leibler divergences and Bayesian dimensionalities using Masked Autoregressive Flows and Kernel Density Estimators to learn and sample posterior distributions of signal subspaces in high dimensional data models, and determines the properties of cosmological subspaces, such as their log-probability densities and how well constrained they are, independent of nuisance parameters. Margarine thus allows for direct and specific comparison of the constraining ability of different experimental approaches, which can in turn lead to improvements in experimental design.

[ascl:2003.010] MARGE: Machine learning Algorithm for Radiative transfer of Generated Exoplanets

MARGE (Machine learning Algorithm for Radiative transfer of Generated Exoplanets) generates exoplanet spectra across a defined parameter space, processes the output, and trains, validates, and tests machine learning models as a fast approximation to radiative transfer. It uses BART (ascl:1608.004) for spectra generation and modifies BART’s Bayesian sampler (MC3, ascl:1610.013) with a random uniform sampler to propose models within a defined parameter space. More generally, MARGE provides a framework for training neural network models to approximate a forward, deterministic process.

[ascl:1011.004] MARS: The MAGIC Analysis and Reconstruction Software

With the commissioning of the second MAGIC gamma-ray Cherenkov telescope situated close to MAGIC-I, the standard analysis package of the MAGIC collaboration, MARS, has been upgraded in order to perform the stereoscopic reconstruction of the detected atmospheric showers. MARS is a ROOT-based code written in C++, which includes all the necessary algorithms to transform the raw data recorded by the telescopes into information about the physics parameters of the observed targets. An overview of the methods for extracting the basic shower parameters is presented, together with a description of the tools used in the background discrimination and in the estimation of the gamma-ray source spectra.

[ascl:1910.015] MarsLux: Illumination Mars maps generator

MarsLux generates illumination maps of Mars from Digital Terrain Model (DTM), permitting users to investigate in detail the illumination conditions on Mars based on its topography and the relative position of the Sun. MarsLux consists of two Python codes, SolaPar and MarsLux. SolaPar calculates the matrix with solar parameters for one date or a range between the two. The Marslux code generates the illumination maps using the same DTM and the files generated by SolaPar. The resulting illumination maps show areas that are fully illuminated, areas in total shadow, and areas with partial shade, and can be used for geomorphological studies to examine gullies, thermal weathering, or mass wasting processes as well as for producing energy budget maps for future exploration missions.

[ascl:1911.005] MARTINI: Mock spatially resolved spectral line observations of simulated galaxies

MARTINI (Mock APERTIF-like Radio Telescope Interferometry of the Neutal ISM) creates synthetic resolved HI line observations (data cubes) of smoothed-particle hydrodynamics simulations of galaxies. The various aspects of the mock-observing process are divided logically into sub-modules handling the data cube, source, beam, noise, spectral model and SPH kernel. MARTINI is object-oriented: each sub-module provides a class (or classes) which can be configured as desired. For most sub-modules, base classes are provided to allow for straightforward customization. Instances of each sub-module class are then given as parameters to the Martini class. A mock observation is then constructed by calling a handful of functions to execute the desired steps in the mock-observing process.

[ascl:2106.005] Marvin: Data access and visualization for MaNGA

Marvin searches, accesses, and visualizes data from the Mapping Nearby Galaxies at Apache Point Observatory (MaNGA) survey. Written in Python, it provides tools for easy efficient interaction with the MaNGA data via local files, files retrieved from the Science Archive Server, or data directly grabbed from the database. The tools come mainly in the form of convenience functions and classes for interacting with the data. Also available is a web app, Marvin-web, offers an easily accessible interface for searching the MaNGA data and visual exploration of individual MaNGA galaxies or of the entire sample, and a powerful query functionality that uses the API to query the MaNGA databases and return the search results to your python session. Marvin-API is the critical link that allows Marvin-tools and Marvin-web to interact with the databases, which enables users to harness the statistical power of the MaNGA data set.

[ascl:1302.001] MARX: Model of AXAF Response to X-rays

MARX (Model of AXAF Response to X-rays) is a suite of programs designed to enable the user to simulate the on-orbit performance of the Chandra satellite. MARX provides a detailed ray-trace simulation of how Chandra responds to a variety of astrophysical sources and can generate standard FITS events files and images as output. It contains models for the HRMA mirror system onboard Chandra as well as the HETG and LETG gratings and all focal plane detectors.

[ascl:1711.020] MARXS: Multi-Architecture Raytrace Xray mission Simulator

MARXS (Multi-Architecture-Raytrace-Xraymission-Simulator) simulates X-ray observatories. Primarily designed to simulate X-ray instruments on astronomical X-ray satellites and sounding rocket payloads, it can also be used to ray-trace experiments in the laboratory. MARXS performs polarization Monte-Carlo ray-trace simulations from a source (astronomical or lab) through a collection of optical elements such as mirrors, baffles, and gratings to a detector.

[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:2101.007] Mask galaxy: Machine learning pipeline for morphological segmentation of galaxies

Mask galaxy is an automatic machine learning pipeline for detection, segmentation and morphological classification of galaxies. The model is based on the Mask R-CNN Deep Learning architecture. This model of instance segmentation also performs image segmentation at the pixel level, and has shown a Mean Average Precision (mAP) of 0.93 in morphological classification of spiral or elliptical galaxies.

[ascl:2401.015] maskfill: Fill in masked values in an image

maskfill inward extrapolates edge pixels just outside masked regions, using iterative median filtering and the full information contained in the edge pixels. This provides seamless transitions between masked pixels and good pixels, and allows high fidelity reconstruction of gaps in continuous narrow features. An image and a mask the only required inputs.

[ascl:1101.009] MasQU: Finite Differences on Masked Irregular Stokes Q,U Grids

MasQU extracts polarization information in the CMB by reducing contamination from so-called "ambiguous modes" on a masked sky, which contain leakage from the larger E-mode signal and utilizing derivative operators on the real-space Stokes Q and U parameters. In particular, the package can perform finite differences on masked, irregular grids and is applied to a semi-regular spherical pixellization, the HEALPix grid. The formalism reduces to the known finite-difference solutions in the case of a regular grid. On a masked sphere, the software represents a considerable reduction in B-mode noise from limited sky coverage.

[ascl:1104.004] MASSCLEAN: MASSive CLuster Evolution and ANalysis Package

MASSCLEAN is a sophisticated and robust stellar cluster image and photometry simulation package. This package is able to create color-magnitude diagrams and standard FITS images in any of the traditional optical and near-infrared bands based on cluster characteristics input by the user, including but not limited to distance, age, mass, radius and extinction. At the limit of very distant, unresolved clusters, we have checked the integrated colors created in MASSCLEAN against those from other simple stellar population (SSP) models with consistent results. Because the algorithm populates the cluster with a discrete number of tenable stars, it can be used as part of a Monte Carlo Method to derive the probabilistic range of characteristics (integrated colors, for example) consistent with a given cluster mass and age.

[ascl:1401.008] massconvert: Halo Mass Conversion

massconvert, written in Fortran, provides driver and fitting routines for converting halo mass definitions from one spherical overdensity to another assuming an NFW density profile. In surveys that probe ever lower cluster masses and temperatures, sample variance is generally comparable to or greater than shot noise and thus cannot be neglected in deriving precision cosmological constraints; massconvert offers an accurate fitting formula for the conversion between different definitions of halo mass.

[ascl:2207.035] massmappy: Mapping dark matter on the celestial sphere

massmappy recovers convergence mass maps on the celestial sphere from weak lensing cosmic shear observations. It relies on SSHT (ascl:2207.034) and HEALPix (ascl:1107.018) to handle sampled data on the sphere. The spherical Kaiser-Squires estimator is implemented.

[ascl:2309.013] maszcal: Mass calibrations for thermal-SZ clusters

maszcal calibrates the observable-mass relation for galaxy clusters, with a focus on the thermal Sunyaev-Zeldovich signal's relation to mass. maszcal explicitly models baryonic matter density profiles, differing from most previous approaches that treat galaxy clusters as purely dark matter. To do this, it uses a generalized Nararro-Frenk-White (GNFW) density to represent the baryons, while using the more typical NFW profile to represent dark matter.

[ascl:1406.010] MATCH: A program for matching star lists

MATCH matches up items in two different lists, which can have two different systems of coordinates. The program allows the two sets of coordinates to be related by a linear, quadratic, or cubic transformation. MATCH was designed and written to work on lists of stars and other astronomical objects but can be applied to other types of data. In order to match two lists of N points, the main algorithm calls for O(N^6) operations; though not the most efficient choice, it does allow for arbitrary translation, rotation, and scaling.

[ascl:1601.018] MATPHOT: Stellar photometry and astrometry with discrete point spread functions

A discrete Point Spread Function (PSF) is a sampled version of a continuous two-dimensional PSF. The shape information about the photon scattering pattern of a discrete PSF is typically encoded using a numerical table (matrix) or a FITS image file. MATPHOT shifts discrete PSFs within an observational model using a 21-pixel- wide damped sinc function and position partial derivatives are computed using a five-point numerical differentiation formula. MATPHOT achieves accurate and precise stellar photometry and astrometry of undersampled CCD observations by using supersampled discrete PSFs that are sampled two, three, or more times more finely than the observational data.

[ascl:2309.007] MATRIX: Multi-phAse Transits Recovery from Injected eXoplanets toolkit

The injection-recovery MATRIX (Multi-phAse Transits Recovery from Injected eXoplanets) Toolkit creates grids of scenarios with a set of periods, radii, and epochs of synthetic transiting exoplanet signals in a provided light curve. Typical injection-recovery executions consist of 2-dimensional scenarios, where only one epoch (random or hardcoded) was used for each period and radius, which may reduce accuracy. MATRIX performs multi-phase analyses needing only a few parameters in a configuration file and running one line of code.

[ascl:2312.030] matvis: Fast matrix-based visibility simulator
Kittiwisit, Piyanat; Murray, Steven G.; Garsden, Hugh; Bull, Philip; Cain, Christopher; Parsons, Aaron R.; Sipple, Jackson; Abdurashidova, Zara; Adams, Tyrone; Aguirre, James E.; Alexander, Paul; Ali, Zaki S.; Baartman, Rushelle; Balfour, Yanga; Beardsley, Adam P.; Berkhout, Lindsay M.; Bernardi, Gianni; Billings, Tashalee S.; Bowman, Judd D.; Bradley, Richard F.; Burba, Jacob; Carey, Steven; Carilli, Chris L.; Chen, Kai-Feng; Cheng, Carina; Choudhuri, Samir; DeBoer, David R.; de Lera Acedo, Eloy; Dexter, Matt; Dillon, Joshua S.; Dynes, Scott; Eksteen, Nico; Ely, John; Ewall-Wice, Aaron; Fagnoni, Nicolas; Fritz, Randall; Furlanetto, Steven R.; Gale-Sides, Kingsley; Gehlot, Bharat Kumar; Ghosh, Abhik; Glendenning, Brian; Gorce, Adelie; Gorthi, Deepthi; Greig, Bradley; Grobbelaar, Jasper; Halday, Ziyaad; Hazelton, Bryna J.; Hewitt, Jacqueline N.; Hickish, Jack; Huang, Tian; Jacobs, Daniel C.; Josaitis, Alec; Julius, Austin; Kariseb, MacCalvin; Kern, Nicholas S.; Kerrigan, Joshua; Kim, Honggeun; Kohn, Saul A.; Kolopanis, Matthew; Lanman, Adam; La Plante, Paul; Liu, Adrian; Loots, Anita; Ma, Yin-Zhe; MacMahon, David H. E.; Malan, Lourence; Malgas, Cresshim; Malgas, Keith; Marero, Bradley; Martinot, Zachary E.; Mesinger, Andrei; Molewa, Mathakane; Morales, Miguel F.; Mosiane, Tshegofalang; Neben, Abraham R.; Nikolic, Bojan; Devi Nunhokee, Chuneeta; Nuwegeld, Hans; Pascua, Robert; Patra, Nipanjana; Pieterse, Samantha; Qin, Yuxiang; Rath, Eleanor; Razavi-Ghods, Nima; Riley, Daniel; Robnett, James; Rosie, Kathryn; Santos, Mario G.; Sims, Peter; Singh, Saurabh; Storer, Dara; Swarts, Hilton; Tan, Jianrong; Thyagarajan, Nithyanandan; van Wyngaarden, Pieter; Williams, Peter K. G.; Xu, Zhilei; Zheng, Haoxuan

matvis simulates radio interferometric visibilities at the necessary scale with both CPU and GPU implementations. It is matrix-based and applicable to wide field-of-view instruments such as the Hydrogen Epoch of Reionization Array (HERA) and the Square Kilometre Array (SKA), as it does not make any approximations of the visibility integral (such as the flat-sky approximation). The only approximation made is that the sky is a collection of point sources, which is valid for sky models that intrinsically consist of point-sources, but is an approximation for diffuse sky models. The matvix matrix-based algorithm is fast and scales well to large numbers of antennas. The code supports both CPU and GPU implementations as drop-in replacements for each other and also supports both dense and sparse sky models.

[ascl:2008.018] maxsmooth: Derivative constrained function fitting

maxsmooth fits derivative constrained functions (DCF) such as Maximally Smooth Functions (MSFs) to data sets. MSFs are functions for which there are no zero crossings in derivatives of order m >= 2 within the domain of interest. They are designed to prevent the loss of signals when fitting out dominant smooth foregrounds or large magnitude signals that mask signals of interest. Here "smooth" means that the foregrounds follow power law structures and do not feature turning points in the band of interest. maxsmooth uses quadratic programming implemented with CVXOPT (ascl:2008.017) to fit data subject to a fixed linear constraint, Ga <= 0, where the product Ga is a matrix of derivatives. The code tests the <= 0 constraint multiplied by a positive or negative sign and can test every available sign combination but by default, it implements a sign navigating algorithm.

[ascl:1205.008] Mayavi2: 3D Scientific Data Visualization and Plotting

Mayavi provides general-purpose 3D scientific visualizations. It offers easy interactive tools for data visualization that fit with the scientific user's workflow. Mayavi provides several entry points: a full-blown interactive application; a Python library with both a MATLAB-like interface focused on easy scripting and a feature-rich object hierarchy; widgets associated with these objects for assembling in a domain-specific application, and plugins that work with a general purpose application-building framework.

[ascl:2204.009] MAYONNAISE: ADI data imaging processing pipeline

MAYONNAISE (Morphological Analysis Yielding separated Objects iN Near infrAred usIng Sources Estimation), or MAYO for short, is a pipeline for exoplanet and disk high-contrast imaging from ADI datasets. The pipeline is mostly automated; the package also loads the data and injects synthetic data if needed. MAYONNAISE parameters are written in a json file called parameters_algo.json and placed in a working_directory.

[ascl:2307.060] MBASC: Multi-Band AGN-SFG Classifier

MBASC (Multi-Band AGN-SFG Classifier) classifies sources as Active Galactic Nuclei (AGNs) and Star Forming Galaxies (SFGs). The algorithm is based on the light gradient-boosting machine ML technique. MBASC can use a wide range of multi-wavelength data and redshifts to predict a classification for sources.

[ascl:1602.020] mbb_emcee: Modified Blackbody MCMC

Mbb_emcee fits modified blackbodies to photometry data using an affine invariant MCMC. It has large number of options which, for example, allow computation of the IR luminosity or dustmass as part of the fit. Carrying out a fit produces a HDF5 output file containing the results, which can either be read directly, or read back into a mbb_results object for analysis. Upper and lower limits can be imposed as well as Gaussian priors on the model parameters. These additions are useful for analyzing poorly constrained data. In addition to standard Python packages scipy, numpy, and cython, mbb_emcee requires emcee (ascl:1303.002), Astropy (ascl:1304.002), h5py, and for unit tests, nose.

[ascl:2010.001] MBF: MOLSCAT 2020, BOUND, and FIELD for atomic and molecular collisions

MOLSCAT, which supercedes MOLSCAT version 14 (ascl:1206.004), performs non-reactive quantum scattering calculations for atomic and molecular collisions using coupled-channel methods. Simple atom-molecule and molecule-molecule collision types are coded internally and additional ones may be handled with plug-in routines. Plug-in routines may include external magnetic, electric or photon fields (and combinations of them).

The package also includes BOUND, which performs calculations of bound-state energies in weakly bound atomic and molecular systems using coupled-channel methods, and FIELD, a development of BOUND that locates values of external fields at which a bound state exists with a specified energy. Though the three programs have different applications, they use closely related methods, share many subroutines, and are released with a single code base.

[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: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: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:1204.005] MC3D: Monte-Carlo 3D Radiative Transfer Code

MC3D is a 3D continuum radiative transfer code; it is based on the Monte-Carlo method and solves the radiative transfer problem self-consistently. It is designed for the simulation of dust temperatures in arbitrary geometric configurations and the resulting observables: spectral energy distributions, wavelength-dependent images, and polarization maps. The main objective is the investigation of "dust-dominated" astrophysical systems such as young stellar objects surrounded by an optically thick circumstellar disk and an optically thin(ner) envelope, debris disks around more evolved stars, asymptotic giant branch stars, the dust component of the interstellar medium, and active galactic nuclei.

[ascl:1511.008] MCAL: M dwarf metallicity and temperature calculator

MCAL calculates high precision metallicities and effective temperatures for M dwarfs; the method behaves properly down to R = 40 000 and S/N = 25, and results were validated against a sample of stars in common with SOPHIE high resolution spectra.

[ascl:2105.008] MCALF: Velocity information from spectral imaging observations

MCALF (Multi-Component Atmospheric Line Fitting) accurately constrains velocity information from spectral imaging observations using machine learning techniques. It is useful for solar physicists trying to extract line-of-sight (LOS) Doppler velocity information from spectral imaging observations (Stokes I measurements) of the Sun. A toolkit is provided that can be used to define a spectral model optimized for a particular dataset. MCALF is particularly suited for extracting velocity information from spectral imaging observations where the individual spectra can contain multiple spectral components. Such multiple components are typically present when active solar phenomenon occur within an isolated region of the solar disk. Spectra within such a region will often have a large emission component superimposed on top of the underlying absorption spectral profile from the quiescent solar atmosphere.

[ascl:2210.022] MCCD: Multi-CCD Point Spread Function Modelling

MCCD (Multi-CCD) generates a Point Spread Function (PSF) model based on stars observations in the field of view. After defining the MCCD model parameters and running and validating the training, the model can recover the PSF at any position in the field of view. Written in Python, MCCD also calculates various statistics and can plot a random test star and its model reconstruction.

[ascl:1906.017] mcfit: Multiplicatively Convolutional Fast Integral Transforms

mcfit computes integral transforms, inverse transforms without analytic inversion, and integral kernels as derivatives. It can also transform input array along any axis, output the matrix form, an is easily extensible for other kernels.

[ascl:2207.023] MCFOST: Radiative transfer code

MCFOST is a 3D continuum and line radiative transfer code based on an hybrid Monte Carlo and ray-tracing method. It is mainly designed to study the circumstellar environment of young stellar objects, but has been used for a wide range of astrophysical problems. The calculations are done exactly within the limitations of the Monte Carlo noise and machine precision, i.e., no approximation are used in the calculations. The code has been strongly optimized for speed.

MCFOST is primarily designed to study protoplanetary disks. The code can reproduce most of the observations of disks, including SEDs, scattered light images, IR and mm visibilities, and atomic and molecular line maps. As the Monte Carlo method is generic, any complex structure can be handled by MCFOST and its use can be extended to other astrophysical objects. For instance, calculations have succesfully been performed on infalling envelopes and AGB stars. MCFOST also includes a non-LTE line transfer module, and NLTE level population are obtained via iterations between Monte Carlo radiative transfer calculations and statistical equilibrium.

[ascl:1107.015] McLuster: A Tool to Make a Star Cluster

The tool McLuster is an open source code that can be used to either set up initial conditions for N-body computations or, alternatively, to generate artificial star clusters for direct investigation. There are two different versions of the code, one basic version for generating all kinds of unevolved clusters (in the following called mcluster) and one for setting up evolved stellar populations at a given age. The former is completely contained in the C file main.c. The latter (dubbed mcluster_sse) is more complex and requires additional FORTRAN routines, namely the Single-Star Evolution (SSE) routines by Hurley, Pols & Tout (ascl:1303.015) that are provided with the McLuster code.

[ascl:1407.004] MCMAC: Monte Carlo Merger Analysis Code

Monte Carlo Merger Analysis Code (MCMAC) aids in the study of merging clusters. It takes observed priors on each subcluster's mass, radial velocity, and projected separation, draws randomly from those priors, and uses them in a analytic model to get posterior PDF's for merger dynamic properties of interest (e.g. collision velocity, time since collision).

[ascl:2011.004] MCMCDiagnostics: Markov Chain Monte Carlo convergence diagnostics

MCMCDiagnostics contains two diagnostics, written in Julia, for Markov Chain Monte Carlo. The first is potential_scale_reduction(chains...), which estimates the potential scale reduction factor, also known as Rhat, for multiple scalar chains
. The second, effective_sample_size(chain), calculates the effective sample size for scalar chains. These diagnostics are intended as building blocks for use by other libraries.

[ascl:2001.012] MCMCI: Markov Chain Monte Carlo + Isochrones method for characterizing exoplanetary systems

MCMCI (Markov chain Monte Carlo + isochrones) characterizes a whole exoplanetary system directly by modeling the star and its planets simultaneously. The code, written in Fortran, uses light curves and basic stellar parameters with a transit analysis algorithm that interacts with stellar evolutionary models, thus using both model-dependent and empirical age indicators to characterize the system.

[ascl:1210.017] McPHAC: McGill Planar Hydrogen Atmosphere Code

The McGill Planar Hydrogen Atmosphere Code (McPHAC) v1.1 calculates the hydrostatic equilibrium structure and emergent spectrum of an unmagnetized hydrogen atmosphere in the plane-parallel approximation at surface gravities appropriate for neutron stars. McPHAC incorporates several improvements over previous codes for which tabulated model spectra are available: (1) Thomson scattering is treated anisotropically, which is shown to result in a 0.2%-3% correction in the emergent spectral flux across the 0.1-5 keV passband; (2) the McPHAC source code is made available to the community, allowing it to be scrutinized and modified by other researchers wishing to study or extend its capabilities; and (3) the numerical uncertainty resulting from the discrete and iterative solution is studied as a function of photon energy, indicating that McPHAC is capable of producing spectra with numerical uncertainties <0.01%. The accuracy of the spectra may at present be limited to ~1%, but McPHAC enables researchers to study the impact of uncertain inputs and additional physical effects, thereby supporting future efforts to reduce those inaccuracies. Comparison of McPHAC results with spectra from one of the previous model atmosphere codes (NSA) shows agreement to lsim1% near the peaks of the emergent spectra. However, in the Wien tail a significant deficit of flux in the spectra of the previous model is revealed, determined to be due to the previous work not considering large enough optical depths at the highest photon frequencies. The deficit is most significant for spectra with T eff < 105.6 K, though even there it may not be of much practical importance for most observations.

[ascl:2107.025] MCPM: Modified CPM method

MCPM extracts K2 photometry in dense stellar regions; the code is a modification and extension of the K2-CPM package (ascl:2107.024), which was developed for less-crowded fields. MCPM uses the pixel response function together with accurate astrometric grids, combining signals from a few pixels, and simultaneously fits for an astrophysical model to produce extracted more precise K2 photometry.

[ascl:2005.019] MCRaT: Monte Carlo Radiation Transfer

MCRaT (Monte Carlo Radiation Transfer) analyzes the radiation signature expected from astrophysical outflows. MCRaT injects photons in a FLASH (ascl:1010.082) simulation and individually propagates and compton scatters the photons through the fluid until the end of the simulation. This process of injection and propagating occurs for a user specified number of times until there are no more photons to be injected. Users can then construct light curves and spectra with the MCRaT calculated results. The hydrodynamic simulations used with this version of MCRaT must be in 2D; however, the photon propagation and scattering is done in 3D by assuming cylindrical symmetry. Additionally, MCRaT uses the full Klein–Nishina cross section including the effects of polarization, which can be fully simulated in the code. MCRaT works with FLASH hydrodynamic simulations and PLUTO (ascl:1010.045) AMR simulations, with both 2D spherical (r, equation) and 2D cartesian ((x,y) and (r,z)).

[ascl:1907.026] MCRGNet: Morphological Classification of Radio Galaxy Network

MCRGNet (Morphological Classification of Radio Galaxy Network) classifies radio galaxies of different morphologies. It is based on the Convolutional Neural Network (CNN), which is trained and applied under a three-step framework: 1.) pretraining the network unsupervisedly with unlabeled samples, 2.) fine-tuning the pretrained network parameters supervisedly with labeled samples, and 3.) classifying a new radio galaxy by the trained network. The code uses a dichotomous tree classifier composed of cascaded CNN based subclassifiers.

[ascl:1201.001] McScatter: Three-Body Scattering with Stellar Evolution

McScatter illustrates a method of combining stellar dynamics with stellar evolution. The method is intended for elaborate applications, especially the dynamical evolution of rich star clusters. The dynamics is based on binary scattering in a multi-mass field of stars with uniform density and velocity dispersion, using the scattering cross section of Giersz (MNRAS, 2001, 324, 218-30).

[ascl:2006.022] MCSED: Spectral energy distribution fitting package for galactic systems

MCSED models the optical, near-infrared and infrared spectral energy distribution (SED) of galactic systems. Its modularity and options make it flexible and able to address the varying physical properties of galaxies over cosmic time and environment and adjust to changes in understanding of stellar evolution, the details of mass loss, and the products of binary evolution through substitution or addition of new datasets or algorithms. MCSED is built to fit a galaxy’s full SED, from the far-UV to the far-IR. Among other physical processes, it can model continuum emission from stars, continuum and line-emission from ionized gas, attenuation from dust, and mid- and far-IR emission from dust and polycyclic aromatic hydrocarbons (PAHs). MCSED performs its calculations by creating a complex stellar population (CSP) out of a linear combination of simple-stellar populations (SSPs) using an efficient Markov Chain Monte Carlo algorithm. It is very quick, and takes advantage of parallel processing.

[ascl:1504.008] MCSpearman: Monte Carlo error analyses of Spearman's rank test

Spearman’s rank correlation test is commonly used in astronomy to discern whether a set of two variables are correlated or not. Unlike most other quantities quoted in astronomical literature, the Spearman’s rank correlation coefficient is generally quoted with no attempt to estimate the errors on its value. This code implements a number of Monte Carlo based methods to estimate the uncertainty on the Spearman’s rank correlation coefficient.

[ascl:1302.012] ME(SSY)**2: Monte Carlo Code for Star Cluster Simulations

ME(SSY)**2 stands for “Monte-carlo Experiments with Spherically SYmmetric Stellar SYstems." This code simulates the long term evolution of spherical clusters of stars; it was devised specifically to treat dense galactic nuclei. It is based on the pioneering Monte Carlo scheme proposed by Hénon in the 70's and includes all relevant physical ingredients (2-body relaxation, stellar mass spectrum, collisions, tidal disruption, ldots). It is basically a Monte Carlo resolution of the Fokker-Planck equation. It can cope with any stellar mass spectrum or velocity distribution. Being a particle-based method, it also allows one to take stellar collisions into account in a very realistic way. This unique code, featuring most important physical processes, allows million particle simulations, spanning a Hubble time, in a few CPU days on standard personal computers and provides a wealth of data only rivalized by N-body simulations. The current version of the software requires the use of routines from the "Numerical Recipes in Fortran 77" (http://www.nrbook.com/a/bookfpdf.php).

[submitted] Mean Motion Resonances

Site with collection of codes and fundamental references on mean motion resonances.

[ascl:1205.001] Mechanic: Numerical MPI framework for dynamical astronomy

The Mechanic package is a numerical framework for dynamical astronomy, designed to help in massive numerical simulations by efficient task management and unified data storage. The code is built on top of the Message Passing Interface (MPI) and Hierarchical Data Format (HDF5) standards and uses the Task Farm approach to manage numerical tasks. It relies on the core-module approach. The numerical problem implemented in the user-supplied module is separated from the host code (core). The core is designed to handle basic setup, data storage and communication between nodes in a computing pool. It has been tested on large CPU-clusters, as well as desktop computers. The Mechanic may be used in computing dynamical maps, data optimization or numerical integration.

[ascl:1106.006] MECI: A Method for Eclipsing Component Identification

We describe an automated method for assigning the most probable physical parameters to the components of an eclipsing binary, using only its photometric light curve and combined colors. With traditional methods, one attempts to optimize a multi-parameter model over many iterations, so as to minimize the chi-squared value. We suggest an alternative method, where one selects pairs of coeval stars from a set of theoretical stellar models, and compares their simulated light curves and combined colors with the observations. This approach greatly reduces the parameter space over which one needs to search, and allows one to estimate the components' masses, radii and absolute magnitudes, without spectroscopic data. We have implemented this method in an automated program using published theoretical isochrones and limb-darkening coefficients. Since it is easy to automate, this method lends itself to systematic analyses of datasets consisting of photometric time series of large numbers of stars, such as those produced by OGLE, MACHO, TrES, HAT, and many others surveys.

[ascl:2105.009] MeerCRAB: Transient classifier using a deep learning model

MeerCRAB (MeerLICHT Classification of Real and Bogus Transients using Deep Learning) filters out false detections of transients from true astrophysical sources in the transient detection pipeline of the MeerLICHT telescope. It uses a deep learning model based on Convolutional Neural Network.

[ascl:1906.018] MEGAlib: Medium Energy Gamma-ray Astronomy library

The Medium Energy Gamma-ray Astronomy library (MEGAlib) simulates, calibrates, and analyzes data of hard X-ray and gamma-ray detectors, with a specialization on Compton telescopes. The library comprises all necessary data analysis steps for these telescopes, from simulation/measurements via calibration, event reconstruction to image reconstruction.

MEGAlib contains a geometry and detector description tool for the detailed modeling of different detector types and characteristics, and provides an easy to use simulation program based on Geant4 (ascl:1010.079). For different Compton telescope detector types (electron tracking, multiple Compton or time of flight based), specialized Compton event reconstruction algorithms are implemented in different approaches (Chi-square and Bayesian). The high level data analysis tools calculate response matrices, perform image deconvolution (specialized in list-mode-likelihood-based Compton image reconstruction), determine detector resolutions and sensitivities, retrieve spectra, and determine polarization modulations.

[ascl:1203.008] MegaLUT: Correcting ellipticity measurements of galaxies

MegaLUT is a simple and fast method to correct ellipticity measurements of galaxies from the distortion by the instrumental and atmospheric point spread function (PSF), in view of weak lensing shear measurements. The method performs a classification of galaxies and associated PSFs according to measured shape parameters, and builds a lookup table of ellipticity corrections by supervised learning. This new method has been applied to the GREAT10 image analysis challenge, and demonstrates a refined solution that obtains the highly competitive quality factor of Q = 142, without any power spectrum denoising or training. Of particular interest is the efficiency of the method, with a processing time below 3 ms per galaxy on an ordinary CPU.

[ascl:1711.012] megaman: Manifold Learning for Millions of Points

megaman is a scalable manifold learning package implemented in python. It has a front-end API designed to be familiar to scikit-learn but harnesses the C++ Fast Library for Approximate Nearest Neighbors (FLANN) and the Sparse Symmetric Positive Definite (SSPD) solver Locally Optimal Block Precodition Gradient (LOBPCG) method to scale manifold learning algorithms to large data sets. It is designed for researchers and as such caches intermediary steps and indices to allow for fast re-computation with new parameters.

[ascl:2109.025] Menura: Multi-GPU numerical model for space plasma simulation

Menura simulates the interaction between a fully turbulent solar wind and various bodies of the solar system using a novel two-step approach. It is an advanced numerical tool for self-consistent modeling that bridges planetary science and plasma physics. Menura is built around a hybrid Particle-In-Cell solver, treating electrons as a charge-neutralising fluid, and ions as massive particles. It solves iteratively the particles’ dynamics, gathers particle moments at the nodes of a grid, at which the magnetic field is also computed, and then solves the Maxwell equations. This solver uses the popular Current Advance Method (CAM).

[ascl:1410.002] MEPSA: Multiple Excess Peak Search Algorithm

MEPSA (Multiple Excess Peak Search Algorithm) identifies peaks within a uniformly sampled time series affected by uncorrelated Gaussian noise. MEPSA scans the time series at different timescales by comparing a given peak candidate with a variable number of adjacent bins. While this has originally been conceived for the analysis of gamma-ray burst light (GRB) curves, its usage can be readily extended to other astrophysical transient phenomena whose activity is recorded through different surveys. MEPSA's high flexibility permits the mask of excess patterns it uses to be tailored and optimized without modifying the code.

[ascl:1209.010] MeqTrees: Software package for implementing Measurement Equations

MeqTrees is a software package for implementing Measurement Equations. This makes it uniquely suited for simulation and calibration of radioastronomical data, especially that involving new radiotelescopes and observational regimes. MeqTrees is implemented as a Python-based front-end called the meqbrowser, and an efficient (C++-based) computational back-end called the meqserver. Numerical models are defined on the front-end via a Python-based Tree Definition Language (TDL), then rapidly executed on the back-end. The use of TDL facilitates an extremely short turn-around time for experimentation with new ideas. This is also helped by unprecedented visualization capabilities for all final and intermediate results. A flexible data model and a number of important optimizations in the back-end ensures that the numerical performance is comparable to that of hand-written code.

MeqTrees includes a highly capable FITS viewer and sky model manager called Tigger, which can also work as a standalone tool.

[submitted] MERA: Analysis Tool for Astrophysical Simulation Data in the Julia Language

MERA works with large 3D AMR/uniform-grid and N-body particle data sets from astrophysical simulations such as those produced by the hydrodynamic code RAMSES (ascl:1011.007) and is written entirely in the Julia language. The package provides essential functions for efficient and memory lightweight data loading and analysis. The core of MERA is a database framework.

[ascl:1511.020] Mercury-T: Tidally evolving multi-planet systems code

Mercury-T calculates the evolution of semi-major axis, eccentricity, inclination, rotation period and obliquity of the planets as well as the rotation period evolution of the host body; it is based on the N-body code Mercury (Chambers 1999, ascl:1201.008). It is flexible, allowing computation of the tidal evolution of systems orbiting any non-evolving object (if its mass, radius, dissipation factor and rotation period are known), but also evolving brown dwarfs (BDs) of mass between 0.01 and 0.08 M⊙, an evolving M-dwarf of 0.1 M⊙, an evolving Sun-like star, and an evolving Jupiter.

[ascl:1201.008] Mercury: A software package for orbital dynamics

Mercury is a new general-purpose software package for carrying out orbital integrations for problems in solar-system dynamics. Suitable applications include studying the long-term stability of the planetary system, investigating the orbital evolution of comets, asteroids or meteoroids, and simulating planetary accretion. Mercury is designed to be versatile and easy to use, accepting initial conditions in either Cartesian coordinates or Keplerian elements in "cometary" or "asteroidal" format, with different epochs of osculation for different objects. Output from an integration consists of osculating elements, written in a machine-independent compressed format, which allows the results of a calculation performed on one platform to be transferred (e.g. via FTP) and decoded on another.

During an integration, Mercury monitors and records details of close encounters, sungrazing events, ejections and collisions between objects. The effects of non-gravitational forces on comets can also be modeled. The package supports integrations using a mixed-variable symplectic routine, the Bulirsch-Stoer method, and a hybrid code for planetary accretion calculations.

[ascl:1305.015] Merger Trees: Formation history of dark matter haloes

Merger Trees uses a Monte Carlo algorithm to generate merger trees describing the formation history of dark matter haloes; the algorithm is implemented in Fortran. The algorithm is a modification of the algorithm of Cole et al. used in the GALFORM semi-analytic galaxy formation model (ascl:1510.005) based on the Extended Press–Schechter theory. It should be applicable to hierarchical models with a wide range of power spectra and cosmological models. It is tuned to be in accurate agreement with the conditional mass functions found in the analysis of merger trees extracted from the Λ cold dark matter Millennium N-body simulation. The code should be a useful tool for semi-analytic models of galaxy formation and for modelling hierarchical structure formation in general.

[ascl:1010.083] MESA: Modules for Experiments in Stellar Astrophysics

Stellar physics and evolution calculations enable a broad range of research in astrophysics. Modules for Experiments in Stellar Astrophysics (MESA) is a suite of open source libraries for a wide range of applications in computational stellar astrophysics. A newly designed 1-D stellar evolution module, MESA star, combines many of the numerical and physics modules for simulations of a wide range of stellar evolution scenarios ranging from very-low mass to massive stars, including advanced evolutionary phases. MESA star solves the fully coupled structure and composition equations simultaneously. It uses adaptive mesh refinement and sophisticated timestep controls, and supports shared memory parallelism based on OpenMP. Independently usable modules provide equation of state, opacity, nuclear reaction rates, and atmosphere boundary conditions. Each module is constructed as a separate Fortran 95 library with its own public interface. Examples include comparisons to other codes and show evolutionary tracks of very low mass stars, brown dwarfs, and gas giant planets; the complete evolution of a 1 Msun star from the pre-main sequence to a cooling white dwarf; the Solar sound speed profile; the evolution of intermediate mass stars through the thermal pulses on the He-shell burning AGB phase; the interior structure of slowly pulsating B Stars and Beta Cepheids; evolutionary tracks of massive stars from the pre-main sequence to the onset of core collapse; stars undergoing Roche lobe overflow; and accretion onto a neutron star.

[ascl:1709.003] MeshLab: 3D triangular meshes processing and editing

MeshLab processes and edits 3D triangular meshes. It includes tools for editing, cleaning, healing, inspecting, rendering, texturing and converting meshes, and offers features for processing raw data produced by 3D digitization tools and devices and for preparing models for 3D printing.

[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:1111.009] MESS: Multi-purpose Exoplanet Simulation System

MESS is a Monte Carlo simulation IDL code which uses either the results of the statistical analysis of the properties of discovered planets, or the results of the planet formation theories, to build synthetic planet populations fully described in terms of frequency, orbital elements and physical properties. They can then be used to either test the consistency of their properties with the observed population of planets given different detection techniques or to actually predict the expected number of planets for future surveys. It can be used to probe the physical and orbital properties of a putative companion within the circumstellar disk of a given star and to test constrain the orbital distribution properties of a potential planet population around the members of the TW Hydrae association. Finally, using in its predictive mode, the synergy of future space and ground-based telescopes instrumentation has been investigated to identify the mass-period parameter space that will be probed in future surveys for giant and rocky planets. A Python version of this code, Exo-DMC (ascl:2010.008), is available.

[ascl:2207.003] MeSsI: MErging SystemS Identification

MeSsI performs an automatic classification between merging and relaxed clusters. This method was calibrated using mock catalogues constructed from the millennium simulation, and performs the classification using some machine learning techniques, namely random forest for classification and mixture of gaussians for the substructure identification.

[ascl:1205.010] Meudon PDR: Atomic & molecular structure of interstellar clouds

The Meudon PDR code computes the atomic and molecular structure of interstellar clouds. It can be used to study the physics and chemistry of diffuse clouds, photodissociation regions (PDRs), dark clouds, or circumstellar regions. The model computes the thermal balance of a stationary plane-parallel slab of gas and dust illuminated by a radiation field and takes into account heating processes such as the photoelectric effect on dust, chemistry, cosmic rays, etc. and cooling resulting from infrared and millimeter emission of the abundant species. Chemistry is solved for any number of species and reactions. Once abundances of atoms and molecules and level excitation of the most important species have been computed at each point, line intensities and column densities can be deduced.

[ascl:2203.021] MG-MAMPOSSt: Test gravity with the mass profiles of galaxy clusters

MG-MAMPOSSt extends the MAMPOSSt code (ascl:2203.020), which performs Bayesian fits of models of mass and velocity anisotropy profiles to the distribution of tracers in projected phase space, to handle modified gravity models and constrain its parameters. It implements two distinct types of gravity modifications: general chameleon (including $f(\mathcal{R})$ models), and beyond Horndeski gravity (Vainshtein screening). MG-MAMPOSSt efficently explores the parameter space either by computing the likelihood over a multi-dimensional grid of points or by performing a simple Metropolis-Hastings MCMC. The code requires a Fortran90 compiler or higher and makes use of the getdist package (ascl:1910.018) to plot the marginalized distributions in the MCMC mode.

[ascl:2306.048] MG-PICOLA: Simulating cosmological structure formation

MG-PICOLA is a modified version of L-PICOLA (ascl:1507.004) that extends the COLA approach for simulating cosmological structure formation to theories that exhibit scale-dependent growth. It can compute matter power-spectra (CDM and total), redshift-space multipole power-spectra P0,P2,P4 and do halofinding on the fly.

[ascl:1907.031] MGB: Interactive spectral classification code

MGB (Marxist Ghost Buster) attacks spectral classification by using an interactive comparison with spectral libraries. It allows the user to move along the two traditional dimensions of spectral classification (spectral subtype and luminosity classification) plus the two additional ones of rotation index and spectral peculiarities. Double-lined spectroscopic binaries can also be fitted using a combination of two standards. The code includes OB2500 v2.0, a standard grid of blue-violet R ~ 2500 spectra of O stars from the Galactic O-Star Spectroscopic Survey, but other grids can be added to MGB.

[ascl:1106.013] MGCAMB: Modification of Growth with CAMB

CAMB is a public Fortran 90 code written by Antony Lewis and Anthony Challinor for evaluating cosmological observables. MGCAMB is a modified version of CAMB in which the linearized Einstein equations of General Relativity (GR) are modified. MGCAMB can also be used in CosmoMC to fit different modified-gravity (MG) models to data.

[ascl:2211.007] mgcnn: Standard and modified gravity (MG) cosmological models classifier

mgcnn is a Convolutional Neural Network (CNN) architecture for classifying standard and modified gravity (MG) cosmological models based on the weak-lensing convergence maps they produce. It is implemented in Keras using TensorFlow as the backend. The code offers three options for the noise flag, which correspond to noise standard deviations, and additional options for the number of training iterations and epochs. Confusion matrices and evaluation metrics (loss function and validation accuracy) are saved as numpy arrays in the generated output/ directory after each iteration.

[ascl:2212.003] MGCosmoPop: Modified gravity and cosmology with binary black holes population models

MGCosmoPop implements a hierarchical Bayesian inference method for constraining the background cosmological history, in particular the Hubble constant, together with modified gravitational-wave propagation and binary black holes population models (mass, redshift and spin distributions) with gravitational-wave data. It includes support for loading and analyzing data from the GWTC-3 catalog as well as for generating injections to evaluate selection effects, and features a module to run in parallel on clusters.

[ascl:1403.017] MGE_FIT_SECTORS: Multi-Gaussian Expansion fits to galaxy images

MGE_FIT_SECTORS performs Multi-Gaussian Expansion (MGE) fits to galaxy images. The MGE parameterizations are useful in the construction of realistic dynamical models of galaxies, PSF deconvolution of images, the correction and estimation of dust absorption effects, and galaxy photometry. The algorithm is well suited for use with multiple-resolution images (e.g. Hubble Space Telescope (HST) and ground-based images).

[ascl:1010.081] MGGPOD: A Monte Carlo Suite for Gamma-Ray Astronomy

We have developed MGGPOD, a user-friendly suite of Monte Carlo codes built around the widely used GEANT (Version 3.21) package. The MGGPOD Monte Carlo suite and documentation are publicly available for download. MGGPOD is an ideal tool for supporting the various stages of gamma-ray astronomy missions, ranging from the design, development, and performance prediction through calibration and response generation to data reduction. In particular, MGGPOD is capable of simulating ab initio the physical processes relevant for the production of instrumental backgrounds. These include the build-up and delayed decay of radioactive isotopes as well as the prompt de-excitation of excited nuclei, both of which give rise to a plethora of instrumental gamma-ray background lines in addition to continuum backgrounds.

[ascl:1402.035] MGHalofit: Modified Gravity extension of Halofit

MGHalofit is a modified gravity extension of the fitting formula for the matter power spectrum of HALOFIT and its improvement by Takahashi et al. MGHalofit is implemented in MGCAMB, which is based on CAMB. MGHalofit calculates the nonlinear matter power spectrum P(k) for the Hu-Sawicki model. Comparing MGHalofit predictions at various redshifts (z<=1) to the f(R) simulations, the accuracy on P(k) is 6% at k<1 h/Mpc and 12% at 1<k<10 h/Mpc respectively.

[ascl:2402.005] MGPT: Modified Gravity Perturbation Theory code

MGPT (Modified Gravity Perturbation Theory) computes 2-point statistics for LCDM model, DGP and Hu-Sawicky f(R) gravity. Written in C, the code can be easily modified to include other models. Specifically, it computes the SPT matter power spectrum, SPT Lagrangian-biased tracers power spectrum, and the CLPT matter correlation function. MGPT also computes the CLPT Lagrangian-biased tracers correlation function and a set of Q and R functionsfrom which other statistics, as leading order bispectrum, can be constructed.

[ascl:2301.026] MGwave: Detect kinematic moving groups in astronomical data

The 2-D wavelet transformation code MGwave detects kinematic moving groups in astronomical data; it can also investigate underdensities which can eventually provide further information about the MW's non-axisymmetric features. The code creates a histogram of the input data, then performs the wavelet transformation at the specified scales, returning the wavelet coefficients across the entire histogram in addition to information about the detected extrema. MGwave can also run Monte Carlo simulations to propagate uncertainties. It runs the wavelet transformation on simulated data (pulled from Gaussian distributions) many times and tracks the percentage of the simulations in which a given extrema is detected. This quantifies whether a detected overdensity or underdensity is robust to variations of the data within the provided errors.

[ascl:1511.007] MHF: MLAPM Halo Finder

MHF is a Dark Matter halo finder that is based on the refinement grids of MLAPM. The grid structure of MLAPM adaptively refines around high-density regions with an automated refinement algorithm, thus naturally "surrounding" the Dark Matter halos, as they are simply manifestations of over-densities within (and exterior) to the underlying host halo. Using this grid structure, MHF restructures the hierarchy of nested isolated MLAPM grids into a "grid tree". The densest cell in the end of a tree branch marks center of a prospective Dark Matter halo. All gravitationally bound particles about this center are collected to obtain the final halo catalog. MHF automatically finds halos within halos within halos.

[ascl:1205.003] MIA+EWS: MIDI data reduction tool

MIA+EWS is a package of two data reduction tools for MIDI data which uses power-spectrum analysis or the information contained in the spectrally-dispersed fringe measurements in order to estimate the correlated flux and the visibility as function of wavelength in the N-band. MIA, which stands for MIDI Interactive Analysis, uses a Fast Fourier Transformation to calculate the Fourier amplitudes of the fringe packets to calculate the correlated flux and visibility. EWS stands for Expert Work-Station, which is a collection of IDL tools to apply coherent visibility analysis to reduce MIDI data. The EWS package allows the user to control and examine almost every aspect of MIDI data and its reduction. The usual data products are the correlated fluxes, total fluxes and differential phase.

[ascl:2005.002] michi2: SED and SLED fitting tool

michi2 fits combinations of arbitrary numbers of libraries/components to a given observational data. Written in C++ and Python, this chi-square fitting tool can fit a galaxy's spectral energy distribution (SED) with stellar, active galactic nuclear, dust and radio SED templates, and fit a galaxy's spectral line energy distribution (SLED) with one or more gas components using radiative transfer LVG model grid libraries.

michi2 first samples the high-dimensional parameter space (N1*N2*N3*..., where N is the number of independent templates in each library, and 1/2/3 is the ID of components) in an optimized way for a few thousand or tens of thousand times to compute the chi-square to the input observational data, then uses Python scripts to analyze the chi-square distribution and derive the best-fit, median, lower and higher 1-sigma values for each parameter in each library/component. This tool is useful for fitting larger number of templates and arbitrary combinations of libraries/components, including some constraining of one library/component onto another.

[ascl:1011.017] Microccult: Occultation and Microlensing

Occultation and microlensing are different limits of the same phenomena of one body passing in front of another body. We derive a general exact analytic expression which describes both microlensing and occultation in the case of spherical bodies with a source of uniform brightness and a non-relativistic foreground body. We also compute numerically the case of a source with quadratic limb-darkening. In the limit that the gravitational deflection angle is comparable to the angular size of the foreground body, both microlensing and occultation occur as the objects align. Such events may be used to constrain the size ratio of the lens and source stars, the limb-darkening coefficients of the source star, and the surface gravity of the lens star (if the lens and source distances are known). Application of these results to microlensing during transits in binaries and giant-star microlensing are discussed. These results unify the microlensing and occultation limits and should be useful for rapid model fitting of microlensing, eclipse, and "microccultation" events.

[ascl:1303.007] micrOMEGAs: Calculation of dark matter properties

micrOMEGAs calculates the properties of cold dark matter in a generic model of particle physics. First developed to compute the relic density of dark matter, the code also computes the rates for dark matter direct and indirect detection. The code provides the mass spectrum, cross-sections, relic density and exotic fluxes of gamma rays, positrons and antiprotons. The propagation of charged particles in the Galactic halo is handled with a module that allows to easily modify the propagation parameters. The cross-sections for both spin dependent and spin independent interactions of WIMPS on protons are computed automatically as well as the rates for WIMP scattering on nuclei in a large detector. Annihilation cross-sections of the dark matter candidate at zero velocity, relevant for indirect detection of dark matter, are computed automatically, and the propagation of charged particles in the Galactic halo is also handled.

[ascl:1010.008] midIR_sensitivity: Mid-infrared astronomy with METIS

midIR_sensitivity is IDL code that calculates the sensitivity of a ground-based mid-infrared instrument for astronomy. The code was written for the Phase A study of the instrument METIS (http://www.strw.leidenuniv.nl/metis), the Mid-Infrared E-ELT Imager and Spectrograph, for the 42-m European Extremely Large Telescope. The model uses a detailed set of input parameters for site characteristics and atmospheric profiles, optical design, and thermal background. The code and all input parameters are highly tailored for the particular design parameters of the E-ELT and METIS, however, the program is structured in such a way that the parameters can easily be adjusted for a different system, or alternative input files used.

[ascl:1807.016] MIDLL: Markwardt IDL Library

The Markwardt IDL Library contains routines for curve fitting and function minimization, including MPFIT (ascl:1208.019), statistical tests, and non-linear optimization (TNMIN); graphics programs including plotting three-dimensional data as a cube and fixed- or variable-width histograms; adaptive numerical integration (Quadpack), Chebyshev approximation and interpolation, and other mathematical tools; many ephemeris and timing routines; and array and set operations, such as computing the fast product of a large array, efficiently inserting or deleting elements in an array, and performing set operations on numbers and strings; and many other useful and varied routines.

[ascl:1810.019] MIEX: Mie scattering code for large grains

Miex calculates Mie scattering coefficients and efficiency factors for broad grain size distributions and a very wide wavelength range (λ ≈ 10-10-10-2m) of the interacting radiation and incorporates standard solutions of the scattering amplitude functions. The code handles arbitrary size parameters, and single scattering by particle ensembles is calculated by proper averaging of the respective parameters.

[ascl:1511.012] milkywayproject_triggering: Correlation functions for two catalog datasets

This triggering code calculates the correlation function between two astrophysical data catalogs using the Landy-Szalay approximator generalized for heterogeneous datasets (Landy & Szalay, 1993; Bradshaw et al, 2011) or the auto-correlation function of one dataset. It assumes that one catalog has positional information as well as an object size (effective radius), and the other only positional information.

[ascl:1811.010] MillCgs: Searching for Compact Groups in the Millennium Simulation

MillCgs clusters galaxies from the semi-analytic models run on top of the Millennium Simulation to identify Compact Groups. MillCgs uses a machine learning clustering algorithm to find the groups and then runs analytics to filter out the groups that do not fit the user specified criteria. The package downloads the data, processes it, and then creates graphs of the data.

[ascl:2108.005] millennium-tap-query: Python tool to query the Millennium Simulation UWS/TAP client

millennium-tap-query is a simple wrapper for the Python package requests to deal with connections to the Millennium TAP Web Client. With this tool you can perform basic or advanced queries to the Millennium Simulation database and download the data products. millennium-tap-query is similar to the TAP query tool in the German Astrophysical Virtual Observatory (GAVO) VOtables package.

[ascl:0101.001] MILLISEARCH: A Search for Millilensing in BATSE GRB Data

The millisearch.for code was used to generate a new search for the gravitational lens effects of a significant cosmological density of supermassive compact objects (SCOs) on gamma-ray bursts. No signal attributable to millilensing was found. We inspected the timing data of 774 BATSE-triggered GRBs for evidence of millilensing: repeated peaks similar in light-curve shape and spectra. Our null detection leads us to conclude that, in all candidate universes simulated, OmegaSCO < 0.1 is favored for 105 < MSCO/Modot < 109, while in some universes and mass ranges the density limits are as much as 10 times lower. Therefore, a cosmologically significant population of SCOs near globular cluster mass neither came out of the primordial universe, nor condensed at recombination.

[ascl:1911.023] miluphcuda: Smooth particle hydrodynamics code

miluphcuda is the CUDA port of the original miluph code; it runs on single Nvidia GPUs with compute capability 5.0 and higher and provides fast and efficient computation. The code can be used for hydrodynamical simulations and collision and impact physics, and features self-gravity via Barnes-Hut trees and porosity models such as P-alpha and epsilon-alpha. It can model solid bodies, including ductile and brittle materials, as well as non-viscous fluids, granular media, and porous continua.

[ascl:2001.001] Min-CaLM: Mineral compositional analysis on debris disk spectra

Min-CaLM performs automated mineral compositional analysis on debris disk spectra. The user inputs the debris disk spectrum, and using Min-CaLM's built-in mineralogical library, Min-CaLM calculates the relative mineral abundances within the disk. To do this calculation, Min-CaLM converts the debris disk spectrum and the mineralogical library spectra into a system of linear equations, which it then solves using non-negative least square minimization. This code comes with a GitHub tutorial on how to use the Min-CaLM package.

[submitted] MINDS: a hybrid pipeline for the reduction of JWST/MIRI-MRS data

The MINDS package contains a hybrid pipeline based on the jwst pipeline and routines from the VIP package for the reduction of JWST MIRI-MRS data. The pipeline was developed by the MINDS - MIRI mid-INfrared Disk Survey - GTO team in an attempt to compensate for some of the known weaknesses of the official jwst pipeline to improve the quality of spectrum extracted from MIRI-MRS data. This is done by leveraging the capabilities of VIP, another large data reduction package used in the field of high-contrast imaging.
The front end of the pipeline is a highly automated Jupyter notebook. Parameters are typically set in one cell at the beginning of the notebook, and the rest of the notebook can be run without any further modification. The Jupyter notebook format provides flexibility, enhanced visibility of intermediate and final results, more straightforward troubleshooting, and the possibility to easily incorporate additional codes by the user to further analyse or exploit their results.

[ascl:1302.006] Minerva: Cylindrical coordinate extension for Athena

Minerva is a cylindrical coordinate extension of the Athena astrophysical MHD code of Stone, Gardiner, Teuben, and Hawley. The extension follows the approach of Athena's original developers and has been designed to alter the existing Cartesian-coordinates code as minimally and transparently as possible. The numerical equations in cylindrical coordinates are formulated to maintain consistency with constrained transport (CT), a central feature of the Athena algorithm, while making use of previously implemented code modules such as the Riemann solvers. Angular momentum transport, which is critical in astrophysical disk systems dominated by rotation, is treated carefully.

[ascl:2009.012] minot: Modeling framework for diffuse components in galaxy clusters

minot (Modeling of the ICM (Non-)thermal content and Observables prediction Tools) provides a self-consistent modeling framework for the thermal and non-thermal diffuse components in galaxy clusters and predictions multi-wavelength observables. The framework sets or modifies the cluster object according to set parameters and defines the physical and observational properties, which can include thermal gas and CR physics, tSZ, inverse Compton, and radio synchotron. minot then generates outputs, including model parameters, plots, and relationships between models.

[ascl:2203.008] MIRaGe: Multi Instrument Ramp Generator

MIRaGe creates simulated exposures for NIRCam’s imaging and wide field slitless spectroscopy (WFSS) modes, NIRISS’s imaging, WFSS, and aperture masking interferometery (AMI) modes, and FGS’s imaging mode. It supports sidereal as well as non-sidereal tracking; for example, sources can be made to move across the field of view within an observation.

[submitted] MiraPy: Python package for Deep Learning in Astronomy

MiraPy is a Python package for problem-solving in astronomy using Deep Learning for astrophysicist, researchers and students. Current applications of MiraPy are X-Ray Binary classification, ATLAS variable star feature classification, OGLE variable star light-curve classification, HTRU1 dataset classification and Astronomical image reconstruction using encoder-decoder network. It also contains modules for loading various datasets, curve-fitting, visualization and other utilities. It is built using Keras for developing ML models to run on CPU and GPU seamlessly.

[ascl:1106.007] MIRIAD: Multi-channel Image Reconstruction, Image Analysis, and Display

MIRIAD is a radio interferometry data-reduction package, designed for taking raw visibility data through calibration to the image analysis stage. It has been designed to handle any interferometric array, with working examples for BIMA, CARMA, SMA, WSRT, and ATCA. A separate version for ATCA is available, which differs in a few minor ways from the CARMA version.

[ascl:2102.017] mirkwood: SED modeling using machine learning

mirkwood uses supervised machine learning to model non-linearly mapping galaxy fluxes to their properties. Multiple models are stacked to mitigate poor performance by any individual model in a given region of the parameter space. The code accounts for uncertainties arising both from intrinsic noise in observations and from finite training data and incorrect modeling assumptions, and provides highly accurate physical properties from observations of galaxies as compared to traditional SED fitting.

[ascl:1110.025] MIS: A Miriad Interferometry Singledish Toolkit

MIS is a pipeline toolkit using the package MIRIAD to combine Interferometric and Single Dish data. This was prompted by our observations made with the Combined Array For Research in Millimeter-wave Astronomy (CARMA) interferometer of the star-forming region NGC 1333, a large survey highlighting the new 23-element and singledish observing modes. The project consists of 20 CARMA datasets each containing interferometric as well as simultaneously obtained single dish data, for 3 molecular spectral lines and continuum, in 527 different pointings, covering an area of about 8 by 11 arcminutes. A small group of collaborators then shared this toolkit and their parameters via CVS, and scripts were developed to ensure uniform data reduction across the group. The pipeline was run end-to-end each night that new observations were obtained, producing maps that contained all the data to date. This approach could serve as a model for repeated calibration and mapping of large mixed-mode correlation datasets from ALMA.

[ascl:1010.062] MissFITS: Basic Maintenance and Packaging Tasks on FITS Files

MissFITS is a program that performs basic maintenance and packaging tasks on FITS files using an optimized FITS library. MissFITS can:

- add, edit, and remove FITS header keywords;
- split and join Multi-Extension-FITS (MEF) files;
- unpile and pile FITS data-cubes; and,
- create, check, and update FITS checksums, using R. Seaman’s protocol.

[ascl:1505.011] missForest: Nonparametric missing value imputation using random forest

missForest imputes missing values particularly in the case of mixed-type data. It uses a random forest trained on the observed values of a data matrix to predict the missing values. It can be used to impute continuous and/or categorical data including complex interactions and non-linear relations. It yields an out-of-bag (OOB) imputation error estimate without the need of a test set or elaborate cross-validation and can be run in parallel to save computation time. missForest has been used to, among other things, impute variable star colors in an All-Sky Automated Survey (ASAS) dataset of variable stars with no NOMAD match.

[ascl:1910.016] MiSTree: Construct and analyze Minimum Spanning Tree graphs

MiSTree quickly constructs minimum spanning tree graphs for various coordinate systems, including Celestial coordinates, by using a k-nearest neighbor graph (k NN, rather than a matrix of pairwise distances) which is then fed to Kruskal's algorithm to create the graph. MiSTree bins the MST statistics into histograms and plots the distributions; enabling the inclusion of high-order statistics information from the cosmic web to provide additional information that improves cosmological parameter constraints. Though MiSTree was designed for use in cosmology, it can be used in any field requiring extracting non-Gaussian information from point distributions.

[ascl:2112.008] MISTTBORN: MCMC Interface for Synthesis of Transits, Tomography, Binaries, and Others of a Relevant Nature

MISTTBORN can simultaneously fit multiple types of data within an MCMC framework. It handles photometric transit/eclipse, radial velocity, Doppler tomographic, or individual line profile data, for an arbitrary number of datasets in an arbitrary number of photometric bands for an arbitrary number of planets and allows the use of Gaussian process regression to handle correlated noise in photometric or Doppler tomographic data. The code can include dilution due to a nearby unresolved star in the transit fits, and an additional line component due to another star or scattered sun/moonlight in Doppler tomographic or line profile fits. It can also be used for eclipsing binary fits, including a secondary eclipse and radial velocities for both stars. MISTTBORN produces diagnostic plots showing the data and best-fit models and the associated code MISTTBORNPLOTTER produces publication-quality plots and tables.

[ascl:2306.029] Mixclask: Mixing Cloudy and SKIRT

Mixclask combines Cloudy (ascl:9910.001) and SKIRT (ascl:1109.003) to predict spectra and gas properties in astrophysical contexts, such as galaxies and HII regions. The main output is the mean intensity of a region filled with stars, gas and dust at different positions, assuming axial symmetry. The inputs for Mixclask are the stellar and ISM data for each region and an file for the positions (x,y,z) that will be output.

[ascl:1409.001] mixT: single-temperature fit for a multi-component thermal plasma

mixT accurately predicts T derived from a single-temperature fit for a multi-component thermal plasma. It can be applied in the deprojection analysis of objects with the temperature and metallicity gradients, for correction of the PSF effects, for consistent comparison of numerical simulations of galaxy clusters and groups with the X-ray observations, and for estimating how emission from undetected components can bias the global X-ray spectral analysis.

[ascl:1206.010] mkj_libs: Helper routines for plane-fitting & analysis tools

mkj_libs provides a set of helper routines (vector operations, astrometry, statistical analysis of spherical data) for the main plane-fitting and analysis tools.

[ascl:0104.001] MLAPM: Simulating Structure Formation from Collisionless Matter

MLAPM simulates structure formation from collisionless matter. The code, written in C, is purely grid-based and uses a recursively refined Cartesian grid to solve Poisson's equation for the potential, rather than obtaining the potential from a Green's function. Refinements can have arbitrary shapes and in practice closely follow the complex morphology of the density field that evolves. The timestep shortens by a factor two with each successive refinement. It is argued that an appropriate choice of softening length is of great importance and that the softening should be at all points an appropriate multiple of the local inter-particle separation. Unlike tree and P3M codes, multigrid codes automatically satisfy this requirement.

[ascl:2012.005] MLC_ELGs: Machine Learning Classifiers for intermediate redshift Emission Line Galaxies

MLC_EPGs classifies intermediate redshift (z = 0.3–0.8) emission line galaxies as star-forming galaxies, composite galaxies, active galactic nuclei (AGN), or low-ionization nuclear emission regions (LINERs). It uses four supervised machine learning classification algorithms: k-nearest neighbors (KNN), support vector classifier (SVC), random forest (RF), and a multi-layer perceptron (MLP) neural network. For input features, it uses properties that can be measured from optical galaxy spectra out to z < 0.8—[O III]/Hβ, [O II]/Hβ, [O III] line width, and stellar velocity dispersion—and four colors (u−g, g−r, r−i, and i−z) corrected to z = 0.1.

[ascl:2009.010] MLG: Microlensing with Gaia

MLG simulates Gaia measurements for predicted astrometric microlensing events. It fits the motion of the lens and source simultaneously and reconstructs the 11 parameters of the lensing event. For lenses passing by multiple background sources, it also fits the motion of all background sources and the lens simultaneously. A Monte-Carlo simulation is used to determine the achievable precision of the mass determination.

[ascl:1403.003] MLZ: Machine Learning for photo-Z

The parallel Python framework MLZ (Machine Learning and photo-Z) computes fast and robust photometric redshift PDFs using Machine Learning algorithms. It uses a supervised technique with prediction trees and random forest through TPZ that can be used for a regression or a classification problem, or a unsupervised methods with self organizing maps and random atlas called SOMz. These machine learning implementations can be efficiently combined into a more powerful one resulting in robust and accurate probability distributions for photometric redshifts.

[ascl:2205.024] MM-LSD: Multi-Mask Least-Squares Deconvolution

MM-LSD (Multi-Mask Least-Squares Deconvolution) performs continuum normalization of 2D spectra (echelle order spectra). It also masks and partially corrects telluric lines and extracts RVs from spectra. The code requires RASSINE (ascl:2102.022) and uses spectral line data from VALD3.

[ascl:1412.010] MMAS: Make Me A Star

Make Me A Star (MMAS) quickly generates stellar collision remnants and can be used in combination with realistic dynamical simulations of star clusters that include stellar collisions. The code approximates the merger process (including shock heating, hydrodynamic mixing, mass ejection, and angular momentum transfer) with simple algorithms based on conservation laws and a basic qualitative understanding of the hydrodynamics. These simple models agree very well with those from SPH (smoothed particle hydrodynamics) calculations of stellar collisions, and the subsequent stellar evolution of these models also matches closely that of the more accurate hydrodynamic models.

[ascl:1905.005] MMIRS-DRP: MMIRS Data Reduction Pipeline

The MMIRS data reduction pipeline provides complete and flexible data reduction for long-slit and multi-slit spectroscopic observations collected using the MMT and Magellan Infrared Spectrograph (MMIRS). Written in IDL, it offers sky subtraction, correction for telluric absorpition, and is fast enough to permit real-time data reduction for quality control.

[ascl:2307.012] mnms: Map-based Noise ModelS

mnms (Map-based Noise ModelS) creates map-based models of Simons Observatory Atacama Cosmology Telescope (ACT) data. Each model supports drawing map-based simulations from data splits with independent realizations of the noise or equivalent, similar to an independent set of time-domain sims. In addition to the ability to create on-the-fly simulations, mnms also includes ready-made scripts for writing a large batch of products to disk in a dedicated SLURM job.

[ascl:2104.012] Mo'Astro: MongoDB framework for observational astronomy

Mo’Astro is a MongoDB framework for observational astronomy pipelines. Mo'Astro sets up a MongoDB collection of a survey's image set, keeping FITS metadata readily available, and providing a place in the reduction pipeline to persist metadata. Mo’Astro also provides facilities for batch processing images with the Astromatic tool suite, and for hosting a local 2MASS star catalog with spatial-search built-in.

[ascl:2306.010] MOBSE: Massive Objects in Binary Stellar Evolution

MOBSE investigates the demography of merging BHBs. A customized version of the binary stellar evolution code BSE (ascl:1303.014), MOBSE includes metallicity-dependent prescriptions for mass-loss of massive hot stars and upgrades for the evolution of single and binary massive stars.

[ascl:1110.010] MOCASSIN: MOnte CArlo SimulationS of Ionized Nebulae

MOCASSIN is a fully 3D or 2D photoionisation and dust radiative transfer code which employs a Monte Carlo approach to the transfer of radiation through media of arbitrary geometry and density distribution. Written in Fortran, it was originally developed for the modelling of photoionised regions like HII regions and planetary nebulae and has since expanded and been applied to a variety of astrophysical problems, including modelling clumpy dusty supernova envelopes, star forming galaxies, protoplanetary disks and inner shell fluorence emission in the photospheres of stars and disk atmospheres. The code can deal with arbitrary Cartesian grids of variable resolution, it has successfully been used to model complex density fields from SPH calculations and can deal with ionising radiation extending from Lyman edge to the X-ray. The dust and gas microphysics is fully coupled both in the radiation transfer and in the thermal balance.

[ascl:2306.020] mockFRBhosts: Limiting the visibility and follow-up of FRB host galaxies

mockFRBhosts estimates the fraction of FRB hosts that can be cataloged with redshifts by existing and future optical surveys. The package uses frbpoppy (ascl:1911.009) to generate a population of FRBs for a given radio telescope. For each FRB, a host galaxy is drawn from a data base generated by GALFORM (ascl:1510.005). The galaxies' magnitudes in different photometric surveys are calculated as are the number of bands in which they are detected. mockFRBhosts also calculates the follow-up time in a 10-m optical telescope required to do photometry or spectroscopy and provides a simple interface to Bayesian inference methods via MCMC simulations provided in the FRB package (ascl:2306.018).

[ascl:2106.025] ModeChord: Primordial scalar and tensor power spectra solver

ModeChord computes the primordial scalar and tensor power spectra for single field inflationary models. The code solves the inflationary mode equations numerically, avoiding the slow roll approximation. It provides an efficient and robust numerical evaluation of the inflationary perturbation spectrum, and allows the free parameters in the inflationary potential to be estimated. ModeChord also allows the estimation of reheating uncertainties once a potential has been specified.

[ascl:1010.009] ModeCode: Bayesian Parameter Estimation for Inflation

ModeCode is a publicly available code that computes the primordial scalar and tensor power spectra for single field inflationary models. ModeCode solves the inflationary mode equations numerically, avoiding the slow roll approximation. It provides an efficient and robust numerical evaluation of the inflationary perturbation spectrum, and allows the free parameters in the inflationary potential to be estimated within an MCMC computation. ModeCode also allows the estimation of reheating uncertainties once a potential has been specified. It is interfaced with CAMB and CosmoMC to compute cosmic microwave background angular power spectra and perform likelihood analysis and parameter estimation. It can be run as a standalone code as well. Errors in the results from ModeCode contribute negligibly to the error budget for analyses of data from Planck or other next generation experiments.

[ascl:1109.023] MOKA: A New Tool for Strong Lensing Studies

MOKA simulates the gravitational lensing signal from cluster-sized haloes. This algorithm implements recent results from numerical simulations to create realistic lenses with properties independent of numerical resolution and can be used for studies of the strong lensing cross section in dependence of halo structure.

[ascl:1501.013] Molecfit: Telluric absorption correction tool

Molecfit corrects astronomical observations for atmospheric absorption features based on fitting synthetic transmission spectra to the astronomical data, which saves a significant amount of valuable telescope time and increases the instrumental efficiency. Molecfit can also estimate molecular abundances, especially the water vapor content of the Earth’s atmosphere. The tool can be run from a command-line or more conveniently through a GUI.

[ascl:1212.004] MOLIERE-5: Forward and inversion model for sub-mm wavelengths

MOLIERE-5 (Microwave Observation LIne Estimation and REtrieval) is a versatile forward and inversion model for the millimeter and submillimeter wavelengths range and includes an inversion model. The MOLIERE-5 forward model includes modules for the calculation of absorption coefficients, radiative transfer, and instrumental characteristics. The radiative transfer model is supplemented by a sensitivity module for estimating the contribution to the spectrum of each catalog line at its center frequency enabling the model to effectively filter for small spectral lines. The instrument model consists of several independent modules, including the calculation of the convolution of spectra and weighting functions with the spectrometer response functions. The instrument module also provides several options for modeling of frequency-switched observations. The MOLIERE-5 inversion model calculates linear Optimal Estimation, a least-squares retrieval method which uses statistical apriori knowledge on the retrieved parameters for the regularization of ill-posed inversion problems and computes diagnostics such as the measurement and smoothing error covariance matrices along with contribution and averaging kernel functions.

[ascl:1907.012] molly: 1D astronomical spectra analyzer

molly analyzes 1D astronomical spectra. Its prime purpose is for handling large numbers of similar spectra (e.g., time series spectroscopy), but it contains many of the standard operations used for normal spectrum analysis as well. It overlaps with the various similar programs such as dipso (ascl:1405.016) and has strengths (particularly for time series spectra) and weaknesses compared to them.

[ascl:1206.004] MOLSCAT: MOLecular SCATtering v. 14

MOLSCAT version 14 is a FORTRAN code for quantum mechanical (coupled channel) solution of the nonreactive molecular scattering problem and was developed to obtain collision rates for molecules in the interstellar gas which are needed to understand microwave and infrared astronomical observations. The code is implemented for various types of collision partners. In addition to the essentially exact close coupling method several approximate methods, including the Coupled States and Infinite Order Sudden approximations, are provided. This version of the code has been superseded by MOLSCAT 2020 (ascl:2010.001).

[ascl:1908.002] Molsoft: Molonglo Telescope Observing Software

Molsoft operates, monitors and schedules observations, both through predetermined schedule files and fully dynamically, at the refurbished Molonglo Observatory Synthesis Radio Telescope (MOST). It was developed as part of the UTMOST upgrade of the facility. The software runs a large-scale pulsar timing program; the autonomous observing system and the dynamic scheduler have increased the observing efficiency by a factor of 2-3 in comparison with static scheduling.

[ascl:2311.006] MONDPMesh: Particle-mesh code for Milgromian dynamics

MONDPMesh provides a particle-mesh method to calculate the time evolution of an system of point masses under modified gravity, namely the AQUAL formalism. This is done by transforming the Poisson equation for the potential into a system of four linear PDEs, and solving these using fast Fourier transforms. The accelerations on the point masses are calculated from this potential, and the system is propagated using Leapfrog integration. The time complexity of the code is O(N⋅p⋅log(p)) for p pixels and N particles, which is the same as for a Newtonian particle-mesh code.

[ascl:2204.020] MonoTools: Planets of uncertain periods detector and modeler

MonoTools detects, vets, and models transiting exoplanets, with a specific emphasis on monotransiting planets and those with unknown periods. It includes scripts specifically for searching and assessing a lightcurve for the presence of monotransits. MonoTools can also performing a best-fit transit model, determine whether transits are linked to any detected multi-transiting planet candidate or with each other, and can fit planets in a Bayesian way to account for uncertain periods, lightcurve gaps, and stellar variability, among other things.

[ascl:1010.036] Montage: An Astronomical Image Mosaicking Toolkit

Montage is an open source code toolkit for assembling Flexible Image Transport System (FITS) images into custom mosaics. It runs on all common Linux/Unix platforms, on desktops, clusters and computational grids, and supports all World Coordinate System (WCS) projections and common coordinate systems. Montage preserves spatial and calibration fidelity of input images, processes 40 million pixels in up to 32 minutes on 128 nodes on a Linux cluster, and provides independent engines for analyzing the geometry of images on the sky, re-projecting images, rectifying background emission to a common level, and co-adding images. It offers convenient tools for managing and manipulating large image files.

[ascl:1502.006] Montblanc: GPU accelerated Radio Interferometer Measurement Equations in support of Bayesian Inference for Radio Observations

Montblanc, written in Python, is a GPU implementation of the Radio interferometer measurement equation (RIME) in support of the Bayesian inference for radio observations (BIRO) technique. The parameter space that BIRO explores results in tens of thousands of computationally expensive RIME evaluations before reduction to a single X2 value. The RIME is calculated over four dimensions, time, baseline, channel and source and the values in this 4D space can be independently calculated; therefore, the RIME is particularly amenable to a parallel implementation accelerated by Graphics Programming Units (GPUs). Montblanc is implemented for NVIDIA's CUDA architecture and outperforms MeqTrees (ascl:1209.010) and OSKAR.

[ascl:1307.002] Monte Python: Monte Carlo code for CLASS in Python

Monte Python is a parameter inference code which combines the flexibility of the python language and the robustness of the cosmological code CLASS (ascl:1106.020) into a simple and easy to manipulate Monte Carlo Markov Chain code.

This version has been archived and replaced by MontePython 3 (ascl:1805.027).

[ascl:1805.027] MontePython 3: Parameter inference code for cosmology

MontePython 3 provides numerous ways to explore parameter space using Monte Carlo Markov Chain (MCMC) sampling, including Metropolis-Hastings, Nested Sampling, Cosmo Hammer, and a Fisher sampling method. This improved version of the Monte Python (ascl:1307.002) parameter inference code for cosmology offers new ingredients that improve the performance of Metropolis-Hastings sampling, speeding up convergence and offering significant time improvement in difficult runs. Additional likelihoods and plotting options are available, as are post-processing algorithms such as Importance Sampling and Adding Derived Parameter.

[ascl:2308.001] MOOG_SCAT: Scattering version of the MOOG Line Transfer Code

MOOG_SCAT, a redevelopment of the LTE radiative transfer code MOOG (ascl:1202.009), contains modifications that allow for the treatment of isotropic, coherent scattering in stars. MOOG_SCAT employs a modified form of the source function and solves radiative transfer with a short charactersitics approach and an acclerated lambda iteration scheme.

[ascl:1202.009] MOOG: LTE line analysis and spectrum synthesis

MOOG performs a variety of LTE line analysis and spectrum synthesis tasks. The typical use of MOOG is to assist in the determination of the chemical composition of a star. The basic equations of LTE stellar line analysis are followed. The coding is in various subroutines that are called from a few driver routines; these routines are written in standard FORTRAN. The standard MOOG version has been developed on unix, linux and macintosh computers.

One of the chief assets of MOOG is its ability to do on-line graphics. The plotting commands are given within the FORTRAN code. MOOG uses the graphics package SM, chosen for its ease of implementation in FORTRAN codes. Plotting calls are concentrated in just a few routines, and it should be possible for users of other graphics packages to substitute other appropriate FORTRAN commands.

[ascl:1308.018] MoogStokes: Zeeman polarized radiative transfer

MOOGStokes is a version of the MOOG one-dimensional local thermodynamic equilibrium radiative transfer code that incorporates a Stokes vector treatment of polarized radiation through a magnetic medium. It consists of three complementary programs that together can synthesize the disk-averaged emergent spectrum of a star with a magnetic field. The MOOGStokes package synthesizes emergent spectra of stars with magnetic fields in a familiar computational framework and produces disk-averaged spectra for all Stokes vectors ( I, Q, U, V ), normalized by the continuum.

[ascl:1111.006] MOPEX: MOsaicker and Point source EXtractor

MOPEX (MOsaicker and Point source EXtractor) is a package for reducing and analyzing imaging data, as well as MIPS SED data. MOPEX includes the point source extraction package, APEX.
MOPEX is designed to allow the user to:

  • perform sophisticated background matching of individual data frames
  • mosaic the individual frames downloaded from the Spitzer archive
  • perform both temporal and spatial outlier rejection during mosaicking
  • apply offline pointing refinement for MIPS data (refinement is already applied to IRAC data)
  • perform source detection on the mosaics using APEX
  • compute aperture photometry or PRF-fitting photometry for point sources
  • perform interpolation, coaddition, and spectrum extraction of MIPS SED images.
MOPEX comes in two different interfaces (GUI and command-line), both of which come packaged together. We recommend that all new users start with the GUI, which is more user-friendly than the command-line interface

[ascl:1303.011] MOPSIC: Extended Version of MOPSI

MOPSIC was created to analyze bolometer data but can be used for much more versatile tasks. It is an extension of MOPSI; this software had been merged with the command interpreter of GILDAS (ascl:1305.010). For data reduction, MOPSIC uses a special method to calculate the chopped signal. This gives much better results than the straight difference of the signals obtained at both chopper positions. In addition there are also scripts to reduce pointings, skydips, and to calculate the RCPs (Receiver Channel Parameters) from calibration maps. MOPSIC offers a much broader range of applications including advanced planning functions for mapping and onoff observations, post-reduction data analysis and processing and even reduction of non-bolometer data (optical, IR, spectroscopy).

[ascl:1911.014] MORDI: Massively-Overlapped Ring-Diagram Inversion

MORDI (Massively-Overlapped Ring-Diagram Inversion) performs three-dimensional ring-diagram inversions. The code reads in frequency shift measurements and their associated sensitivity kernels and outputs two-dimensional slices of the subsurface flow field at a constant depth and (optionally) the associated averaging kernels. It relies on both distributed-memory (MPI) and shared-memory (OpenMP) parallelism to scale efficiently up to a few thousand processors, but can also run reasonably well on small machines (1-4 cpus). The actions of the code are modified by command-line parameters, which enable a significant amount of flexibility when setting up an inversion.

[ascl:1906.013] MORPHEUS: A 3D Eulerian Godunov MPI-OpenMP hydrodynamics code with multiple grid geometries

MORPHEUS (Manchester Omni-geometRical Program for Hydrodynamical EUlerian Simulations) is a 3D hydrodynamical code used to simulate astrophysical fluid flows. It has three different grid geometries (cartesian, spherical, and cylindrical) and uses a second-order Godunov method to solve the equations of hydrodynamics. Physical modules also include radiative cooling and gravity, and a hybrid MPI-OpenMP parallelization allows computations to be run on large-scale architectures. MORPHEUS is written in Fortran90 and does not require any libraries (apart from MPI) to run.

[ascl:1906.012] Morpheus: Library to generate morphological semantic segmentation maps of astronomical images

Morpheus generates pixel level morphological classifications of astronomical sources by leveraging advances in deep learning to perform source detection, source segmentation, and morphological classification pixel-by-pixel via a semantic segmentation algorithm adopted from the field of computer vision. By utilizing morphological information about the flux of real astronomical sources during object detection, Morpheus shows resiliency to false positive identifications of sources.

[ascl:2303.018] MORPHOFIT: Morphological analysis of galaxies

MORPHOFIT consists of a series of modules for estimating galaxy structural parameters. The package uses SEXTRACTOR (ascl:1010.064) in forced photometry mode to get an initial estimate of the galaxy structural parameters and create a multiband catalog. It also uses GALFIT (ascl:1010.064), running it on galaxy stamps and galaxy regions from the parent image and also on galaxies from the full image using SEXTRACTOR properties as input. MORPHOFIT has been optimized and tested in both low-density and crowded environments, and can recover the input structural parameters of galaxies with good accuracy.

[ascl:2102.020] MOSAIC: Multipole operator generator for Fast Multipole Method operators

MOSAIC (Multipole Operators in Symbols, Automatically Improved and Condensed) automatically produces, verifies, and optimizes computer code for Fast Multipole Method (FMM) operators. It is based on a symbolic algebra library, and can produce code for any expansion order and be extended to use any basis or kernel function. The code applies algebraic modifications to reduce the number of floating-point operations and can symbolically verify correctness.

[ascl:1908.007] MosfireDRP: MOSFIRE Data Reduction Pipeline

MosfireDRP reduces data from the MOSFIRE spectrograph of the Keck Observatory; it produces flat-fielded, wavelength calibrated, rectified, and stacked 2D spectrograms for each slit on a given mask in nearly real time. Background subtraction is performed in two states: a simple pairwise subtraction of interleaved stacks, and then fitting a 2D b-spline model to the background residuals.

[ascl:1710.006] MOSFiT: Modular Open-Source Fitter for Transients

MOSFiT (Modular Open-Source Fitter for Transients) downloads transient datasets from open online catalogs (e.g., the Open Supernova Catalog), generates Monte Carlo ensembles of semi-analytical light curve fits to those datasets and their associated Bayesian parameter posteriors, and optionally delivers the fitting results back to those same catalogs to make them available to the rest of the community. MOSFiT helps bridge the gap between observations and theory in time-domain astronomy; in addition to making the application of existing models and creation of new models as simple as possible, MOSFiT yields statistically robust predictions for transient characteristics, with a standard output format that includes all the setup information necessary to reproduce a given result.

[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:1208.019] MPFIT: Robust non-linear least squares curve fitting

These IDL routines provide a robust and relatively fast way to perform least-squares curve and surface fitting. The algorithms are translated from MINPACK-1, which is a rugged minimization routine found on Netlib, and distributed with permission. This algorithm is more desirable than CURVEFIT because it is generally more stable and less likely to crash than the brute-force approach taken by CURVEFIT, which is based upon Numerical Recipes.

[ascl:1304.014] MPgrafic: A parallel MPI version of Grafic-1

MPgrafic is a parallel MPI version of Grafic-1 (ascl:9910.004) which can produce large cosmological initial conditions on a cluster without requiring shared memory. The real Fourier transforms are carried in place using fftw while minimizing the amount of used memory (at the expense of performance) in the spirit of Grafic-1. The writing of the output file is also carried in parallel. In addition to the technical parallelization, it provides three extensions over Grafic-1:

  • it can produce power spectra with baryon wiggles (DJ Eisenstein and W. Hu, Ap. J. 496);
  • it has the optional ability to load a lower resolution noise map corresponding to the low frequency component which will fix the larger scale modes of the simulation (extra flag 0/1 at the end of the input process) in the spirit of Grafic-2 (ascl:1106.008);
  • it can be used in conjunction with constrfield, which generates initial conditions phases from a list of local constraints on density, tidal field density gradient and velocity.

[ascl:1712.002] MPI_XSTAR: MPI-based parallelization of XSTAR program

MPI_XSTAR parallelizes execution of multiple XSTAR runs using Message Passing Interface (MPI). XSTAR (ascl:9910.008), part of the HEASARC's HEAsoft (ascl:1408.004) package, calculates the physical conditions and emission spectra of ionized gases. MPI_XSTAR invokes XSTINITABLE from HEASoft to generate a job list of XSTAR commands for given physical parameters. The job list is used to make directories in ascending order, where each individual XSTAR is spawned on each processor and outputs are saved. HEASoft's XSTAR2TABLE program is invoked upon the contents of each directory in order to produce table model FITS files for spectroscopy analysis tools.

[ascl:1208.014] MPI-AMRVAC: MPI-Adaptive Mesh Refinement-Versatile Advection Code

MPI-AMRVAC is an MPI-parallelized Adaptive Mesh Refinement code, with some heritage (in the solver part) to the Versatile Advection Code or VAC, initiated by Gábor Tóth at the Astronomical Institute at Utrecht in November 1994, with help from Rony Keppens since 1996. Previous incarnations of the Adaptive Mesh Refinement version of VAC were of restricted use only, and have been used for basic research in AMR strategies, or for well-targeted applications. This MPI version uses a full octree block-based approach, and allows for general orthogonal coordinate systems. MPI-AMRVAC aims to advance any system of (primarily hyperbolic) partial differential equations by a number of different numerical schemes. The emphasis is on (near) conservation laws, with shock-dominated problems as a main research target. The actual equations are stored in separate modules, can be added if needed, and they can be selected by a simple configuration of the VACPP preprocessor. The dimensionality of the problem is also set through VACPP. The numerical schemes are able to handle discontinuities and smooth flows as well.

[ascl:1106.022] MPI-Defrost: Extension of Defrost to MPI-based Cluster Environment

MPI-Defrost extends Frolov’s Defrost (ascl:1011.012) to an MPI-based cluster environment. This version has been restricted to a single field. Restoring two-field support should be straightforward, but will require some code changes. Some output options may also not be fully supported under MPI.

This code was produced to support our own work, and has been made available for the benefit of anyone interested in either oscillon simulations or an MPI capable version of Defrost, and it is provided on an "as-is" basis. Andrei Frolov is the primary developer of Defrost and we thank him for placing his work under the GPL (GNU Public License), and thus allowing us to distribute this modified version.

[ascl:2007.008] MPSolve: Multiprecision Polynomial SOLVEr

MPSolve (Multiprecision Polynomial SOLVEr) provides an easy-to-use universal blackbox for solving polynomials and secular equations. Its features include arbitrary precision approximation and guaranteed inclusion radii for the results. It can exploit polynomial structures, taking advantage of sparsity as well as coefficients in a particular domain (i.e., integers or rationals), and can be specialized for specific classes of polynomials.

[ascl:1212.003] MPWide: Light-weight communication library for distributed computing

MPWide is a light-weight communication library for distributed computing. It is specifically developed to allow message passing over long-distance networks using path-specific optimizations. An early version of MPWide was used in the Gravitational Billion Body Project to allow simulations across multiple supercomputers.

[ascl:1912.020] MRExo: Non-parametric mass-radius relationship for exoplanets

MRExo performs non-parametric fitting and analysis of the mass-radius (M-R) relationship for exoplanets. Written in Python, it offers tools for fitting the M-R relationship to a given data set and also includes predicting (M->R, and R->M) and plotting functions.

[ascl:1102.005] MRLENS: Multi-Resolution methods for gravitational LENSing

The MRLENS package offers a new method for the reconstruction of weak lensing mass maps. It uses the multiscale entropy concept, which is based on wavelets, and the False Discovery Rate which allows us to derive robust detection levels in wavelet space. We show that this new restoration approach outperforms several standard techniques currently used for weak shear mass reconstruction. This method can also be used to separate E and B modes in the shear field, and thus test for the presence of residual systematic effects. We concentrate on large blind cosmic shear surveys, and illustrate our results using simulated shear maps derived from N-Body Lambda-CDM simulations with added noise corresponding to both ground-based and space-based observations.

[ascl:1809.015] MrMoose: Multi-Resolution Multi-Object/Origin Spectral Energy distribution fitting procedure

MrMoose (Multi-Resolution Multi-Object/Origin Spectral Energy) fits user-defined models onto a set of multi-wavelength data using a Bayesian framework. The code can handle blended sources, large variation in resolution, and even upper limits consistently. It also generates a series of outputs allowing for an quick interpretation of the results. The code uses emcee (ascl:1303.002), and saves the emcee sampler object, thus allowing users to transfer the output to a personal graphical interface.

[ascl:1802.015] mrpy: Renormalized generalized gamma distribution for HMF and galaxy ensemble properties comparisons

mrpy calculates the MRP parameterization of the Halo Mass Function. It calculates basic statistics of the truncated generalized gamma distribution (TGGD) with the TGGD class, including mean, mode, variance, skewness, pdf, and cdf. It generates MRP quantities with the MRP class, such as differential number counts and cumulative number counts, and offers various methods for generating normalizations. It can generate the MRP-based halo mass function as a function of physical parameters via the mrp_b13 function, and fit MRP parameters to data in the form of arbitrary curves and in the form of a sample of variates with the SimFit class. mrpy also calculates analytic hessians and jacobians at any point, and allows the user to alternate parameterizations of the same form via the reparameterize module.

[ascl:1504.016] MRrelation: Posterior predictive mass distribution

MRrelation calculates the posterior predictive mass distribution for an individual planet. The probabilistic mass-radius relationship (M-R relation) is evaluated within a Bayesian framework, which both quantifies this intrinsic dispersion and the uncertainties on the M-R relation parameters.

[submitted] MRS: The MOS Reduction Software

The MRS (The MOS Reduction Software) suite reduces the spectra taken with the multi-object spectrograph spectra used as the focal plane instrument of RTT150 telescope in the TÜBİTAK National Observatory.

[ascl:1112.010] MRS3D: 3D Spherical Wavelet Transform on the Sphere

Future cosmological surveys will provide 3D large scale structure maps with large sky coverage, for which a 3D Spherical Fourier-Bessel (SFB) analysis is natural. Wavelets are particularly well-suited to the analysis and denoising of cosmological data, but a spherical 3D isotropic wavelet transform does not currently exist to analyse spherical 3D data. We present a new fast Discrete Spherical Fourier-Bessel Transform (DSFBT) based on both a discrete Bessel Transform and the HEALPIX angular pixelisation scheme. We tested the 3D wavelet transform and as a toy-application, applied a denoising algorithm in wavelet space to the Virgo large box cosmological simulations and found we can successfully remove noise without much loss to the large scale structure. The new spherical 3D isotropic wavelet transform, called MRS3D, is ideally suited to analysing and denoising future 3D spherical cosmological surveys; it uses a novel discrete spherical Fourier-Bessel Transform. MRS3D is based on two packages, IDL and Healpix and can be used only if these two packages have been installed.

[ascl:2009.024] MSL: Mining for Substructure Lenses

MSL applies simulation-based inference techniques to the problem of substructure inference in galaxy-galaxy strong lenses. It leverages additional information extracted from the simulator, then trains neural networks to estimate likelihood ratios associated with population-level parameters characterizing dark matter substructure. The package including five high-level scripts which run the simulation and create samples, combing multiple simulation runs into a single file to use for training, then train the neural networks. After training, the estimated likelihood ratio is tested, and calibrated network predictions are made based on histograms of the network output.

[ascl:1709.007] MSSC: Multi-Source Self-Calibration

Multi-Source Self-Calibration (MSSC) provides direction-dependent calibration to standard phase referencing. The code combines multiple faint sources detected within the primary beam to derive phase corrections. Each source has its CLEAN model divided into the visibilities which results in multiple point sources that are stacked in the uv plane to increase the S/N, thus permitting self-calibration. This process applies only to wide-field VLBI data sets that detect and image multiple sources within one epoch.

[ascl:2102.002] MST: Minimum Spanning Tree algorithm for identifying large-scale filaments

MST (Minimum Spanning Tree) identifies velocity coherent large-scale filaments through ATLASGAL clumps. It can also isolate filaments embedded in a crowded position–position–velocity (PPV) space. One strength of this method is its repeatability compared to manual approaches.

[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:2212.005] MTNeedlet: Spherical maps filtering

MTNeedlet uses needlets to filter spherical (Healpix) maps and detect and analyze the maxima population using a multiple testing approach. It has been developed with the CMB in mind, but it can be applied to other spherical maps. It pivots around three basic steps: 1.) The calculation of several types of needlets and their possible use to filter maps; 2.) The detection of maxima (or minima) on spherical maps, their visualization and basic analysis; and 3.) The multiple testing approach in order to detect anomalies in the maxima population of the maps with respect to the expected behavior for a random Gaussian map. MTNeedlet relies on Healpy (ascl:2008.022) to efficiently deal with spherical maps.

[ascl:1710.011] mTransport: Two-point-correlation function calculator

mTransport computes the 2-point-correlation function of the curvature and tensor perturbations in multifield models of inflation in the presence of a curved field space. It is a Mathematica implementation of the transport method which encompasses scenarios with violations of slow-roll conditions and turns of the trajectory in field space. It can be used for an arbitrary mass spectrum, including massive modes, particle production and models with quasi-single-field dynamics.

[ascl:1811.012] muLAn: gravitational MICROlensing Analysis Software

muLAn analyzes and fits light curves of gravitational microlensing events. The code includes all classical microlensing models (for example, single and binary microlenses, ground- and space-based parallax effects, orbital motion, finite-source effects, and limb-darkening); these can be combined into several time intervals of the analyzed light curve. Minimization methods include an Affine-Invariant Ensemble Sampler to generate a multivariate proposal function while running several Markov Chain Monte Carlo (MCMC) chains, for the set of parameters which is chosen to be fit; non-fitting parameters can be either kept fixed or set on a grid defined by the user. Furthermore, the software offers a model-free option to align all data sets together and allow inspection the light curve before any modeling work. It also comes with many useful routines (export publication-quality figures, data formatting and cleaning) and state-of-the-art statistical tools.

Modeling results can be interpreted using an interactive html page which contains all information about the light curve model, caustics, source trajectory, best-fit parameters and chi-square. Parameters uncertainties and statistical properties (such as multi-modal features of the posterior density) can be assessed from correlation plots. The code is modular, allowing the addition of other computation or minimization routines by directly adding their Python files without modifying the main code. The software has been designed to be easy to use even for the newcomer in microlensing, with external, synthetic and self-explanatory setup files containing all important commands and option settings. The user may choose to launch the code through command line instructions, or to import muLAn within another Python project like any standard Python package.

[ascl:1803.006] MulensModel: Microlensing light curves modeling

MulensModel calculates light curves of microlensing events. Both single and binary lens events are modeled and various higher-order effects can be included: extended source (with limb-darkening), annual microlensing parallax, and satellite microlensing parallax. The code is object-oriented and written in Python3, and requires AstroPy (ascl:1304.002).

[ascl:2102.023] Multi_CLASS: Cross-tracer angular power spectra of number counts using CLASS

Multi_CLASS modifies the Boltzmann code CLASS (ascl:1106.020) to compute of the cross-tracer angular power spectra of the number count fluctuations for two different tracers of the underlying dark matter density field. In other words, it generalizes the standard nCl output option of CLASS to the case of two different tracers, for example, two different galaxy populations with their own redshift distribution, and galaxy and magnification bias parameters, among others.

Multi_CLASS also includes an implementation of the effect of primordial non-Gaussianities of the local type, parametrized by the parameter f_NL (following the large-scale structure convention), on the effective bias of the tracers. There is also the possibility of having a tilted non-Gaussian correction, parametrized by n_NG, with a pivot scale determined by k_pivot_NG. The package includes galaxy redshift distributions for forthcoming galaxy surveys, with the ease of choosing between them (or an input file) from the parameters input file (e.g., multi_explanatory.ini). In addition, Multi_CLASS includes the possibility of using resolved gravitational wave events as a tracer.

[ascl:1506.004] multiband_LS: Multiband Lomb-Scargle Periodograms

The multiband periodogram is a general extension of the well-known Lomb-Scargle approach for detecting periodic signals in time-domain data. In addition to advantages of the Lomb-Scargle method such as treatment of non-uniform sampling and heteroscedastic errors, the multiband periodogram significantly improves period finding for randomly sampled multiband light curves (e.g., Pan-STARRS, DES and LSST). The light curves in each band are modeled as arbitrary truncated Fourier series, with the period and phase shared across all bands.

[ascl:1909.002] MultiColorFits: Colorize and combine multiple fits images for visually aesthetic scientific plots

MultiColorFits is a tool to colorize and combine multiple fits images for making visually aesthetic scientific plots. The standard method to make color composites by combining fits images programmatically in python is to assign three images as separate red, green, and blue channels. This can produce unsatisfactory results for a variety of reasons, such as when less than three images are available, or additional images are desired to be shown. MultiColorFits breaks these limitations by allowing users to apply any color to a given image, not just red, green, or blue. Composites can then be created from an arbitrary number of images. Controls are included for stretching brightness scales with common functions.

[ascl:2207.001] MULTIGRIS: Multicomponent probabilistic grid search

MULTIGRIS (also called mgris) uses the sequential Monte Carlo method in PyMC (ascl:1506.005) to extract the posterior distributions of primary grid parameters and predict unobserved parameters/observables. The code accepts either a discrete number of components and/or continuous (e.g., power-law, normal) distributions for any given parameter. MULTIGRIS, written in Python, infers the posterior probability functions of parameters in a multidimensional potentially incomplete grid with some observational tracers defined for each parameter set. Observed values and their potentially asymmetric uncertainties are used to calculate a likelihood which, together with predefined or custom priors, produces the posterior distributions. Linear combinations of parameter sets may be used with inferred mixing weights and nearest neighbor or linear interpolation may be used to sample the parameter space.

[ascl:2106.027] MultiModeCode: Numerical exploration of multifield inflation models

MultiModeCode facilitates efficient Monte Carlo sampling of prior probabilities for inflationary model parameters and initial conditions and efficiently generates large sample-sets for inflation models with O(100) fields. The code numerically solves the equations of motion for the background and first-order perturbations of multi-field inflation models with canonical kinetic terms and arbitrary potentials, providing the adiabatic, isocurvature, and tensor power spectra at the end of inflation. For models with sum-separable potentials MultiModeCode also computes the slow-roll prediction via the δN formalism for easy model exploration and validation.

[ascl:2207.006] MultiModes: Efficiently analyze pulsating stars

MultiModes extracts the most significant frequencies of a sample of classical pulsating stars. The code takes a directory with light curves and initial parameters as input. For every light curve, the code calculates the frequencies spectrum, or periodogram, with the Fast Lomb Scargle algorithm, extracts the higher amplitude peak, and evaluates whether it is a real signal or noise. It fits frequency, amplitude, and phase through non-linear optimization, using a multisine function. This function is redefined with the new calculated parameters. MultiModes then does a simultaneous fit of a number of peaks (20 by default), subtracts them from the original signal, and goes back to the beginning of the loop with the residual, repeating the same process until the stop criterion is reached. After that, the code can filter suspicious spurious frequencies, those of low amplitude below the Rayleigh resolution, and possible combined frequencies.

[ascl:1109.006] MultiNest: Efficient and Robust Bayesian Inference

We present further development and the first public release of our multimodal nested sampling algorithm, called MultiNest. This Bayesian inference tool calculates the evidence, with an associated error estimate, and produces posterior samples from distributions that may contain multiple modes and pronounced (curving) degeneracies in high dimensions. The developments presented here lead to further substantial improvements in sampling efficiency and robustness, as compared to the original algorithm presented in Feroz & Hobson (2008), which itself significantly outperformed existing MCMC techniques in a wide range of astrophysical inference problems. The accuracy and economy of the MultiNest algorithm is demonstrated by application to two toy problems and to a cosmological inference problem focusing on the extension of the vanilla $Lambda$CDM model to include spatial curvature and a varying equation of state for dark energy. The MultiNest software is fully parallelized using MPI and includes an interface to CosmoMC (ascl:1106.025). It will also be released as part of the SuperBayeS package (ascl:1109.007) for the analysis of supersymmetric theories of particle physics.

[ascl:1109.008] Multipole Vectors: Decomposing Functions on a Sphere

We propose a novel representation of cosmic microwave anisotropy maps, where each multipole order l is represented by l unit vectors pointing in directions on the sky and an overall magnitude. These "multipole vectors and scalars" transform as vectors under rotations. Like the usual spherical harmonics, multipole vectors form an irreducible representation of the proper rotation group SO(3). However, they are related to the familiar spherical harmonic coefficients, alm, in a nonlinear way, and are therefore sensitive to different aspects of the CMB anisotropy. Nevertheless, it is straightforward to determine the multipole vectors for a given CMB map and we present an algorithm to compute them. Using the WMAP full-sky maps, we perform several tests of the hypothesis that the CMB anisotropy is statistically isotropic and Gaussian random. We find that the result from comparing the oriented area of planes defined by these vectors between multipole pairs 2<=l1!=l2<=8 is inconsistent with the isotropic Gaussian hypothesis at the 99.4% level for the ILC map and at 98.9% level for the cleaned map of Tegmark et al. A particular correlation is suggested between the l=3 and l=8 multipoles, as well as several other pairs. This effect is entirely different from the now familiar planarity and alignment of the quadrupole and octupole: while the aforementioned is fairly unlikely, the multipole vectors indicate correlations not expected in Gaussian random skies that make them unusually likely. The result persists after accounting for pixel noise and after assuming a residual 10% dust contamination in the cleaned WMAP map. While the definitive analysis of these results will require more work, we hope that multipole vectors will become a valuable tool for various cosmological tests, in particular those of cosmic isotropy.

[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:1402.006] Munipack: General astronomical image processing software

Munipack provides easy-to-use tools for all astronomical astrometry and photometry, access to Virtual Observatory as well as FITS files operations and a simple user interface along with a powerful processing engine. Its many features include a FITS images viewer that allows for basic (astronomical) operations with frames, advanced image processor supporting an infinite dynamic range and advanced color management, and astrometric calibration of images. The astrometry module uses robust statistical estimators and algorithms. The photometry module provides the classical method detection of stars and implements the aperture photometry, calibrated on the basis of photon statistics, and allows for the automatic detection and aperture photometry of stars; calibration on absolute fluxes is possible. The software also provides a standard way to correct for all the bias, dark and flat-field frames, and many other features.

[ascl:2207.013] MuSCAT2_transit_pipeline: MuSCAT2 photometry and transit analysis pipelines

MuSCAT2_transit_pipeline provides photometry and transit analysis pipelines for MuSCAT2. It consists of a set of executable scripts and two Python packages: muscat2ph for photometry, and muscat2ta for transit analysis. The MuSCAT2 photometry can be carried out using the scripts only. The transit analysis can also in most cases be done using the main transit analysis script m2fit, but the muscat2ta package also offers high-level classes that can be used to carry out more customized transit analysis as a Python script (or Jupyter notebook).

[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: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:2102.012] MUSE-PSFR: PSF reconstruction for MUSE WFM-AO mode

MUSE-PSFR reconstructs a PSF for the MUSE WFM-AO mode using telemetry data from SPARTA. The algorithm conducts a Fourier analysis of the laser-assisted ground layer adaptive optics (GLAO) residual phase statistics and has been test in end-to-end simulations. A sensitivity analysis was conducted to determine the required accuracy in terms of input parameters. MUSE-PSFR is capable of reconstructing the critical parameters of a PSF and can be used with MUSE 3D data by all MUSE users.

[ascl:1311.011] MUSIC: MUlti-Scale Initial Conditions

MUSIC generates multi-scale initial conditions with multiple levels of refinements for cosmological ‘zoom-in’ simulations. The code uses an adaptive convolution of Gaussian white noise with a real-space transfer function kernel together with an adaptive multi-grid Poisson solver to generate displacements and velocities following first- (1LPT) or second-order Lagrangian perturbation theory (2LPT). MUSIC achieves rms relative errors of the order of 10−4 for displacements and velocities in the refinement region and thus improves in terms of errors by about two orders of magnitude over previous approaches. In addition, errors are localized at coarse-fine boundaries and do not suffer from Fourier space-induced interference ringing.

[ascl:2008.024] MUSIC2-monofonIC: 3LPT initial condition generator

The original MUSIC code (ascl:1311.011) was designed to provide initial conditions for zoom initial conditions and is limited for applications to large-scale cosmological simulations. MUSIC2-monofonIC generates high order LPT/PPT cosmological initial conditions for single resolution cosmological simulations, and can be used for rapid predictions of large-scale structure. MUSIC2-monofonIC offers support for up to 3rd order Lagrangian perturbation theory, PPT (Semiclassical PT for Eulerian grids) up to 2nd order, and for mixed CDM+baryon sims. It direct interfaces with CLASS and can use file input from CAMB; it offers multiple output modules for RAMSES (ascl:1011.007), Arepo (ascl:1909.010), Gadget-2/3 (ascl:0003.001), and HACC via plugins, and new modules/plugins can be easily added.

[ascl:2205.011] myRadex: Radex with a twist

myRadex solves essentially the same problem as RADEX (ascl:1010.075), except that it takes a different approach to solve the statistical equilibrium problem. Given an initial distribution, myRadex evolves the system towards equilibrium using an ODE solver. Frequencies in the input file are used by default, and a function for calculating critical densities of all the transitions of a molecule is included.

[ascl:2206.006] MYRaf: Aperture photometry GUI for IRAF

MYRaf is a practicable astronomical image reduction and photometry software and interface for IRAF (ascl:9911.002). The library uses IRAF, PyRAF (ascl:1207.011), Ginga (ascl:1303.020), and other python packages with a Qt framework for automated software processing of data from robotic telescopes.

[ascl:1203.009] MYRIAD: N-body code for simulations of star clusters

MYRIAD is a C++ code for collisional N-body simulations of star clusters. The code uses the Hermite fourth-order scheme with block time steps, for advancing the particles in time, while the forces and neighboring particles are computed using the GRAPE-6 board. Special treatment is used for close encounters, binary and multiple sub-systems that either form dynamically or exist in the initial configuration. The structure of the code is modular and allows the appropriate treatment of more physical phenomena, such as stellar and binary evolution, stellar collisions and evolution of close black-hole binaries. Moreover, it can be easily modified so that the part of the code that uses GRAPE-6 could be replaced by another module that uses other accelerating-hardware like the Graphics Processing Units (GPUs). Appropriate choice of the free parameters give a good accuracy and speed for simulations of star clusters up to and beyond core collapse. The code accuracy becomes comparable and even better than the accuracy of existing codes when a number of close binary systems is dynamically created in a simulation; this is due to the high accuracy of the method that is used for close binary and multiple sub-systems. The code can be used for evolving star clusters containing equal-mass stars or star clusters with an initial mass function (IMF) containing an intermediate mass black hole (IMBH) at the center and/or a fraction of primordial binaries, which are systems of particular astrophysical interest.

[ascl:1502.003] N-GenIC: Cosmological structure initial conditions

N-GenIC is an initial conditions code for cosmological structure formation that can be used to set-up random N-body realizations of Gaussian random fields with a prescribed power spectrum in a homogeneously sampled periodic box. The code creates cosmological initial conditions based on the Zeldovich approximation, in a format directly compatible with GADGET (ascl:0003.001) or AREPO (ascl:1909.010).

[ascl:1102.001] N-MODY: A Code for Collisionless N-body Simulations in Modified Newtonian Dynamics

N-MODY is a parallel particle-mesh code for collisionless N-body simulations in modified Newtonian dynamics (MOND). N-MODY is based on a numerical potential solver in spherical coordinates that solves the non-linear MOND field equation, and is ideally suited to simulate isolated stellar systems. N-MODY can be used also to compute the MOND potential of arbitrary static density distributions. A few applications of N-MODY indicate that some astrophysically relevant dynamical processes are profoundly different in MOND and in Newtonian gravity with dark matter.

[ascl:1411.014] NAFE: Noise Adaptive Fuzzy Equalization

NAFE (Noise Adaptive Fuzzy Equalization) is an image processing method allowing for visualization of fine structures in SDO AIA high dynamic range images. It produces artifact-free images and gives significantly better results than methods based on convolution or Fourier transform.

[ascl:1409.009] Nahoon: Time-dependent gas-phase chemical model

Nahoon is a gas-phase chemical model that computes the chemical evolution in a 1D temperature and density structure. It uses chemical networks downloaded from the KInetic Database for Astrochemistry (KIDA) but the model can be adapted to any network. The program is written in Fortran 90 and uses the DLSODES (double precision) solver from the ODEPACK package (ascl:1905.021) to solve the coupled stiff differential equations. The solver computes the chemical evolution of gas-phase species at a fixed temperature and density and can be used in one dimension (1D) if a grid of temperature, density, and visual extinction is provided. Grains, both neutral and negatively charged, and electrons are considered as chemical species and their concentrations are computed at the same time as those of the other species. Nahoon contains a test to check the temperature range of the validity of the rate coefficients and avoid extrapolations outside this range. A test is also included to check for duplication of chemical reactions, defined over complementary ranges of temperature.

[ascl:2303.004] naif: Frequency analysis package

naif extracts frequencies and respective amplitudes from time-series, such as that of an orbital coordinate. Based on the Numerical Analysis of Fundamental Frequencies (NAFF) algorithm and written in Python, naif offers some improvements, particularly in computation time. It also offers functions to plot the power-spectrum before extraction of each frequency, which can be useful for debugging particular orbits.

[ascl:1708.022] Naima: Derivation of non-thermal particle distributions through MCMC spectral fitting

Naima computes non-thermal radiation from relativistic particle populations. It includes tools to perform MCMC fitting of radiative models to X-ray, GeV, and TeV spectra using emcee (ascl:1303.002), an affine-invariant ensemble sampler for Markov Chain Monte Carlo. Naima is an Astropy (ascl:1304.002) affiliated package.

[ascl:2307.048] NaMaster: Unified pseudo-Cl framework

NaMaster computes full-sky angular cross-power spectra of masked, spin-0 and spin-2 fields with an arbitrary number of known contaminants using a pseudo-Cl (aka MASTER) approach. The code also implements E/B-mode purification and offers both full-sky and flat-sky modes. NaMaster is available as a C library, Python module, and standalone program.

[ascl:1803.004] nanopipe: Calibration and data reduction pipeline for pulsar timing

nanopipe is a data reduction pipeline for calibration, RFI removal, and pulse time-of-arrival measurement from radio pulsar data. It was developed primarily for use by the NANOGrav project. nanopipe is written in Python, and depends on the PSRCHIVE (ascl:1105.014) library.

[ascl:1905.020] NAPLES: Numerical Analysis of PLanetary EncounterS

NAPLES (Numerical Analysis of PLanetary EncounterS) performs batch propagations of close encounters in the three-body problem and computes the numerical error with respect to reference trajectories computed in quadruple precision. It uses the LSODAR integrator from ODEPACK (ascl:1905.021) and the equations of motion correspond to several regularized formulations.

[ascl:2110.013] Nauyaca: N-body approach for determining planetary masses and orbital elements

Nauyaca infers planetary masses and orbits from mid-transit times fitting. The code requires transit ephemeris per planet and stellar mass and radius, and uses minimization routines and a Markov chain Monte Carlo method to find planet parameters that best reproduce the transit times based on numerical simulations. The code package provides customized plotting tools for analyzing the results.

[ascl:2307.045] NAVanalysis: Normalized Additional Velocity analysis

NAVanalysis studies the non-baryonic, or non-Newtonian, contribution to galaxy rotation curves straight from a given data sample. Conclusions on the radial profile of a given model can be drawn without individual galaxy fits to provide an efficient sample comparison. The method can be used to eliminate model parameter regions, find the most probable parameter regions, and uncover trends not easy to find from standard fits. Further, NAVanalysis can compare different approaches and models.

[ascl:1102.006] NBODY Codes: Numerical Simulations of Many-body (N-body) Gravitational Interactions

I review the development of direct N-body codes at Cambridge over nearly 40 years, highlighting the main stepping stones. The first code (NBODY1) was based on the simple concepts of a force polynomial combined with individual time steps, where numerical problems due to close encounters were avoided by a softened potential. Fortuitously, the elegant Kustaanheimo-Stiefel two-body regularization soon permitted small star clusters to be studied (NBODY3). Subsequent extensions to unperturbed three-body and four-body regularization proved beneficial in dealing with multiple interactions. Investigations of larger systems became possible with the Ahmad-Cohen neighbor scheme which was used more than 20 years ago for expanding universe models of 4000 galaxies (NBODY2). Combining the neighbor scheme with the regularization procedures enabled more realistic star clusters to be considered (NBODY5). After a period of simulations with no apparent technical progress, chain regularization replaced the treatment of compact subsystems (NBODY3, NBODY5). More recently, the Hermite integration method provided a major advance and has been implemented on the special-purpose HARP computers (NBODY4) together with an alternative version for workstations and supercomputers (NBODY6). These codes also include a variety of algorithms for stellar evolution based on fast lookup functions. The treatment of primordial binaries contains efficient procedures for chaotic two-body motion as well as tidal circularization, and special attention is paid to hierarchical systems and their stability. This family of N-body codes constitutes a powerful tool for dynamical simulations which is freely available to the astronomical community, and the massive effort owes much to collaborators.

[ascl:1502.010] nbody6tt: Tidal tensors in N-body simulations

nbody6tt, based on Aarseth's nbody6 (ascl:1102.006) code, includes the treatment of complex galactic tides in a direct N-body simulation of a star cluster through the use of tidal tensors (tt) and offers two complementary methods. The first allows consideration of any kind of galaxy and orbit, thus offering versatility; this method cannot be used to study tidal debris, as it relies on the tidal approximation (linearization of the tidal force). The second method is not limited by this and does not require a galaxy simulation; the user defines a numerical function which takes position and time as arguments, and the galactic potential is returned. The space and time derivatives of the potential are used to (i) integrate the motion of the cluster on its orbit in the galaxy (starting from user-defined initial position and velocity vector), and (ii) compute the tidal acceleration on the stars.

[ascl:1904.027] nbodykit: Massively parallel, large-scale structure toolkit

nbodykit provides algorithms for analyzing cosmological datasets from N-body simulations and large-scale structure surveys, and takes advantage of the abundance and availability of large-scale computing resources. The package provides a unified treatment of simulation and observational datasets by insulating algorithms from data containers, and reduces wall-clock time by scaling to thousands of cores. All algorithms are parallel and run with Message Passing Interface (MPI); the code is designed to be deployed on large super-computing facilities. nbodykit offers an interactive user interface that performs as well in a Jupyter notebook as on super-computing machines.

[ascl:1010.019] NBSymple: A Double Parallel, Symplectic N-body Code Running on Graphic Processing Units

NBSymple is a numerical code which numerically integrates the equation of motions of N 'particles' interacting via Newtonian gravitation and move in an external galactic smooth field. The force evaluation on every particle is done by mean of direct summation of the contribution of all the other system's particle, avoiding truncation error. The time integration is done with second-order and sixth-order symplectic schemes. NBSymple has been parallelized twice, by mean of the Computer Unified Device Architecture to make the all-pair force evaluation as fast as possible on high-performance Graphic Processing Units NVIDIA TESLA C 1060, while the O(N) computations are distributed on various CPUs by mean of OpenMP Application Program. The code works both in single precision floating point arithmetics or in double precision. The use of single precision allows the use at best of the GPU performances but, of course, limits the precision of simulation in some critical situations. We find a good compromise in using a software reconstruction of double precision for those variables that are most critical for the overall precision of the code.

[ascl:2303.008] nd-redshift: Number Density Redshift Evolution Code

Comparing galaxies across redshifts via cumulative number densities is a popular way to estimate the evolution of specific galaxy populations. nd-redshift uses abundance matching in the ΛCDM paradigm to estimate the median change in number density with redshift. It also provides estimates for the 1σ range of number densities corresponding to galaxy progenitors and descendants.

[ascl:1411.023] NDF: Extensible N-dimensional Data Format Library

The Extensible N-Dimensional Data Format (NDF) stores bulk data in the form of N-dimensional arrays of numbers. It is typically used for storing spectra, images and similar datasets with higher dimensionality. The NDF format is based on the Hierarchical Data System (HDS) and is extensible; not only does it provide a comprehensive set of standard ancillary items to describe the data, it can also be extended indefinitely to handle additional user-defined information of any type. The NDF library is used to read and write files in the NDF format. It is distributed with the Starlink software (ascl:1110.012).

[ascl:1101.002] NDSPMHD Smoothed Particle Magnetohydrodynamics Code

This paper presents an overview and introduction to Smoothed Particle Hydrodynamics and Magnetohydrodynamics in theory and in practice. Firstly, we give a basic grounding in the fundamentals of SPH, showing how the equations of motion and energy can be self-consistently derived from the density estimate. We then show how to interpret these equations using the basic SPH interpolation formulae and highlight the subtle difference in approach between SPH and other particle methods. In doing so, we also critique several `urban myths' regarding SPH, in particular the idea that one can simply increase the `neighbour number' more slowly than the total number of particles in order to obtain convergence. We also discuss the origin of numerical instabilities such as the pairing and tensile instabilities. Finally, we give practical advice on how to resolve three of the main issues with SPMHD: removing the tensile instability, formulating dissipative terms for MHD shocks and enforcing the divergence constraint on the particles, and we give the current status of developments in this area. Accompanying the paper is the first public release of the NDSPMHD SPH code, a 1, 2 and 3 dimensional code designed as a testbed for SPH/SPMHD algorithms that can be used to test many of the ideas and used to run all of the numerical examples contained in the paper.

[submitted] NE2001p: A Native Python Implementation of the NE2001 Galactic Electron Density Model

NE2001p is a fully Python implementation of the NE2001 Galactic electron density model. NE2001p forward models the dispersion and scattering of compact radio sources, including pulsars, fast radio bursts, AGNs, and masers, and the model predicts the distances of radio sources that lack independent distance measures.

[ascl:1411.013] NEAT: Nebular Empirical Analysis Tool

NEAT is a fully automated code which carries out a complete analysis of lists of emission lines to estimate the amount of interstellar extinction, calculate representative temperatures and densities, compute ionic abundances from both collisionally excited lines and recombination lines, and finally to estimate total elemental abundances using an ionization correction scheme. NEAT uses a Monte Carlo technique to robustly propagate uncertainties from line flux measurements through to the derived abundances.

[ascl:1809.009] NEBULA: Radiative transfer code of ionized nebulae at radio wavelengths

NEBULA performs the radiative transfer of the 3He+ hyperfine transition, radio recombination lines (RRLs), and free-free continuum emission through a model nebula. The model nebula is composed of only H and He within a three-dimension Cartesian grid with arbitrary density, temperature, and ionization structure. The 3He+ line is assumed to be in local thermodynamic equilibrium (LTE), but non-LTE effects and pressure broadening from electron impacts can be included for the RRLs. All spectra are broadened by thermal and microturbulent motions.

[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:1010.004] Needatool: A Needlet Analysis Tool for Cosmological Data Processing

NeedATool (Needlet Analysis Tool) performs data analysis based on needlets, a wavelet rendition powerful for the analysis of fields defined on a sphere. Needlets have been applied successfully to the treatment of astrophysical and cosmological observations, particularly to the analysis of cosmic microwave background (CMB) data. Wavelets have emerged as a useful tool for CMB data analysis, as they combine most of the advantages of both pixel space, where it is easier to deal with partial sky coverage and experimental noise, and the harmonic domain, in which beam treatment and comparison with theoretical predictions are more effective due in large part to their sharp localization.

[ascl:2210.009] NEMESIS: Non-linear optimal estimator for multivariate spectral analysis

NEMESIS (Non-linear optimal Estimator for MultivariatE spectral analySIS) is the general purpose correlated-k/LBL retrieval code developed from the RADTRAN project (ascl:2210.008). Originally based on the correlated-k approximation, NEMESIS also works in line-by-line (LBL) mode. It has been designed to be generally applicable to any planet and with any observing mode and so is suitable for both solar-system studies and also exoplanetary studies.

[ascl:2311.015] nemiss: Neutrino emission from hydrocode data

nemiss calculates neutrino emission from an astrophysical jet. nemiss works as part of the PLUTO-nemiss-rlos pipeline. PLUTO (ascl:1010.045) produces a hydrodynamical jet. Then, nemiss calculates beamed neutrino emission at each eligible cell along a given direction in space. Finally, rlos (ascl:1811.009) produces a synthetic neutrino image of the jet along the given direction, taking into consideration the finite nature of the speed of light.

[ascl:1010.051] NEMO: A Stellar Dynamics Toolbox

NEMO is an extendible Stellar Dynamics Toolbox, following an Open-Source Software model. It has various programs to create, integrate, analyze and visualize N-body and SPH like systems, following the pipe and filter architecture. In addition there are various tools to operate on images, tables and orbits, including FITS files to export/import to/from other astronomical data reduction packages. A large growing fraction of NEMO has been contributed by a growing list of authors. The source code consist of a little over 4000 files and a little under 1,000,000 lines of code and documentation, mostly C, and some C++ and Fortran. NEMO development started in 1986 in Princeton (USA) by Barnes, Hut and Teuben. See also ZENO (ascl:1102.027) for the version that Barnes maintains.

[ascl:2308.006] Nemo: Millimeter-wave map filtering and Sunyaev-Zel'dovich galaxy cluster and source detection

Nemo detects millimeter-wave Sunyaev-Zel'dovich galaxy clusters and compact sources. Originally developed for the Atacama Cosmology Telescope project, the code is capable of analyzing the next generation of deep, wide multifrequency millimeter-wave maps that will be produced by experiments such as the Simons Observatory. Nemo provides several modules for analyzing ACT/SO data in addition to the command-line programs provided in the package.

[ascl:2311.005] NEOexchange: Target and Observation Manager for the Solar System

The NEOexchange web portal and Target and Observation Manager ingests solar system objects, including Near-Earth Object (NEO) candidates from the Minor Planet Center, schedules observations on the Las Cumbres Observatory global telescope network and reduces, displays, and analyzes the resulting data. NEOexchange produces calibrated photometry from the imaging data and uses Source Extractor (ascl:1010.064) and SCAMP (ascl:1010.063) to perform object detection and astrometric fitting and calviacat (ascl:2207.015) to perform photometric calibration against photometric catalogs. It also has the ability to perform image registration and subtraction using SWARP (ascl:1010.068) and HOTPANTS (ascl:1504.004) and image stacking, alignment, and faint feature detection using gnuastro (ascl:1801.009).

[ascl:1307.017] NEST: Noble Element Simulation Technique

NEST (Noble Element Simulation Technique) offers comprehensive, accurate, and precise simulation of the excitation, ionization, and corresponding scintillation and electroluminescence processes in liquid noble elements, useful for direct dark matter detectors, double beta decay searches, PET scans, and general radiation detection technology. Written in C++, NEST is an add-on module for the Geant4 simulation package that incorporates more detailed physics than is currently available into the simulation of scintillation. NEST is of particular use for low-energy nuclear recoils. All available liquid xenon data on nuclear recoils and electron recoils to date have been taken into consideration in arriving at the current models. NEST also handles the magnitude of the light and charge yields of nuclear recoils, including their electric field dependence, thereby shedding light on the possibility of detection or exclusion of a low-mass dark matter WIMP by liquid xenon detectors.

[ascl:1809.012] nestcheck: Nested sampling calculations analysis

Nestcheck analyzes nested sampling runs and estimates numerical uncertainties on calculations using them. The package can load results from a number of nested sampling software packages, including MultiNest (ascl:1109.006), PolyChord (ascl:1502.011), dynesty (ascl:1809.013) and perfectns (ascl:1809.005), and offers the flexibility to add input functions for other nested sampling software packages. Nestcheck utilities include error analysis, diagnostic tests, and plots for nested sampling calculations.

[ascl:2103.022] nestle: Nested sampling algorithms for evaluating Bayesian evidence

nestle is a pure Python implementation of nested sampling algorithms for evaluating Bayesian evidence. Nested sampling integrates posterior probability in order to compare models in Bayesian statistics. It is similar to Markov Chain Monte Carlo (MCMC) in that it generates samples that can be used to estimate the posterior probability distribution. Unlike MCMC, the nature of the sampling also allows one to calculate the integral of the distribution. It is also a pretty good method for robustly finding global maxima.

[submitted] Network Flux Transport Demonstration

We have developed a method to efficiently simulate the dynamics of the magnetic flux in the solar network. We call this method Network Flux Transport (NFT). Implemented using a Spherical Centroidal Voronoi Tessellation (SCVT) based network model, magnetic flux is advected by photospheric plasma velocity fields according to the geometry of the SCVT model. We test NFT by simulating the magnetism of the Solar poles. The poles of the sun above 55 deg latitude are free from flux emergence from active regions or ephemeral regions. As such, they are ideal targets for a simplified simulation that relies on the strengths of the NFT model. This simulation method reproduces the magnetic and spatial distributions for the solar poles over two full solar cycles.

[ascl:1010.085] Network Tools for Astronomical Data Retrieval

The first step in a science project is the acquisition and understanding of the relevant data. The tools range from simple data transfer methods to more complex browser-emulating scripts. When integrated with a defined sample or catalog, these scripts provide seamless techniques to retrieve and store data of varying types. These tools can be used to leapfrog from website to website to acquire multi-wavelength datasets. This project demonstrates the capability to use multiple data websites, in conjunction, to perform the type of calculations once reserved for on-site datasets.

[ascl:2112.007] NeutrinoFog: Neutrino fog and floor for direct dark matter searches

NeutrinoFog calculates the neutrino floor based on the derivative of a hypothetical experimental discovery limit as a function of exposure, and leads to a neutrino floor that is only influenced by the systematic uncertainties on the neutrino flux normalizations.

[ascl:2305.024] Nextflow: DSL for data-driven computational pipelines

Nextflow enables scalable and reproducible scientific workflows using software containers. It allows the adaptation of pipelines written in the most common scripting languages. Its fluent DSL simplifies the implementation and the deployment of complex parallel and reactive workflows on clouds and clusters. Nextflow supports deploying workflows on a variety of execution platforms including local, HPC schedulers, AWS Batch, Google Cloud Life Sciences, and Kubernetes. Additionally, it provides support for workflow dependencies through built-in support for, for example, Conda, Spack, Docker, Podman, Singularity, and Modules.

[ascl:1807.011] nfield: Stochastic tool for QFT on inflationary backgrounds

nfield uses a stochastic formalism to compute the IR correlation functions of quantum fields during cosmic inflation in n-field dimensions. This is a necessary 1-loop resummation of the correlation functions to render them finite. The code supports the implementation of n-numbers of coupled test fields (energetically sub-dominant) as well as non-test fields.

[submitted] nFITSview: A simple and user-friendly FITS image viewer

nFITSview is a simple, user-friendly and open-source FITS image viewer available for Linux and Windows. One of the main concepts of nFITSview is to provide an intuitive user interface which may be helpful both for scientists and for amateur astronomers. nFITSview has different color mapping and manipulation schemes, supports different formats of FITS data files as well as exporting them to different popular image formats. It also supports command-line exporting (with some restrictions) of FITS files to other image formats.
The application is written in C++/Qt for achieving better performance, and with every next version the performance aspect is taken into account.
nFITSview uses its own libnfits library (can be used separately as well) for parsing the FITS files.

[ascl:1903.013] NFWdist: Density, distribution function, quantile function and random generation for the 3D NFW profile

Available in R and Python, the simple analytic scheme NFWdist performs highly efficient and exact sampling of the Navarro, Frenk & White (NFW) profile as a true probability distribution function, with the only variable being the concentration.

[ascl:1508.008] NGMIX: Gaussian mixture models for 2D images

NGMIX implements Gaussian mixture models for 2D images. Both the PSF profile and the galaxy are modeled using mixtures of Gaussians. Convolutions are thus performed analytically, resulting in fast model generation as compared to methods that perform the convolution in Fourier space. For the galaxy model, NGMIX supports exponential disks and de Vaucouleurs and Sérsic profiles; these are implemented approximately as a sum of Gaussians using the fits from Hogg & Lang (2013). Additionally, any number of Gaussians can be fit, either completely free or constrained to be cocentric and co-elliptical.

[ascl:2302.001] nicaea: NumerIcal Cosmology And lEnsing cAlculations

nicaea calculates cosmology and weak-lensing quantities and functions from theoretical models of the large-scale structure. Written in C, it can compute the Hubble parameter, distances, and geometry for background cosmology, and linear perturbations, including growth factor, transfer function, cluster mass function, and linear 3D power spectra. It also calculates fitting formulae for non-linear power spectra, emulators, and halo model for Non-linear evolution, and the HOD model for galaxy clustering. In addition, nicaea can compute quantities for cosmic shear such as the convergence power spectrum, second-order correlation functions and derived second-order quantities, and third-order aperture mass moment; it can also calculate CMB anisotropies via CAMB (ascl:1102.026).

[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:1508.002] NICOLE: NLTE Stokes Synthesis/Inversion Code

NICOLE, written in Fortran 90, seeks the model atmosphere that provides the best fit to the Stokes profiles (in a least-squares sense) of an arbitrary number of simultaneously-observed spectral lines from solar/stellar atmospheres. The inversion core used for the development of NICOLE is the LORIEN engine (the Lovely Reusable Inversion ENgine), which combines the SVD technique with the Levenberg-Marquardt minimization method to solve the inverse problem.

[ascl:1302.013] NIFTY: A versatile Python library for signal inference

NIFTY (Numerical Information Field TheorY) is a versatile library enables the development of signal inference algorithms that operate regardless of the underlying spatial grid and its resolution. Its object-oriented framework is written in Python, although it accesses libraries written in Cython, C++, and C for efficiency. NIFTY offers a toolkit that abstracts discretized representations of continuous spaces, fields in these spaces, and operators acting on fields into classes. Thereby, the correct normalization of operations on fields is taken care of automatically. This allows for an abstract formulation and programming of inference algorithms, including those derived within information field theory. Thus, NIFTY permits rapid prototyping of algorithms in 1D and then the application of the developed code in higher-dimensional settings of real world problems. NIFTY operates on point sets, n-dimensional regular grids, spherical spaces, their harmonic counterparts, and product spaces constructed as combinations of those.

[ascl:1903.008] NIFTy5: Numerical Information Field Theory v5

NIFTy (Numerical Information Field Theory) facilitates the construction of Bayesian field reconstruction algorithms for fields being defined over multidimensional domains. A NIFTy algorithm can be developed for 1D field inference and then be used in 2D or 3D, on the sphere, or on product spaces thereof. NIFTy5 is a complete redesign of the previous framework (ascl:1302.013), and requires only the specification of a probabilistic generative model for all involved fields and the data in order to be able to recover the former from the latter. This is achieved via Metric Gaussian Variational Inference, which also provides posterior samples for all unknown quantities jointly.

[ascl:1106.016] Nightfall: Animated Views of Eclipsing Binary Stars

Nightfall is an astronomy application for fun, education, and science. It can produce animated views of eclipsing binary stars, calculate synthetic lightcurves and radial velocity curves, and eventually determine the best-fit model for a given set of observational data of an eclipsing binary star system.

Nightfall comes with a user guide and a set of observational data for several eclipsing binary star systems.

[ascl:1501.002] NIGO: Numerical Integrator of Galactic Orbits

NIGO (Numerical Integrator of Galactic Orbits) predicts the orbital evolution of test particles moving within a fully-analytical gravitational potential generated by a multi-component galaxy. The code can simulate the orbits of stars in elliptical and disc galaxies, including non-axisymmetric components represented by a spiral pattern and/or rotating bar(s).

[ascl:2101.011] Nigraha: Find and evaluate planet candidates from TESS light curves

Nigraha identifies and evaluates planet candidates from TESS light curves. Using a combination of high signal to noise ratio (SNR) shallow transits, supervised machine learning, and detailed vetting, the neural network-based pipeline identifies planet candidates missed by prior searches. The pipeline runs in four stages. It first performs period finding using the Transit Least Squares (TLS) package and runs sector by sector to build a per-sector catalog. It then transforms the flux values in .fits lightcurve files to global/local views and write out the output in .tfRecords files, builds a model on training data, and saves a checkpoint. Finally, it loads a previously saved model to generate predictions for new sectors. Nigraha provides helper scripts to generate candidates in new sectors, thus allowing others to perform their own analyses.

[ascl:2111.010] Nii: Multidimensional posterior distributions framework

Nii implements an automatic parallel tempering Markov chain Monte Carlo (APT-MCMC) framework for sampling multidimensional posterior distributions and provides an observation simulation platform for the differential astrometric measurement of exoplanets. Although this code specifically focuses on the orbital parameter retrieval problem of differential astrometry, Nii can be applied to other scientific problems with different posterior distributions and offers many control parameters in the APT part to facilitate the adjustment of the MCMC sampling strategy; these include the number of parallel chains, the β values of different chains, the dynamic range of the sampling step sizes, and frequency of adjusting the step sizes.

[ascl:2203.003] NIMBLE: Non-parametrIc jeans Modeling with B-spLinEs

NIMBLE (Non-parametrIc jeans Modeling with B-spLinEs) inferrs the cumulative mass distribution of a gravitating system from full 6D phase space coordinates of its tracers via spherical Jeans modeling. It models the Milky Way's dark matter halo using Gaia and Dark Energy Spectroscopic Instrument Milky Way Survey (DESI MWS) data. NIMBLE includes a basic inverse modeling Jeans routine that assumes perfect and complete data is available and a more complex forward modeling Jeans routine that deconvolves observational effects (uncertainties and limited survey volume) characteristic of Gaia and the DESI-MWS. It also includes tools for generating simple equilibrium model galaxies using Agama (ascl:1805.008) and imposing mock Gaia+DESI errors on 6D phase space input data.

[ascl:2107.008] nimbus: A Bayesian inference framework to constrain kilonova models

nimbus is a hierarchical Bayesian framework to infer the intrinsic luminosity parameters of kilonovae (KNe) associated with gravitational-wave (GW) events, based purely on non-detections. This framework makes use of GW 3-D distance information and electromagnetic upper limits from a given survey for multiple events, and self-consistently accounts for finite sky-coverage and probability of astrophysical origin.

[ascl:2210.003] NIRDust: Near Infrared Dust finder for Type2 AGN K-band spectra

NIRDust uses K-band (2.2 micrometers) spectra to measure the temperature of the dust heated by an Active Galactic Nuclei (AGN) accretion disk. The package provides several functionalities to pre-process spectra and fit the hot dust component of a AGN K-band spectrum with a blackbody function. NIRDust needs a minimum of two spectra to run: a target spectrum, where the dust temperature will be estimated, and a reference spectrum, where the emission is considered to be purely stellar. The reference spectrum will be used by NIRDust to model the stellar emission from the target spectrum.

[ascl:1101.006] NIRVANA: A Numerical Tool for Astrophysical Gas Dynamics

The NIRVANA code is capable of the simulation of multi-scale self-gravitational magnetohydrodynamics problems in three space dimensions employing the technique of adaptive mesh refinement. The building blocks of NIRVANA are (i) a fully conservative, divergence-free Godunov-type central scheme for the solution of the equations of magnetohydrodynamics; (ii) a block-structured mesh refinement algorithm which automatically adds and removes elementary grid blocks whenever necessary to achieve adequate resolution and; (iii) an adaptive mesh Poisson solver based on multigrid philosophy which incorporates the so-called elliptic matching condition to keep the gradient of the gravitational potential continous at fine/coarse mesh interfaces.

[ascl:2111.004] NLopt: Nonlinear optimization library

The library NLopt performs nonlinear local and global optimization for functions with and without gradient information. It provides a simple, unified interface and wraps many algorithms for global and local, constrained or unconstrained, optimization, and provides interfaces for many other languages, including C++, Fortran, Python, Matlab or GNU Octave, OCaml, GNU Guile, GNU R, Lua, Rust, and Julia.

[ascl:2402.001] NMMA: Nuclear Multi Messenger Astronomy framework

NMMA probes nuclear physics and cosmology with multimessenger analysis. This fully featured, Bayesian multi-messenger pipeline targets joint analyses of gravitational-wave and electromagnetic data (focusing on the optical). Using bilby (ascl:1901.011) as the back-end, the software uses a variety of samplers to sampling these data sets. NMMA uses chiral effective field theory based neutron star equation of states when performing inference, and is also capable of estimating the Hubble Constant.

[ascl:2005.010] NNKCDE: Nearest Neighbor Kernel Conditional Density Estimation

NNKCDE is a simple and easily interpretable Conditional Density Estimation (CDE) method. It computes a kernel density estimate of y using the k nearest neighbors of the evaluation point x. The model has only two tuning parameters: the number of nearest neighbors k and the bandwidth h of the smoothing kernel in y-space. Both tuning parameters are chosen in a principled way by minimizing the CDE loss on validation data.

[ascl:1711.024] NOD3: Single dish reduction software

NOD3 processes and analyzes maps from single-dish observations affected by scanning effects from clouds, receiver instabilities, or radio-frequency interference. Its “basket-weaving” tool combines orthogonally scanned maps into a final map that is almost free of scanning effects. A restoration tool for dual-beam observations reduces the noise by a factor of about two compared to the NOD2 version. Combining single-dish with interferometer data in the map plane ensures the full recovery of the total flux density.

[ascl:1305.013] Non-Gaussian Realisations

Non-Gaussian Realisations provides code based on a spectral distortion/quantile transformation that generates a realization of a field on a cubic grid that has a specified probability distribution function and a specified power spectrum.

[ascl:1011.016] Non-LTE Models and Theoretical Spectra of Accretion Disks in Active Galactic Nuclei. III. Integrated Spectra for Hydrogen-Helium Disks

We have constructed a grid of non-LTE disk models for a wide range of black hole mass and mass accretion rate, for several values of viscosity parameter alpha, and for two extreme values of the black hole spin: the maximum-rotation Kerr black hole, and the Schwarzschild (non-rotating) black hole. Our procedure calculates self-consistently the vertical structure of all disk annuli together with the radiation field, without any approximations imposed on the optical thickness of the disk, and without any ad hoc approximations to the behavior of the radiation intensity. The total spectrum of a disk is computed by summing the spectra of the individual annuli, taking into account the general relativistic transfer function. The grid covers nine values of the black hole mass between M = 1/8 and 32 billion solar masses with a two-fold increase of mass for each subsequent value; and eleven values of the mass accretion rate, each a power of 2 times 1 solar mass/year. The highest value of the accretion rate corresponds to 0.3 Eddington. We show the vertical structure of individual annuli within the set of accretion disk models, along with their local emergent flux, and discuss the internal physical self-consistency of the models. We then present the full disk-integrated spectra, and discuss a number of observationally interesting properties of the models, such as optical/ultraviolet colors, the behavior of the hydrogen Lyman limit region, polarization, and number of ionizing photons. Our calculations are far from definitive in terms of the input physics, but generally we find that our models exhibit rather red optical/UV colors. Flux discontinuities in the region of the hydrogen Lyman limit are only present in cool, low luminosity models, while hotter models exhibit blueshifted changes in spectral slope.

[ascl:2206.005] NonnegMFPy: Nonnegative Matrix Factorization with heteroscedastic uncertainties and missing data

NonnegMFPy solves nonnegative matrix factorization (NMF) given a dataset with heteroscedastic uncertainties and missing data with a vectorized multiplicative update rule; this can be used create a mask and iterate the process to exclude certain new data by updating the mask. The code can work on multi-dimensional data, such as images, if the data are first flattened to 1D.

[ascl:1202.003] NOVAS: Naval Observatory Vector Astrometry Software

NOVAS is an integrated package of subroutines and functions for computing various commonly needed quantities in positional astronomy. The package can provide, in one or two subroutine or function calls, the instantaneous coordinates of any star or planet in a variety of coordinate systems. At a lower level, NOVAS also supplies astrometric utility transformations, such as those for precession, nutation, aberration, parallax, and the gravitational deflection of light. The computations are accurate to better than one milliarcsecond. The NOVAS package is an easy-to-use facility that can be incorporated into data reduction programs, telescope control systems, and simulations. The U.S. parts of The Astronomical Almanac are prepared using NOVAS. Three editions of NOVAS are available: Fortran, C, and Python.

[ascl:2201.014] nProFit: n-Profile Fitting tool

nProFit analyzes surface brightness profiles. It obtains the best-fit structural, scale, and shape parameters of star clusters in Hubble Space Telescope images of nearby galaxies. The code fits dynamical models and can derive physically-relevant parameters. Among these are central volume and luminosity densities, total masses and luminosities, central velocity dispersions, core radius, half-light radius, tidal radius, and binding energy.

[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:1804.015] NR-code: Nonlinear reconstruction code

NR-code applies nonlinear reconstruction to the dark matter density field in redshift space and solves for the nonlinear mapping from the initial Lagrangian positions to the final redshift space positions; this reverses the large-scale bulk flows and improves the precision measurement of the baryon acoustic oscillations (BAO) scale.

[ascl:2108.012] NRDD_constraints: Dark Matter interaction with the Standard Model exclusion plot calculator

The NRDD_constraints tool provides simple interpolating functions written in Python that return the most constraining limit on the dark matter-nucleon scattering cross section for a list of non-relativistic effective operators. The package contains four files: the main code, NRDD_constraints.py; a simple driver, NRDD_constraints-example.py; and two data files, NRDD_data1.npy and NRDD_data2.npy

[ascl:1807.025] NRPy+: Code generator for Numerical Relativity

NRPy+ (Python-based Code generation for Numerical Relativity and Beyond) generates highly-optimized C code from complex tensorial expressions input in Einstein-like notation. NRPy+ uses SymPy as its computer algebra system backend. It is part of the NRPy+/SENR numerical relativity code package for solving Einstein's equations of general relativity to model compact objects at about 1/100 the cost in memory of more traditional, AMR-based numerical relativity codes, thus allowing desktop computers to be used for gravitational wave astrophysics.

[ascl:2012.002] NSCG: NOIRLab Source Catalog Generator

The NOIRLab Source Catalog Generator generates the NOIRLab Source Catalog (NSC), a catalog of all publicly available imagining data in the NOIRLab Astro Data Archive. The second data release (DR2) of the archive contains over 3.9 billion unique objects, 68 billion individual source measurements, covers 35,000 square degrees of the sky, has depths of 23rd magnitude in most broadband filters with 1-2% photometric precision, and astrometric accuracy of 7 mas. NSCG is written in Python and IDL. Three main steps generate the NSC: (1) Source Extractor (ascl:1010.064) is used to detect and measure sources in individual images; (2) astrometrics are calibrated with Gaia DR2 and photometric calibration using large public photometric catalogs such as Pan-STARRS1 and ATLAS-Refcat2; and, (3) measurements are clustered into unique objects, averaging photometric and morphological properties, and calculating proper motions and photometric variability indices.

[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:1602.008] NuCraft: Oscillation probabilities for atmospheric neutrinos calculator

NuCraft calculates oscillation probabilities for atmospheric neutrinos, taking into account matter effects and the Earth's atmosphere, and supports an arbitrary number of sterile neutrino flavors with easily configurable continuous Earth models. Continuous modeling of the Earth instead of the often-used approximation of four layers with constant density and consideration of the smearing of baseline lengths due to the variable neutrino production heights in Earth's atmosphere each lead to deviations of 10% or more for conventional neutrinos between 1 and 10 GeV.

[ascl:1904.030] nudec_BSM: Neutrino Decoupling Beyond the Standard Model

nudec_BSM uses a simplified approach to solve for the neutrino decoupling, allowing one to capture the time dependence of the process while accounting for all possible interactions that can alter it.

[ascl:1601.014] Nulike: Neutrino telescope likelihood tools

Nulike is software for including full event-level information in likelihood calculations for neutrino telescope searches for dark matter annihilation. It includes both angular and spectral information about neutrino events as well as their total number, and can be used for single models without reference to the rest of a parameter space.

[ascl:1408.013] NumCosmo: Numerical Cosmology

NumCosmo is a free software C library whose main purposes are to test cosmological models using observational data and to provide a set of tools to perform cosmological calculations. The software implements three different probes: cosmic microwave background (CMB), supernovae type Ia (SNeIa) and large scale structure (LSS) information, such as baryonic acoustic oscillations (BAO) and galaxy cluster abundance. The code supports a joint analysis of these data and the parameter space can include cosmological and phenomenological parameters. NumCosmo matter power spectrum and CMB codes were written independent of other implementations such as CMBFAST (ascl:9909.004), CAMB (ascl:1102.026), etc.

The library structure simplifies the inclusion of non-standard cosmological models. Besides the functions related to cosmological quantities, this library also implements mathematical and statistical tools. The former were developed to enable the inclusion of other probes and/or theoretical models and to optimize the codes. The statistical framework comprises algorithms which define likelihood functions, minimization, Monte Carlo, Fisher Matrix and profile likelihood methods.

[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:2306.045] nuPyProp: Propagate neutrinos through the earth

nuPyProp simulates tau neutrino and muon neutrino interactions in the Earth and predicts the spectrum of the τ-leptons and muons that emerge. The code produces tables of charged lepton exit probabilities and energies that can be used directly or as inputs to nuSpaceSim (ascl:2306.043), which is designed to simulate optical and radio signals from extensive air showers induced by the emerging charged leptons.

[ascl:1908.011] NuRadioMC: Monte Carlo simulation package for radio neutrino detectors

NuRadioMC simulates ultra-high energy neutrino detectors that rely on the radio detection method, which exploits the radio emission generated in the electromagnetic component of a particle shower following a neutrino interaction. The code simulates the neutrino interaction in a medium, subsequent Askaryan radio emission, propagation of the radio signal to the detector and the detector response. NuRadioMC is a Monte Carlo framework that combines flexibility in detector design with user-friendliness. It includes an event generator, improved modeling of the radio emission, a revisited approach to signal propagation, and increased flexibility and precision in the detector simulation.

[ascl:2306.044] nuSpaceSim: Cosmic neutrino simulation

nuSpaceSim simulates upward-going extensive air showers caused by neutrino interactions with the atmosphere. It is an end-to-end, neutrino flux to space-based signal detection, modeling tool for the design of sub-orbital and space-based neutrino detection experiments. This comprehensive suite of modeling packages accepts an experimental design input and then models the experiment's sensitivity to both the diffuse, cosmogenic neutrino flux as well as astrophysical neutrino transient events, such as that postulated from binary neutron star (BNS) mergers. nuSpaceSim calculates the tau neutrino acceptance for the Optical Cherenkov technique; tau propagation is interpolated using included data tables from nupyprop (ascl:2306.044). The simulation is parameterized by an input XML configuration file, with settings for detector characteristics and global parameters; nuSpaceSim also provides a python API for programmatic access.

[ascl:2102.014] nway: Bayesian cross-matching of astronomical catalogs

nway is a source cross-matching tool for arbitrarily many astronomical catalogs. It features Bayesian match probabilities based on astronomical sky coordinates (RA, DEC), works with arbitrarily many catalogs, and can handle varying errors. nway can also incorporate additional prior information, such as the magnitude or color distributions of the sources to match, and works accurately and fast in small areas and all-sky catalogs.

[ascl:2202.002] NWelch: Spectral analysis of time series with nonuniform observing cadence

NWelch uses Welch's method to estimate the power spectra, complex cross-spectrum, magnitude-squared coherence, and phase spectrum of bivariate time series with nonuniform observing cadence. For univariate time series, users can apply the Welch's power spectrum estimator or compute a nonuniform fast Fourier transform-based periodogram. Options include tapering in the time domain and computing bootstrap false alarm levels. Users may choose standard 50%-overlapping Welch's segments or apply a custom-made segmentation scheme. NWelch was designed for Doppler planet searches but may be applied to any type of time series.

[ascl:1712.006] Nyx: Adaptive mesh, massively-parallel, cosmological simulation code

Nyx code solves equations of compressible hydrodynamics on an adaptive grid hierarchy coupled with an N-body treatment of dark matter. The gas dynamics in Nyx use a finite volume methodology on an adaptive set of 3-D Eulerian grids; dark matter is represented as discrete particles moving under the influence of gravity. Particles are evolved via a particle-mesh method, using Cloud-in-Cell deposition/interpolation scheme. Both baryonic and dark matter contribute to the gravitational field. In addition, Nyx includes physics for accurately modeling the intergalactic medium; in optically thin limits and assuming ionization equilibrium, the code calculates heating and cooling processes of the primordial-composition gas in an ionizing ultraviolet background radiation field.

[ascl:2112.019] O'TRAIN: Optical TRAnsient Identification NEtwork

The O'TRAIN package identifies transients in astronomical images based on a Convolutional Neural Network (CNN). It works on images from different telescopes and, through the use of Docker, can be deployed on different operating systems. O'TRAIN uses image cutouts containing real and false transients provided by the user to train a CNN algorithm implemented with Keras. Built-in diagnostics help to characterize the accuracy of the training, and a trained model is used to classify any new cutouts.

[ascl:1408.019] O2scl: Object-oriented scientific computing library

O2scl is an object-oriented library for scientific computing in C++ useful for solving, minimizing, differentiating, integrating, interpolating, optimizing, approximating, analyzing, fitting, and more. Many classes operate on generic function and vector types; it includes classes based on GSL and CERNLIB. O2scl also contains code for computing the basic thermodynamic integrals for fermions and bosons, for generating almost all of the most common equations of state of nuclear and neutron star matter, and for solving the TOV equations. O2scl can be used on Linux, Mac and Windows (Cygwin) platforms and has extensive documentation.

[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).

[ascl:1307.008] Obit: Radio Astronomy Data Handling

Obit is a group of software packages for handling radio astronomy data, especially interferometric and single dish OTF imaging. Obit is primarily an environment in which new data processing algorithms can be developed and tested but which can also be used for production processing of a certain range of scientific problems. The package supports both prepackaged, compiled tasks and a python interface to the major class functionality to allow rapid prototyping using python scripts; it allows access to multiple disk--resident data formats, in particular access to either AIPS disk data or FITS files. Obit applications are interoperable with Classic AIPS and the ObitTalk python interface gives access to AIPS tasks as well as Obit libraries and tasks.

[submitted] ObsPlanner

Simple program for planning and managing astronomical observations as observational diary or logs.

[ascl:1910.020] OCD: O'Connell Effect Detector using push-pull learning

OCD (O'Connell Effect Detector) detects eclipsing binaries that demonstrate the O'Connell Effect. This time-domain signature extraction methodology uses a supporting supervised pattern detection algorithm. The methodology maps stellar variable observations (time-domain data) to a new representation known as Distribution Fields (DF), the properties of which enable efficient handling of issues such as irregular sampling and multiple values per time instance. Using this representation, the code applies a metric learning technique directly on the DF space capable of specifically identifying the stars of interest; the metric is tuned on a set of labeled eclipsing binary data from the Kepler survey, targeting particular systems exhibiting the O’Connell Effect. This code is useful for large-scale data volumes such as that expected from next generation telescopes such as LSST.

[ascl:1901.002] OCFit: Python package for fitting of O-C diagrams

OCFit fits and analyzes O-C diagrams using Genetic Algorithms and Markov chain Monte Carlo methods. The MC method is used to determine a very good estimation of errors of the parameters. Unlike some other fitting routines, OCFit does not need any initial values of fitted parameters. An intuitive graphic user interface is provided for ease of fitting, and nine common models of periodic O-C changes are included.

[ascl:1812.018] OctApps: Octave functions for continuous gravitational-wave data analysis

The OctApps library provides various functions, written in Octave, for performing searches for the weak signatures of continuous gravitational waves from rapidly-rotating neutron stars amidst the instrumental noise of the LIGO and Virgo detectors.

[ascl:1010.048] OCTGRAV: Sparse Octree Gravitational N-body Code on Graphics Processing Units

Octgrav is a very fast tree-code which runs on massively parallel Graphical Processing Units (GPU) with NVIDIA CUDA architecture. The algorithms are based on parallel-scan and sort methods. The tree-construction and calculation of multipole moments is carried out on the host CPU, while the force calculation which consists of tree walks and evaluation of interaction list is carried out on the GPU. In this way, a sustained performance of about 100GFLOP/s and data transfer rates of about 50GB/s is achieved. It takes about a second to compute forces on a million particles with an opening angle of $ heta approx 0.5$.

To test the performance and feasibility, we implemented the algorithms in CUDA in the form of a gravitational tree-code which completely runs on the GPU. The tree construction and traverse algorithms are portable to many-core devices which have support for CUDA or OpenCL programming languages. The gravitational tree-code outperforms tuned CPU code during the tree-construction and shows a performance improvement of more than a factor 20 overall, resulting in a processing rate of more than 2.8 million particles per second.

The code has a convenient user interface and is freely available for use.

[ascl:2101.012] Octo-Tiger: HPX parallelized 3-D hydrodynamic code for stellar mergers

Octo-Tiger models mass transfer in binary systems using a Cartesian adaptive mesh refinement grid. It simulates the evolution of star systems based on a modified fast multipole method (FMM) on adaptive octrees. The code takes shock heating into account and uses the dual energy formalism with an ideal gas equation of state; it also conserves linear and angular momenta to machine precision. Octo-Tiger is implemented in C++ and is parallelized using the High Performance ParalleX (HPX) runtime system.

[ascl:1905.021] ODEPACK: Ordinary differential equation solver library

ODEPACK solves for the initial value problem for ordinary differential equation systems. It consists of nine solvers, a basic solver called LSODE and eight variants of it: LSODES, LSODA, LSODAR, LSODPK, LSODKR, LSODI, LSOIBT, and LSODIS. The collection is suitable for both stiff and nonstiff systems. It includes solvers for systems given in explicit form, dy/dt = f(t,y), and also solvers for systems given in linearly implicit form, A(t,y) dy/dt = g(t,y). The ODEPACK solvers are written in standard Fortran and there are separate double and single precision versions. Each solver consists of a main driver subroutine having the same name as the solver and some number of subordinate routines. For each solver, there is also a demonstration program, which solves one or two simple problems in a somewhat self-checking manner.

[ascl:2211.018] ODNet: Asteroid occultation detection convolutional neural network

ODNet uses a convolutional neural network to examine frames of a given observation, using the flux of a targeted star along time, to detect occultations. This is particularly useful to reliably detect asteroid occultations for the Unistellar Network, which consists of 10,000 digital telescopes owned by citizen scientists that is regularly used to record asteroid occultations. ODNet is not costly in term of computing power, opening the possibility for embedding the code on the telescope directly. ODNet's models were developed and trained using TensorFlow version 2.4.

[ascl:1810.010] ODTBX: Orbit Determination Toolbox

ODTBX (Orbit Determination Toolbox) provides orbit determination analysis, advanced mission simulation, and analysis for concept exploration, proposal, early design phase, and/or rapid design center environments. The core ODTBX functionality is realized through a set of estimation commands that incorporate Monte Carlo data simulation, linear covariance analysis, and measurement processing at a generic level; its functions and utilities are combined in a flexible architecture to allow modular development of navigation algorithms and simulations. ODTBX is written in Matlab and Java.

[ascl:2002.005] ODUSSEAS: Observing Dwarfs Using Stellar Spectroscopic Energy-Absorption Shapes

ODUSSEAS (Observing Dwarfs Using Stellar Spectroscopic Energy-Absorption Shapes) uses machine learning to derive the Teff and [Fe/H] of M dwarf stars by using their optical spectra obtained by different spectrographs with different resolutions. The software uses the measurement of the pseudo equivalent widths for more than 4000 stellar absorption lines and the machine learning Python package scikit-learn (https://scikit-learn.org/stable/) to predict the stellar parameters.

[ascl:1601.004] Odyssey: Ray tracing and radiative transfer in Kerr spacetime

Odyssey is a GPU-based General Relativistic Radiative Transfer (GRRT) code for computing images and/or spectra in Kerr metric describing the spacetime around a rotating black hole. Odyssey is implemented in CUDA C/C++. For flexibility, the namespace structure in C++ is used for different tasks; the two default tasks presented in the source code are the redshift of a Keplerian disk and the image of a Keplerian rotating shell at 340GHz. Odyssey_Edu, an educational software package for visualizing the ray trajectories in the Kerr spacetime that uses Odyssey, is also available.

[ascl:1906.015] OIT: Nonconvex optimization approach to optical-interferometric imaging

In the context of optical interferometry, only undersampled power spectrum and bispectrum data are accessible, creating an ill-posed inverse problem for image recovery. Recently, a tri-linear model was proposed for monochromatic imaging, leading to an alternated minimization problem; in that work, only a positivity constraint was considered, and the problem was solved by an approximated Gauss–Seidel method.

The Optical-Interferometry-Trilinear code improves the approach on three fundamental aspects. First, the estimated image is defined as a solution of a regularized minimization problem, promoting sparsity in a fixed dictionary using either an l1 or a (re)weighted-l1 regularization term. Second, the resultant non-convex minimization problem is solved using a block-coordinate forward–backward algorithm. This algorithm is able to deal both with smooth and non-smooth functions, and benefits from convergence guarantees even in a non-convex context. Finally, the model and algorithm are generalized to the hyperspectral case, promoting a joint sparsity prior through an l2,1 regularization term.

[ascl:1806.018] OMEGA: One-zone Model for the Evolution of GAlaxies

OMEGA (One-zone Model for the Evolution of GAlaxies) calculates the global chemical evolution trends of galaxies. From an input star formation history, it uses SYGMA to create as a function of time multiple simple stellar populations with different masses, ages, and initial compositions. OMEGA offers several prescriptions for modeling the star formation efficiency and the evolution of galactic inflows and outflows. OMEGA is part of the NuGrid (ascl:1610.015) chemical evolution package.

[ascl:2212.020] Omega: Photon equations of motion

Omega solves the photon equations of motion in the environment surrounding a black hole. This black hole can be either Schwarzschild (nonrotating) or Kerr (rotating) by choice of the user. The software offers numerous options, such as the geometrical setup of the accretion disk around the black hole (including no disk, band, slab, wedge, among others, the spin parameter of the central black hole, and the thickness of the accretion disk. Other options that can be set includ the azimuthal angle of the photon emission/reception, the poloidal angle of the photon emission/reception, and how far away or close to the system to look.

[ascl:1907.010] OMNICAL: Redundant calibration code for low frequency radio interferometers

OMNICAL calibrates antennas in the redundant subset of the array. The code consists of two algorithms, a logarithmic method (logcal) and a linearized method (lincal). OMNICAL makes visibilities from physically redundant baselines agree with each other and also explicitly minimizes the variance within redundant visibilities.

[ascl:1904.024] OoT: Out-of-Transit Light Curve Generator

OoT (Out-of-Transit) calculates the light curves and radial velocity signals due to a planet orbiting a star. It explicitly models the effects of tides, orbital motion. relativistic beaming, and reflection of the stars light by the planet. The code can also be used to model secondary eclipses.

[ascl:2104.009] OpacityTool: Dust opacities for disk modeling

OpacityTool computes dust opacities for disc modelling; it includes a number of robust facts obtained from observations and theory and goes beyond astronomical silicates. It provides output files with κext(λ),κabs(λ),κsca(λ) as a function of wavelength λ, and the 6 scattering matrix elements for randomly oriented particles, F11(λ,θ), F12(λ,θ), F22(λ,θ), F33(λ, θ), F34(λ, θ), F44(λ, θ) as functions of wavelength and scattering angle θ.

This code is superseded by optool (ascl:2104.010).

[ascl:1604.001] OpenMHD: Godunov-type code for ideal/resistive magnetohydrodynamics (MHD)

OpenMHD is a Godunov-type finite-volume code for ideal/resistive magnetohydrodynamics (MHD). It is written in Fortran 90 and is parallelized by using MPI-3 and OpenMP. The code was originally developed for studying magnetic reconnection problems and has been made publicly available in the hope that others may find it useful.

[ascl:1502.002] OpenOrb: Open-source asteroid orbit computation software

OpenOrb (OOrb) contains tools for rigorously estimating the uncertainties resulting from the inverse problem of computing orbital elements using scarce astrometry. It uses the least-squares method and also contains both Monte-Carlo (MC) and Markov-Chain MC versions of the statistical ranging method. Ranging obtains sampled, non-Gaussian orbital-element probability-density functions and is optimized for cases where the amount of astrometry is scarce or spans a relatively short time interval.

[ascl:1911.003] OpenSPH: Astrophysical SPH and N-body simulations and interactive visualization tools

OpenSPH runs hydrodynamical and N-body simulations and was written for asteroid collisions and subsequent gravitational evolution. The code offers SPH and N-body solvers with several different equations of state and material rheologies. It is written in C++14 with a modular object-oriented design, focused on extensibility and maintainability, and it can be used either as a library or as a standalone graphical program that allows to set up the problem in a convenient graphical node editor. The graphical program further allows real-time visualization of the simulation, diagnostics and tools for analysis of the results.

[ascl:1509.009] OPERA: Objective Prism Enhanced Reduction Algorithms

OPERA (Objective Prism Enhanced Reduction Algorithms) automatically analyzes astronomical images using the objective-prism (OP) technique to register thousands of low resolution spectra in large areas. It detects objects in an image, extracts one-dimensional spectra, and identifies the emission line feature. The main advantages of this method are: 1) to avoid subjectivity inherent to visual inspection used in past studies; and 2) the ability to obtain physical parameters without follow-up spectroscopy.

[ascl:1411.004] OPERA: Open-source Pipeline for Espadons Reduction and Analysis

OPERA (Open-source Pipeline for Espadons Reduction and Analysis) is an open-source collaborative software reduction pipeline for ESPaDOnS data. ESPaDOnS is a bench-mounted high-resolution echelle spectrograph and spectro-polarimeter designed to obtain a complete optical spectrum (from 370 to 1,050 nm) in a single exposure with a mode-dependent resolving power between 68,000 and 81,000. OPERA is fully automated, calibrates on two-dimensional images and reduces data to produce one-dimensional intensity and polarimetric spectra. Spectra are extracted using an optimal extraction algorithm. Though designed for CFHT ESPaDOnS data, the pipeline is extensible to other echelle spectrographs.

[submitted] Opik Collision Probability

The Opik method gives the mean probability of collision of a small body with a given planet. It is a statistical value valid for an orbit with given (a,e,i) and undefined argument of perihelion. In some cases, the planet can eject the small body from the solar system; in these cases, the program estimates the mean time for the ejection. The Opik method does not take into account other perturbers than the planet considered, so it only provides an idea of the timescales involved.

[ascl:2112.018] Optab: Ideal-gas opacity tables generator

Optab, written in Fortran90, generates ideal-gas opacity tables. It computes opacity based on user-provided chemical equilibrium abundances, and outputs mean opacities as well as monochromatic opacities, thus providing opacity tables that are consistent with one's equation of state for radiation hydrodynamics simulations. For convenience, Optab also provides interfaces for FastChem (ascl:1804.025) or TEA (ascl:1505.031) for computing chemical abundances.

[ascl:1803.013] optBINS: Optimal Binning for histograms

optBINS (optimal binning) determines the optimal number of bins in a uniform bin-width histogram by deriving the posterior probability for the number of bins in a piecewise-constant density model after assigning a multinomial likelihood and a non-informative prior. The maximum of the posterior probability occurs at a point where the prior probability and the the joint likelihood are balanced. The interplay between these opposing factors effectively implements Occam's razor by selecting the most simple model that best describes the data.

[ascl:2104.010] OpTool: Command-line driven tool for creating complex dust opacities

Optool computes dust opacities and scattering matrices, for specific grain sizes or averaged over size distributions. It is derived from OpacityTool (ascl:2104.009) and implements the Distribution of Hollow Spheres (DHS) statistical method to approximate irregular and low porosity grains. Mie theory is available as a limiting case of DHS. It also implements the Tazaki Modified Mean Field Theory (MMF) to treat fractal and highly porous aggregates. The refractive index data for many astronomically relevant materials are compiled into the code, and external refractive index data can be used as well. A compact and intuitive command line interface makes it easy to construct complex particles on the fly. Available output formats are ASCII and FITS, including files directly readable by RADMC-3D (ascl:1202.015). A python interface to the FORTRAN program is included.

[ascl:2102.016] OPUS: Interoperable access to analysis and simulation codes

OPUS (Observatoire de Paris UWS System) provides interoperable access to analysis and simulation codes on local machines or work clusters. This job control system was developed using the micro-framework bottle.py, and executes jobs asynchronously to better manage jobs with a long execution duration. The software follows the proposed IVOA Provenance Data Model to capture and expose the provenance information of jobs and results.

[ascl:1310.001] ORAC-DR: Astronomy data reduction pipeline

ORAC-DR is a generic data reduction pipeline infrastructure; it includes specific data processing recipes for a number of instruments. It is used at the James Clerk Maxwell Telescope, United Kingdom Infrared Telescope, AAT, and LCOGT. This pipeline runs at the JCMT Science Archive hosted by CADC to generate near-publication quality data products; the code has been in use since 1998.

[ascl:1210.024] ORBADV: ORBital ADVection by interpolation

ORBADV adopts a ZEUS-like scheme to solve magnetohydrodynamic equations of motion in a shearing sheet. The magnetic field is discretized on a staggered mesh, and magnetic field variables represent fluxes through zone faces. The code uses obital advection to ensure fast and accurate integration in a large shearing box.

[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:1307.016] orbfit: Orbit fitting software

Orbfit determines positions and orbital elements, and associated uncertainties, of outer solar system planets. The orbit-fitting procedure is greatly streamlined compared with traditional methods because acceleration can be treated as a perturbation to the inertial motion of the body. Orbfit quickly and accurately calculates orbital elements and ephemerides and their associated uncertainties for targets ≳ 10 AU from the Sun and produces positional estimates and uncertainty ellipses even in the face of the substantial degeneracies of short-arc orbit fits; the sole a priori assumption is that the orbit should be bound or nearly so.

[ascl:1106.015] OrbFit: Software to Determine Orbits of Asteroids

OrbFit is a software system allowing one to compute the orbits of asteroids starting from the observations, to propagate these orbits, and to compute predictions on the future (and past) position on the celestial sphere. It is a tool to be used to find a well known asteroid, to recover a lost one, to attribute a small group of observations, to identify two orbits with each other, to study the future (and/or past) close approaches to Earth, thus to assess the risk of an impact, and more.

[ascl:1804.009] orbit-estimation: Fast orbital parameters estimator

orbit-estimation tests and evaluates the Stäckel approximation method for estimating orbit parameters in galactic potentials. It relies on the approximation of the Galactic potential as a Stäckel potential, in a prolate confocal coordinate system, under which the vertical and horizontal motions decouple. By solving the Hamilton Jacobi equations at the turning points of the horizontal and vertical motions, it is possible to determine the spatial boundary of the orbit, and hence calculate the desired orbit parameters.

[ascl:1910.009] orbitize: Orbit-fitting for directly imaged objects

orbitize fits the orbits of directly-imaged objects by packaging the Orbits for the Impatient (OFTI) algorithm and a parallel-tempered Markov Chain Monte Carlo (MCMC) algorithm into a consistent API. It accepts observations in three measurement formats, which can be mixed in the same input file, generates orbits, and plots the computed orbital parameters. orbitize offers numerous ways to visualize the data, including histograms, corner plots, and orbit plots. Generated orbits can be saved in HDF5 format for future use and analysis.

[ascl:2307.059] orbitN: Symplectic integrator for near-Keplerian planetary systems

orbitN generates accurate and reproducible long-term orbital solutions for near-Keplerian planetary systems with a dominant mass M0. The code focuses on hierarchical systems without close encounters but can be extended to include additional features. Among other features, the package includes M0's quadrupole moment, a lunar contribution, and post-Newtonian corrections (1PN) due to M0 (fast symplectic implementation). To reduce numerical roundoff errors, orbitN features Kahan compensated summation.

[ascl:1409.007] ORBS: A reduction software for SITELLE and SpiOMM data

ORBS merges, corrects, transforms and calibrates interferometric data cubes and produces a spectral cube of the observed region for analysis. It is a fully automatic data reduction software for use with SITELLE (installed at the Canada-France-Hawaii Telescope) and SpIOMM (a prototype attached to the Observatoire du Mont Mégantic); these imaging Fourier transform spectrometers obtain a hyperspectral data cube which samples a 12 arc-minutes field of view into 4 millions of visible spectra. ORBS is highly parallelized; its core classes (ORB) have been designed to be used in a suite of softwares for data analysis (ORCS and OACS), data simulation (ORUS) and data acquisition (IRIS).

[ascl:1911.019] OrbWeaver: Galaxy/(sub)halo orbital processing tool

OrbWeaver extracts orbits from halo catalogs, enabling large statistical studies of their orbital parameters. The code is run in two stages. For the first run, a configuration file is used to modify orbit host selection and the region around orbit host used for the superset of orbiting halos. Each orbit host has a orbit forest (containing halos that passed within the region of interest); the code generates a pre-processed catalog which contains a superset of orbiting halo for each identified orbit host. The second run uses the file list generated in the first stage for the creation of the orbit catalog, which is the final output.

[ascl:2001.009] ORCS: Analysis engine for SITELLE spectral cubes

ORCS (Outils de Réduction de Cubes Spectraux) is an analysis engine for SITELLE spectral cubes. The software extracts integrated spectra, fits the sinc emission lines, and recalibrates data in wavelength, astrometry and flux. ORCS offers a choice between a Bayesian or a classical fitting algorithm
, and also provides automatic source detection and radial velocity correction.

[ascl:1304.012] ORIGAMI: Structure-finding routine in N-body simulation

ORIGAMI is a dynamical method of determining the morphology of particles in a cosmological simulation by checking for whether, and in how many dimensions, a particle has undergone shell-crossing. The code is written in C and makes use of the Delaunay tessellation calculation routines from the VOBOZ package (which relies on the Qhull package).

[ascl:2002.003] ORIGIN: detectiOn and extRactIon of Galaxy emIssion liNes

ORIGIN performs blind detection of faint emitters in MUSE datacubes. The algorithm is tuned to detect faint spatial-spectral emission signatures while allowing for a stable false detection rate over the data cube, and providing in the same time an automated and reliable estimation of the purity. ORIGIN implements a nuisance removal part based on a continuum subtraction combining a Discrete Cosine Transform and an iterative Principal Component Analysis and a detection part based on the local maxima of Generalized Likelihood Ratio test statistics obtained for a set of spatial-spectral profiles of emission line emitters. In addition, it performs a purity estimation in which the proportion of true emission lines is estimated from the data itself: the distribution of the local maxima in the noise only configuration is estimated from that of the local minima.

[ascl:1204.013] ORSA: Orbit Reconstruction, Simulation and Analysis

ORSA is an interactive tool for scientific grade Celestial Mechanics computations. Asteroids, comets, artificial satellites, solar and extra-solar planetary systems can be accurately reproduced, simulated, and analyzed. The software uses JPL ephemeris files for accurate planets positions and has a Qt-based graphical user interface. It offers an advanced 2D plotting tool and 3D OpenGL viewer and the standalone numerical library liborsa and can import asteroids and comets from all the known databases (MPC, JPL, Lowell, AstDyS, and NEODyS). In addition, it has an integrated download tool to update databases.

[ascl:2105.012] orvara: Orbits from Radial Velocity, Absolute, and/or Relative Astrometry

orvara (Orbits from Radial Velocity, Absolute, and/or Relative Astrometry) fits orbits of bright stars and their faint companions (exoplanets, brown dwarfs, white dwarfs, and low-mass stars). It can use any combination of radial velocity, relative astrometry, and absolute astrometry data and offers a variety of plots from the orbital fit, such as the radial velocity orbit over an extended time baseline, position angle between two companions, and a density plot of the predicted position at a chosen epoch. orvara can also check convergence of fitted parameters in the HDU1 extension, save the results from the fitted and inferred parameters from the HDU1 extension, and plot the results of a three-body or multiple-body fit.

[ascl:1908.012] oscode: Oscillatory ordinary differential equation solver

oscode solves oscillatory ordinary differential equations efficiently. It is designed to deal with equations of the form x¨(t)+2γ(t)x˙(t)+ω2(t)x(t)=0, where γ(t) and ω(t) can be given as explicit functions or sequence containers (Eigen::Vectors, arrays, std::vectors, lists) in C++ or as numpy.arrays in Python. oscode makes use of an analytic approximation of x(t) embedded in a stepping procedure to skip over long regions of oscillations, giving a reduction in computing time. The approximation is valid when the frequency changes slowly relative to the timescales of integration, it is therefore worth applying when this condition holds for at least some part of the integration range.

[ascl:1710.021] OSIRIS Toolbox: OH-Suppressing InfraRed Imaging Spectrograph pipeline

OSIRIS Toolbox reduces data for the Keck OSIRIS instrument, an integral field spectrograph that works with the Keck Adaptive Optics System. It offers real-time reduction of raw frames into cubes for display and basic analysis. In this real-time mode, it takes about one minute for a preliminary data cube to appear in the “quicklook” display package. The reduction system also includes a growing set of final reduction steps including correction of telluric absorption and mosaicing of multiple cubes.

[ascl:2007.018] OSPEX: Object Spectral Executive

OSPEX (Object Spectral Executive) is an object-oriented interface for X-ray spectral analysis of solar data. The next generation of SPEX (ascl:2007.017), it reads and displays input data, selects and subtracts background, selects time intervals of interest, selects a combination of photon flux model components to describe the data, and fits those components to the spectrum in each time interval selected. During the fitting process, the response matrix is used to convert the photon model to the model counts to compare with the input count data. The resulting time-ordered fit parameters are stored and can be displayed and analyzed with OSPEX. The entire OSPEX session can be saved in the form of a script and the fit results stored in the form of a FITS file. Part of the SolarSoft (ascl:1208.013) package, OSPEX works with any type of data structured in the form of time-ordered count spectra; RHESSI, Fermi, SOXS, MESSENGER, Yohkoh, SMM, and SMART data analysis have all been implemented in OSPEX.

[ascl:2109.027] OSPREI: Sun-to-Earth (or satellite) CME simulator

OSPREI simulates the Sun-to-Earth (or satellite) behavior of CMEs. It is comprised of three separate models: ForeCAT, ANTEATR, and FIDO. ForeCAT uses the PFSS background to determine the external magnetic forces on a CME; ANTEATR takes the ForeCAT CME and propagates it to the final satellite distance, and outputs the final CME speed (both propagation and expansion), size, and shape (and their profiles with distance) as well as the arrival time and internal thermal and magnetic properties of the CME. FIDO takes the evolved CME from ANTEATR with the position and orientation from ForeCAT and passes the CME over a synthetic spacecraft. The relative location of the spacecraft within the CME determines the in situ magnetic field vector and velocity. It also calculates the Kp index from these values. OSPREI includes tools for creating figures from the results, including histograms, contour plots, and ensemble correlation plots, and new figures can be created using the results object that contains all the simulation data in an easily accessible format.

[ascl:1805.014] OSS: OSSOS Survey Simulator

Comparing properties of discovered trans-Neptunian Objects (TNOs) with dynamical models is impossible due to the observational biases that exist in surveys. The OSSOS Survey Simulator takes an intrinsic orbital model (from, for example, the output of a dynamical Kuiper belt emplacement simulation) and applies the survey biases, so the biased simulated objects can be directly compared with real discoveries.

[ascl:2401.011] ostrich: Surrogate modeling using PCA and Gaussian process interpolation

Ostrich emulates surrogate models for complex and expensive functions using Principal Component Analysis (PCA) to decompose a signal, then interpolate the PCA weights over the parameters θ using a Gaussian Process interpolator. The code is trained on samples from the expensive functions, recreating and interpolating between those training samples with reduced computational cost, and recalculating for each use.

[ascl:2211.009] ovejero: Bayesian neural network inference of strong gravitational lenses

ovejero conducts hierarchical inference of strongly-lensed systems with Bayesian neural networks. It requires lenstronomy (ascl:1804.012) and fastell (ascl:9910.003) to run lens models with elliptical mass distributions. The code trains Bayesian Neural Networks (BNNs) to predict posteriors on strong gravitational lensing images and can integrate with forward modeling tools in lenstronomy to allow comparison between BNN outputs and more traditional methods. ovejero also provides hierarchical inference tools to generate population parameter estimates and unbiased posteriors on independent test sets.

[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:2009.003] oxkat: Semi-automated imaging of MeerKAT observations

oxkat semi-automatically performs calibration and imaging of data from the MeerKAT radio telescope. Taking as input raw visibilities in Measurement Set format, the entire processing workflow is covered, from flagging and reference calibration, to imaging and self-calibration, and (optionally) direction-dependent calibration. The oxkat scripts use Python, and draw on numerous existing radio astronomy packages, including CASA (ascl:1107.013), WSClean (ascl:1408.023), and CubiCal (ascl:1805.031), among others, that are containerized using Singularity. Submission scripts for slurm and PBS job schedulers are automatically generated where necessary, catering for HPC facilities that are commonly used for processing MeerKAT data.

[ascl:2111.011] p-winds: Python implementation of Parker wind models for planetary atmospheres

p-winds produces simplified, 1-D models of the upper atmosphere of a planet and performs radiative transfer to calculate observable spectral signatures. The scalable implementation of 1D models allows for atmospheric retrievals to calculate atmospheric escape rates and temperatures. In addition, the modular implementation allows for a smooth plugging-in of more complex descriptions to forward model their corresponding spectral signatures (e.g., self-consistent or 3D models).

[ascl:1806.011] P2DFFT: Parallelized technique for measuring galactic spiral arm pitch angles

P2DFFT is a parallelized version of 2DFFT (ascl:1608.015). It isolates and measures the spiral arm pitch angle of galaxies. The code allows direct input of FITS images, offers the option to output inverse Fourier transform FITS images, and generates idealized logarithmic spiral test images of a specified size that have 1 to 6 arms with pitch angles of -75 degrees to 75 degrees​​. Further, it can output Fourier amplitude versus inner radius and pitch angle versus inner radius for each Fourier component (m = 0 to m = 6), and calculates the Fourier amplitude weighted mean pitch angle across m = 1 to m = 6 versus inner radius.

[ascl:1402.030] P2SAD: Particle Phase Space Average Density

P2SAD computes the Particle Phase Space Average Density (P2SAD) in galactic haloes. The model for the calculation is based on the stable clustering hypothesis in phase space, the spherical collapse model, and tidal disruption of substructures. The multiscale prediction for P2SAD computed by this IDL code can be used to estimate signals sensitive to the small scale structure of dark matter distributions (e.g. dark matter annihilation). The code computes P2SAD averaged over the whole virialized region of a Milky-Way-size halo at redshift zero.

[ascl:1205.002] p3d: General data-reduction tool for fiber-fed integral-field spectrographs

p3d is semi-automatic data-reduction tool designed to be used with fiber-fed integral-field spectrographs. p3d is a highly general and freely available tool based on IDL but can be used with full functionality without an IDL license. It is easily extended to include improved algorithms, new visualization tools, and support for additional instruments. It uses a novel algorithm for automatic finding and tracing of spectra on the detector, and includes two methods of optimal spectrum extraction in addition to standard aperture extraction. p3d also provides tools to combine several images, perform wavelength calibration and flat field data.

[ascl:1105.002] PACCE: Perl Algorithm to Compute Continuum and Equivalent Widths

PACCE (Perl Algorithm to Compute continuum and Equivalent Widths) computes continuum and equivalent widths. PACCE is able to determine mean continuum and continuum at line center values, which are helpful in stellar population studies, and is also able to compute the uncertainties in the equivalent widths using photon statistics.

[ascl:1110.011] Pacerman: Polarisation Angle CorrEcting Rotation Measure ANalysis

Pacerman, written in IDL, is a new method to calculate Faraday rotation measure maps from multi-frequency polarisation angle data. In order to solve the so called n-pi-ambiguity problem which arises from the observationally ambiguity of the polarisation angle which is only determined up to additions of n times pi, where n is an integer, we suggest using a global scheme. Instead of solving the n-pi-ambiguity for each data point independently, our algorithm, which we chose to call Pacerman solves the n-pi-ambiguity for a high signal-to-noise region "democratically" and uses this information to assist computations in adjacent low signal-to-noise areas.

[ascl:2212.013] PACMAN: Planetary Atmosphere, Crust, and MANtle geochemical evolution

PACMAN (Planetary Atmosphere, Crust, and MANtle geochemical evolution) runs a coupled redox-geochemical-climate evolution model. It runs Monte Carlo calculations over nominal parameter ranges, including number of iterations and number of cores for parallelization, which can be altered to reproduce different scenarios and sensitivity tests. Model outputs and corresponding input parameters are saved in separate files which are used to plot results; the the user can choose which outputs to plot, including all successful outputs, nominal Earth outputs, waterworld false positives, desertworld false positives, and high CO2:H2O false positives. Among other functions, PACMAN contains functions for interpolating the pre-computed Outgoing Longwave Radiation (OLR) grid, the atmosphere-ocean partitioning grid, and the stratospheric water vapor grid, calculating bond albedo and outgassing fluxes.

[ascl:1708.014] PACSman: IDL Suite for Herschel/PACS spectrometer data

PACSman provides an alternative for several reduction and analysis steps performed in HIPE (ascl:1111.001) on PACS spectroscopic data; it is written in IDL. Among the operations possible with it are transient correction, line fitting, map projection, and map analysis, and unchopped scan, chop/nod, and the decommissioned wavelength switching observation modes are supported.

[ascl:2211.004] PAHDecomp: Decomposing the mid-IR spectra of extremely obscured galaxies

PAHDecomp models mid-infrared spectra of galaxies; it is based on the popular PAHFIT code (ascl:1210.009). In contrast to PAHFIT, this model decomposes the continuum into a star-forming component and an obscured nuclear component based on Bayesian priors on the shape of the star-forming component (using templates + prior on extinction), making this tool ideally suited for modeling the spectra of heavily obscured galaxies. PAHDecomp successfully recovers properties of Compact Obscured Nuclei (CONs) where the inferred nuclear optical depth strongly correlates with the surface brightness of HCN-vib emission in the millimeter. This is currently set up to run on the short low modules of Spitzer IRS data (5.2 - 14.2 microns) but will be ideal for JWST/MIRI MRS data in the future.

[ascl:1210.009] PAHFIT: Properties of PAH Emission

PAHFIT is an IDL tool for decomposing Spitzer IRS spectra of PAH emission sources, with a special emphasis on the careful recovery of ambiguous silicate absorption, and weak, blended dust emission features. PAHFIT is primarily designed for use with full 5-35 micron Spitzer low-resolution IRS spectra. PAHFIT is a flexible tool for fitting spectra, and you can add or disable features, compute combined flux bands, change fitting limits, etc., without changing the code.

PAHFIT uses a simple, physically-motivated model, consisting of starlight, thermal dust continuum in a small number of fixed temperature bins, resolved dust features and feature blends, prominent emission lines (which themselves can be blended with dust features), as well as simple fully-mixed or screen dust extinction, dominated by the silicate absorption bands at 9.7 and 18 microns. Most model components are held fixed or are tightly constrained. PAHFIT uses Drude profiles to recover the full strength of dust emission features and blends, including the significant power in the wings of the broad emission profiles. This means the resulting feature strengths are larger (by factors of 2-4) than are recovered by methods which estimate the underlying continuum using line segments or spline curves fit through fiducial wavelength anchors.

[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:2202.005] palettable: Color palettes for Python

Palettable is a library of color palettes for Python. The code is written in pure Python with no dependencies; it can be used to supply color maps for matplotlib plots, customize matplotlib plots, and to supply colors for a web application.

[ascl:2210.029] paltas: Simulation-based inference on strong gravitational lensing systems

paltas conducts simulation-based inference on strong gravitational lensing images. It builds on lenstronomy (ascl:1804.012) to create large datasets of strong lensing images with realistic low-mass halos, Hubble Space Telescope (HST) observational effects, and galaxy light from HST's COSMOS field. paltas also includes the capability to easily train neural posterior estimators of the parameters of the lensing system and to run hierarchical inference on test populations.

[ascl:1406.002] PAMELA: Optimal extraction code for long-slit CCD spectroscopy

PAMELA is an implementation of the optimal extraction algorithm for long-slit CCD spectroscopy and is well suited for time-series spectroscopy. It properly implements the optimal extraction algorithm for curved spectra, including on-the-fly cosmic ray rejection as well as proper calculation and propagation of the errors. The software is distributed as part of the Starlink software collection (ascl:1110.012).

[ascl:1805.021] PampelMuse: Crowded-field 3D spectroscopy

PampelMuse analyzes integral-field spectroscopic observations of crowded stellar fields and provides several subroutines to perform the individual steps of the data analysis. All analysis steps assume that the IFS data has been properly reduced and that all the instrumental artifacts have been removed. PampelMuse is designed to correctly handle IFS data regardless of which instrument was used to observe the data. In addition to the actual data, the software also requires an estimate of the variances for the analysis; optionally, it can use a bad pixel mask. The analysis relies on the presence of a reference catalogue, containing coordinates and magnitudes of the stars in and around the observed field.

[ascl:2212.008] panco2: Pressure profile measurements of galaxy clusters

panco2 extracts measurements of the pressure profile of the hot gas inside galaxy clusters from millimeter-wave observations. The extraction is performed using forward modeling the millimeter-wave signal of clusters and MCMC sampling of a posterior distribution for the parameters given the input data. Many characteristic features of millimeter-wave observations can be taken into account, such as filtering (both through PSF smearing and transfer functions), point source contamination, and correlated noise.

[ascl:1906.016] PandExo: Instrument simulations for exoplanet observation planning

PandExo generates instrument simulations of JWST’s NIRSpec, NIRCam, NIRISS and NIRCam and HST WFC3 for planning exoplanet observations. It uses throughput calculations from STScI’s Exposure Time Calculator, Pandeia, and offers both an online tool and a python package.

[ascl:2303.009] Pandora: Fast exomoon transit detection algorithm

Pandora searches for exomoons by employing an analytical photodynamical model that includes stellar limb darkening, full and partial planet-moon eclipses, and barycentric motion of planet and moon. The code can be used with nested samplers such as UltraNest (ascl:1611.001) or dynesty (ascl:1809.013). Pandora is fast, calculating 10,000 models and log-likelihood evaluation per second (give or take an order of magnitude, depending on parameters and data); this means that a retrieval with 250 Mio. evaluations until convergence takes about 5 hours on a single core. For searches in large amounts of data, it is most efficient to assign one core per light curve.

[ascl:1511.009] Pangloss: Reconstructing lensing mass

Pangloss reconstructs all the mass within a light cone through the Universe. Understanding complex mass distributions like this is important for accurate time delay lens cosmography, and also for accurate lens magnification estimation. It aspires to use all available data in an attempt to make the best of all mass maps.

[ascl:2105.020] PAP: PHANGS-ALMA pipeline

The PHANGS-ALMA pipeline process data from radio interferometer observations. It uses CASA (ascl:1107.013), AstroPy (ascl:1304.002), and other affiliated packages to process data from calibrated visibilities to science-ready spectral cubes and maps. The PHANGS-ALMA pipeline offers a flexible alternative to the scriptForImaging script distributed by ALMA. The pipeline runs in two separate software environments: CASA 5.6 or 5.7 (staging, imaging and post-processing) and Python 3.6 or later (derived products) with modern versions of several packages.

[ascl:1103.008] Parallel HOP: A Scalable Halo Finder for Massive Cosmological Data Sets

Modern N-body cosmological simulations contain billions ($10^9$) of dark matter particles. These simulations require hundreds to thousands of gigabytes of memory, and employ hundreds to tens of thousands of processing cores on many compute nodes. In order to study the distribution of dark matter in a cosmological simulation, the dark matter halos must be identified using a halo finder, which establishes the halo membership of every particle in the simulation. The resources required for halo finding are similar to the requirements for the simulation itself. In particular, simulations have become too extensive to use commonly-employed halo finders, such that the computational requirements to identify halos must now be spread across multiple nodes and cores. Here we present a scalable-parallel halo finding method called Parallel HOP for large-scale cosmological simulation data. Based on the halo finder HOP, it utilizes MPI and domain decomposition to distribute the halo finding workload across multiple compute nodes, enabling analysis of much larger datasets than is possible with the strictly serial or previous parallel implementations of HOP. We provide a reference implementation of this method as a part of the toolkit yt, an analysis toolkit for Adaptive Mesh Refinement (AMR) data that includes complementary analysis modules. Additionally, we discuss a suite of benchmarks that demonstrate that this method scales well up to several hundred tasks and datasets in excess of $2000^3$ particles. The Parallel HOP method and our implementation can be readily applied to any kind of N-body simulation data and is therefore widely applicable. Parallel HOP is part of yt.

[ascl:1106.009] PARAMESH V4.1: Parallel Adaptive Mesh Refinement

PARAMESH is a package of Fortran 90 subroutines designed to provide an application developer with an easy route to extend an existing serial code which uses a logically cartesian structured mesh into a parallel code with adaptive mesh refinement (AMR). Alternatively, in its simplest use, and with minimal effort, it can operate as a domain decomposition tool for users who want to parallelize their serial codes, but who do not wish to use adaptivity.

The package builds a hierarchy of sub-grids to cover the computational domain, with spatial resolution varying to satisfy the demands of the application. These sub-grid blocks form the nodes of a tree data-structure (quad-tree in 2D or oct-tree in 3D). Each grid block has a logically cartesian mesh. The package supports 1, 2 and 3D models. PARAMESH is released under the NASA-wide Open-Source software license.

[ascl:1010.039] Parameter Estimation from Time-Series Data with Correlated Errors: A Wavelet-Based Method and its Application to Transit Light Curves

We consider the problem of fitting a parametric model to time-series data that are afflicted by correlated noise. The noise is represented by a sum of two stationary Gaussian processes: one that is uncorrelated in time, and another that has a power spectral density varying as $1/f^gamma$. We present an accurate and fast [O(N)] algorithm for parameter estimation based on computing the likelihood in a wavelet basis. The method is illustrated and tested using simulated time-series photometry of exoplanetary transits, with particular attention to estimating the midtransit time. We compare our method to two other methods that have been used in the literature, the time-averaging method and the residual-permutation method. For noise processes that obey our assumptions, the algorithm presented here gives more accurate results for midtransit times and truer estimates of their uncertainties.

[ascl:2009.008] Paramo: PArticle and RAdiation MOnitor

Paramo (PArticle and RAdiation MOnitor) numerically solves the Fokker-Planck kinetic equation, which is used to model the dynamics of a particle distribution function, using a robust implicit method, for the proper modeling of the acceleration processes, and accounts for accurate cooling coefficient (e.g., radiative cooling with Klein-Nishina corrections). The numerical solution at every time step is used to calculate radiations processes, namely synchrotron and IC, with sophisticated numerical techniques, obtaining the multi-wavelength spectral evolution of the system.

[ascl:2008.016] ParaMonte: Parallel Monte Carlo library

ParaMonte contains serial and parallel Monte Carlo routines for sampling mathematical objective functions of arbitrary-dimensions. It is used for posterior distributions of Bayesian models in data science, Machine Learning, and scientific inference and unifies the automation of Monte Carlo simulations. ParaMonte is user friendly and accessible from multiple programming environments, including C, C++, Fortran, MATLAB, and Python, and offers high performance at runtime and scalability across many parallel processors.

[ascl:1103.014] ParaView: Data Analysis and Visualization Application

ParaView is an open-source, multi-platform data analysis and visualization application. ParaView users can quickly build visualizations to analyze their data using qualitative and quantitative techniques. The data exploration can be done interactively in 3D or programmatically using ParaView's batch processing capabilities.

ParaView was developed to analyze extremely large datasets using distributed memory computing resources. It can be run on supercomputers to analyze datasets of terascale as well as on laptops for smaller data.

[ascl:1601.010] PARAVT: Parallel Voronoi Tessellation

PARAVT offers massive parallel computation of Voronoi tessellations (VT hereafter) in large data sets. The code is focused for astrophysical purposes where VT densities and neighbors are widely used. There are several serial Voronoi tessellation codes, however no open source and parallel implementations are available to handle the large number of particles/galaxies in current N-body simulations and sky surveys. Parallelization is implemented under MPI and VT using Qhull library. Domain decomposition take into account consistent boundary computation between tasks, and support periodic conditions. In addition, the code compute neighbors lists, Voronoi density and Voronoi cell volumes for each particle, and can compute density on a regular grid.

[ascl:2007.014] PARS: Paint the Atmospheres of Rotating Stars

PARS (Paint the Atmospheres of Rotating Stars) quickly computes magnitudes and spectra of rotating stellar models. It uses the star's mass, equatorial radius, rotational speed, luminosity, and inclination as input; the models incorporate Roche mass distribution (where all mass is at the center of the star), solid body rotation, and collinearity of effective gravity and energy flux.

[ascl:1502.005] PARSEC: PARametrized Simulation Engine for Cosmic rays

PARSEC (PARametrized Simulation Engine for Cosmic rays) is a simulation engine for fast generation of ultra-high energy cosmic ray data based on parameterizations of common assumptions of UHECR origin and propagation. Implemented are deflections in unstructured turbulent extragalactic fields, energy losses for protons due to photo-pion production and electron-pair production, as well as effects from the expansion of the universe. Additionally, a simple model to estimate propagation effects from iron nuclei is included. Deflections in the Galactic magnetic field are included using a matrix approach with precalculated lenses generated from backtracked cosmic rays. The PARSEC program is based on object oriented programming paradigms enabling users to extend the implemented models and is steerable with a graphical user interface.

[ascl:1208.020] ParselTongue: AIPS Python Interface

ParselTongue is a Python interface to classic AIPS, Obit and possibly other task-based data reduction packages. It serves as the software infrastructure for some of the ALBUS implementation. It allows you to run AIPS tasks, and access AIPS headers and extension tables from Python. There is also support for running Obit tasks and accessing data in FITS files. Full access to the visibilities in AIPS UV data is also available.

[ascl:2110.008] ParSNIP: Parametrization of SuperNova Intrinsic Properties

ParSNIP learns generative models of transient light curves from a large dataset of transient light curves. It is designed to work with light curves in sncosmo format using the lcdata package to handle large datasets. This code can be used for classification of transients, cosmological distance estimation, and identifying novel transients.

[ascl:2306.026] Parthenon: Portable block-structured adaptive mesh refinement framework

The Parthenon framework, derived from Athena++ (ascl:1912.005), handles massively-parallel, device-accelerated adaptive mesh refinement. It provides a device first/device resident approach, transparent packing of data across blocks (to reduce/hide kernel launch latency), and direct device-to-device communication via asynchronous, one-sided MPI communication to enable high performance. Parthenon uses an intermediate abstraction layer to hide complexity of device kernel launches, offers support for particles and abstract variable control via metadata tags, and has a flexible plug-in package system.

[ascl:1010.005] Particle module of Piernik MHD code

Piernik is a multi-fluid grid magnetohydrodynamic (MHD) code based on the Relaxing Total Variation Diminishing (RTVD) conservative scheme. The original code has been extended by addition of dust described within the particle approximation. The dust is now described as a system of interacting particles. The particles can interact with gas, which is described as a fluid. The comparison between the test problem results and the results coming from fluid simulations made with Piernik code shows the most important differences between fluid and particle approximations used to describe dynamical evolution of dust under astrophysical conditions.

[ascl:2207.029] ParticleGridMapper: Particle data interpolator

ParticleGridMapper.jl interpolates particle data onto either a Cartesian (uniform) grid or an adaptive mesh refinement (AMR) grid where each cell contains no more than one particle. The AMR grid can be trimmed with a user-defined maximum level of refinement. Three different interpolation schemes are supported: nearest grid point (NGP), smoothed-particle hydrodynamics (SPH), and Meshless finite mass (MFM). It is multi-threading parallel.

[ascl:1010.073] partiview: Immersive 4D Interactive Visualization of Large-Scale Simulations

In dense clusters a bewildering variety of interactions between stars can be observed, ranging from simple encounters to collisions and other mass-transfer encounters. With faster and special-purpose computers like GRAPE, the amount of data per simulation is now exceeding 1TB. Visualization of such data has now become a complex 4D data-mining problem, combining space and time, and finding interesting events in these large datasets. We have recently starting using the virtual reality simulator, installed in the Hayden Planetarium in the American Museum for Natural History, to tackle some of these problem. partiview is a program that enables you to visualize and animate particle data. partiview runs on relatively simple desktops and laptops, but is mostly compatible with its big brother VirDir.

[ascl:1809.003] PASTA: Python Astronomical Stacking Tool Array

PASTA performs median stacking of astronomical sources. Written in Python, it can filter sources, provide stack statistics, generate Karma annotations, format source lists, and read information from stacked Flexible Image Transport System (FITS) images. PASTA was originally written to examine polarization stack properties and includes a Monte Carlo modeler for obtaining true polarized intensity from the observed polarization of a stack. PASTA is also useful as a generic stacking tool, even if polarization properties are not being examined.

[ascl:1102.002] PBL: Particle-Based Lensing for Gravitational Lensing Mass Reconstructions of Galaxy Clusters

We present Particle-Based Lensing (PBL), a new technique for gravitational lensing mass reconstructions of galaxy clusters. Traditionally, most methods have employed either a finite inversion or gridding to turn observational lensed galaxy ellipticities into an estimate of the surface mass density of a galaxy cluster. We approach the problem from a different perspective, motivated by the success of multi-scale analysis in smoothed particle hydrodynamics. In PBL, we treat each of the lensed galaxies as a particle and then reconstruct the potential by smoothing over a local kernel with variable smoothing scale. In this way, we can tune a reconstruction to produce constant signal-noise throughout, and maximally exploit regions of high information density.

PBL is designed to include all lensing observables, including multiple image positions and fluxes from strong lensing, as well as weak lensing signals including shear and flexion. In this paper, however, we describe a shear-only reconstruction, and apply the method to several test cases, including simulated lensing clusters, as well as the well-studied ``Bullet Cluster'' (1E0657-56). In the former cases, we show that PBL is better able to identify cusps and substructures than are grid-based reconstructions, and in the latter case, we show that PBL is able to identify substructure in the Bullet Cluster without even exploiting strong lensing measurements.

[ascl:1708.007] PBMC: Pre-conditioned Backward Monte Carlo code for radiative transport in planetary atmospheres

PBMC (Pre-Conditioned Backward Monte Carlo) solves the vector Radiative Transport Equation (vRTE) and can be applied to planetary atmospheres irradiated from above. The code builds the solution by simulating the photon trajectories from the detector towards the radiation source, i.e. in the reverse order of the actual photon displacements. In accounting for the polarization in the sampling of photon propagation directions and pre-conditioning the scattering matrix with information from the scattering matrices of prior (in the BMC integration order) photon collisions, PBMC avoids the unstable and biased solutions of classical BMC algorithms for conservative, optically-thick, strongly-polarizing media such as Rayleigh atmospheres.

[ascl:1403.007] PC: Unified EOS for neutron stars

The equation of state (EOS) of dense matter is a crucial input for the neutron-star structure calculations. This Fortran code can obtain a "unified EOS" in the many-body calculations based on a single effective nuclear Hamiltonian, and is valid in all regions of the neutron star interior. For unified EOSs, the transitions between the outer crust and the inner crust and between the inner crust and the core are obtained as a result of many-body calculations.

[ascl:1207.012] PCA: Principal Component Analysis for spectra modeling

The mid-infrared spectra of ultraluminous infrared galaxies (ULIRGs) contain a variety of spectral features that can be used as diagnostics to characterize the spectra. However, such diagnostics are biased by our prior prejudices on the origin of the features. Moreover, by using only part of the spectrum they do not utilize the full information content of the spectra. Blind statistical techniques such as principal component analysis (PCA) consider the whole spectrum, find correlated features and separate them out into distinct components.

This code, written in IDL, classifies principal components of IRS spectra to define a new classification scheme using 5D Gaussian mixtures modelling. The five PCs and average spectra for the four classifications to classify objects are made available with the code.

[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:1809.002] PCCDPACK: Polarimetry with CCD

PCCDPACK analyzes polarimetry data. The set of routines is written in CL-IRAF (including compiled Fortran codes) and analyzes dozens of point objects simultaneously on the same CCD image. A subpackage, specpol, is included to analyze spectropolarimetry data.

[ascl:2309.011] PCOSTPD: Periodogram Comparison for Optimizing Small Transiting Planet Detection

The Periodogram Comparison for Optimizing Small Transiting Planet Detection R code compares two periodogram algorithms for detecting transiting exoplanets: the Box-fitting Least Squares (BLS) and the Transit Comb Filter (TCF). It calculates the False Alarm Probability (FAP) based on extreme value theory and signal-to-noise ratio (SNR) metrics to quantify periodogram peak significance. The comparison approach is aimed at optimizing the detection of small transiting planets in future transiting exoplanet surveys. The code can be extended for comparing any set of periodograms.

[ascl:2211.014] PDFchem: Average abundance of species from Av-PDFs

PDFchem models the cold ISM at moderate and large scales using functions connecting the quantities of the local and the observed visual extinctions and the local number density with probability density functions. For any given observed visual extinction sampled with thousands of clouds, the algorithm instantly computes the average abundances of the most important species and performs radiative transfer calculations to estimate the average emission of the most commonly observed lines.

[ascl:2105.002] PDM2: Phase Dispersion Minimization

PDM2 (Phase Dispersion Minimization) ddetermines periodic components of data sets with erratic time intervals, poor coverage, non-sine-wave curve shape, and/or large noise components. Essentially a least-squares fitting technique, the fit is relative to the mean curve as defined by the means of each bin; the code simultaneously obtains the best least-squares light curve and the best period. PDM2 allows an arbitrary degree of smoothing and provides improved curve fits, suppressed subharmonics, and beta function statistics.

[ascl:1102.022] PDRT: Photo Dissociation Region Toolbox

Ultraviolet photons from O and B stars strongly influence the structure and emission spectra of the interstellar medium. The UV photons energetic enough to ionize hydrogen (hν > 13.6 eV) will create the H II region around the star, but lower energy UV photons escape. These far-UV photons (6 eV < hν < 13.6 eV) are still energetic enough to photodissociate molecules and to ionize low ionization-potential atoms such as carbon, silicon, and sulfur. They thus create a photodissociation region (PDR) just outside the H II region. In aggregate, these PDRs dominate the heating and cooling of the neutral interstellar medium.

The PDR Toolbox is a science-enabling Python package for the community, designed to help astronomers determine the physical parameters of photodissociation regions from observations. Typical observations of both Galactic and extragalactic PDRs come from ground- and space-based millimeter, submillimeter, and far-infrared telescopes such as ALMA, SOFIA, JWST, Spitzer, and Herschel. Given a set of observations of spectral line or continuum intensities, PDR Toolbox can compute best-fit FUV incident intensity and cloud density based on our models of PDR emission.

[ascl:2207.026] pdspy: MCMC tool for continuum and spectral line radiative transfer modeling

pdspy fits Monte Carlo radiative transfer models for protostellar/protoplanetary disks to ALMA continuum and spectral line datasets using Markov Chain Monte Carlo fitting. It contains two tools, one to fit ALMA continuum visibilities and broadband spectral energy distributions (SEDs) with full radiative transfer models, and another to fit ALMA spectral line visibilities with protoplanetary disk models that include a vertically isothermal, power law temperature distribution. No radiative equilibrium calculation is done.

[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:2001.014] Peasoup: C++/CUDA GPU pulsar searching library

The NVIDIA GPU-based pipeline code peasoup provides a one-step pulsar search, including searching for pulsars with up to moderate accelerations, with only one command. Its features include dedispersion, dereddening in the Fourier domain, resampling, peak detection, and optional time series folding. peasoup's output is the candidate list.

[ascl:1304.001] PEC: Period Error Calculator

The PEC (Period Error Calculator) algorithm estimates the period error for eclipsing binaries observed by the Kepler Mission. The algorithm is based on propagation of error theory and assumes that observation of every light curve peak/minimum in a long time-series observation can be unambiguously identified. A simple C implementation of the PEC algorithm is available.

[ascl:1108.008] PÉGASE-HR: Stellar Population Synthesis at High Resolution Spectra

PÉGASE-HR is a code aimed at computing synthetic evolutive optical spectra of galaxies with a very high resolution (R=10 000, or dlambda=0.55) in the range Lambda=[4000, 6800] Angstroms. PÉGASE-HR is the result of combining the code PÉGASE.2 with the high-resolution stellar library ÉLODIE. This code can also be used at low resolution (R=200) over the range covered by the BaSeL library (from far UV to the near IR), and then produces the same results as PÉGASE.2. In PEGASE-HR, the BaSeL library is replaced by a grid of spectra interpolated from the high-resolution ÉLODIE library of stellar spectra. The ÉLODIE library is a stellar database of 1959 spectra for 1503 stars, observed with the echelle spectrograph ÉLODIE on the 193 cm telescope at the Observatoire de Haute Provence.

[ascl:1108.007] PÉGASE: Metallicity-consistent Spectral Evolution Model of Galaxies

PÉGASE (Projet d'Étude des GAlaxies par Synthèse Évolutive) is a code to compute the spectral evolution of galaxies. The evolution of the stars, gas and metals is followed for a law of star formation and a stellar initial mass function. The stellar evolutionary tracks extend from the main sequence to the white dwarf stage. The emission of the gas in HII regions is also taken into account. The main improvement in version 2 is the use of evolutionary tracks of different metallicities (from 10-4 to 5×solar). The effect of extinction by dust is also modelled using a radiative transfer code. PÉGASE.2 uses the BaSeL library of stellar spectra and can therefore synthesize low-resolution (R~200) ultraviolet to near-infrared spectra of Hubble sequence galaxies as well as of starbursts.

[ascl:1507.003] Pelican: Pipeline for Extensible, Lightweight Imaging and CAlibratioN

Pelican is an efficient, lightweight C++ library for quasi-real time data processing. The library provides a framework to separate the acquisition and processing of data, allowing the scalability and flexibility to fit a number of scenarios. Though its origin was in radio astronomy, processing data as it arrives from a telescope, the framework is sufficiently generic to be useful to any application that requires the efficient processing of incoming data streams.

[ascl:1010.060] Pencil: Finite-difference Code for Compressible Hydrodynamic Flows

The Pencil code is a high-order finite-difference code for compressible hydrodynamic flows with magnetic fields. It is highly modular and can easily be adapted to different types of problems. The code runs efficiently under MPI on massively parallel shared- or distributed-memory computers, like e.g. large Beowulf clusters. The Pencil code is primarily designed to deal with weakly compressible turbulent flows. To achieve good parallelization, explicit (as opposed to compact) finite differences are used. Typical scientific targets include driven MHD turbulence in a periodic box, convection in a slab with non-periodic upper and lower boundaries, a convective star embedded in a fully nonperiodic box, accretion disc turbulence in the shearing sheet approximation, self-gravity, non-local radiation transfer, dust particle evolution with feedback on the gas, etc. A range of artificial viscosity and diffusion schemes can be invoked to deal with supersonic flows. For direct simulations regular viscosity and diffusion is being used. The code is written in well-commented Fortran90.

[ascl:1811.019] PENTACLE: Large-scale particle simulations code for planet formation

PENTACLE calculates gravitational interactions between particles within a cut-off radius and a Barnes-Hut tree method for gravity from particles beyond. It uses FDPS (ascl:1604.011) to parallelize a Barnes-Hut tree algorithm for a memory-distributed supercomputer. The software can handle 1-10 million particles in a high-resolution N-body simulation on CPU clusters for collisional dynamics, including physical collisions in a planetesimal disc.

[ascl:2306.027] PEP: Planetary Ephemeris Program

Planetary Ephemeris Program (PEP) computes numerical ephemerides and simultaneously analyzes a heterogeneous collection of astrometric data. Written in Fortran, it is a general-purpose astrometric data-analysis program and models orbital motion in the solar system, determines orbital initial conditions and planetary masses, and has been used to, for example, measure general relativistic effects and test physics theories beyond the standard model. PEP also models pulsar motions and distant radio sources, and can solve for sky coordinates for radio sources, plasma densities, and the second harmonic of the Sun's gravitational field.

[ascl:2306.040] PEPITA: Prediction of Exoplanet Precisions using Information in Transit Analysis

PEPITA (Prediction of Exoplanet Precisions using Information in Transit Analysis) makes predictions for the precision of exoplanet parameters using transit light-curves. The code uses information analysis techniques to predict the best precision that can be obtained by fitting a light-curve without actually needing to perform the fit, thus allowing more efficient planning of observations or re-observations.

[ascl:2309.016] PEREGRINE: Gravitational wave parameter inference with neural ration estimation

PEREGRINE performs full parameter estimation on gravitational wave signals. Using an internal Truncated Marginal Neural Ratio Estimation (TMNRE) algorithm and building upon the swyft (ascl:2302.016) code to efficiently access marginal posteriors, PEREGRINE conducts a sequential simulation-based inference approach to support the analysis of both transient and continuous gravitational wave sources. The code can fully reconstruct the posterior distributions for all parameters of spinning, precessing compact binary mergers using waveform approximants.

[ascl:1809.005] perfectns: "Perfect" dynamic and standard nested sampling for spherically symmetric likelihoods and priors

perfectns performs dynamic nested sampling and standard nested sampling for spherically symmetric likelihoods and priors, and analyses the samples produced. The spherical symmetry allows the nested sampling algorithm to be followed “perfectly” - i.e. without implementation-specific errors correlations between samples. It is intended for use in research into the statistical properties of nested sampling, and to provide a benchmark for testing the performance of nested sampling software packages used for practical problems - which rely on numerical techniques to produce approximately uncorrelated samples.

[ascl:1406.005] PERIOD: Time-series analysis package

PERIOD searches for periodicities in data. It is distributed within the Starlink software collection (ascl:1110.012).

[ascl:1407.009] Period04: Statistical analysis of large astronomical time series

Period04 statistically analyzes large astronomical time series containing gaps. It calculates formal uncertainties, can extract the individual frequencies from the multiperiodic content of time series, and provides a flexible interface to perform multiple-frequency fits with a combination of least-squares fitting and the discrete Fourier transform algorithm. Period04, written in Java/C++, supports the SAMP communication protocol to provide interoperability with other applications of the Virtual Observatory. It is a reworked and extended version of Period98 (Sperl 1998) and PERIOD/PERDET (Breger 1990).

[ascl:2007.005] PeTar: ParticlE Tree & particle-particle & Algorithmic Regularization code for simulating massive star clusters

The N-body code PETAR (ParticlE Tree & particle-particle & Algorithmic Regularization) combines the methods of Barnes-Hut tree, Hermite integrator and slow-down algorithmic regularization (SDAR). It accurately handles an arbitrary fraction of multiple systems (e.g. binaries, triples) while keeping a high performance by using the hybrid parallelization methods with MPI, OpenMP, SIMD instructions and GPU. PETAR has very good agreement with NBODY6++GPU results on the long-term evolution of the global structure, binary orbits and escapers and is significantly faster when used on a highly configured GPU desktop computer. PETAR scales well when the number of cores increase on the Cray XC50 supercomputer, allowing a solution to the ten million-body problem which covers the region of ultra compact dwarfs and nuclear star clusters.

[ascl:2207.014] petitRADTRANS: Exoplanet spectra calculator

petitRADTRANS (pRT) calculates transmission and emission spectra of exoplanets for clear and cloudy planets. It also incorporates an easy subpackage for running retrievals with nested sampling. It allows the calculation of emission or transmission spectra, at low or high resolution, clear or cloudy, and includes a retrieval module to fit a petitRADTRANS model to spectral data. pRT has two different opacity treatment modes. The low resolution mode runs calculations at λ/Δλ ≤ 1000 using the so-called correlated-k treatment for opacities. The high resolution mode runs calculations at λ/Δλ ≤ 106, using a line-by-line opacity treatment.

[ascl:2203.013] PetroFit: Petrosian properties calculator and galaxy light profiles fitter

PetroFit calculates Petrosian properties, such as radii and concentration indices; it also fits galaxy light profiles. The package, built on Photutils (ascl:1609.011), includes tools for performing accurate photometry, segmentations, Petrosian properties, and fitting.

[ascl:2210.016] PETSc: Portable, Extensible Toolkit for Scientific Computation

PETSc (Portable, Extensible Toolkit for Scientific Computation) provides a suite of data structures and routines for the scalable (parallel) solution of scientific applications modeled by partial differential equations, and is intended for use in large-scale application projects. The toolkit includes a large suite of parallel linear, nonlinear equation solvers and ODE integrators that are easily used in application codes written in C, C++, Fortran and Python. PETSc provides many of the mechanisms needed within parallel application codes, such as simple parallel matrix and vector assembly routines that allow the overlap of communication and computation. In addition, PETSc (pronounced PET-see) includes support for managing parallel PDE discretizations.

[ascl:1910.010] PEXO: Precise EXOplanetology

PEXO provides a global modeling framework for ns timing, μas astrometry, and μm/s radial velocities. It can account for binary motion and stellar reflex motions induced by planetary companions and also treat various relativistic effects both in the Solar System and in the target system (Roemer, Shapiro, and Einstein delays). PEXO is able to model timing to a precision of 1 ns, astrometry to a precision of 1 μas, and radial velocity to a precision of 1 μm/s.

[ascl:1812.003] PFANT: Stellar spectral synthesis code

PFANT computes a synthetic spectrum assuming local thermodynamic equilibrium from a given stellar model atmosphere and lists of atomic and molecular lines; it provides large wavelength coverage and line lists from ultraviolet through the visible and near-infrared. PFANT has been optimized for speed, offers error reporting, and command-line configuration options.

[ascl:2104.013] pfits: PSRFITS-format data file processor

pfits reads, manipulates and processes PSRFITS format search- and fold-mode pulsar astronomy data files. It summerizes the header information in a PSRFITS file, reproduces some of fv's (ascl:1205.005) functionality, and allows the user to obtain detailed information about the file. It can determine whether the data is search mode or fold mode and plot the profile, color scale image, frequency time, sum in frequency, and 4-pol data, as appropriate. pfits can also read in a search mode file, dedisperses, and frequency-sums (if requested), and offers an option to output multiple dispersed data files, among other tasks.

[ascl:2105.022] PFITS: Spectra data reduction

PFITS performs data reduction of spectra, including dark removal and flat fielding; this software was a standard 1983 Reticon reduction package available at the University of Texas. It was based on the plotting program PCOSY by Gary Ferland, and in 1985 was updated by Andrew McWilliam.

[ascl:2210.026] PGOPHER: Rotational, vibrational, and electronic spectra simulator

PGOPHER simulates and fits rotational, vibrational, and electronic spectra. It handles linear molecules and symmetric and asymmetric tops, including effects due to unpaired electrons and nuclear spin, with a separate mode for vibrational structure. The code performs many sorts of transitions, including Raman, multiphoton, and forbidden transitions. It can simulate multiple species and states simultaneously, including special effects such as perturbations and state dependent predissociation. Fitting can be to line positions, intensities, or band contours. PGOPHER uses a standard graphical user interface and makes comparison with, and fitting to, spectra from various sources easy. In addition to overlaying numerical spectra, it is also possible to overlay pictures from pdf files and even plate spectra to assist in checking that published constants are being used correctly.

[ascl:1103.002] PGPLOT: Device-independent Graphics Package for Simple Scientific Graphs

The PGPLOT Graphics Subroutine Library is a Fortran- or C-callable, device-independent graphics package for making simple scientific graphs. It is intended for making graphical images of publication quality with minimum effort on the part of the user. For most applications, the program can be device-independent, and the output can be directed to the appropriate device at run time.

The PGPLOT library consists of two major parts: a device-independent part and a set of device-dependent "device handler" subroutines for output on various terminals, image displays, dot-matrix printers, laser printers, and pen plotters. Common file formats supported include PostScript and GIF.

PGPLOT itself is written mostly in standard Fortran-77, with a few non-standard, system-dependent subroutines. PGPLOT subroutines can be called directly from a Fortran-77 or Fortran-90 program. A C binding library (cpgplot) and header file (cpgplot.h) are provided that allow PGPLOT to be called from a C or C++ program; the binding library handles conversion between C and Fortran argument-passing conventions.

[ascl:1209.008] Phantom-GRAPE: SIMD accelerated numerical library for N-body simulations

Phantom-GRAPE is a numerical software library to accelerate collisionless $N$-body simulation with SIMD instruction set on x86 architecture. The Newton's forces and also central forces with an arbitrary shape f(r), which have a finite cutoff radius r_cut (i.e. f(r)=0 at r>r_cut), can be quickly computed.

[ascl:1709.002] PHANTOM: Smoothed particle hydrodynamics and magnetohydrodynamics code

Phantom is a smoothed particle hydrodynamics and magnetohydrodynamics code focused on stellar, galactic, planetary, and high energy astrophysics. It is modular, and handles sink particles, self-gravity, two fluid and one fluid dust, ISM chemistry and cooling, physical viscosity, non-ideal MHD, and more. Its modular structure makes it easy to add new physics to the code.

[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:2008.002] PhaseTracer: Cosmological phases mapping

PhaseTracer maps out cosmological phases, and potential transitions between them, for Standard Model extensions with any number of scalar fields. The code traces the minima of effective potential as the temperature changes, and then calculates the critical temperatures at which the minima are degenerate. PhaseTracer can use potentials provided by other packages and can be used to analyze cosmological phase transitions which played an important role in the early evolution of the Universe.

[ascl:1112.006] PhAst: Display and Analysis of FITS Images

PhAst (Photometry-Astrometry) is an IDL astronomical image viewer based on the existing application ATV which displays and analyzes FITS images. It can calibrate raw images, provide astrometric solutions, and do circular aperture photometry. PhAst allows the user to load, process, and blink any number of images. Analysis packages include image calibration, photometry, and astrometry (provided through an interface with SExtractor, SCAMP, and missFITS). PhAst has been designed to generate reports for Minor Planet Center reporting.

[ascl:2107.029] PHL: Persistent_Homology_LSS

Persistent_Homology_LSS analyzes halo catalogs using persistent homology to constrain cosmological parameters. It implements persistent homology on a point cloud composed of halos positions in a cubic box from N-body simulations of the universe at large scales. The output of the code are persistence diagrams and images that are used to constrain cosmological parameters from the halo catalog.

[ascl:1106.002] PHOEBE: PHysics Of Eclipsing BinariEs

PHOEBE (PHysics Of Eclipsing BinariEs) is a modeling package for eclipsing binary stars, built on top of the widely used WD program (Wilson & Devinney 1971). This introductory paper overviews most important scientific extensions (incorporating observational spectra of eclipsing binaries into the solution-seeking process, extracting individual temperatures from observed color indices, main-sequence constraining and proper treatment of the reddening), numerical innovations (suggested improvements to WD's Differential Corrections method, the new Nelder & Mead's downhill Simplex method) and technical aspects (back-end scripter structure, graphical user interface). While PHOEBE retains 100% WD compatibility, its add-ons are a powerful way to enhance WD by encompassing even more physics and solution reliability.

[ascl:1010.056] PHOENIX: A General-purpose State-of-the-art Stellar and Planetary Atmosphere Code

PHOENIX is a general-purpose state-of-the-art stellar and planetary atmosphere code. It can calculate atmospheres and spectra of stars all across the HR-diagram including main sequence stars, giants, white dwarfs, stars with winds, TTauri stars, novae, supernovae, brown dwarfs and extrasolar giant planets.

[ascl:1307.011] PhoSim: Photon Simulator

The Photon Simulator (PhoSim) is a set of fast photon Monte Carlo codes used to calculate the physics of the atmosphere, telescope, and detector by using modern numerical techniques applied to comprehensive physical models. PhoSim generates images by collecting photons into pixels. The code takes the description of what astronomical objects are in the sky at a particular time (the instance catalog) as well as the description of the observing configuration (the operational parameters) and produces a realistic data stream of images that are similar to what a real telescope would produce. PhoSim was developed for large aperture wide field optical telescopes, such as the planned design of LSST. The initial version of the simulator also targeted the LSST telescope and camera design, but the code has since been broadened to include existing telescopes of a related nature. The atmospheric model, in particular, includes physical approximations that are limited to this general context.

[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:2312.011] PhotochemPy: 1-D photochemical model of rocky planet atmospheres

PhotochemPy finds the steady-state chemical composition of an atmosphere or evolves atmospheres through time. Given inputs such as the stellar UV flux and atmospheric temperature structure, the code creates a photochemical model of a planet's atmosphere. PhotochemPy is a distant fork of Atmos (ascl:2106.039). It provides a Python wrapper to Fortran source code but can also be used exclusively in Fortran.

[ascl:1712.013] photodynam: Photodynamical code for fitting the light curves of multiple body systems

Photodynam facilitates so-called "photometric-dynamical" modeling. This model is quite simple and this is reflected in the code base. A N-body code provides coordinates and the photometric code produces light curves based on coordinates.

[ascl:2302.003] PHOTOe: Monte Carlo model for simulating the slowing down of photoelectrons

PHOTOe simulates the slowing down of photoelectrons in a gas with arbitrary amounts of H, He and O atoms, and thermal electrons, making PHOTOe useful for investigating the atmospheres of exoplanets. The multi-score scheme used in this code differs from other Monte Carlo approaches in that it efficiently handles rare collisional channels, as in the case of low-abundance excited atoms that undergo superelastic and inelastic collisions. PHOTOe outputs include production and energy yields, steady-state photoelectron flux, and estimates of the 'relaxation' time required by the photoelectrons to slow down from the injection energy to the cutoff energy. The model can also estimate the pathlength travelled by the photoelectrons while relaxing.

[ascl:1405.013] PHOTOM: Photometry of digitized images

PHOTOM performs photometry of digitized images. It has two basic modes of operation: using an interactive display to specify the positions for the measurements, or obtaining those positions from a file. In both modes of operation PHOTOM performs photometry using either the traditional aperture method or via optimal extraction. When using the traditional aperture extraction method the target aperture can be circular or elliptical and its size and shape can be varied interactively on the display, or by entering values from the keyboard. Both methods allow the background sky level to be either sampled interactively by the manual positioning of an aperture, or automatically from an annulus surrounding the target object. PHOTOM is the photometry backend for the GAIA tool (ascl:1403.024) and is part of the Starlink software collection (ascl:1110.012).

[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:1901.007] Photon: Python tool for data plotting

Photon makes simple 1D plots in python. It uses mainly matplotlib and PyQt5 and has been build to be fully customizable, allowing the user to change the fontstyle, fontsize, fontcolors, linewidth of the axes, thickness, and other parameters, and see the changes directly in the plot. Once a customization is created, it can be saved in a configuration file and reloaded for future use, allowing reuse of the customization for other plots. The main tool is a graphical user interface and it is started using a command line interface.

[ascl:2306.007] PhotoParallax: Data-driven photometric parallaxes built with Gaia and 2MASS

PhotoParallax calculates photometric parallaxes for distant stars in the Gaia TGAS catalog without any use of physical stellar models or stellar density models of the Milky Way. It uses the geometric parallaxes to calibrate a photometric model that is purely statistical, which is a model of the data rather than a model of stars per se.

[ascl:1408.022] PhotoRApToR: PHOTOmetric Research APplication TO Redshifts

PhotoRApToR (PHOTOmetric Research APplication TO Redshifts) solves regression and classification problems and is specialized for photo-z estimation. PhotoRApToR offers data table manipulation capabilities and 2D and 3D graphics tools for data visualization; it also provides a statistical report for both classification and regression experiments. The code is written in Java; the machine learning model is in C++ to increase the core execution speed.

[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:1112.004] PHOX: X-ray Photon Simulator

PHOX is a novel, virtual X-ray observatory designed to obtain synthetic observations from hydro-numerical simulations. The code is a photon simulator and can be apply to simulate galaxy clusters. In fact, X-ray observations of clusters of galaxies continue to provide us with an increasingly detailed picture of their structure and of the underlying physical phenomena governing the gaseous component, which dominates their baryonic content. Therefore, it is fundamental to find the most direct and faithful way to compare such observational data with hydrodynamical simulations of cluster-like objects, which can currently include various complex physical processes. Here, we present and analyse synthetic Suzaku observations of two cluster-size haloes obtained by processing with PHOX the hydrodynamical simulation of the large-scale, filament-like region in which they reside. Taking advantage of the simulated data, we test the results inferred from the X-ray analysis of the mock observations against the underlying, known solution. Remarkably, we are able to recover the theoretical temperature distribution of the two haloes by means of the multi-temperature fitting of the synthetic spectra. Moreover, the shapes of the reconstructed distributions allow us to trace the different thermal structure that distinguishes the dynamical state of the two haloes.

[ascl:2309.008] PI: Plages Identification

Plages Identification identifies solar plages from Ca II K photographic observations irrespective of noise level, brightness, and other image properties. The code provides an efficient, reliable method for identifying solar plages. The output of the algorithm is an image highlighting the plages and the calculated plage index. Plages Identification is also deployed as a webapp, allowing users to experiment with different hyperparameters and visualize their impact on the output image in real time.

[ascl:1408.003] PIA: ISOPHOT Interactive Analysis

ISOPHOT is one of the instruments on board the Infrared Space Observatory (ISO). ISOPHOT Interactive Analysis (PIA) is a scientific and calibration interactive data analysis tool for ISOPHOT data reduction. Written in IDL under Xwindows, PIA offers a full context sensitive graphical interface for retrieving, accessing and analyzing ISOPHOT data. It is available in two nearly identical versions; a general observers version omits the calibration sequences.

[ascl:1412.007] PIAO: Python spherIcAl Overdensity code

PIAO is an efficient memory-controlled Python code that uses the standard spherical overdensity (SO) algorithm to identify halos. PIAO employs two additional parameters besides the overdensity Δc. The first is the mesh-box size, which splits the whole simulation box into smaller ones then analyzes them one-by-one, thereby overcoming a possible memory limitation problem that can occur when dealing with high-resolution, large-volume simulations. The second is the smoothed particle hydrodynamics (SPH) neighbors number, which is used for the SPH density calculation.

[ascl:1905.019] PICASO: Planetary Intensity Code for Atmospheric Scattering Observations

PICASO (Planetary Intensity Code for Atmospheric Scattering Observations), written in Python, computes the reflected light of exoplanets at any phase geometry using direct and diffuse scattering phase functions and Raman scattering spectral features.

[ascl: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 (ascl:2002.017). 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:1306.011] Pico: Parameters for the Impatient Cosmologist

Pico is an algorithm that quickly computes the CMB scalar, tensor and lensed power spectra, the matter transfer function and the WMAP 5 year likelihood. It is intended to accelerate parameter estimation codes; Pico can compute the CMB power spectrum and matter transfer function, as well as any computationally expensive likelihoods, in a few milliseconds. It is extremely fast and accurate over a large volume of parameter space and its accuracy can be improved by using a larger training set. More generally, Pico allows using massively parallel computing resources, including distributed computing projects such as Cosmology@Home, to speed up the slow steps in inherently sequential calculations.

[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:1408.014] pieflag: CASA task to efficiently flag bad data

pieflag compares bandpass-calibrated data to a clean reference channel and identifies and flags essentially all bad data. pieflag compares visibility amplitudes in each frequency channel to a 'reference' channel that is rfi-free (or manually ensured to be rfi-free). pieflag performs this comparison independently for each correlation on each baseline, but will flag all correlations if threshold conditions are met. To operate effectively, pieflag must be supplied with bandpass-calibrated data. pieflag has two core modes of operation (static and dynamic flagging) with an additional extend mode; the type of data largely determines which mode to choose. Instructions for pre-processing data and selecting the mode of operation are provided in the help file. Once pre-processing and selecting the mode of operation are done, pieflag should work well 'out of the box' with its default parameters.

[ascl:2102.024] Piff: PSFs In the Full FOV

Piff models the point-spread function (PSF) across multiple detectors in the full field of view (FOV). Models can be built in chip coordinates or in sky coordinates if needed to account for the effects of astrometric distortion. The software can fit in either real or Fourier space, and can identify and excise outlier stars that are poor exemplars of the PSF according to some metric.

[ascl:1806.014] pile-up: Monte Carlo simulations of star-disk torques on hot Jupiters

The pile-up gnuplot script generates a Monte Carlo simulation with a selectable number of randomized drawings (1000 by default, ~1min on a modern laptop). For each realization, the script calculates the torque acting on a hot Jupiter around a young, solar-type star as a function of the star-planet distance. The total torque on the planet is composed of the disk torque in the type II migration regime (that is, the planet is assumed to have opened up a gap in the disk) and of the stellar tidal torque. The model has four free parameters, which are drawn from a normal or lognormal distribution: (1) the disk's gas surface density at 1 astronomical unit, (2) the magnitude of tidal dissipation within the star, (3) the disk's alpha viscosity parameter, and (4) and the mean molecular weight of the gas in the disk midplane. For each realization, the total torque is screened for a distance at which it becomes zero. If present, then this distance would represent a tidal migration barrier to the planet. In other words, the planet would stop migrating. This location is added to a histogram on top of the main torque-over-distance panel and the realization is counted as one case that contributes to the overall survival rate of hot Jupiters. Finally, the script generates an output file (PDF by default) and prints the hot Jupiter survival rate for the assumed parameterization of the star-planet-disk system.

[ascl:1407.012] PINGSoft2: Integral Field Spectroscopy Software

PINGSoft2 visualizes, manipulates and analyzes integral field spectroscopy (IFS) data based on either 3D cubes or Raw Stacked Spectra (RSS) format. Any IFS data can be adapted to work with PINGSoft2, regardless of the original data format and the size/shape of the spaxel. Written in IDL, PINGSoft2 is optimized for fast visualization rendering; it also includes various routines useful for generic astronomy and spectroscopy tasks.

[ascl:2209.008] PINION: Accelerating radiative transfer simulations for cosmic reionization

PINION (Physics-Informed neural Network for reIONization) predicts the complete 4-D hydrogen fraction evolution from the smoothed gas and mass density fields from pre-computed N-body simulations. Trained on C2-Ray simulation outputs with a physics constraint on the reionization chemistry equation, PINION accurately predicts the entire reionization history between z = 6 and 12 with only five redshift snapshots and a propagation mask as a simplistic approximation of the ionizing photon mean free path. The network's predictions are in good agreement with simulation to redshift z > 7, though the oversimplified propagation mask degrades the network's accuracy for z < 7.

[ascl:1910.001] PINK: Parallelized rotation and flipping INvariant Kohonen maps

Morphological classification is one of the most demanding challenges in astronomy. With the advent of all-sky surveys, an enormous amount of imaging data is publicly available, and are typically analyzed by experts or encouraged amateur volunteers. For upcoming surveys with billions of objects, however, such an approach is not feasible anymore. PINK (Parallelized rotation and flipping INvariant Kohonen maps) is a simple yet effective variant of a rotation-invariant self-organizing map that is suitable for many analysis tasks in astronomy. The code reduces the computational complexity via modern GPUs and applies the resulting framework to galaxy data for morphological analysis.

[ascl:1305.007] PINOCCHIO: PINpointing Orbit-Crossing Collapsed HIerarchical Objects

PINOCCHIO generates catalogues of cosmological dark matter halos with known mass, position, velocity and merger history. It is able to reproduce, with very good accuracy, the hierarchical formation of dark matter halos from a realization of an initial (linear) density perturbation field, given on a 3D grid. Its setup is similar to that of a conventional N-body simulation, but it is based on the powerful Lagrangian Perturbation Theory. It runs in just a small fraction of the computing time taken by an equivalent N-body simulation, producing promptly the merging histories of all halos in the catalog.

[ascl:1902.007] PINT: High-precision pulsar timing analysis package

PINT (PINT Is Not Tempo3) analyzes high-precision pulsar timing data, enabling interactive data analysis and providing an extensible and flexible development platform for timing applications. PINT utilizes well-debugged public Python packages and modern software development practices (e.g., the NumPy and Astropy libraries, version control and development with git and GitHub, and various types of testing) for increased development efficiency and enhanced stability. PINT has been developed and implemented completely independently from traditional pulsar timing software such as TEMPO (ascl:1509.002) and Tempo2 (ascl:1210.015) and is a robust tool for cross-checking timing analyses and simulating data.

[ascl:1007.001] PINTofALE: Package for Interactive Analysis of Line Emission

PINTofALE was originally developed to analyze spectroscopic data from optically-thin coronal plasmas, though much of the software is sufficiently general to be of use in a much wider range of astrophysical data analyses. It is based on a modular set of IDL tools that interact with an atomic database and with observational data. The tools are designed to allow easy identification of spectral features, measure line fluxes, and carry out detailed modeling. The basic philosophy of the package is to provide access to the innards of atomic line databases, and to have flexible tools to interactively compare with the observed data. It is motivated by the large amount of book-keeping, computation and iterative interaction that is required between the researcher and observational and theoretical data in order to derive astrophysical results. The tools link together transparently and automatically the processes of spectral "browsing", feature identification, measurement, and computation and derivation of results. Unlike standard modeling and fitting engines currently in use, PINTofALE opens up the "black box" of atomic data required for UV/X-ray analyses and allows the user full control over the data that are used in any given analysis.

[ascl:2103.024] PION: Computational fluid-dynamics package for astrophysics

PION (PhotoIonization of Nebulae) is a grid-based fluid dynamics code for hydrodynamics and magnetohydrodynamics, including a ray-tracing module for calculating the attenuation of radiation from point sources of ionizing photons. It also has a module for coupling fluid dynamics and the radiation field to microphysical processes such as heating/cooling and ionization/recombination. PION models the evolution of HII regions, photoionized bubbles that form around hot stars, and has been extended to include stellar wind sources so that both wind bubbles and photoionized bubbles can be simulated at the same time. It is versatile enough to be extended to other applications.

[ascl:2306.021] pipes_vis: Interactive GUI and visualizer tool for SPS spectra

pipes_vis is an interactive graphical user interface for visualizing SPS spectra. Powered by Bagpipes (ascl:2104.017), it provides real-time manipulation of a model galaxy's star formation history, dust, and other relevant properties through sliders and text boxes.

[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:2311.011] PIPPIN: Polarimetric Differential Imaging (PDI) pipeline for NACO data

PIPPIN (PDI pipeline for NACO data) reduces the polarimetric observations made with the VLT/NACO instrument. It applies the Polarimetric Differential Imaging (PDI) technique to distinguish the polarized, scattered light from the (largely) un-polarized, stellar light. As a result, circumstellar dust can be uncovered. PIPPIN appropriately handles various instrument configurations, including half-wave plate and de-rotator usage, Wollaston beam-splitter, and wiregrid observations. As part of the PDI reduction, PIPPIN performs various levels of corrections for instrumental polarization and crosstalk.

[ascl:2108.019] PIPS: Period detection and Identification Pipeline Suite

PIPS analyzes the lightcurves of astronomical objects whose brightness changes periodically. Originally developed to determine the periods of RR Lyrae variable stars, the code offers many features designed for variable star analysis and can obtain period values for almost any type of lightcurve with both speed and accuracy. PIPS determines periods through several different methods, analyzes the morphology of lightcurves via Fourier analysis, estimates the statistical significance of the detected signal, and determines stellar properties based on pre-existing stellar models.

[ascl:1405.012] PISA: Position Intensity and Shape Analysis

PISA (Position, Intensity and Shape Analysis) routines deal with the location and parameterization of objects on an image frame. The core of this package is the routine PISAFIND which performs image analysis on a 2-dimensional data frame. The program searches the data array for objects that have a minimum number of connected pixels above a given threshold and extracts the image parameters (position, intensity, shape) for each object. The image parameters can be determined using thresholding techniques or an analytical stellar profile can be used to fit the objects. In crowded regions deblending of overlapping sources can be performed. PISA is distributed as part of the Starlink software collection (ascl:1110.012).

[ascl:2110.007] PISCOLA: Python for Intelligent Supernova-COsmology Light-curve Analysis

PISCOLA (Python for Intelligent Supernova-COsmology Light-curve Analysis) fits supernova light curves and corrects them in a few lines of code. It uses Gaussian Processes to estimate rest-frame light curves of transients without needing an underlying light-curve template. The user can add filters, calculates the light-curves parameters, and obtain transmission functions for the observed filters and the Bessell filters. The correction process can be applied with default settings to obtain restframe light curves and light-curve parameters. PISCOLA can plot the SN light curves, filter transmission functions, light-curves fits results, the mangling function for a given phase, and includes several utilities that can, for example, convert fluxes to magnitudes and magnitudes to fluxes, and trim leading and trailing zeros from a 1-D array or sequence.

[ascl:2010.014] Pix2Prof: Deep learning for textraction of useful sequential information from galaxy imagery

Pix2Prof produces a surface brightness profile from an unprocessed galaxy image from the SDSS in either the g, r, or i bands. It is fast, and given suitable training data, Pix2Prof can be retrained to produce any galaxy profile from any galaxy image.

[ascl:2207.033] piXedfit: Analyze spatially resolved SEDs of galaxies

piXedfit provides a self-contained set of tools for analyzing spatially resolved properties of galaxies using imaging data or a combination of imaging data and the integral field spectroscopy (IFS) data. piXedfit has six modules that can handle all tasks in the analysis of the spatially resolved SEDs of galaxies, including images processing, a spatial-matching between reduced broad-band images with an IFS data cube, pixel binning, performing SED fitting, and making visualization plots for the SED fitting results.

[ascl:1102.007] PixeLens: A Portable Modeler of Lensed Quasars

We introduce and implement two novel ideas for modeling lensed quasars. The first is to require different lenses to agree about H0. This means that some models for one lens can be ruled out by data on a different lens. We explain using two worked examples. One example models 1115+080 and 1608+656 (time-delay quadruple systems) and 1933+503 (a prospective time-delay system) all together, yielding time-delay predictions for the third lens and a 90% confidence estimate of H0-1=14.6+9.4-1.7 Gyr (H0=67+9-26 km s-1 Mpc-1) assuming ΩM=0.3 and ΩΛ=0.7. The other example models the time-delay doubles 1520+530, 1600+434, 1830-211, and 2149-275, which gives H0-1=14.5+3.3-1.5 Gyr (H0=67+8-13 km s-1 Mpc-1). Our second idea is to write the modeling software as a highly interactive Java applet, which can be used both for coarse-grained results inside a browser and for fine-grained results on a workstation. Several obstacles come up in trying to implement a numerically intensive method thus, but we overcome them.

[ascl:2102.003] Pixell: Rectangular pixel map manipulation and harmonic analysis library

Pixell loads, manipulates, and analyzes maps stored in rectangular pixelization. It is mainly targeted for use with maps of the sky (e.g., CMB intensity and polarization maps, stacks of 21 cm intensity maps, binned galaxy positions or shear) in cylindrical projection, but its core functionality is more general. It extends numpy's ndarray to an ndmap class that associates a World Coordinate System (WCS) with a numpy array. It includes tools for Fourier transforms (through numpy or pyfft) and spherical harmonic transforms (through libsharp2 (ascl:1402.033)) of such maps and tools for visualization (through the Python Image Library).

[ascl:2210.012] pixmappy: Python interface to gbdes astrometry solutions

pixmappy provides a Python interface to gbdes pixel map (astrometry) solutions. It reads the YAML format astrometry solutions produced by gbdes (ascl:2210.011) and issues a PixelMap instance, which is a map from one 2d coordinate system ("pixel") to another ("world") 2d system. A PixelMap instance can be used as a function mapping one (or many) coordinate pairs. An inverse method does reverse mapping, and the local jacobian of the map is available also. The type of mapping that can be expressed is very flexible, and PixelMaps can be compounded into chains of tranformations.

[ascl:1305.005] PkdGRAV2: Parallel fast-multipole cosmological code

PkdGRAV2 is a high performance N-body treecode for self-gravitating astrophysical simulations. It is designed to run efficiently in serial and on a wide variety of parallel computers including both shared memory and message passing architectures. It can spatially adapt to large ranges in particle densities, and temporally adapt to large ranges in dynamical timescales. The code uses a non-standard data structure for efficiently calculating the gravitational forces, a variant on the k-D tree, and a novel method for treating periodic boundary conditions.

[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:2307.055] plan-net: Bayesian neural networks for exoplanetary atmospheric retrieval

plan-net uses machine learning with an ensemble of Bayesian neural networks for atmospheric retrieval; this approach yields greater accuracy and more robust uncertainties than a single model. A new loss function for BNNs learns correlations between the model outputs. Performance is improved by incorporating domain-specific knowledge into the machine learning models and provides additional insight by inferring the covariance of the retrieved atmospheric parameters.

[ascl:1911.001] PLAN: A Clump-finder for Planetesimal Formation Simulations

PLAN (PLanetesimal ANalyzer) identifies and characterizes planetesimals produced in numerical simulations of the Streaming Instability that includes particle self-gravity with code Athena (ascl:1010.014). PLAN works with the 3D particle output of Athena and finds gravitationally bound clumps robustly and efficiently. PLAN — written in C++ with OpenMP/MPI — is massively parallelized, memory-efficient, and scalable to analyze billions of particles and multiple snapshots simultaneously. The approach of PLAN is based on the dark matter halo finder HOP (ascl:1102.019), but with many customizations for planetesimal formation. PLAN can be easily adapted to analyze other object formation simulations that use Lagrangian particles (e.g., Athena++ simulations). PLAN is also equipped with a toolkit to analyze the grid-based hydro data (VTK dumps of primitive variables) from Athena, which requires the Boost MultiDimensional Array Library.

[ascl:1505.032] Planck Level-S: Planck Simulation Package

The Planck simulation package takes a cosmological model specified by the user and calculates a potential CMB sky consistent with this model, including astrophysical foregrounds, and then performs a simulated observation of this sky. This Simulation embraces many instrumental effects such as beam convolution and noise. Alternatively, the package can simulate the observation of a provided sky model, generated by another program such as the Planck Sky Model software. The Planck simulation package does not only provide Planck-like data, it can also be easily adopted to mimic the properties of other existing and upcoming CMB experiments.

[ascl:2010.009] plancklens: Planck 2018 lensing pipeline

plancklens contains most of Planck 2018 CMB lensing pipeline and makes it possible to reproduce the published map and band-powers. Some numerical parts are written in Fortran, and portions of it (structure and code) have been directly adapted from pre-existing work by Duncan Hanson. The lensed CMB skies is produced by the stand-alone package lenspyx (ascl:2010.010).

[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:1311.004] PlanetPack: Radial-velocity time-series analysis tool

PlanetPack facilitates and standardizes the advanced analysis of radial velocity (RV) data for the goal of exoplanets detection, characterization, and basic dynamical N-body simulations. PlanetPack is a command-line interpreter that can run either in an interactive mode or in a batch mode of automatic script interpretation.

[ascl:1911.007] planetplanet: General photodynamical code for exoplanet light curves

planetplanet models exoplanet transits, secondary eclipses, phase curves, and exomoons, as well as eclipsing binaries, circumbinary planets, and more. The code was originally developed to model planet-planet occultation (PPO) light curves for the TRAPPIST-1 system, but it is generally applicable to any exoplanet system. During a PPO, a planet occults (transits) the disk of another planet in the same planetary system, blocking its thermal (and reflected) light, which can be measured photometrically by a distant observer. planetplanet is coded in C and wrapped in a user-friendly Python interface.

[ascl:2309.020] PlanetSlicer: Orange-slice algorithm for fitting brightness maps to phase curves

PlanetSlicer fits brightness maps to phase curves using the "orange-slice" method and works both for self-luminous objects and those that diffuse reflected light assuming Lambertian reflectance. In both cases, the model supposes that a spherical object can be divided into slices of constant brightness (or albedo) which may be integrated to yield the total flux observed, given the angles of observation. The package contains two key functions: toPhaseCurve and fromPhaseCurve; the former integrates the brightness for each slice to calculate the observed total flux from the object, given the longitude of observation. The latter does the opposite, estimating the brightness of the slices from a set of observed total flux (the phase curve).

[ascl:2107.019] PlaSim: Planet Simulator

PlaSim is a climate model of intermediate complexity for Earth, Mars and other planets. It is written for a university environment, to be used to train the next GCM (general circulation model) developers, to support scientists in understanding climate processes, and to do fundamental research. In addition to an atmospheric GCM of medium complexity, PlaSim includes other compartments of the climate system such as, for example, an ocean with sea ice and a land surface with a biosphere. These other compartments are reduced to linear systems. In other words, PlaSim consists of a GCM with a linear ocean/sea-ice module formulated in terms of a mixed layer energy balance. The soil/biosphere module is introduced analoguously. Thus, working with PlaSim is like testing the performance of an atmospheric or oceanic GCM interacting with various linear processes, which parameterize the variability of the subsystems in terms of their energy (and mass) balances.

[ascl:1906.019] PlasmaPy: Core Python package for plasma physics

PlasmaPy provides core functionality and a common framework for data visualization and analysis for plasma physics. It has modules for basic plasma physics calculations, running desktop-scale simulations to test preliminary ideas such as one-dimensional MHD/PIC or test particles, or comparing data from two different sources, such as simulations and spacecraft.

[ascl:1506.003] PLATO Simulator: Realistic simulations of expected observations

PLATO Simulator is an end-to-end simulation software tool designed for the performance of realistic simulations of the expected observations of the PLATO mission but easily adaptable to similar types of missions. It models and simulates photometric time-series of CCD images by including models of the CCD and its electronics, the telescope optics, the stellar field, the jitter movements of the spacecraft, and all important natural noise sources.

[ascl:1903.014] PLATON: PLanetary Atmospheric Transmission for Observer Noobs

PLATON (PLanetary Atmospheric Transmission for Observer Noobs) calculates transmission spectra for exoplanets and retrieves atmospheric characteristics based on observed spectra; it is based on ExoTransmit (ascl:1611.005). PLATON supports the most common atmospheric parameters, such as temperature, metallicity, C/O ratio, cloud-top pressure, and scattering slope. It also has less commonly included features, such as a Mie scattering cloud model and unocculted starspot corrections.

[ascl:1907.009] Plonk: Smoothed particle hydrodynamics data analysis and visualization

Plonk analyzes and visualizes smoothed particle hydrodynamics simulation data, focusing on astrophysical applications. It calculates extra quantities on the particles, calculates and plots radial profiles, accesses subsets of particles, and provides visualization of any quantity defined on the particles via kernel density estimation. Plock's visualization module uses Splash (ascl:1103.004) to produce images using smoothed particle hydrodynamics interpolation. The code is modular and extendible, and can be scripted or used interactively.

[ascl:1106.003] PLplot: Cross-platform Software Package for Scientific Plots

PLplot is a cross-platform software package for creating scientific plots. To help accomplish that task it is organized as a core C library, language bindings for that library, and device drivers which control how the plots are presented in non-interactive and interactive plotting contexts. The PLplot core library can be used to create standard x-y plots, semi-log plots, log-log plots, contour plots, 3D surface plots, mesh plots, bar charts and pie charts. Multiple graphs (of the same or different sizes) may be placed on a single page, and multiple pages are allowed for those device formats that support them. PLplot has core support for Unicode. This means for our many Unicode-aware devices that plots can be labelled using the enormous selection of Unicode mathematical symbols. A large subset of our Unicode-aware devices also support complex text layout (CTL) languages such as Arabic, Hebrew, and Indic and Indic-derived CTL scripts such as Devanagari, Thai, Lao, and Tibetan. PLplot device drivers support a number of different file formats for non-interactive plotting and a number of different platforms that are suitable for interactive plotting. It is easy to add new device drivers to PLplot by writing a small number of device dependent routines.

[ascl:1206.007] Plumix: Generating mass segregated star clusters

Plumix is a small package for generating mass segregated star clusters. Its output can be directly used as input initial conditions for NBODY4 or NBODY6 code. Mass segregation stands as one of the most robust features of the dynamical evolution of self-gravitating star clusters. We formulate parametrized models of mass segregated star clusters in virial equilibrium. To this purpose we introduce mean inter-particle potentials for statistically described unsegregated systems and suggest a single-parameter generalization of its form which gives a mass-segregated state. Plumix is a numerical C-code generating the cluster according the algorithm given for construction of appropriate star cluster models. Their stability over several crossing-times is verified by following the evolution by means of direct N-body integration.

[ascl:1010.045] PLUTO: A Code for Flows in Multiple Spatial Dimensions

PLUTO is a modular Godunov-type code intended mainly for astrophysical applications and high Mach number flows in multiple spatial dimensions. The code embeds different hydrodynamic modules and multiple algorithms to solve the equations describing Newtonian, relativistic, MHD, or relativistic MHD fluids in Cartesian or curvilinear coordinates. PLUTO is entirely written in the C programming language and can run on either single processor machines or large parallel clusters through the MPI library. A simple user-interface based on the Python scripting language is available to setup a physical problem in a quick and self-explanatory way. Computations may be carried on either static or adaptive (structured) grids, the latter functionality being provided through the Chombo adaptive mesh refinement library.

[ascl:2211.008] pmclib: Population Monte Carlo library

The Population Monte-Carlo (PMC) sampling code pmclib performs fast end efficient parallel iterative importance sampling to compute integrals over the posterior including the Bayesian evidence.

[ascl:9909.001] PMCode: Particle-Mesh Code for Cosmological Simulations

Particle-Mesh (PM) codes are still very useful tools for testing predictions of cosmological models in cases when extra high resolution is not very important. We release for public use a cosmological PM N-body code. The code is very fast and simple. We provide a complete package of routines needed to set initial conditions, to run the code, and to analyze the results. The package allows you to simulate models with numerous combinations of parameters: open/flat/closed background, with or without the cosmological constant, different values of the Hubble constant, with or without hot neutrinos, tilted or non-tilted initial spectra, different amount of baryons.

[ascl:1102.008] PMFAST: Towards Optimal Parallel PM N-body Codes

The parallel PM N-body code PMFAST is cost-effective and memory-efficient. PMFAST is based on a two-level mesh gravity solver where the gravitational forces are separated into long and short range components. The decomposition scheme minimizes communication costs and allows tolerance for slow networks. The code approaches optimality in several dimensions. The force computations are local and exploit highly optimized vendor FFT libraries. It features minimal memory overhead, with the particle positions and velocities being the main cost. The code features support for distributed and shared memory parallelization through the use of MPI and OpenMP, respectively.

The current release version uses two grid levels on a slab decomposition, with periodic boundary conditions for cosmological applications. Open boundary conditions could be added with little computational overhead. Timing information and results from a recent cosmological production run of the code using a 3712^3 mesh with 6.4 x 10^9 particles are available.

[ascl:1102.015] PMFASTIC: Initial condition generator for PMFAST

PMFASTIC is a parallel initial condition generator, a slab decomposition Fortran 90 parallel cosmological initial condition generator for use with PMFAST (ascl:1102.008). Files required for generating initial dark matter particle distributions and instructions are included, however one would require CMBFAST to create alternative transfer functions.

[ascl:2107.003] PMN-body: Particle Mesh N-body code

PMN-body computes the non-linear evolution of the cosmological matter density contrast. It is based on the Particle Mesh (PM) technique. Written in C, the code is parallelized for shared-memory machines using Open Multi-Processing (OpenMP).

[ascl:2205.001] PMOIRED: Parametric Modeling of Optical Interferometric Data

PMOIRED models astronomical spectro-interferometric data stored in the OIFITS format. Parametric modeling is used to describe the observed scene as blocks such as disks, rings and Gaussians which can be combined and their parameters linked. It includes plotting, least-square fitting and bootstrapping estimation of uncertainties. For spectroscopic instruments (such as GRAVITY), tools are provided to model spectral lines and correct spectra for telluric lines.

[ascl:1010.065] PN: Higher Post Newtonian Gravity Calculations

Motivated by experimental probes of general relativity, we adopt methods from perturbative (quantum) field theory to compute, up to certain integrals, the effective lagrangian for its n-body problem. Perturbation theory is performed about a background Minkowski spacetime to O[(v/c)^4] beyond Newtonian gravity, where v is the typical speed of these n particles in their center of energy frame. For the specific case of the 2 body problem, the major efforts underway to measure gravitational waves produced by in-spiraling compact astrophysical binaries require their gravitational interactions to be computed beyond the currently known O[(v/c)^7]. We argue that such higher order post-Newtonian calculations must be automated for these field theoretic methods to be applied successfully to achieve this goal. In view of this, we outline an algorithm that would in principle generate the relevant Feynman diagrams to an arbitrary order in v/c and take steps to develop the necessary software. The Feynman diagrams contributing to the n-body effective action at O[(v/c)^6] beyond Newton are derived.

[ascl:2307.009] pnautilus: Three-phase chemical code

The three-phase pnautilus chemical code finds the abundance of each species by solving rate equations for gas-phase and grain surface chemistries. It performs gas–grain simulations in which both the icy mantle and the surface are considered active, taking into account mantle photodissociation, diffusion, and reactions; the code also considers the competition among reaction, diffusion and evaporation.

[ascl:1302.004] pNbody: A python parallelized N-body reduction toolbox

pNbody is a parallelized python module toolbox designed to manipulate and interactively display very large N-body systems. It allows the user to perform complicated manipulations with only very few commands and to load an N-body system and explore it interactively using the python interpreter. pNbody may also be used in python scripts. pNbody contains graphical facilities for creating maps of physical values of the system, such as density, temperature, and velocities maps. Stereo capabilities are also implemented. pNbody is not limited by file format; the user may use a parameter file to redefine how to read a preferred format.

[ascl:2011.025] PNICER: Extinction estimator

PNICER estimates extinction for individual sources and creates extinction maps using unsupervised machine learning algorithms. Extinction towards single sources is determined by fitting Gaussian Mixture Models along the extinction vector to (extinction-free) control field observations. PNICER also offers access to the well-established NICER technique in a simple unified interface and is capable of building extinction maps including the NICEST correction for cloud substructure.

[ascl:2207.018] pocoMC: Preconditioned Monte Carlo method for accelerated Bayesian inference

pocoMC performs Bayesian inference, including model comparison, for challenging scientific problems. The code utilizes a normalizing flow to precondition the target distribution by removing any correlations between its parameters. pocoMC then generates posterior samples, used for parameter estimation, with a powerful adaptive Sequential Monte Carlo algorithm manifesting a sampling efficiency that can be orders of magnitude higher than without precondition. Furthermore, pocoMC also provides an unbiased estimate of the model evidence that can be used for the task of Bayesian model comparison. The code is designed to excel in demanding parameter estimation problems that include multimodal and highly non–Gaussian target distributions.

[ascl:1907.006] POCS: PANOPTES Observatory Control System

PANOPTES (Panoptic Astronomical Networked Observatories for a Public Transiting Exoplanets Survey) is a citizen science project for low cost, robotic detection of transiting exoplanets. POCS (PANOPTES Observatory Control System) is the main software driver for the PANOPTES telescope system, responsible for high-level control of the unit. POCS defines an Observatory class that automatically controls a commercially available equatorial mount, including image analysis and corresponding mount adjustment to obtain a percent-level photometric precision.

[ascl:1408.005] POET: Planetary Orbital Evolution due to Tides

POET (Planetary Orbital Evolution due to Tides) calculates the orbital evolution of a system consisting of a single star with a single planet in orbit under the influence of tides. The following effects are The evolutions of the semimajor axis of the orbit due to the tidal dissipation in the star and the angular momentum of the stellar convective envelope by the tidal coupling are taken into account. In addition, the evolution includes the transfer of angular momentum between the stellar convective and radiative zones, effect of the stellar evolution on the tidal dissipation efficiency, and stellar core and envelope spins and loss of stellar convective zone angular momentum to a magnetically launched wind. POET can be used out of the box, and can also be extended and modified.

[ascl:2208.011] POIS: Python Optical Interferometry Simulation

POIS (Python Optical Interferometry Simulation) provides the building blocks to simulate the operation of a ground-based optical interferometer perturbed by atmospheric seeing perturbations. The package includes functions to generate simulated atmospheric turbulent wavefront perturbations, correct these perturbations using adaptive optics, and combine beams from an arbitrary number of telescopes, with or without spatial filtering, to provide complex fringe visibility measurements.

[submitted] Poke: An open-source ray-based physical optics platform

Integrated optical models allow for accurate prediction of the as-built performance of an optical instrument. Optical models are typically composed of a separate ray trace and diffraction model to capture both the geometrical and physical regimes of light. These models are typically separated across both open-source and commercial software that don't interface with each other directly. To bridge the gap between ray trace models and diffraction models, we have built an open-source optical analysis platform in Python called Poke that uses commercial ray tracing APIs and open-source physical optics engines to simultaneously model scalar wavefront error, diffraction, and polarization. Poke operates by storing ray data from a commercial ray tracing engine into a Python object, from which physical optics calculations can be made. We present an introduction to using Poke, and highlight the capabilities of two new propagation physics modules that add to the utility of existing scalar diffraction models. Gaussian Beamlet Decomposition is a ray-based approach to diffraction modeling that allows us to integrate physical optics models with ray trace models to directly capture the influence of ray aberrations in diffraction simulations. Polarization Ray Tracing is a ray-based method of vector field propagation that can diagnose the polarization aberrations in optical systems.

[ascl:1505.018] POKER: P Of K EstimatoR

POKER (P Of K EstimatoR) estimates the angular power spectrum of a 2D map or the cross-power spectrum of two 2D maps in the flat sky limit approximation in a realistic data context: steep power spectrum, non periodic boundary conditions, arbitrary pixel resolution, non trivial masks and observation patch geometry.

[ascl:1807.001] POLARIS: POLArized RadIation Simulator

POLARIS (POLArized RadIation Simulator) simulates the intensity and polarization of light emerging from analytical astrophysical models as well as complex magneto-hydrodynamic simulations on various grids. This 3D Monte-Carlo continuum radiative transfer code is written in C++ and is capable of performing dust heating, dust grain alignment, line radiative transfer, and synchrotron simulations to calculate synthetic intensity and polarization maps. The code makes use of a full set of physical quantities (density, temperature, velocity, magnetic field distribution, and dust grain properties as well as different sources of radiation) as input.

[ascl:2402.006] polarizationtools: Polarization analysis and simulation tools in python

polarizationtools converts, analyzes, and simulates polarization data. The different python scripts (1) convert Stokes parameters into linear polarization parameters with proper treatment of the uncertainties and vice versa; (2) shift electric vector position angle (EVPA) data points in time series to account for the 180 degrees ambiguity; (3) identify rotations of the EVPA e.g. in blazar polarization monitoring data according to various rotation definitions; and (4) simulate polarization time series as a random walk in the Stokes Q-U plane.

[ascl:2102.011] polgraw-allsky: All-sky almost-monochromatic gravitational-wave pipeline

polgraw-allsky searches for almost monochromatic gravitational wave signals. This pipeline searches for continuous gravitational wave signals in time-domain data using the F-statistic on data from a network of detectors. The software generates a parameter space grid, conducts a coherent search for candidate signals in narrowband time segments, and searches for coincidences among different time segments. The pipeline also estimates the false alarm probability of coincidences and follows up on interesting outliers.

[ascl:1406.012] POLMAP: Interactive data analysis package for linear spectropolarimetry

POLMAP provides routines for displaying and analyzing spectropolarimetry data that are not available in the complementary TSP package. Commands are provided to read and write TSP (ascl:1406.011) polarization spectrum format files from within POLMAP. This code is distributed as part of the Starlink software collection (ascl:1110.012).

[ascl:1405.014] POLPACK: Imaging polarimetry reduction package

POLPACK maps the linear or circular polarization of extended astronomical objects, either in a single waveband, or in multiple wavebands (spectropolarimetry). Data from both single and dual beam polarimeters can be processed. It is part of the Starlink software collection (ascl:1110.012).

[ascl:1603.018] PolRadTran: Polarized Radiative Transfer Model Distribution

PolRadTran is a plane-parallel polarized radiative transfer model. It is used to compute the radiance exiting a vertically inhomogeneous atmosphere containing randomly-oriented particles. Both solar and thermal sources of radiation are considered. A direct method of incorporating the polarized scattering information is combined with the doubling and adding method to produce a relatively simple formulation.

[ascl:1109.005] PolSpice: Spatially Inhomogeneous Correlation Estimator for Temperature and Polarisation

PolSpice (aka Spice) is a tool to statistically analyze Cosmic Microwave Background (CMB) data, as well as any other diffuse data pixelized on the sphere.

This Fortran90 program measures the 2 point auto (or cross-) correlation functions w(θ) and the angular auto- (or cross-) power spectra C(l) from one or (two) sky map(s) of Stokes parameters (intensity I and linear polarisation Q and U). It is based on the fast Spherical Harmonic Transforms allowed by isolatitude pixelisations such as Healpix [for Npix pixels over the whole sky, and a C(l) computed up to l=lmax, PolSpice complexity scales like Npix1/2 lmax2 instead of Npix lmax2]. It corrects for the effects of the masks and can deal with inhomogeneous weights given to the pixels of the map. In the case of polarised data, the mixing of the E and B modes due to the cut sky and pixel weights can be corrected for to provide an unbiased estimate of the "magnetic" (B) component of the polarisation power spectrum. Most of the code is parallelized for shared memory (SMP) architecture using OpenMP.

[ascl:2307.020] PolyBin: Binned polyspectrum estimation on the full sky

PolyBin estimates the binned power spectrum, bispectrum, and trispectrum for full-sky HEALPix maps such as the CMB. This can include both spin-0 and spin-2 fields, such as the CMB temperature and polarization, or galaxy positions and galaxy shear. Alternatively, one can use only scalar maps. For each statistic, two estimators are available: the standard (ideal) estimators, which do not take into account the mask, and window-deconvolved estimators. For the second case, a Fisher matrix must be computed; this depends on binning and the mask, but does not need to be recomputed for each new simulation. PolyBin can compute both the parity-even and parity-odd components, accounting for any leakage between the two, for the bispectrum and trispectrum.

[ascl:1502.011] PolyChord: Nested sampling for cosmology

PolyChord is a Bayesian inference tool for the simultaneous calculation of evidences and sampling of posterior distributions. It is a variation on John Skilling's Nested Sampling, utilizing Slice Sampling to generate new live points. It performs well on moderately high dimensional (~100s D) posterior distributions, and can cope with arbitrary degeneracies and multimodality.

[ascl:2007.009] polyMV: Multipolar coefficients converter

polyMV converts multipolar coefficients (alms in healpix order) into Multipole Vectors (MVs) and also Fréchet Vectors (FVs) given a specific multipole. The code uses MPSolve (ascl:2007.008) and is order of magnitudes faster than other existing public codes at high multipoles.

[ascl:1912.001] Polyspectrum: Computing polyspectra using an FFT estimator

Polyspectrum computes the polyspectrum from 3D grids using a fast Fourier transformation (FFT) estimator. The code, written in C and MPI-parallelized, support the computation of power- and bispectra; it also supports higher-order polyspectra, but streamlining the input data is required.

[ascl:2012.016] Pomegranate: Probabilistic model builder

Pomegranate builds probabilistic models in Python that is implemented in Cython for speed. The code merges the easy-to-use API of scikit-learn with the modularity of probabilistic modeling, including general mixture and hidden Markov models and Bayesian networks, to allow users to specify complicated models without the need to be concerned about implementation details. The models are built from the ground up and natively support features such as multi-threaded parallelism and out-of-core processing.

[ascl:1805.011] PoMiN: A Post-Minkowskian N-Body Solver

PoMiN is a lightweight N-body code based on the Post-Minkowskian N-body Hamiltonian of Ledvinka, Schafer, and Bicak, which includes General Relativistic effects up to first order in Newton's constant G, and all orders in the speed of light c. PoMiN is a single file written in C and uses a fourth-order Runge-Kutta integration scheme. PoMiN has also been written to handle an arbitrary number of particles (both massive and massless) with a computational complexity that scales as O(N^2).

[ascl:2007.006] PoPE: Population Profile Estimator

PoPE (Population Profile Estimator) analyzes spatial distribution or internal spatial structure problems of samples of astronomical systems. This population-based Bayesian inference model uses the conditional statistics of spatial profile of multiple observables assuming the individual observations are measured with errors of varying magnitude. Assuming the conditional statistics of the observables can be described with a multivariate normal distribution, the model reduces to the conditional average profile and conditional covariance between all observables. The method consists of two steps: (1) reconstructing the average profile using non-parametric regression with Gaussian Processes and (2) estimating the property profiles covariance given a set of independent variable. PoPE is computationally efficient and capable of inferring average profiles of a population from noisy measurements without stacking and binning nor parameterizing the shape of the average profile.

[ascl:1602.018] POPPY: Physical Optics Propagation in PYthon

POPPY (Physical Optics Propagation in PYthon) simulates physical optical propagation including diffraction. It implements a flexible framework for modeling Fraunhofer and Fresnel diffraction and point spread function formation, particularly in the context of astronomical telescopes. POPPY provides the optical modeling framework for WebbPSF (ascl:1504.007) and was developed as part of a simulation package for JWST, but is available separately and is broadly applicable to many kinds of imaging simulations.

[ascl:0202.001] PopRatio: A program to calculate atomic level populations in astrophysical plasmas

PopRatio is a Fortran 90 code to calculate atomic level populations in astrophysical plasmas. The program solves the equations of statistical equilibrium considering all possible bound-bound processes: spontaneous, collisional or radiation induced (the later either directly or by fluorescence). There is no limit on the number of levels or in the number of processes that may be taken into account. The program may find a wide range of applicability in astronomical problems, such as interpreting fine-structure absorption lines or collisionally excited emission lines and also in calculating the cooling rates due to collisional excitation.

[ascl:1912.008] PopSyCLE: Population Synthesis for Compact object Lensing Events

PopSyCLE performs compact object population synthesis while taking photometric and astrometric microlensing effects into consideration. It uses Galaxia (ascl:1101.007) to produces a synthetic survey, injects compact objects into the resulting survey, and then produces a list of microlensing events, enabling the discovery of black holes with microlensing. It can be used to examine historical microlensing events from photometric surveys to statistically constrain the abundance of black holes in our galaxy, and to forward model microlensing survey results to constrain, for example, the properties of compact objects, Galactic structure, and the initial-final mass relation.

[ascl:2202.021] popsynth: Observed surveys from latent population models

Popsynth provides an abstract way to generate survey populations from arbitrary luminosity functions and redshift distributions. Additionally, auxiliary quantities can be sampled and stored. Populations can be saved and restored via an HDF5 files for later use, and population synthesis routines can be created via classes or structured YAML files. Users can construct their own classes for spatial, luminosity, and other distributions, all of which can be connected to arbitrarily complex selection functions.

[ascl:2106.037] PORTA: POlarized Radiative TrAnsfer

PORTA solves three-dimensional non-equilibrium radiative transfer problems with massively parallel computers. The code can be used for modeling the spectral line polarization produced by the scattering of anisotropic radiation and the Hanle and Zeeman effects assuming complete frequency redistribution, either using two-level or multilevel atomic models. The numerical method of solution used to find the self-consistent values of the atomic density matrix at each point of the model’s Cartesian grid is based on Jacobi iterative scheme and on a short-characteristics formal solver of the Stokes-vector transfer equation that uses monotonic Bézier interpolation. The code can also be used to compute the linear polarization of the continuum radiation caused by Rayleigh and Thomson scattering in 3D models of stellar atmospheres, and to solve the simpler 3D radiative transfer problem of unpolarized radiation in multilevel systems. PORTA accepts/produces HDF5 input/output and offers an advanced graphical user interface.

[ascl:2003.006] PORTAL: POlarized Radiative Transfer Adapted to Lines

PORTAL (POlarized Radiative Transfer Adapted to Lines), a 3D polarized radiative transfer code, simulates the emergence of polarization in the emission of atomic or molecular (sub-)millimeter lines. Written in Fortran90, PORTAL can be used in standalone mode or can process the output of other 3D radiative transfer codes

[ascl:2104.031] Posidonius: N-Body simulator for planetary and/or binary systems

Posidonius is a N-body code based on the tidal model used in Mercury-T (ascl:1511.020). It uses the REBOUND (ascl:1110.016) symplectic integrator WHFast to compute the evolution of positions and velocities, which is also combined with a midpoint integrator to calculate the spin evolution in a consistent way. As Mercury-T, Posidonius takes into account tidal forces, rotational-flattening effects and general relativity corrections. It also includes different evolution models for FGKML stars and gaseous planets. The N-Body code is written in Rust; a Python package is provided to easily define simulation cases in JSON format, which is readable by the Posidonius integrator.

[ascl:1411.021] POSTMORTEM: Visibility data reduction and map making package

POSTMORTEM is the visibility data reduction and map making package from MRAO (Mullard Radio Astronomy Observatory) and is used with the Ryle and CLFST telescopes at Cambridge. It contains sub-systems for nonitoring telescope performance, displaying and editing the visibility data, performing calibrations, removing flux from interfering bright sources, and map-making. It requires PGPLOT (ascl:1103.002), SLALIB (ascl:1403.025), and NAG numerical routines, all of which are distributed with the STARLINK software collection (ascl:1110.012) or available separately.

[ascl:2210.019] POSYDON: Single and binary star population synthesis code

POSYDON (POpulation SYnthesis with Detailed binary-evolution simulatiONs) incorporates full stellar structure and evolution modeling for single and binary-star population synthesis. The code is modular and allows the user to specify initial population properties and adopt choices that determine how stellar evolution proceeds. Populations are simulated with the use of MESA (ascl:1010.083) evolutionary tracks for single, non-interacting, and interacting binaries organized in grids. Machine-learning methods are incorporated and applied on the grids for classification and various interpolation calculations, and the development of irregular grids guided by active learning, for computational efficiency.

[ascl:2006.018] Powderday: Dust radiative transfer package

The dust radiative transfer software Powderday interfaces with galaxy formation simulations to produce spectral energy distributions and images. The code uses fsps (ascl:1010.043) and its Python bindings python-fsps for stellar SEDs, Hyperion (ascl:1207.004) for dust radiative transfer, and works with a variety of packages, including Arepo (ascl:1909.010), Changa (ascl:1105.005), Gasoline (ascl:1710.019), and Gizmo (ascl:1410.003); threaded throughout is yt (ascl:1011.022).

[ascl:1807.021] POWER: Python Open-source Waveform ExtractoR

POWER (Python Open-source Waveform ExtractoR) monitors the status and progress of numerical relativity simulations and post-processes the data products of these simulations to compute the gravitational wave strain at future null infinity.

[ascl:1805.001] powerbox: Arbitrarily structured, arbitrary-dimension boxes and log-normal mocks

powerbox creates density grids (or boxes) with an arbitrary two-point distribution (i.e. power spectrum). The software works in any number of dimensions, creates Gaussian or Log-Normal fields, and measures power spectra of output fields to ensure consistency. The primary motivation for creating the code was the simple creation of log-normal mock galaxy distributions, but the methodology can be used for other applications.

[ascl:1110.017] POWMES: Measuring the Power Spectrum in an N-body Simulation

POWMES is a F90 program to measure very accurately the power spectrum in a N-body simulation, using Taylor expansion of some order on the cosine and sine transforms. It can read GADGET format and requires FFTW2 to be installed.

[ascl:2301.023] PoWR: Potsdam Wolf-Rayet Models

PoWR (Potsdam Wolf-Rayet Models) calculates synthetic spectra for Wolf-Rayet and OB stars from model atmospheres which account for Non-LTE, spherical expansion and metal line blanketing. The model data is provided through a web interface and includes Spectral Energy Distribution, line spectrum in high resolution for different wavelength bands, and atmosphere stratification. For Wolf-Rayet stars of the nitrogen subclass, there are grids of hydrogen-free models and of models with a specified mass fraction of hydrogen. The iron-group and total CNO mass fractions correspond to the metallicity of the Galaxy, the Large Magellanic Cloud, or the Small Magellanic Cloud, respectively. The source code is available as a tarball on the same web interface.

[ascl:2212.017] powspec: Power and cross spectral density of 2D arrays

powspec provides functions to compute power and cross spectral density of 2D arrays. Units are properly taken into account. It can, for example, create fake Gaussian field images, compute power spectra P(k) of each image, shrink a mask with regard to a kernel, generate a Gaussian field, and plot various results.

[ascl:1401.009] PPF module for CAMB

The main CAMB code supports smooth dark energy models with constant equation of state and sound speed of one, or a quintessence model based on a potential. This modified code generalizes it to support a time-dependent equation of state w(a) that is allowed to cross the phantom divide, i.e. w=-1 multiple times by implementing a Parameterized Post-Friedmann(PPF) prescription for the dark energy perturbations.

[ascl:1507.009] PPInteractions: Secondary particle spectra from proton-proton interactions

PPInteractions generates the secondary particle energy spectra produced in proton-proton interactions over the entire chosen energy range for any value of the primary proton spectral index by adjusting the low energy part of the spectra (below 0.1TeV) to the high energy end of the spectra (above 0.1TeV). This code is based on the parametrization of Kelner et al (2006), in which the normalization of the low energy part of the spectra is given only for 3 values of the primary proton spectral indices (2, 2.5, 3).

[ascl:2004.008] PPMAP: Column density mapping with extra dimensions

PPMAP provides column density mapping with extra dimensions (temperature and dust opacity index); it generate image cubes of differential column density as a function of (x,y) sky position and temperature for diffuse dusty structures. The code incorporates parallel processing using OpenMP for some of the more CPU-intensive steps. It is currently configured for the "Raven" cluster at Cardiff University and runs in a mode in which the computations are split between 16 separate nodes, each of which uses 16 cores with OpenMP.

[ascl:1210.002] pPXF: Penalized Pixel-Fitting stellar kinematics extraction

pPXF extracts the stellar kinematics or stellar population from absorption-line spectra of galaxies using the Penalized Pixel-Fitting method (pPXF) developed by Cappellari & Emsellem (2004, PASP, 116, 138). Additional features implemented in the pPXF routine include:

  • Optimal template: Fitted together with the kinematics to minimize template-mismatch errors. Also useful to extract gas kinematics or derive emission-corrected line-strengths indexes. One can use synthetic templates to study the stellar population of galaxies via "Full Spectral Fitting" instead of using traditional line-strengths.
  • Regularization of templates weights: To reduce the noise in the recovery of the stellar population parameters and attach a physical meaning to the output weights assigned to the templates in term of the star formation history (SFH) or metallicity distribution of an individual galaxy.
  • Iterative sigma clipping: To clean the spectra from residual bad pixels or cosmic rays.
  • Additive/multiplicative polynomials: To correct low frequency continuum variations. Also useful for calibration purposes.

The code is available in IDL and in Python versions.

[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:2004.016] PRECISION: Astronomical infrared observations data reduction

PRECISION reduces astronomical IR imaging data. Written with SPHERE data in mind, it provides a fast and easy reduction of bright sources suitable for science. While it may not extract the absolute maximum amount of science, the objective is to provide a means to get science-ready data with minimal computing time or human interaction.

[ascl:1710.024] pred_loggs: Predicting individual galaxy G/S probability distributions

pred_loggs models the entire PGF probability density field, enabling iterative statistical modeling of upper limits and prediction of full G/S probability distributions for individual galaxies.

[ascl:1112.016] PREDICT: Satellite tracking and orbital prediction

PREDICT is an open-source, multi-user satellite tracking and orbital prediction program written under the Linux operating system. PREDICT provides real-time satellite tracking and orbital prediction information to users and client applications through:

  • the system console
  • the command line
  • a network socket
  • the generation of audio speech
Data such as a spacecraft's sub-satellite point, azimuth and elevation headings, Doppler shift, path loss, slant range, orbital altitude, orbital velocity, footprint diameter, orbital phase (mean anomaly), squint angle, eclipse depth, the time and date of the next AOS (or LOS of the current pass), orbit number, and sunlight and visibility information are provided on a real-time basis. PREDICT can also track (or predict the position of) the Sun and Moon. PREDICT has the ability to control AZ/EL antenna rotators to maintain accurate orientation in the direction of communication satellites. As an aid in locating and tracking satellites through optical means, PREDICT can articulate tracking coordinates and visibility information as plain speech.

[ascl:1910.002] PreProFit: Pressure Profile Fitter for galaxy clusters in Python

PreProFit fits the pressure profile of galaxy clusters using Markov chain Monte Carlo (MCMC). The software can analyze data from different sources and offers flexible parametrization for the pressure profile. PreProFit accounts for Abel integral, beam smearing, and transfer function filtering when fitting data and returns χ2, model parameters and uncertainties in addition to marginal and joint probability contours, diagnostic plots, and surface brightness radial profiles. The code can be used for analytic approximations for the beam and transfer functions for feasibility studies.

[ascl:1305.006] Pressure-Entropy SPH: Pressure-entropy smooth-particle hydrodynamics

Pressure-Entropy SPH, a modified version of GADGET-2, uses the Lagrangian “Pressure-Entropy” formulation of the SPH equations. This removes the spurious “surface tension” force substantially improving the treatment of fluid mixing and contact discontinuities. Pressure-Entropy SPH shows good performance in mixing experiments (e.g. Kelvin-Helmholtz & blob tests), with conservation maintained even in strong shock/blastwave tests, where formulations without manifest conservation produce large errors. This improves the treatment of sub-sonic turbulence and lessens the need for large kernel particle numbers.

[ascl:1107.017] PRESTO: PulsaR Exploration and Search TOolkit

PRESTO is a large suite of pulsar search and analysis software. It was primarily designed to efficiently search for binary millisecond pulsars from long observations of globular clusters (although it has since been used in several surveys with short integrations and to process a lot of X-ray data as well). To date, PRESTO has discovered well over a hundred and fifty pulsars, including approximately 100 recycled pulsars, about 80 of which are in binaries. It is written primarily in ANSI C, with many of the recent routines in Python.

Written with portability, ease-of-use, and memory efficiency in mind, it can currently handle raw data from the following pulsar machines or formats:

- PSRFITS search-format data (as from GUPPI at the GBT and the Mock Spectrometers at Arecibo)
- SPIGOT at the GBT
- Most Wideband Arecibo Pulsar Processor (WAPP) at Arecibo
- The Parkes and Jodrell Bank 1-bit filterbank formats
- Berkeley-Caltech Pulsar Machine (BCPM) at the GBT (may it RIP...)
- 8-bit filterbank format from SIGPROC (other formats will be added if required)
- A time series composed of single precision (i.e. 4-byte) floating point data
- Photon arrival times (or events) in ASCII or double-precision binary formats

[submitted] PREVIS: Python Request Engine for Virtual Interferometric Survey

PREVIS is a Python module that provides functions to help determine the observability of astronomical sources from long-baseline interferometers worldwide: VLTI (ESO, Chile) and CHARA (USA). PREVIS uses data from the Virtual Observatory (OV), such as magnitudes, Spectral Energy Distribution (SED), celestial coordinates or Gaia distances. Then, it compares the target brightness to the limiting magnitudes of each instrument to determine whether the target is observable with present performances. PREVIS includes main facilities at the VLTI with PIONIER (H band), GRAVITY (K band) and MATISSE (L, M, N bands), and at CHARA array with VEGA (V band), PAVO (R bands), MIRC (H band), CLIMB (K band) and CLASSIC (H, K bands). PREVIS also uses the V or G magnitudes to check the guiding restriction or the tip/tilt correction limit. For the VLTI: if the star is too faint in G mag, PREVIS will look for the list of stars around the target (57 arcsec) with the appropriate magnitude and give the list of celestial coordinates usable as the guiding star.

[ascl:1903.009] PRF: Probabilistic Random Forest

PRF (Probabilistic Random Forest) is a machine learning algorithm for noisy datasets. The PRF is a modification of the long-established Random Forest (RF) algorithm, and takes into account uncertainties in the measurements (i.e., features) as well as in the assigned classes (i.e., labels). To do so, the Probabilistic Random Forest (PRF) algorithm treats the features and labels as probability distribution functions, rather than as deterministic quantities.

[ascl:2006.002] PRIISM: Python module for Radio Interferometry Imaging with Sparse Modeling

PRIISM images radio interferometry data using the sparse modeling technique. In addition to generating an image, PRIISM can choose the best image from a range of processing parameters using cross validation. User can obtain statistically optimal images by providing the visibility data with some configuration parameters. The software is implemented as a Python module.

[ascl:2006.010] PRISim: Precision Radio Interferometer Simulator

PRISim is a modular radio interferometer array simulator, including the radio sky and instrumental effects, and generates a transit dataset in HD5 format.

[ascl:1907.021] PRISM: Probabilistic Regression Instrument for Simulating Models

PRISM analyzes scientific models using the Bayes linear approach, the emulation technique, and history matching to construct an approximation ('emulator') of any given model. The software facilitates and enhances existing MCMC methods by restricting plausible regions and exploring parameter space efficiently and can be used as a standalone alternative to MCMC for model analysis, providing insight into the behavior of complex scientific models. PRISM stores results in HDF5-files and can be executed in serial or MPI on any number of processes. It accepts any type of model and comparison data and can reduce relevant parameter space by factors over 100,000 using only a few thousand model evaluations.

[ascl:1601.020] ProC: Process Coordinator

ProC (short for Process Coordinator) is a versatile workflow engine that allows the user to build, run and manage workflows with just a few clicks. It automatically documents every processing step, making every modification to data reproducible. ProC provides a graphical user interface for constructing complex data processing workflows out of a given set of computer programs. The user can, for example, specify that only data products which are affected by a change in the input data are updated selectively, avoiding unnecessary computations. The ProC suite is flexible and satisfies basic needs of data processing centers that have to be able to restructure their data processing along with the development of a project.

[submitted] prodimopy: Python tools for the radiation thermo-chemical code ProDiMo.

prodimopy is an open-source Python package to read, analyze and plot modelling results of the radiation thermo-chemical disk code ProDiMo (PROtoplanetary DIsk MOdel, https://prodimo.iwf.oeaw.ac.at). It also includes tools to run ProDiMo in 1D slap model mode, to run simple ProDimo model grids and to interface ProDiMo with 1D and 2D disk codes (i.e. use input structure from hydrodynamic models).

prodimopy can also be used independently of ProDiMo (no ProDiMo installation is required) and hence is also useful to extract information from already available ProDiMo models (e.g. as input for other codes) or for model comparison.

[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: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: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:1204.015] PROFIT: Emission-line PROfile FITting routine

The PROFIT is an IDL routine to do automated fitting of emission-line profiles by Gaussian curves or Gauss-Hermite series optimized for use in Integral Field and Fabry-Perot data cubes. As output PROFIT gives two-dimensional FITS files for the emission-line flux distribution, centroid velocity, velocity dispersion and higher order Gauss-Hermite moments (h3 and h4).

[ascl:1804.006] ProFound: Source Extraction and Application to Modern Survey Data

ProFound detects sources in noisy images, generates segmentation maps identifying the pixels belonging to each source, and measures statistics like flux, size, and ellipticity. These inputs are key requirements of ProFit (ascl:1612.004), our galaxy profiling package; these two packages used in unison semi-automatically profile large samples of galaxies. The key novel feature introduced in ProFound is that all photometry is executed on dilated segmentation maps that fully contain the identifiable flux, rather than using more traditional circular or ellipse-based photometry. Also, to be less sensitive to pathological segmentation issues, the de-blending is made across saddle points in flux. ProFound offers good initial parameter estimation for ProFit, and also segmentation maps that follow the sometimes complex geometry of resolved sources, whilst capturing nearly all of the flux. A number of bulge-disc decomposition projects are already making use of the ProFound and ProFit pipeline.

[ascl:2204.018] ProFuse: Galaxies and components modeler

ProFuse produces physical models of galaxies and their components by combining the functionalities of the source extraction code PROFOUND (ascl:1804.006), the Bayesian galaxy fitting tool ProFit (ascl:1612.004), and the spectral generation package ProSpect (ascl:2002.007). ProFuse uses a self-consistent model for the star formation and metallicity history of the bulge and disk separately to generate images. The package then defines the model likelihood and optimizes the physical galaxy reconstruction using target images across a range of wavelengths.

[ascl:1306.004] PROM4: 1D isothermal and isobaric modeler for solar prominences

PROM4 computes simple models of solar prominences which consist of plane-parallel slabs standing vertically above the solar surface. Each model is defined by 5 parameters: temperature, density, geometrical thickness, microturbulent velocity and height above the solar surface. PROM4 solves the equations of radiative transfer, statistical equilibrium, ionization and pressure equilibria, and computes electron and hydrogen level populations and hydrogen line profiles. Written in Fortran 90 and with two versions available (one with text in English, one with text in French), the code needs 64-bit arithmetic for real numbers.

PROM7 (ascl:1805.023) is a more recent version of this code.

[ascl:1805.023] PROM7: 1D modeler of solar filaments or prominences

PROM7 is an update of PROM4 (ascl:1306.004) and computes simple models of solar prominences and filaments using Partial Radiative Distribution (PRD). The models consist of plane-parallel slabs standing vertically above the solar surface. Each model is defined by 5 parameters: temperature, density, geometrical thickness, microturbulent velocity and height above the solar surface. It solves the equations of radiative transfer, statistical equilibrium, ionization and pressure equilibria, and computes electron and hydrogen level population and hydrogen line profiles. Moreover, the code treats calcium atom which is reduced to 3 ionization states (Ca I, Ca II, CA III). Ca II ion has 5 levels which are useful for computing 2 resonance lines (H and K) and infrared triplet (to 8500 A).

[ascl:1511.023] PromptNuFlux: Prompt atmospheric neutrino flux calculator

PromptNuFlux computes the prompt atmospheric neutrino flux E3Φ(GeV2/(cm2ssr)), including the total associated theory uncertainty, for a range of energies between E=103 GeV and E=107.5 GeV. Results are available for five different parametrizations of the input cosmic ray flux: BPL, H3P, H3A, H14a, H14b.

[ascl:2312.020] ProPane: Image warping and stacking utilities

The ProPane package comes with key utilities for warping between different WCS systems: propaneWarp (for warping individual frames once). ProPane also contains the various functions for creating large stacks of many warped frames (which is of class ProPane, which is roughly meant to suggest the idea of many panes of glass being stacked together). It uses the wcslib C library (ascl:1108.003) for projections (all legal ones are supported) via the Rwcs package, and uses the threaded Cimg C++ library via the imager library to do image warping. ProPane also contains functions converted from older (deprecated) Rwcs and ProFound (ascl:1804.006) related functions.

[ascl:1405.006] PROPER: Optical propagation routines

PROPER simulates the propagation of light through an optical system using Fourier transform algorithms (Fresnel, angular spectrum methods). Available in IDL, Python, and Matlab, it includes routines to create complex apertures, aberrated wavefronts, and deformable mirrors. It is especially useful for the simulation of high contrast imaging telescopes (extrasolar planet imagers like TPF).

[ascl:1904.025] Properimage: Image coaddition and subtraction

Properimage processes astronomical image; it is specially written for coaddition and image subtraction. It performs the statistical proper-coadd of several images using a spatially variant PSF estimation, and also difference image analysis by several strategies developed by others. Most of the code is based on a class called SingleImage, which provides methods and properties for image processing such as PSF determination.

[ascl:1306.005] PROS: Multi-mission X-ray analysis software system

PROS is a multi-mission x-ray analysis software system designed to run under IRAF. The PROS software includes spatial, spectral, timing, data I/O and conversion routines, plotting applications, and general algorithms for performing arithmetic operations with imaging data.

[ascl:2111.006] prose: FITS images processing pipeline

prose provides pipelines for performing common tasks, such as automated calibration, reduction and photometry, and makes building custom pipelines easy. The prose framework is instrument-agnostic and makes constructing pipelines easy. It offers a wide range of implemented building blocks and also allows users to define their own.

[ascl:2312.002] PROSPECT: Profile likelihood for frequentist cosmological inference

PROSPECT infers cosmological parameters using profile likelihoods. It constructs an approximate profile likelihood from an MCMC and optimizes it using simulated annealing, a gradient-free stochastic optimization algorithm. It employs an automatic tuning of the step size parameter and binned covariance matrices from the MCMC to achieve efficient optimizations of the profile likelihood.

[ascl:2002.007] ProSpect: Spectral generation package

ProSpect generates good quality SEDs that can be used to estimate the broad band photometric properties of galaxies that have known star formation and gas metallicity histories. It allows for complex star formation and metallicity histories to be specified, and can be used in a generative or fitting (Bayesian) mode. ProSpect provides a high level interface to the BC03 (low and high resolution) and EMILES libraries, as well as the Dale 2014 dust emission templates. Its source code is available for download, and it is also available as an interactive web tool.

[ascl:1905.025] Prospector: Stellar population inference from spectra and SEDs

Prospector conducts principled inference of stellar population properties from photometric and/or spectroscopic data. The code combine photometric and spectroscopic data rigorously using a flexible spectroscopic calibration model and infer high-dimensional stellar population properties using parameteric SFHs (with ensemble MCMC sampling). Prospector also constrains the linear combination of stellar population components that are present in a galaxy (e.g. non-parametric SFHs) using spectra and/or photometry, and fits individual stellar spectra using large interpolated grids.

[ascl:2001.006] Protostellar Evolution: Stellar evolution simulator

Protostellar Evolution simulates the evolution of stellar stellar radius and luminosity from the bound core stage through to the core hydrogen ignition as a zero-age main-sequence (ZAMS) star and beyond. Written in Fortran 90, the code is implemented as a module of the FLASH astrophysical fluid dynamics code (ascl:1010.082).

[ascl:2205.016] Pryngles: PlanetaRY spaNGLES

Pryngles produces visualizations of the geometric configuration of a ringed exoplanet (an exoplanet with a ring or exoring for short) and calculates the light-curve signatures produced by these kind of planets. The model behind the package has been developed in an effort to predict the signatures that exorings may produce not only in the light-curve of transiting exoplanets (a problem that has been extensively studied) but also in the light of stars having non-transiting exoplanets.

[ascl:1301.001] PSFEx: Point Spread Function Extractor

PSFEx (“PSF Extractor”) extracts models of the Point Spread Function (PSF) from FITS images processed with SExtractor and measures the quality of images. The generated PSF models can be used for model-fitting photometry or morphological analyses.

[ascl:2306.056] PSFMachine: Toolkit for doing PSF photometry

PSFMachine creates models of instrument effective Point Spread Functions (ePSFs), also called Pixel Response Functions (PRFs). These models are then used to fit a scene in a stack of astronomical images. PSFMachine is able to quickly derive photometry from stacks of Kepler and TESS images and separate crowded sources.

[ascl:2210.005] PSFr: Point Spread Function reconstruction

PSFr empirically reconstructs an oversampled version of the point spread function (PSF) from astronomical imaging observations. The code provides a light-weighted API of a refined version of an algorithm originally implemented in lenstronomy (ascl:1804.012). It provides user support with different artifacts in the data and supports the masking of pixels, or the treatment of saturation levels. PSFr has been used to reconstruct the PSF from multiply imaged lensed quasar images observed by the Hubble Space Telescope in a crowded lensing environment and more recently with James Webb Space Telescope (JWST) imaging data for a wide dynamical flux range.

[ascl:2202.013] PSLS: PLATO Solar-like Light-curve Simulator

PSLS simulates solar-like oscillators representative of PLATO targets. It includes planetary transits, stochastically-excited oscillations, granulation and activity background components, as well as instrumental systematic errors and random noises representative for PLATO.

[ascl:1208.005] PSM: Planck Sky Model

The Planck Sky Model (PSM) is a global representation of the multi-component sky at frequencies ranging from a few GHz to a few THz. It summarizes in a synthetic way as much of our present knowledge as possible of the GHz sky. PSM is a complete and versatile set of programs and data that can be used for the simulation or the prediction of sky emission in the frequency range of typical CMB experiments, and in particular of the Planck sky mission. It was originally developed as part of the activities of Planck component separation Working Group (or "Working Group 2" - WG2), and of the ADAMIS team at APC.

PSM gives users the opportunity to investigate the model in some depth: look at its parameters, visualize its predictions for all individual components in various formats, simulate sky emission compatible with a given parameter set, and observe the modeled sky with a synthetic instrument. In particular, it makes possible the simulation of sky emission maps as could be plausibly observed by Planck or other CMB experiments that can be used as inputs for the development and testing of data processing and analysis techniques.

[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:1010.011] PSpectRe: A Pseudo-Spectral Code for (P)reheating

PSpectRe, written in C++, uses Fourier-space pseudo-spectral methods to evolve interacting scalar fields in an expanding universe. The code is optimized for the analysis of parametric resonance in the post-inflationary universe and provides an alternative to finite differencing codes. PSpectRe has both second- (Velocity-Verlet) and fourth-order (Runge-Kutta) time integrators. In some circumstances PSpectRe obtains reliable results while using substantially fewer points than a finite differencing code by computing the post-resonance equation of state. PSpectRe is designed to be easily extended to other problems in early-universe cosmology, including the generation of gravitational waves during phase transitions and pre-inflationary bubble collisions.

[ascl:1710.020] PSPLINE: Princeton Spline and Hermite cubic interpolation routines

PSPLINE is a collection of Spline and Hermite interpolation tools for 1D, 2D, and 3D datasets on rectilinear grids. Spline routines give full control over boundary conditions, including periodic, 1st or 2nd derivative match, or divided difference-based boundary conditions on either end of each grid dimension. Hermite routines take the function value and derivatives at each grid point as input, giving back a representation of the function between grid points. Routines are provided for creating Hermite datasets, with appropriate boundary conditions applied. The 1D spline and Hermite routines are based on standard methods; the 2D and 3D spline or Hermite interpolation functions are constructed from 1D spline or Hermite interpolation functions in a straightforward manner. Spline and Hermite interpolation functions are often much faster to evaluate than other representations using e.g. Fourier series or otherwise involving transcendental functions.

[ascl:1105.014] PSRCHIVE: Development Library for the Analysis of Pulsar Astronomical Data

PSRCHIVE is an Open Source C++ development library for the analysis of pulsar astronomical data. It implements an extensive range of algorithms for use in pulsar timing, polarimetric calibration, single-pulse analyses, RFI mitigation, scintillation studies, etc. These tools are utilized by a powerful suite of user-end programs that come with the library.

[ascl:2110.003] PSRDADA: Distributed Acquisition and Data Analysis for Radio Astronomy

PSRDADA supports the development of distributed data acquisition and analysis systems; it provides a flexible and well-managed ring buffer in shared memory with a variety of applications for piping data from device to ring buffer and from ring buffer to device. PSRDADA allows more than one data set to be queued in the ring buffer at one time, and data may be recorded in selected bursts using data validity flags. A variety of clients have been implemented that can write data to the ring buffer and read data from it. The primary write clients can be controlled via a simple, text-based socket interface, and read client software exists for writing data to an array of disks, sending data to an array of nodes, or processing the data directly from RAM. At the highest level of control and configuration, scripts launch the PSRDADA configuration across all nodes in the cluster, monitor all relevant processes, configure and control through a web-based interface, interface with observatory scheduling tools, and manage the ownership and archival of project data. It has been used in the implementation of baseband recording and processing instrumentation for radio pulsar astronomy.

[ascl:1107.019] PSRPOP: Pulsar Population Modelling Programs

PSRPOP is a package developed to model the Galactic population and evolution of radio pulsars. It is a collection of modules written in Fortran77 for an analysis of a large sample of pulsars detected by the Parkes Multibeam Pulsar Survey. The main programs are: 1.) populate, which creates a model Galaxy of pulsars distributed according according to various assumptions; 2.) survey, which searches the model galaxies generated using populate using realistic models of pulsar surveys; and 3.) visualize, a Tk/PGPLOT script to plot various aspects of model detected pulsars from survey. A sample screenshot from visualize can be found here.

[ascl:1501.006] PsrPopPy: Pulsar Population Modelling Programs in Python

PsrPopPy is a Python implementation of the Galactic population and evolution of radio pulsars modelling code PSRPOP (ascl:1107.019).

[ascl:1812.017] psrqpy: Python module to query the ATNF Pulsar Catalogue

psrqpy directly queries the Australia Telescope National Facility (ATNF) Pulsar Catalogue by downloading and parsing the full catalog database, which is cached and can be reused. The module assists astronomers who want access to the latest pulsar information via a script rather than through the standard web interface.

[ascl:2007.007] PSRVoid: Statistical suite for folded pulsar data

PSRVoid performs RFI excision, flux calibration and timing of folded pulsar data. RFI excision is administered via both traditional and multi-layered deep learning neural network algorithms. The software offers full neural network control (over training set creation and manipulation and network parameters). PSRVoid also contains useful data miners for the ATNF, a multitude of plotting tools, as well as many useful pulsar processing macros such as space velocity simulators and Tempo2 (ascl:1210.015) wrappers.

[ascl:2210.001] PSS: Pulsar Survey Scraper

Pulsar Survey Scraper aggregates pulsar discoveries before they are included in the ATNF pulsar catalog and enables searching and filtering based on position and dispersion measure. This facilitates identifying new pulsar discoveries. Pulsar Survey Scraper can be downloaded or run online using the Pulsar Survey Scraper webform.

[ascl:2111.003] PSwarm: Global optimization solver for bound and linear constrained problems

PSwarm is a global optimization solver for bound and linear constrained problems (for which the derivatives of the objective function are unavailable, inaccurate or expensive). The algorithm combines pattern search and particle swarm. Basically, it applies a directional direct search in the poll step (coordinate search in the pure simple bounds case) and particle swarm in the search step. PSwarm makes no use of derivative information of the objective function. It has been shown to be efficient and robust for smooth and nonsmooth problems, both in serial and in parallel.

[ascl:2110.021] PT-REX: Point-to-point TRend EXtractor

PT-REX (Point-to-point TRend EXtractor) performs ptp analysis on every kind of extended radio source. The code exploits a set of different fitting methods to allow study of the spatial correlation, and is structured in a series of tasks to handle the individual steps of a ptp analysis independently, from defining a grid to sample the radio emission to accurately analyzing the data using several statistical methods. A major feature of PT-REX is the use of an automatic, randomly-generated sampling routine to combine several SMptp analysis into a Monte Carlo ptp (MCptp) analysis. By repeating several cycles of SMptp analysis with randomly-generated grids, PT-REX produces a distribution of values of k that describe its parameter space, thus allowing a reliably estimate of the trend (and its uncertainties).

[ascl:2211.001] PTAfast: PTA correlations from stochastic gravitational wave background

PTAfast calculates the overlap reduction function in Pulsar Timing Array produced by the stochastic gravitational wave background for arbitrary polarizations, propagation velocities, and pulsar distances.

[ascl:2101.006] ptemcee: A parallel-tempered version of emcee

ptemcee, pronounced "tem-cee", is fork of Daniel Foreman-Mackey's emcee (ascl:1303.002) to implement parallel tempering more robustly. As far as possible, it is designed as a drop-in replacement for emcee. It is helpful for characterizing awkward, multi-modal probability distributions.

[ascl:1912.017] PTMCMCSampler: Parallel tempering MCMC sampler package written in Python

PTMCMCSampler performs MCMC sampling using advanced techniques. The code implements a variety of proposal schemes, including adaptive Metropolis, differential evolution, and parallel tempering, which can be used together in the same run.

[ascl:2303.019] pulsar_spectra: Pulsar flux density measurements, spectral models fitting, and catalog

pulsar_spectra provides a pulsar flux density catalog and automated spectral fitting software for finding spectral models. The package can also produce publication-quality plots and allows users to add new spectral measurements to the catalog. The spectral fitting software uses robust statistical methods to determine the best-fitting model for individual pulsar spectra.

[ascl:1811.020] PulsarHunter: Searching for and confirming pulsars

Pulsarhunter searches for and confirms pulsars; it provides a set of time domain optimization tools for processing timeseries data produced by SIGPROC (ascl:1107.016). The software can natively write candidate lists for JReaper (included in the package), removing the need to manually import candidates into JReaper; JReaper also reads the PulsarHunter candidate file format.

[ascl:2312.012] PulsarX: Pulsar searching

The folding pipeline PulsarX searches for pulsars. The code includes radio frequency interference mitigation, de-dispersion, folding, and parameter optimization, and supports both psrfits and filterbank data formats. The toolset has two implementations of the folding pipelines; one uses a brute-force de-dispersion algorithm, and the other an algorithm that becomes more efficient than the brute-force de-dispersion algorithm as the number of candidates increases. PulsarX is appropriate for large-scale pulsar surveys.

[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:1807.022] PUMA: Low-frequency radio catalog cross-matching

PUMA (Positional Update and Matching Algorithm) cross-matches low-frequency radio catalogs using a Bayesian positional probability with spectral matching criteria. The code reliably finds the correct spectral indices of sources and recovers ionospheric offsets. PUMA can be used to facilitate all-sky cross-matches with further constraints applied for other science goals.

[ascl:1110.014] pureS2HAT: S 2HAT-based Pure E/B Harmonic Transforms

The pS2HAT routines allow efficient, parallel calculation of the so-called 'pure' polarized multipoles. The computed multipole coefficients are equal to the standard pseudo-multipoles calculated for the apodized sky maps of the Stokes parameters Q and U subsequently corrected by so-called counterterms. If the applied apodizations fullfill certain boundary conditions, these multipoles correspond to the pure multipoles. Pure multipoles of one type, i.e., either E or B, are ensured not to contain contributions from the other one, at least to within numerical artifacts. They can be therefore further used in the estimation of the sky power spectra via the pseudo power spectrum technique, which has to however correctly account for the applied apodization on the one hand, and the presence of the counterterms, on the other.

In addition, the package contains the routines permitting calculation of the spin-weighted apodizations, given an input scalar, i.e., spin-0 window. The former are needed to compute the counterterms. It also provides routines for maps and window manipulations. The routines are written in C and based on the S2HAT library, which is used to perform all required spherical harmonic transforms as well as all inter-processor communication. They are therefore parallelized using MPI and follow the distributed-memory computational model. The data distribution patterns, pixelization choices, conventions etc are all as those assumed/allowed by the S2HAT library.

[ascl:2301.027] Puri-Psi: Radio interferometric imaging

Puri-Psi addresses radio interferometric imaging problems using state-of-the-art optimization algorithms and deep learning. It performs scalable monochromatic, wide-band, and polarized imaging. It also provide joint calibration and imaging, and scalable uncertainty quantification. A scalable framework for wide-field monochromatic intensity imaging is also available, which encompasses a pure optimization algorithm, as well as an AI-based method in the form of a plug-and-play algorithm propelled by Deep Neural Network denoisers.

[ascl:1307.019] PURIFY: Tools for radio-interferometric imaging

PURIFY is a collection of routines written in C that implements different tools for radio-interferometric imaging including file handling (for both visibilities and fits files), implementation of the measurement operator and set-up of the different optimization problems used for image deconvolution. The code calls the generic Sparse OPTimization (SOPT) (ascl:1307.020) package to solve the imaging optimization problems.

[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:1210.026] PVS-GRMHD: Conservative GRMHD Primitive Variable Solvers

Conservative numerical schemes for general relativistic magnetohydrodynamics (GRMHD) require a method for transforming between "conserved'' variables such as momentum and energy density and "primitive" variables such as rest-mass density, internal energy, and components of the four-velocity. The forward transformation (primitive to conserved) has a closed-form solution, but the inverse transformation (conserved to primitive) requires the solution of a set of five nonlinear equations. This code performs the inversion.

[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:1806.032] pwv_kpno: Modeling atmospheric absorption

pwv_kpno provides models for the atmospheric transmission due to precipitable water vapor (PWV) at user specified sites. Atmospheric transmission in the optical and near-infrared is highly dependent on the PWV column density along the line of sight. The pwv_kpno package uses published SuomiNet data in conjunction with MODTRAN models to determine the modeled, time-dependent atmospheric transmission between 3,000 and 12,000 Å. By default, models are provided for Kitt Peak National Observatory (KPNO). Additional locations can be added by the user for any of the hundreds of SuomiNet locations worldwide.

[ascl:2006.012] pxf_kin_err: Radial velocity and velocity dispersion uncertainties estimator

pxf_kin_err estimates the radial velocity and velocity dispersion uncertainties based solely on the shape of a template spectrum used in the fitting procedure and signal-to-noise information. This method can be used for exposure time calculators, in the design of observational programs and estimates on expected uncertainties for spectral surveys of galaxies and star clusters, and as an accurate substitute for Monte-Carlo simulations when running them for large samples of thousands of spectra is unfeasible.

[submitted] Py-PDM: A Python wrapper of the Phase Dispersion Minimization (PDM)

Phase Dispersion Minimization (PDM) is a periodical signal detection method, and it is originally implemented by Stellingwerf with C (https://www.stellingwerf.com/rfs-bin/index.cgi?action=PageView&id=34). With the help of Cython, Py-PDM is much faster than other Python implementations.

[ascl:1808.009] py-sdm: Support Distribution Machines

py-sdm (Support Distribution Machines) is a Python implementation of nonparametric nearest-neighbor-based estimators for divergences between distributions for machine learning on sets of data rather than individual data points. It treats points of sets of data as samples from some unknown probability distribution and then statistically estimates the distance between those distributions, such as the KL divergence, the closely related Rényi divergence, L2 distance, or other similar distances.

[ascl:1712.003] Py-SPHViewer: Cosmological simulations using Smoothed Particle Hydrodynamics

Py-SPHViewer visualizes and explores N-body + Hydrodynamics simulations. The code interpolates the underlying density field (or any other property) traced by a set of particles, using the Smoothed Particle Hydrodynamics (SPH) interpolation scheme, thus producing not only beautiful but also useful scientific images. Py-SPHViewer enables the user to explore simulated volumes using different projections. Py-SPHViewer also provides a natural way to visualize (in a self-consistent fashion) gas dynamical simulations, which use the same technique to compute the interactions between particles.

[ascl:1905.002] Py4CAtS: PYthon for Computational ATmospheric Spectroscopy

Py4CAtS (PYthon scripts for Computational ATmospheric Spectroscopy) implements the individual steps of an infrared or microwave radiative transfer computation in separate scripts (and corresponding functions) to extract lines of relevant molecules in the spectral range of interest, compute line-by-line cross sections for given pressure(s) and temperature(s), combine cross sections to absorption coefficients and optical depths, and integrate along the line-of-sight to transmission and radiance/intensity. The code is a Python re-implementation of the Fortran code GARLIC (Generic Atmospheric Radiation Line-by-line Code) and uses the Numeric/Scientific Python modules for computationally-intensive highly optimized array-processing. Py4CAtS can be used in the console/terminal, inside the (I)Python interpreter, and in Jupyter notebooks.

[ascl:1906.010] PyA: Python astronomy-related packages

The PyA (PyAstronomy) suite of astronomy-related packages includes a convenient fitting package that provides support for minimization and MCMC sampling, a set of astrophysical models (e.g., transit light-curve modeling), and algorithms for timing analysis such as the Lomb-Scargle and the Generalized Lomb-Scargle periodograms.

[ascl:1806.007] PyAMOR: AMmOnia data Reduction

PyAMOR models spectra of low level ammonia transitions (between (J,K)=(1,1) and (5,5)) and derives parameters such as intrinsic linewidth, optical depth, and rotation temperature. For low S/N or low spectral resolution data, the code uses cross-correlation between a model and a regridded spectrum (e.g. 10 times smaller channel width) to find the velocity, then fixes it and runs the minimization process. For high S/N data, PyAMOR runs with the velocity as a free parameter.

[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:2102.028] PyAutoFit: Classy probabilistic programming

PyAutoFit supports advanced statistical methods such as massively parallel non-linear search grid-searches, chaining together model-fits and sensitivity mapping. It is a Python-based probabilistic programming language which composes and fits models using a range of Bayesian inference libraries, such as emcee (ascl:1303.002) and dynesty (ascl:1809.013). It performs model composition and customization, outputting results, model-specific visualization and posterior analysis. Built for big-data analysis, results are output as a database which can be loaded after model-fitting is complete.

[ascl:1807.003] PyAutoLens: Strong lens modeling

PyAutoLens models and analyzes galaxy-scale strong gravitational lenses. This automated module suite simultaneously models the lens galaxy's light and mass while reconstructing the extended source galaxy on an adaptive pixel-grid. Source-plane discretization is amorphous, adapting its clustering and regularization to the intrinsic properties of the lensed source. The lens's light is fitted using a superposition of Sersic functions, allowing PyAutoLens to cleanly deblend its light from the source. Bayesian model comparison is used to automatically chose the complexity of the light and mass models. PyAutoLens provides accurate light, mass, and source profiles inferred for data sets representative of both existing Hubble imaging and future Euclid wide-field observations.

[ascl:1502.007] PyBDSF: Python Blob Detection and Source Finder

PyBDSF (Python Blob Detector and Source Finder, formerly PyBDSM) decomposes radio interferometry images into sources and makes their properties available for further use. PyBDSF can decompose an image into a set of Gaussians, shapelets, or wavelets as well as calculate spectral indices and polarization properties of sources and measure the psf variation across an image. PyBDSF uses an interactive environment based on CASA (ascl:1107.013); PyBDSF may also be used in Python scripts.

[ascl:2104.023] PyBird: Python code for biased tracers in redshift space

PyBird evaluates the multipoles of the power spectrum of biased tracers in redshift space. In general, PyBird can evaluate the power spectrum of matter or biased tracers in real or redshift space. The code uses FFTLog (ascl:1512.017) to evaluate the one-loop power spectrum and the IR resummation. PyBird is designed for a fast evaluation of the power spectra, and can be easily inserted in a data analysis pipeline. It is a standalone tool whose input is the linear matter power spectrum which can be obtained from any Boltzmann code, such as CAMB (ascl:1102.026) or CLASS (ascl:1106.020). The Pybird output can be used in a likelihood code which can be part of the routine of a standard MCMC sampler. The design is modular and concise, such that parts of the code can be easily adapted to other case uses (e.g., power spectrum at two loops or bispectrum). PyBird can evaluate the power spectrum either given one set of EFT parameters, or independently of the EFT parameters. If the former option is faster, the latter is useful for subsampling or partial marginalization over the EFT parameters, or to Taylor expand around a fiducial cosmology for efficient parameter exploration.

[ascl:1204.002] pyBLoCXS: Bayesian Low-Count X-ray Spectral analysis

pyBLoCXS is a sophisticated Markov chain Monte Carlo (MCMC) based algorithm designed to carry out Bayesian Low-Count X-ray Spectral (BLoCXS) analysis in the Sherpa environment. The code is a Python extension to Sherpa that explores parameter space at a suspected minimum using a predefined Sherpa model to high-energy X-ray spectral data. pyBLoCXS includes a flexible definition of priors and allows for variations in the calibration information. It can be used to compute posterior predictive p-values for the likelihood ratio test. The pyBLoCXS code has been tested with a number of simple single-component spectral models; it should be used with great care in more complex settings.

[ascl:2306.057] pybranch: Calculate experimental branching fractions and transition probabilities from atomic spectra

pybranch calculates experimental branching fractions and transition probabilities from measurements of atomic spectra. Though the program is usually used with spectral line lists from intensity-calibrated spectra from Fourier transform spectrometers, it can in principle be used with any calibrated spectra that meet the input requirements. pybranch takes a set of linelists, computes a weighted average branching fraction (Fki) for each line, combines these branching fractions with the level lifetime to obtain the transition probability, and then prints the calibrated intensities and S/N ratios for all the lines observed from a particular upper level in each spectrum. One line can be chosen to use as a reference to put all of the intensities on the same scale. pybranch can use calculated transition probabilities to calculate a residual from lines that have not been observed.

[ascl:2312.025] pyC2Ray: Python interface to C2Ray with GPU acceleration

pyC2Ray updates C2-Ray (ascl:2312.022), an astrophysical radiative transfer code used to simulate the Epoch of Reionization (EoR). pyC2Ray includes a new raytracing method, ASORA, developed for GPUs, and provides a Python interface for customizable use of the code. The core features of C2-Ray, written in Fortran90, are wrapped using f2py as a Python extension module, while the raytracing library ASORA is implemented in C++ using CUDA. Both are native Python C-extensions and can be directly accessed from any Python script.

[ascl:2107.017] PyCactus: Post-processing tools for Cactus computational toolkit simulation data

PyCactus contains tools for postprocessing data from numerical simulations performed with the Einstein Toolkit, based on the Cactus computational toolkit. The main package is PostCactus, which provides a high-level Python interface to the various data formats in a simulation folder. Further, the package SimRep allows the automatic creation of html reports for a simulation, and the SimVideo package allows the creation of movies visualizing simulation data.

[ascl:2206.021] PyCASSO2: Stellar population and emission line fits in integral field spectra

PyCASSO runs the STARLIGHT code (ascl:1108.006) in integral field spectra (IFS). Cubes from various instruments are supported, including PMAS/PPAK (CALIFA), MaNGA, GMOS and MUSE. Emission lines can be measured using DOBBY, which is included in the package. The package also includes tools for IFS cubes analysis and plotting.

[ascl:1805.030] PyCBC: Gravitational-wave data analysis toolkit

PyCBC analyzes data from gravitational-wave laser interferometer detectors, finds signals, and studies their parameters. It contains algorithms that can detect coalescing compact binaries and measure the astrophysical parameters of detected sources. PyCBC was used in the first direct detection of gravitational waves by LIGO and is used in the ongoing analysis of LIGO and Virgo data.

[ascl:1805.032] PyCCF: Python Cross Correlation Function for reverberation mapping studies

PyCCF emulates a Fortran program written by B. Peterson for use with reverberation mapping. The code cross correlates two light curves that are unevenly sampled using linear interpolation and measures the peak and centroid of the cross-correlation function. In addition, it is possible to run Monto Carlo iterations using flux randomization and random subset selection (RSS) to produce cross-correlation centroid distributions to estimate the uncertainties in the cross correlation results.

[ascl:2112.001] pycelp: Python package for Coronal Emission Line Polarization

pyCELP (aka "pi-KELP") calculates Coronal Emission Line Polarization. It forward synthesizes the polarized emission of ionized atoms formed in the solar corona and calculates the atomic density matrix elements for a single ion under coronal equilibrium conditions and excited by a prescribed radiation field and thermal collisions. pyCELP solves a set of statistical equilibrium equations in the spherical statistical tensor representation for a multi-level atom for the no-coherence case. This approximation is useful in the case of forbidden line emission by visible and infrared lines, such as Fe XIII 1074.7 nm and Si X 3934 nm.

[submitted] pycf3 - Cosmicflows-3 Distance-Velocity Calculator client for Python

The project is a simple Python client for Cosmicflows-3 Distance-Velocity Calculator at distances less than 400 Mpc (http://edd.ifa.hawaii.edu/CF3calculator/)

Compute expectation distances or velocities based on smoothed velocity field from the Wiener filter model of https://ui.adsabs.harvard.edu/abs/2019MNRAS.488.5438G/abstract.

[submitted] Pyckles

A super lightweight interface in Python to load spectra from the Pickles 1998 (stellar) and Brown 2014 (galactic) spectral catalogues

[ascl:1304.020] pyCloudy: Tools to manage astronomical Cloudy photoionization code

PyCloudy is a Python library that handles input and output files of the Cloudy photoionization code (Gary Ferland). It can also generate 3D nebula from various runs of the 1D Cloudy code. pyCloudy allows you to:
- define and write input file(s) for Cloudy code. As you can have it in a code, you may generate automatically sets of input files, changing parameters from one to the other.<
- read the Cloudy output files and play with the data: you will be able to plot line emissivity ratio vs. the radius of the nebula, the electron temperature, or any Cloudy output.
- build pseudo-3D models, a la Cloudy_3D, by running a set of models, changing parameters (e.g. inner radius, density) following angular laws, reading the outputs of the set of models and interpolating the results (Te, ne, line emissivities) in a 3D cube.

[ascl:1509.007] pycola: N-body COLA method code

pycola is a multithreaded Python/Cython N-body code, implementing the Comoving Lagrangian Acceleration (COLA) method in the temporal and spatial domains, which trades accuracy at small-scales to gain computational speed without sacrificing accuracy at large scales. This is especially useful for cheaply generating large ensembles of accurate mock halo catalogs required to study galaxy clustering and weak lensing. The COLA method achieves its speed by calculating the large-scale dynamics exactly using LPT while letting the N-body code solve for the small scales, without requiring it to capture exactly the internal dynamics of halos.

[ascl:2303.007] PyCom: Interstellar communication

PyCom provides function calls for deriving the optimal communication scheme to maximize the data rate between a remote probe and home-base. It includes models for the loss of photons from diffraction, technological limitations, interstellar extinction and atmospheric transmission, and manages major atmospheric, zodiacal, stellar and instrumental noise sources. It also includes scripts for creating figures appearing in the referenced paper.

[ascl:1311.002] PyCOOL: Cosmological Object-Oriented Lattice code

PyCOOL is a Python + CUDA program that solves the evolution of interacting scalar fields in an expanding universe. PyCOOL uses modern GPUs to solve this evolution and to make the computation much faster. The code includes numerous post-processing functions that provide useful information about the cosmological model, including various spectra and statistics of the fields.

[ascl:1210.027] PyCosmic: Detecting cosmics in CALIFA and other fiber-fed integral-field spectroscopy datasets

The detection of cosmic ray hits (cosmics) in fiber-fed integral-field spectroscopy (IFS) data of single exposures is a challenging task because of the complex signal recorded by IFS instruments. Existing detection algorithms are commonly found to be unreliable in the case of IFS data, and the optimal parameter settings are usually unknown a priori for a given dataset. The Calar Alto legacy integral field area (CALIFA) survey generates hundreds of IFS datasets for which a reliable and robust detection algorithm for cosmics is required as an important part of the fully automatic CALIFA data reduction pipeline. PyCosmic combines the edge-detection algorithm of L.A.Cosmic with a point-spread function convolution scheme. PyCosmic is the only algorithm that achieves an acceptable detection performance for CALIFA data. Only for strongly undersampled IFS data does L.A.Cosmic exceed the performance of PyCosmic by a few percent. Thus, PyCosmic appears to be the most versatile cosmics detection algorithm for IFS data.

[ascl:2004.007] PyCosmo: Multi-purpose cosmology calculation tool

PyCosmo provides accurate predictions for cosmological observables including background quantities, power spectra and Limber and beyond-Limber angular power spectra. The software is designed to be interactive and user-friendly. It is available for download and is also offered on an interactive platform (PyCosmo Hub), which allows users to perform their own computations using Jupyter Notebooks without installing any software.

[ascl:1810.008] pycraf: Spectrum-management compatibility

The pycraf Python package provides functions and procedures for spectrum-management compatibility studies, such as calculating the interference levels at a radio telescope produced from a radio broadcasting tower. It includes an implementation of ITU-R Recommendation P.452-16 for calculating path attenuation for the distance between an interferer and the victim service. It supports NASA's Shuttle Radar Topography Mission (SRTM) data for height-profile generation, includes a full implementation of ITU-R Rec. P.676-10, which provides two atmospheric models to calculate the attenuation for paths through Earth's atmosphere, and provides various antenna patterns necessary for compatibility studies (e.g., RAS, IMT, fixed-service links). The package can also convert power flux densities, field strengths, transmitted and received powers at certain distances and frequencies into each other.

[ascl:2307.040] pycrires: Data reduction pipeline for VLT/CRIRES+

pycrires runs the CRIRES+ recipes of EsoRex. The pipeline organizes the raw data, creates SOF and configuration files, runs the calibration and science recipes, and creates plots of the images and extracted spectra. Additionally, it corrects remaining inaccuracies in the wavelength solution and the spectrum curvature. pycrires also provides dedicated routines for the extraction, calibration, and detection of spatially-resolved objects such as directly imaged planets.

[ascl:1509.010] PyCS : Python Curve Shifting

PyCS is a software toolbox to estimate time delays between multiple images of strongly lensed quasars, from resolved light curves such as obtained by the COSMOGRAIL monitoring program. The pycs package defines a collection of classes and high level functions, that you can script in a flexible way. PyCS makes it easy to compare different point estimators (including your own) without much code integration. The package heavily depends on numpy, scipy, and matplotlib.

[submitted] pydftools: Distribution function fitting in Python

pydftools is a pure-python port of the dftools R package (ascl:1805.002), which finds the most likely P parameters of a D-dimensional distribution function (DF) generating N objects, where each object is specified by D observables with measurement uncertainties. For instance, if the objects are galaxies, it can fit a MF (P=1), a mass-size distribution (P=2) or the mass-spin-morphology distribution (P=3). Unlike most common fitting approaches, this method accurately accounts for measurement in uncertainties and complex selection functions. Though this package imitates the dftools package quite closely while being as Pythonic as possible, it has not implemented 2D+ nor non-parametric.

[ascl:2106.003] PyDoppler: Wrapper for Doppler tomography software

PyDoppler is a python-based wrapper for the Spruit Doppler tomography software dopmap (ascl:2106.002). PyDoppler is designed to study time-resolved spectroscopic datasets of accreting compact binaries. This code can produce a trail spectra of a dataset and create Doppler tomography maps. It is intended to be a light-weight code for single emission line datasets.

[ascl:1401.005] PyDrizzle: Python version of Drizzle

PyDrizzle provides a semi-automated interface for computing the parameters necessary for running Drizzle (ascl:1212.011). PyDrizzle performs the task of determining the parameters necessary for aligning images based on the WCS information in the input image headers, as well as any supplemental alignment information provided in shift files, and combines the images onto the same WCS. Though it does not identify cosmic rays, it has the ability to ignore pixels flagged as bad, such as pixels identified by other programs as affected by cosmic rays.

[ascl:2103.008] Pyedra: Python implementation for asteroid phase curve fitting

Pyedra performs asteroid phase curve fitting. From a simple table containing the asteroid MPC number, phase angle and reduced magnitude, Pyedra estimates the parameters of the phase function using the least squares method. The user can choose from three different models for the phase curve fit: H-G model, H-G1-G2 model and the Shevchenko model. The output in all cases is a table containing the adjusted parameters and their corresponding errors. This package allows carrying out phase function analysis for a few asteroids as well as to process large volumes of data such as those released by current large surveys.

[ascl:1112.014] PyEphem: Astronomical Ephemeris for Python

PyEphem provides scientific-grade astronomical computations for the Python programming language. Given a date and location on the Earth’s surface, it can compute the positions of the Sun and Moon, of the planets and their moons, and of any asteroids, comets, or earth satellites whose orbital elements the user can provide. Additional functions are provided to compute the angular separation between two objects in the sky, to determine the constellation in which an object lies, and to find the times at which an object rises, transits, and sets on a particular day.

The numerical routines that lie behind PyEphem are those from the XEphem astronomy application (ascl:1112.013), whose author, Elwood Downey, generously gave permission for us to use them as the basis for PyEphem.

[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:2301.013] pyExoRaMa: An interactive tool to investigate the radius-mass diagram for exoplanets

pyExoRaMa visualizes and manipulates data related to exoplanets and their host stars in a multi-dimensional parameter space. It enables statistical studies based on the large and constantly increasing number of detected exoplanets, identifies possible interdependence among several physical parameters, and compares observables with theoretical models describing the exoplanet composition and structure.

[ascl:1403.002] pyExtinction: Atmospheric extinction

The Python script/package pyExtinction computes and plots total atmospheric extinction from decomposition into physical components (Rayleigh attenuation, ozone absorption, aerosol extinction). Its default extinction parameters are adapted to mean Mauna Kea summit conditions.

[ascl:2109.009] pyFFTW: Python wrapper around FFTW

pyFFTW is a pythonic wrapper around FFTW (ascl:1201.015), the speedy FFT library. Both the complex DFT and the real DFT are supported, as well as on arbitrary axes of arbitrary shaped and strided arrays, which makes it almost feature equivalent to standard and real FFT functions of numpy.fft. Additionally, it supports the clongdouble dtype, which numpy.fft does not, and operating FFTW in multithreaded mode.

[ascl:1207.009] PyFITS: Python FITS Module

PyFITS provides an interface to FITS formatted files in the Python scripting language and PyRAF, the Python-based interface to IRAF. It is useful both for interactive data analysis and for writing analysis scripts in Python using FITS files as either input or output. PyFITS is a development project of the Science Software Branch at the Space Telescope Science Institute.

PyFITS has been deprecated. Please see Astropy.

[ascl:1103.012] Pyflation: Second Order Perturbations During Inflation Beyond Slow-roll

Pyflation calculates cosmological perturbations during an inflationary expansion of the universe. The modules in the pyflation Python package can be used to run simulations of different scalar field models of the early universe. The main classes are contained in the cosmomodels module and include simulations of background fields and first order and second order perturbations. The sourceterm package contains modules required for the computation of the term required for the evolution of second order perturbations.

Alongside the Python package, the bin directory contains Python scripts which can run first and second order simulations. A helper script called pyflation-qsubstart.py sets up a full second order run (including background, first order and source calculations) to be used on queueing system which contains the qsub executable (e.g. a Rocks cluster).

[submitted] PyFOSC: a pipeline toolbox for BFOSC/YFOSC long-slit spectroscopy data reduction

PyFOSC is a pipeline toolbox for long-slit spectroscopy data reduction written in Python. It can be used for FOSC (Faint Object Spectrograph and Camera) data from Xinglong/Lijiang 2-meter telescopes in China. This pipeline privodes a neat way for data pre-processing, including updating missing header fileds for BFOSC data, reducing fits file extension for YFOSC data, etc. And it makes the data reduction procedure efficient by using previously identified lamp spectra as re-identification references during wavelength calibration, and applying multiprocessing in some modules. PyFOSC also enables customization for any other long-slit spectroscopy data.

[ascl:2102.027] PyFstat: Continuous gravitational-wave data analysis

PyFstat performs F-statistic-based continuous gravitational wave (CW) searches and other CW data analysis tasks. It is built on top of the LALSuite library (ascl:2012.021), making that library's functionality more accessible through a Python interface; it also provides MCMC-based followup of promising candidates from wide-parameter-space searches.

[ascl:2203.005] pygacs: Toolkit to manipulate Gaia catalog tables

pygacs manipulates Gaia catalog tables hosted at ESA's Gaia Archive Core Systems (GACS). It provides python modules for the access and manipulation of tables in GACS, such as a basic query on a single table or crossmatch between two tables. It employs the TAP command line access tools described in the Help section of the GACS web pages. Both public and authenticated access have been implemented.

[ascl:1811.014] pygad: Analyzing Gadget Simulations with Python

pygad provides a framework for dealing with Gadget snapshots. The code reads any of the many different Gadget (ascl:0003.001) formats, allows easy masking snapshots to particles of interest, decorates the data blocks with units, allows to add automatically updating derived blocks, and provides several binning and plotting routines, among other tasks, to provide convenient, intuitive handling of the Gadget data without the need to worry about technical details. pygad provides access to single stellar population (SSP) models, has an interface to Rockstar (ascl:1210.008) output files, provides its own friends-of-friends (FoF) finder, calculates spherical overdensities, and has a sub-module to generate mock absorption lines.

[ascl:1411.001] pyGadgetReader: GADGET snapshot reader for python

pyGadgetReader is a universal GADGET snapshot reader for python that supports type-1, type-2, HDF5, and TIPSY (ascl:1111.015) binary formats. It additionally supports reading binary outputs from FoF_Special, P-StarGroupFinder, Rockstar (ascl:1210.008), and Rockstar-Galaxies.

[ascl:1603.013] PyGDSM: Python interface to Global Diffuse Sky Models

PyGDSM (formely PyGSM) is a Python interface for the Global Sky Model (GSM, ascl:1011.010). The GSM is a model of diffuse galactic radio emission, constructed from a variety of all-sky surveys spanning the radio band (e.g. Haslam and WMAP). PyGDSM uses the GSM to generate all-sky maps in Healpix format of diffuse Galactic radio emission from 10 MHz to 94 GHz. The PyGDSM module provides visualization utilities, file output in FITS format, and the ability to generate observed skies for a given location and date. PyGDSM requires Healpy (ascl:2008.022), PyEphem (ascl:1112.014), and AstroPy (ascl:1304.002).

[ascl:1402.021] PyGFit: Python Galaxy Fitter

PyGFit measures PSF-matched photometry from images with disparate pixel scales and PSF sizes; its primary purpose is to extract robust spectral energy distributions (SEDs) from crowded images. It fits blended sources in crowded, low resolution images with models generated from a higher resolution image, thus minimizing the impact of crowding and also yielding consistently measured fluxes in different filters which minimizes systematic uncertainty in the final SEDs.

[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:1907.004] pyGTC: Parameter covariance plots

pyGTC creates giant triangle confusogram (GTC) plots. Triangle plots display the results of a Monte-Carlo Markov Chain (MCMC) sampling or similar analysis. The recovered parameter constraints are displayed on a grid in which the diagonal shows the one-dimensional posteriors (and, optionally, priors) and the lower-left triangle shows the pairwise projections. Such plots are useful for seeing the parameter covariances along with the priors when fitting a model to data.

[ascl:2311.013] pygwb: Lighweight python stochastic GWB analysis pipeline

pygwb analyzes laser interferometer data and designs a gravitational wave background (GWB) search pipeline. Its modular and flexible codebase is tailored to current ground-based interferometers such as LIGO Hanford, LIGO Livingston, and Virgo, but can be generalized to other configurations. It is based on GWpy (ascl:1912.016) and bilby (ascl:1901.011) for optimal integration with widely-used gravitational wave data analysis tools. pygwb also includes a set of scripts to analyze data and perform large-scale searches on a high-performance computing cluster efficiently.

[ascl:2007.020] pygwinc: Gravitational Wave Interferometer Noise Calculator

pygwinc processes and plots noise budgets for ground-based gravitational wave detectors. Its primary feature is a collection of mostly analytic noise calculation functions for various sources of noise affecting detectors, including quantum and seismic noise, mirror coating and substrate thermal noise, suspension fiber thermal noise, and residual gas noise. It is also a generalized noise budgeting tool that allows users to create arbitrary noise budgets for any experiment, not just ground-based GW detectors, using measured or analytically calculated data.

[ascl:2307.025] pyhalomodel: Halo-model implementation for power spectra

pyhalomodel computes halo-model power spectra for any desired tracer combination. The software requires only halo profiles for the tracers to be specified; these could be matter profiles, galaxy profiles, or something else, such as electron-pressure or HI profiles. pyhalomodel makes it easier to perform basic calculations using the halo model by reducing the changes of variables required to integrate halo profiles against halo mass functions, which can be confusing and tedious.

[ascl:2002.011] PyHammer: Python spectral typing suite

PyHammer performs rapid and automatic spectral classification of stars according to the Morgan-Keenan classification system; it is a Python revision of the IDL code The Hammer (ascl:1405.003) and offers additional capabilities. Working in the range of 3,650-10,200 Angstroms, the automatic spectral typing algorithm compares important spectral lines to template spectra and determines the best matching spectral type, ranging from O to L type stars. The code can also determine a star's metallicity ([Fe/H]) and radial velocity shifts. Once the automatic classification algorithm has run, PyHammer provides the user an interface for determining spectral types visually by comparing their spectra to provided templates.

[ascl:2206.010] pyHIIexplorerV2: Integrated spectra of HII regions extractor

pyHIIexplorerV2 extracts the integrated spectra of HII regions from integral field spectroscopy (IFS) datacubes. The detection of HII regions performed by pyHIIexplorer is based on two assumptions: 1) HII regions have strong emission lines that are clearly above the continuum emission and the average ionized gas emission across each galaxy, and 2) the typical size of HII regions is about a few hundreds of parsecs, which corresponds to a usual projected size of a few arcsec at the distance of our galaxies. These assumptions will define clumpy structures with a high Ha emission line contrast in comparison to the continuum. pyHIIexplorerV2 is written in Python; it is based on and is a successor to HIIexplorer (ascl:1603.017).

[ascl:1511.005] pyhrs: Spectroscopic data reduction package for SALT

The pyhrs package reduces data from the High Resolution Spectrograph (HRS) on the Southern African Large Telescope (SALT). HRS is a dual-beam, fiber fed echelle spectrectrograph with four modes of operation: low (R~16000), medium (R~34000), high (R~65000), and high stability (R~65000). pyhrs, written in Python, includes all of the steps necessary to reduce HRS low, medium, and high resolution data; this includes basic CCD reductions, order identification, wavelength calibration, and extraction of the spectra.

Previous
12Next

Would you like to view a random code?