[ascl:2007.003]
SPARTA: Subhalo and PARticle Trajectory Analysis

SPARTA is a post-processing framework for particle-based cosmological simulations. The code is written in pure, MPI-parallelized C and is optimized for high performance. The main purpose of SPARTA is to understand the formation of structure in a dynamical sense, namely by analyzing the trajectories (or orbits) of dark matter particles around their halos. Within this framework, the user can add analysis modules that operate on individual trajectories or entire halos. The initial goal of SPARTA was to compute the splashback radius of halos, but numerous other applications have been implemented as well, including spherical overdensity calculations and tracking subhalos via their constituent particles.

[ascl:2007.004]
spex_to_xspec: Convert SPEX output to XSPEC input

spex_to_xspec takes the output from the collisional ionisation equilibrium model in the SPEX spectral modelling and fitting package (ascl:1308.014), and converts it into a form usable by the XSPEC spectral fitting package (ascl:9910.005). For a list of temperatures it computes the line strengths and continuum spectra using SPEX. These are collated and written into an APEC-format table model which can be loaded into Xspec. By allowing SPEX models to be loaded into XSPEC, the program allows easy comparison between the results of the SPEX and APEC codes.

[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: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: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: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: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: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:2007.011]
FleCSPH: Parallel and distributed SPH implementation based on the FleCSI

Loiseau, Julien; Lim, Hyun; Kaltenborn, Mark Alexander; Korobkin, Oleg; Mauney, Christopher M.; Sagert, Irina; Even, Wesley P.; Bergen, Benjamin K.

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: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:2007.013]
wdtools: Spectroscopic analysis of white dwarfs

wdtools characterizes the atmospheric parameters of white dwarfs using spectroscopic data. The flagship class is the generative fitting pipeline (GFP), which fits ab initio theoretical models to observed spectra in a Bayesian framework using high-speed neural networks to interpolate synthetic spectra.

[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: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:2007.016]
ReadPDS: Visualization tools for PDS4 data

ReadPDS reads in and visualizes data from the Planetary Data System in PDS4 format. Tools are available in Python as PDS4Viewer and in IDL as PDS4-IDL. These tools support PDS4 data, including images, spectra, and arrays and provide multiple views of the data, including summary, image, plot, and table views in addition to easy access to metadata such as structure labels and spectral characteristics.

[ascl:2007.017]
SPEX: Spectral Executive

SPEX provides a uniform interface suitable for the X-ray spectral analysis of a number of solar (or other) instruments in the X and Gamma Ray energy ranges. Part of the SolarSoft (ascl:1208.013) library, this package is suitable for any datastream which can be placed in the form of response vs interval where the response is usually a counting rate (spectrum) and the interval is normally an accumulation over time. Together with an algorithm which can be used to relate a model input spectrum to the observed response, generally a response matrix, the dataset is amenable to analysis with this package. Currently the data from a large number of instruments, including SMM (HXRBS, GRS Gamma, GRS X1, and GRS X2), Yohkoh (HXT, HXS, GRS, and SXT,) CGRO (BATSE SPEC and BATSE LAD), WIND (TGRS), HIREX, and NEAR (PIN). SPEX's next generation software is available in OSPEX (ascl:2007.018), an object-oriented package that is also part of and dependent on SolarSoft.

[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:2007.019]
TROVE: Theoretical ROVibrational Energies

TROVE (Theoretical ROVibrational Energies) performs variational calculations of rovibrational energies for general polyatomic molecules of arbitrary structure in isolated electronic states. The software numerically constructs the kinetic energy operator, which is represented as an expansion in terms of internal coordinates. The code is self-contained, requiring no analytical pre-derivation of the kinetic energy operator. TROVE is also general and can be used with any internal coordinates.

[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: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:2007.022]
SPARTA: SPectroscopic vARiabiliTy Analysis

SPARTA analyzes periodically-variable spectroscopic observations. Intended for common astronomical uses, SPARTA facilitates analysis of single- and double-lined binaries, high-precision radial velocity extraction, and periodicity searches in complex, high dimensional data. It includes two modules, UNICOR and USuRPER. UNICOR analyzes spectra using 1-d CCF. It includes maximum-likelihood analysis of multi-order spectra and detection of systematic shifts. USuRPER (Unit Sphere Representation PERiodogram) is a phase-distance correlation (PDC) based periodogram and is designed for very high-dimensional data such as spectra.

[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: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: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: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:2008.003]
KLLR: Kernel Localized Linear Regression

Farahi, Arya; Evrard, August E.; McCarthy, Ian; Barnes, David J.; Kay, Scott T.; Anbajagane, Dhayaa; Dolag, Klaus; McCarthy, Ian G.; Nelson, Dylan; Pillepich, Annalisa

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:2008.004]
SOT: Spin-Orbit Tomography

Spin-Orbit Tomography (SOT) is a retrieval technique of a two-dimensional map of an Exo-Earth from time-series data of integrated reflection light. The software provides code for the Bayesian version of the static SOT and dynamic mapping (time-varying mapping) with full Bayesian modeling, and tutorials for L2 and Bayesian SOT are available in jupyter notebooks.

[ascl:2008.005]
PySAP: Python Sparse data Analysis Package

Farrens, S.; Grigis, A.; El Gueddari, L.; Ramzi, Z.; Chaithya G. R.; Starck, S.; Sarthou, B.; Cherkaoui, H.; Ciuciu, P.; Starck, J.-L.

PySAP (Python Sparse data Analysis Package) provides a common API for astronomical and neuroimaging datasets and access to iSAP's (ascl:1303.029) Sparse2D executables with both wrappers and bindings. It also offers a graphical user interface for exploring the provided functions and access to application specific plugins.

[ascl:2008.006]
Umbrella: Asteroid detection, validation, and identification

Umbrella detects, validates, and identifies asteroids. The core of this software suite, Umbrella2, includes algorithms and interfaces for all steps of the processing pipeline, including a novel detection algorithm for faint trails. A detection pipeline accessible as a desktop program (ViaNearby) builds on the library to provide near real-time data reduction of asteroid surveys on the Wide Field Camera of the Isaac Newton Telescope. Umbrella can read and write MPC optical reports, supports SkyBoT and VizieR querying, and can be extended by user image processing functions to take advantage of the algorithms framework as a multi-threaded CPU scheduler for easy algorithm parallelization.

[ascl:2008.007]
sslf: A simple spectral-line finder

sslf is a simple, effective and useful spectral line finder for 1D data. It utilizes the continuous wavelet transform from SciPy, which is a productive way to find even weak spectral lines.

[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:2008.009]
SuperNNova: Photometric classification

SuperNNova performs photometric classification by leveraging recent advances in deep neural networks. It can train either a recurrent neural network or random forest to classify light-curves using only photometric information. It also allows additional information, such as host-galaxy redshift, to be incorporated to improve performance.

[ascl:2008.010]
zeus: Lightning Fast MCMC

Zeus is a pure-Python implementation of the Ensemble Slice Sampling method. Ensemble Slice Sampling improves upon Slice Sampling by bypassing some of that method's difficulties; it also exploits an ensemble of parallel walkers, thus making it immune to linear correlations. Zeus offers fast and robust Bayesian inference and efficient Markov Chain Monte Carlo without hand-tuning. The code provides excellent performance in terms of autocorrelation time and convergence rate, can scale to multiple CPUs without any extra effort, and includes convergence diagnostics.

[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:2008.012]
Ujti: Geodesics in general relativity

Ujti calculates geodesics, gravitational lenses and gravitational redshift in principle, for any metric. Special attention has been given to compact objects, so the current implementation considers only metrics in spherical coordinates.

[ascl:2008.013]
SEDBYS: Spectral Energy Distribution Builder for Young Stars

SEDBYS (Spectral Energy Distribution Builder for Young Stars) provides command-line tools and uses existing functions from standard packages such as Astropy (ascl:1304.002) to collate archival photometric and spectroscopic data. It also builds and inspects SEDS, and automatically collates the necessary software references.

[ascl:2008.014]
SuperRAENN: Supernova photometric classification pipeline

SuperRAENN performs photometric classification of supernovae in the following categories: Type I superluminos supernovae, Type II, Type IIn, Type Ia and Type Ib/c. Though the code is optimized for use with complete (rather than realtime) light curves from the Pan-STARRS Medium Deep Survey, the classifier can be trained on other data. SuperRAENN can be used on a dataset containing both spectroscopically labelled and unlabelled SNe; all events will be used to train the RAENN, while labelled events will be used to train the random forest.

[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: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: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: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: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:2008.020]
Eclaire: CUDA-based Library for Astronomical Image REduction

Niwano, Masafumi; Murata, Katsuhiro L.; Adachi, Ryo; Wang, Sili; Tachibana, Yutaro; Yatsu, Youichi; Kawai, Nobuyuki; Shimokawabe, Takashi; Itoh, Ryousuke

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:2008.021]
ramses2hsim: RAMSES output to 3D data cube for HSIM

Richardson, Mark L. A.; Routledge, L.; Thatte, N.; Tecza, M.; Houghton, Ryan C. W.; Pereira-Santaella, M.; Rigopoulou, D

The ramses2hsim pipeline converts a simulated galaxy in a RAMSES (ascl:1011.007) output into an 3D input data cube for HSIM (ascl:1912.006). The code incorporates gas kinematics (both bulk and turbulence), line emission and line width for Hα, and accounts for dust extinction.

[ascl:2008.022]
healpy: Python wrapper for HEALPix

Zonca, Andrea; Singer, Leo; Lenz, Daniel; Reinecke, Martin; Rosset, Cyrille; Hivon, Eric; Gorski, Krzysztof

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: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: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:2008.025]
TRISTAN: TRIdimensional STANford code

TRISTAN (TRIdimensional STANford) is a fully electromagnetic code with full relativistic particle dynamics. The code simulates large-scale space plasma phenomena such as the formation of systems of galaxies. TRISTAN particles which hit the boundaries are arrested there and redistributed more uniformly by having the boundaries slightly conducting, thus allowing electrons to recombine with ions and provides a realistic way of eliminating escaping particles from the code. Fresh particle fluxes can then be introduced independently across the boundaries. Written in 1993, this code has largely been superceded by TRISTAN-MP (ascl:1908.008).

[ascl:2008.026]
TDEmass: Tidal Disruption Event interpretor

TDEmass interprets Tidal Disruption Event (TDE) observations. In TDEs, a supermassive black hole at the center of a galaxy tears apart an ordinary star; the debris is placed on highly eccentric orbits and ultimately produces a very bright flare. Using this TDEmass, one can infer the mass of the black hole (mbh) and the mass of the star (mstar) involved in a TDE.

[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: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:2009.002]
vlt-sphere: Automatic VLT/SPHERE data reduction and analysis

The high-contrast imager SPHERE at the Very Large Telescope combines extreme adaptive optics and coronagraphy to directly image exoplanets in the near-infrared. The vlt-sphere package enables easy reduction of the data coming from IRDIS and IFS, the two near-infrared subsystems of SPHERE. The package relies on the official ESO pipeline (ascl:1402.010), which must be installed separately.

[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: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: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:2009.006]
SPInS: Stellar Parameters INferred Systematically

SPInS (Stellar Parameters INferred Systematically) provides the age, mass, and radius of a star, among other parameters, from a set of photometric, spectroscopic, interferometric, and/or asteroseismic observational constraints; it also generates error bars and correlations. Derived from AIMS (ascl:1611.014), it relies on a stellar model grid and uses a Bayesian approach to find the PDF of stellar parameters from a set of classical constraints. The heart of SPInS is a MCMC solver coupled with interpolation within a pre-computed stellar model grid. The code can consider priors such as the IMF or SFR and can characterize single stars or coeval stars, such as members of binary systems or of stellar clusters.

[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: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:2009.009]
MADHAT: Gamma-ray emission analyzer

Boddy, Kimberly K.; Hill, Stephen; Kumar, Jason; Sandick, Pearl; Haghi, Barmak Shams Es; Marfatia, Danny

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: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:2009.011]
PyWST: WST and RWST for astrophysics

PyWST performs statistical analyses of two-dimensional data with the Wavelet Scattering Transform (WST) and the Reduced Wavelet Scattering Transform (RWST). The WST/RWST provides convenient sets of coefficients for describing non-Gaussian data in a comprehensive way.

[ascl:2009.012]
minot: Modeling framework for diffuse components in galaxy clusters

Adam, R.; Goksu, H.; Leingärtner-Goth, A.; Ettori, S.; Gnatyk, R.; Hnatyk, B.; Hütten, M.; Pérez-Romero, J.; Sánchez-Conde, M. A.; Sergijenko, O.

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: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:2009.014]
pySpectrum: Power spectrum and bispectrum calculator

pySpectrum calculates the power spectrum and bispectrum for galaxies, halos, and dark matter.

[ascl:2009.015]
rcosmo: Cosmic Microwave Background data analysis

rcosmo provides information processing, visualization, manipulation and spatial statistical analysis of Cosmic Microwave Background (CMB) radiation and other spherical data stored in or converted to HEALPix coordinates. The package has more than 100 different functions, and can perform spherical geometry, manipulate CMB and other spherical data, and visualize HEALPix data. rcosmo can also perform statistical analysis of CMB and spherical data, and transforme spherical data in cartesian and geographic coordinates into HEALPix format.

[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: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: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:2009.019]
FLEET: Finding Luminous and Exotic Extragalactic Transients

Gomez, Sebastian; Berger, Edo; Blanchard, Peter K.; Hosseinzadeh, Griffin; Nicholl, Matt; Villar, V. Ashley; Yin, Yao

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: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:2009.021]
Chrono: Multi-physics simulation engine

Tasora, Alessandro; Serban, Radu; Mazhar, Hammad; Pazouki, Arman; Melanz, Daniel; Fleischmann, Jonathan; Taylor, Michael; Sugiyama, Hiroyuki; Negrut, Dan

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

[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: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: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: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:2010.003]
stsynphot: synphot for HST and JWST

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

[ascl:2010.004]
TACHE: TensoriAl Classification of Hydrodynamic Elements

TACHE (TensoriAl Classification of Hydrodynamic Elements) performs classification of the eigenvalues of either the tidal tensor or the velocity shear tensor at the point of a smoothed particle. This provides local information as to how matter is collapsing or flowing, respectively, in particular what stable manifold is being produced. The code reads in smoothed particle hydrodynamics (SPH) snapshot files in sphNG format and computes neighbor lists for SPH data and either the (symmetric) velocity shear tensor or tidal tensor and their eigenvalues/eigenvectors. It classifies fluid elements by number of "positive" eigenvalues and permits decomposition of snapshots into classified components; it also includes several Python plotting scripts.

[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: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:2010.007]
stella: Stellar flares identifier

stella creates and trains a neural network to identify stellar flares. Within stella, users can simulate flares as a training set, run a neural network, and feed in their own data to the neural network model. The software returns a probability at each data point as to whether that data point is part of a flare; the code can also characterize the flares identified.

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

[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: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:2010.011]
ROGER: Automatic classification of galaxies using phase-space information

de los Rios, Martín; Julián Martínez, Héctor; Coenda, Valeria; Muriel, Hernán; Nicolás Ruiz, Andrés; Vega-Martínez, Cristian Antonio; Cora, Sofia Alejandra

ROGER (Reconstructing Orbits of Galaxies in Extreme Regions) predicts the dynamical properties of galaxies using the projected phase-space information. Written in R, it offers a choice of machine learning methods to classify the dynamical properties of galaxies. An interface for online use of the software is available at https://mdelosrios.shinyapps.io/roger_shiny/.

[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: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: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:2010.015]
relxill: Reflection models of black hole accretion disks

Dauser, T.; García, J.; Parker, M. L.; Fabian, A. C.; Wilms, J.; Lohfink, A.; Kallman, T. R.; Steiner, J. F.; McClintock, J. E.; Brenneman, L.; Eikmann, W.; Reynolds, C. S.; Tombesi, F.

relxill self-consistently connects an angle-dependent reflection model constructed with XILLVER (http://www.srl.caltech.edu/personnel/javier/xillver/index.html) with the relativistic blurring code RELLINE (ascl:1505.021). It calculates the proper emission angle of the radiation at each point on the accretion disk and then takes the corresponding reflection spectrum into account.

[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: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:2011.003]
Kalkayotl: Inferring distances to stellar clusters from Gaia parallaxes

Olivares, J.; Sarro, L. M.; Bouy, H.; Miret-Roig, N.; Casamiquela, L.; Galli, P. A. B.; Berihuete, A.; Tarricq, Y.

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: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: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:2011.006]
tlpipe: Data processing pipeline for the Tianlai experiment

tlpipe processes the drift scan survey data from the Tianlai experiment; the Tainlai project is a 21cm intensity mapping experiment aimed at detecting dark energy by measuring the baryon acoustic oscillation (BAO) features in the large scale structure power spectrum. tlpipe performs offline data processing tasks such as radio frequency interference (RFI) flagging, array calibration, binning, and map-making, in addition to other tasks. It includes utility functions needed for the data analysis, such as data selection, transformation, visualization and others. tlpipe implements a number of new algorithms are implemented, including the eigenvector decomposition method for array calibration and the Tikhnov regularization for m-mode analysis.

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

[ascl:2011.012]
wobble: Time-series spectra analyzer

wobble analyzes time-series spectra. It was designed with stabilized extreme precision radial velocity (EPRV) spectrographs in mind, but is highly flexible and extensible to a variety of applications. It takes a data-driven approach to deriving radial velocities and requires no *a priori* knowledge of the stellar spectrum or telluric features.

[ascl:2011.013]
TLC: Tidally Locked Coordinates

Tidally Locked Coordinates converts global climate model (GCM) output from standard/Earth-like coordinates into a tidally locked coordinate system. The transformations in Tidally Locked Coordinates are useful for plotting and analyzing GCM simulations of slowly rotating tidally locked planets such as Earth-like planets inside the habitable zone of small stars. They can be used to leverage the fact that a slowly rotating planet's climate will start to look approximately symmetric about the axis of insolation.

[ascl:2011.014]
SEDkit: Spectral energy distribution construction and analysis tools

SEDkit constructs and analyzes simple spectral energy distributions (SED). This collection of pure Python modules creates individual SEDs or SED catalogs from spectra and/or photometry and calculates fundamental parameters (fbol, Mbol, Lbol, Teff, mass, log(g)).

[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: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:2011.017]
RRATtrap: Rotating Radio Transient identifier

Karako-Argaman, C.; Kaspi, V. M.; Lynch, R. S.; Hessels, J. W. T.; Kondratiev, V. I.; McLaughlin, M. A.; Ransom, S. M.; Archibald, A. M.; Boyles, J.; Jenet, F. A.; Kaplan, D. L.; Levin, L.; Lorimer, D. R.; Madsen, E. C.; Roberts, M. S. E.; Siemens, X.; Stairs, I. H.; Stovall, K.; Swiggum, J. K.; van Leeuwen, J.

RRATtrap is a single-pulse sifting algorithm to identify Rotating Radio Transients (RRATs) and transients using output from the PRESTO (ascl:1107.017) routine single_pulse_search.py. It can be integrated into pulsar survey data analysis pipelines and, in addition to finding RRATs, it can also identify Fast Radio Bursts.

[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:2011.019]
Scintools: Pulsar scintillation data tools

SCINTOOLS (SCINtillation TOOLS) simulates and analyzes pulsar scintillation data. The code can be used for processing observed dynamic spectra, computing secondary spectra and ACFs, measuring scintillation arcs, simulating dynamic spectra, and modeling pulsar transverse velocities through scintillation arcs or diffractive timescales.

[ascl:2011.020]
REBOUNDx: Adding effects in REBOUND N-body integrations

REBOUNDx incorporates additional physics into REBOUND (ascl:1110.016) simulations. Users can add effects from a list of pre-implemented astrophysical forces or contribute new ones. The main code is written in C, and a Python wrapper is provided for interfacing with other libraries. The REBOUNDx source code is machine independent and a binary format to save REBOUNDx configurations interfaces with the SimulationArchive class in REBOUND, making it possible to share and reproduce results bit by bit.

[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: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:2011.023]
reproject: Python-based astronomical image reprojection

reproject implements image reprojection (resampling) methods for astronomical images using various techniques via a uniform interface. Reprojection re-grids images from one world coordinate system to another (for example changing the pixel resolution, orientation, coordinate system). reproject works on celestial images by interpolation, as well as by finding the exact overlap between pixels on the celestial sphere. It can also reproject to/from HEALPIX projections by relying on the astropy-healpix package.

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

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

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

[ascl: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: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:2011.027]
kiauhoku: Stellar model grid interpolation

Claytor, Zachary R.; van Saders, Jennifer L.; Santos, Ângela R. G.; García, Rafael A.; Mathur, Savita; Tayar, Jamie; Pinsonneault, Marc H.; Shetrone, Matthew

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: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:2011.029]
DarkBit: Dark matter constraints calculator

Bringmann, Torsten; Conrad, Jan; Cornell, Jonathan M.; Dal, Lars A.; Edsjö, Joakim; Farmer, Ben; Kahlhoefer, Felix; Kvellestad, Anders; Putze, Antje; Savage, Christopher; Scott, Pat; Weniger, Christoph; White, Martin; Wild, Sebastian

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.030]
DDCalc: Dark matter direct detection phenomenology package

Bringmann, Torsten; Conrad, Jan; Cornell, Jonathan M.; Dal, Lars A.; Edsjö, Joakim; Farmer, Ben; Kahlhoefer, Felix; Kvellestad, Anders; Putze, Antje; Savage, Christopher; Scott, Pat; Weniger, Christoph; White, Martin; Wild, Sebastian

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.

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

[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: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:2012.003]
Sengi: Interactive viewer for spectral outputs from stellar population synthesis models

Sengi enables online viewing of the spectral outputs of stellar population synthesis (SPS) codes. Typical SPS codes require significant disk space or computing resources to produce spectra for simple stellar populations with arbitrary parameters, making it difficult to present their results in an interactive, web-friendly format. Sengi uses Non-negative Matrix Factorisation (NMF) and bilinear interpolation to estimate output spectra for arbitrary values of stellar age and metallicity; this reduces the disk requirements and computational expense, allowing Sengi to serve the results in a client-based Javascript application.

[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:2012.005]
MLC_ELGs: Machine Learning Classifiers for intermediate redshift Emission Line Galaxies

Zhang, Kai; Schlegel, David J.; Andrews, Brett H.; Comparat, Johan; Schäfer, Christoph; Vazquez Mata, Jose Antonio; Kneib, Jean-Paul; Yan, Renbin

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:2012.006]
Robovetter: Automatic vetting of Threshold Crossing Events (TCEs)

The DR25 Kepler Robovetter is a robotic decision-making code that dispositions each Threshold Crossing Event (TCE) from the final processing (DR 25) of the Kepler data into Planet Candidates (PCs) and False Positives (FPs). The Robovetter provides four major flags to designate each FP TCE as Not Transit-Like (NTL), a Stellar Eclipse (SS), a Centroid Offset (CO), and/or an Ephemeris Match (EM). It produces a score ranging from 0.0 to 1.0 that indicates the Robovetter's disposition confidence, where 1.0 indicates strong confidence in PC, and 0.0 indicates strong confidence in FP. Finally, the Robovetter provides comments in a text string that indicate the specific tests each FP TCE fails and provides supplemental information on all TCEs as necessary.

[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: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: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: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:2012.011]
Skye: Excess clustering of transit times detection

Skye detects a statistically significant excess clustering of transit times, indicating that there are likely systematics at specific times that cause many false positive detections, for the Kepler DR25 planet candidate catalog. The technique could be used for any survey looking to statistically cull false alarms.

[ascl:2012.012]
TRAN_K2: Planetary transit search

TRAN_K2 searches for periodic transits in the photometric time series of the Kepler K2 mission. The search is made by considering stellar variability and instrumental systematics. TRAN_K2 is written in Fortran 77 and has a single input parameter file that can be edited by the user depending on the type of run and parameter ranges to be used.

[ascl:2012.013]
sedop: Optimize discrete versions of common SEDs

sedop is a Monte-Carlo minimization code designed to optimally construct spectral energy distributions (SEDs) for sources of ultraviolet and X-ray radiation employed in numerical simulations of reionization and radiative feedback.

[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:2012.015]
seaborn: Statistical data visualization

Waskom, Michael; Botvinnik, Olga; Gelbart, Maoz; Ostblom, Joel; Hobson, Paul; Lukauskas, Saulius; Gemperline, David C; Augspurger, Tom; Halchenko, Yaroslav; Warmenhoven, Jordi; Cole, John B.; De Ruiter, Julian; Vanderplas, Jake; Hoyer, Stephan; Pye, Cameron; Miles, Alistair; Swain, Corban; Meyer, Kyle; Martin, Marcel; Bachant, Pete Quintero, Eric; Kunter, Gero; Villalba, Santi; Brian; Fitzgerald, Clark; Evans, C. G.; Williams, Mike Lee; O'Kane, Drew; Yarkoni, Tal; Brunner, Thomas

Seaborn provides a high-level interface for drawing attractive statistical graphics. Written in Python, it builds on matplotlib and integrates closely with pandas data structures. Its plotting functions operate on dataframes and arrays containing whole datasets and internally perform the necessary semantic mapping and statistical aggregation to produce informative plots. Its dataset-oriented, declarative API allows the user to focus on what the different elements of the plots mean, rather than on the details of how to draw them.

[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:2012.017]
SLIT: Sparse Lens Inversion Technique

SLIT (Sparse Lens Inversion Technique) provides a method for inversion of lensed images in the frame of strong gravitational lensing. The code requires the input image along with lens mass profile and a PSF. The user then has to chose a maximum number of iterations after which the algorithm will stop if not converged and a image size ratio to the input image to set the resolution of the reconstructed source. Results are displayed in pyplot windows.

[ascl:2012.018]
SimCADO: Observations simulator for infrared telescopes and instruments

SimCADO simulates observations with any NIR/Vis imaging system. Though the package was originally designed to simulate images for the European Extremely Large Telescope (ELT) and MICADO, with the proper input, it is capable of simulating observations from many different telescope and instrument configurations.

[ascl:2012.019]
PyXel: Astronomical X-ray imaging data modeling

PyXel models astronomical X-ray imaging data; it provides a common set of image analysis tools for astronomers working with extended X-ray sources. PyXel can model surface brightness profiles from X-ray satellites using a variety of models and statistics. PyXel can, for example, fit a broken power-law model to a surface brightness profile, and fit a constant to the sky background level in the direction of the merging galaxy cluster.

[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: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:2012.022]
SWIGLAL: Access LALSuite libraries with Python and Octave scripts

SWIGLAL, a wrapper for and component of the LALSuite (ascl:2012.021) gravitational wave detection and analysis libraries, which are primarily written in C, makes LALSuite routines directly accessible to Python and Octave scripts.

[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: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:2012.025]
Magritte: 3D radiative transfer library

De Ceuster, Frederik; Bolte, Jan; Homan, Ward; Maes, Silke; Malfait, Jolien; Decin, Leen; Yates, Jeremy; Boyle, Peter; Hetherington, James

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:2012.026]
EinsteinPy: General Relativity and gravitational physics problems solver

Bapat, Shreyas; Saha, Ritwik; Bhatt, Bhavya; Jain, Shilpi; Jain, Akshita; Ortín Vela, Sofía; Khandelwal, Priyanshu; Shivottam, Jyotirmaya; Ma, Jialin; Ng, Gim Seng; Kerhalkar, Pratyush; Sudam Sarode, Hrishikesh; Sharma, Rishi; Gupta, Manvi; Gupta, Divya; Tyagi, Tushar; Rustagi, Tanmay; Singh, Varun; Bansal, Saurabh; Tayal, Naman Manhas, Abhijeet; Reyna, Raphael; Kumar, Gaurav; Dixit, Govind; Kumar, Ratin; Mishra, Sashank; Jamgade, Alpesh; Singh, Raahul; Sanjay, Rohit; Shaikh, Khalid; Vidyarthi, Bhavam; Nayak K, Shamanth R; Gandham, Vineet; Vashistha, Nimesh; Das, Arnav; Saurabh; Kalvankar, Shreyas; Tarone, Ganesh; Mangat, Atul; Garg, Suyog; Gautam, Bibek; Srinivasan, Sitara; Gautam, Aayush; Singh, Swaastick Kumar; Salampuria, Suyash; Yauney, Zac; Gupte, Nihar; Shenoy, Gagan; Chan, Micky Yun

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: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: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:2101.003]
whereistheplanet: Predicting positions of directly imaged companions

whereistheplanet predicts the locations of directly imaged companions (mainly exoplanets and brown dwarfs) based on past orbital fits to the data. This tool helps coordinate follow-up observations to characterize their properties, as precise pointing of the instrument is often needed. It uses orbitize! (ascl:1910.009) as a backend. whereistheplanet is available as a Python API, a command line tool, and a web form at whereistheplanet.com.

[ascl:2101.004]
radiowinds: Radio emission from stellar winds

radiowinds calculates the radio emission produced by the winds around stars. The code calculates thermal bremsstrahlung that is emitted from the wind, which depends directly on the density and temperature of the stellar wind plasma. The program takes input data in the form of an interpolated 3d grid of points (of the stellar wind) containing position, temperature and density data. From this it calculates the thermal free-free emission expected from the wind at a range of user-defined frequencies.

[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: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: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: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: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: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: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:2101.012]
Octo-Tiger: HPX parallelized 3-D hydrodynamic code for stellar mergers

Marcello, Dominic C.; Shiber, Sagiv; De Marco, Orsola; Frank, Juhan; Clayton, Geoffrey C.; Motl, Patrick M.; Diehl, Patrick; Kaiser, Hartmut

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: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:2101.014]
PyXspec: Python interface to XSPEC spectral-fitting program

PyXspec is an object oriented Python interface to the XSPEC (ascl:9910.005) spectral-fitting program. It provides an alternative to Tcl, the sole scripting language for standard Xspec usage. With PyXspec loaded, a user can run Xspec with Python language scripts or interactively at a Python shell prompt; everything in PyXspec is accessible by importing the package xspec into your Python script. PyXspec can be utilized in a Python script or from the command line of the plain interactive Python interpreter. PyXspec does not implement its own command handler, so it is not intended to be run as the Python equivalent of a traditional interactive XSPEC session (which is really an enhanced interactive Tcl interpreter).

[ascl:2101.015]
DarpanX: X-ray reflectivity of multilayer mirrors

Mondal, Biswajit; Vadawale, Santosh V.; Mithun, N. P. S.; Vaishnava, C. S.; Tiwari, Neeraj K.; Goyal, S. K.; Panini, Singam S.; Navalkar, Vinita; Karmakar, Chiranjit; Patel, Mansukhlal R.; Upadhyay, R. B.

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:2101.016]
pyUPMASK: Unsupervised clustering method for stellar clusters

pyUPMASK is an unsupervised clustering method for stellar clusters that builds upon the original UPMASK (ascl:1504.001) package. Its general approach makes it applicable to analyses that deal with binary classes of any kind, as long as the fundamental hypotheses are met. The core of the algorithm follows the method developed in UPMASK but introducing several key enhancements that make it not only more general, they also improve its performance.

[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:2101.018]
stratsi: Stratified streaming instability

Stratsi calculates stratified and vertically-shearing streaming instabilities. It solves one- and two-fluid linearized equations, and, for two-fluid models, also provides the parameters and analytic vertical structure and solves for equilibrium horizontal velocity profiles. It offers utilities and various plotting options, including plots to compare one- and two-fluid results, viscous results to inviscid results, and results from two different stokes numbers or two different metallicities. stratsi requires Dedalus (ascl:1603.015) and Eigentools (ascl:2101.017).

[ascl:2102.001]
spinOS: SPectroscopic and INterferometric Orbital Solution finder

Fabry, Matthias; Hawcroft, Calum; Mahy, Laurent; Marchant, Pablo; Le Bouquin, Jean-Baptiste; Sana, Hugues

spinOS calculates binary orbital elements. Given a set of radial velocity measurements of a spectroscopic binary and/or relative position measurement of an astrometric binary, spinOS fits an orbital model by minimizing a chi squared metric. These routines are neatly packaged in a graphical user interface, developed using tkinter, facilitating use. Minimization is achieved by default using a Levenberg-Marquardt algorithm from lmfit [ascl:1606.014]. A Markov Chain Monte Carlo option is available to sample the posterior probability distribution in order to estimate errors on the orbital elements.

[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: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:2102.004]
ThumbStack: Map and profile stacking pipeline

ThumbStack produces stacked maps and profiles, given catalogs of object positions and maps. It is designed for thermal and kinematic Sunyaev-Zel'dovich measurements. Based on Pixell (ascl:2102.003), it outputs 2D stacked maps and radial profiles for different filters (e.g., aperture photometry filters), as well as their covariances, estimated through several methods including bootstrap.

[ascl:2102.005]
X-PSI: X-ray Pulse Simulation and Inference

X-PSI simulates rotationally-modified (pulsed) surface X-ray emission from neutron stars, taking into account relativistic effects on the emitted radiation. This can then be used to perform Bayesian statistical inference on real or simulated astronomical data sets. Model parameters of interest may include neutron star mass and radius (useful to constrain the properties of ultradense nuclear matter) or the system geometry and properties of the hot emitting surface-regions. To achieve this, X-PSI couples code for likelihood functionality (simulation) with existing open-source software for posterior sampling (inference).

[submitted]
The NASA Goddard Exoplanet Modeling and Analysis Center

Mandell, A.; Lopez, E.; Hostetter, C.; Patel, A.; Brande, J.; Sutton, M.; Moore, M.; Cruz-Arce, C.; Kelahan, C.; Susemiehl, N.

The Exoplanet Modeling and Analysis Center (EMAC) is a website which serves as a catalog, repository and integration platform for modeling and analysis resources focused on the study of exoplanet characteristics and environments. EMAC hosts user-submitted software ranging in category from planetary interior models to data visualization tools. Other features of EMAC include integrated web tools developed by the EMAC team in collaboration with the tools' original authors and video demonstrations of a growing number of hosted tools. EMAC aims to be a comprehensive repository for researchers to access a variety of exoplanet resources that can assist them in their work, and currently hosts a growing number of code bases, models, and tools. EMAC is a key project of the NASA GSFC Sellers Exoplanet Environments Collaboration (SEEC).

[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:2102.007]
viscm: Colormaps analyzer and creator

viscm is a Python tool for visualizing and designing colormaps using colorspacious and matplotlib.

[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: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: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:2102.011]
polgraw-allsky: All-sky almost-monochromatic gravitational-wave pipeline

Astone, Pia; Bejger, Michał; Bolek, Jan; Ciecieląg, Paweł; Dorosh, Orest; Garus, Aleksander; Królak, Andrzej; Nagy-Egri, Máté Ferenc; Piętka, Maciej; Pisarski, Andrzej; Poghosyan, Gevorg; Sieniawska, Magdalena; Skrzypiec, Rafał

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:2102.012]
MUSE-PSFR: PSF reconstruction for MUSE WFM-AO mode

Fusco, Thierry; Bacon, Roland; Kamann, Sebastian; Conseil, Simon; Neichel, Benoit; Correia, Carlos; Beltramo-Martin, Olivier; Vernet, Joel; Kolb, Johan; Madec, Pierre-Yves

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: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: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: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: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: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: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: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: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: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:2102.022]
RASSINE: Normalizing 1D stellar spectra

RASSINE normalizes merged 1D spectra using the concept of convex hulls. The code uses six parameters that can be fine-tuned, and provides an interactive interface, including graphical feedback, for easily choosing the parameters. RASSINE can also provide a first guess for the parameters that are derived directly from the merged 1D spectrum based on previously performed calibrations.

[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: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:2102.025]
binaryoffset: Detecting and correcting the binary offset effect in CCDs

Boone, K.; Aldering, G.; Copin, Y.; Dixon, S.; Domagalski, R. S.; Gangler, E.; Pecontal, E.; Perlmutter, S.

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

[submitted]
21cmDeepLearning

Python codes to extract the underlying matter density map from a 21 cm intensity field, making use of a convolutional neural network (CNN) with the U-Net architecture. Implemented in Pytorch. The astrophysical parameters of the simulations can also be predicted with a secondary CNN. The simulations of matter density and 21 cm maps have been performed with the code 21cmFAST.

[submitted]
hfs_fit: Atomic Emission Spectral Line Hyperfine Structure Fitting

Python codes for parameter optimisation in the analysis of emission line hyperfine structure. The code uses a simulated annealing algorithm to optimise the magnetic dipole interaction constants, electric quadrupole interaction constants, Voigt profile widths and the centre of gravity wavenumber for a given emission line profile.

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

Would you like to view a random code?