Understanding diffuse Galactic radio emission is interesting both in its own right and for minimizing foreground contamination of cosmological measurements. Cosmic Microwave Background experiments have focused on frequencies > 10 GHz, whereas 21 cm tomography of the high redshift universe will mainly focus on < 0.2 GHz, for which less is currently known about Galactic emission. Motivated by this, we present a global sky model derived from all publicly available total power large-area radio surveys, digitized with optical character recognition when necessary and compiled into a uniform format, as well as the new Villa Elisa data extending the 1.4 GHz map to the entire sky. We quantify statistical and systematic uncertainties in these surveys by comparing them with various global multi-frequency model fits. We find that a principal component based model with only three components can fit the 11 most accurate data sets (at 10, 22, 45 & 408 MHz and 1.4, 2.3, 23, 33, 41, 61, 94 GHz) to an accuracy around 1%-10% depending on frequency and sky region. The data compilation and software returning a predicted all-sky map at any frequency from 10 MHz to 100 GHz are publicly available in the archive file at the link below.

globalemu emulates the Global or sky averaged 21-cm signal and the associated neutral fraction history. The code can train a network on your own Global 21-cm signal or neutral fraction simulations using the built-in globalemu pre-processing techniques. It also features a GUI that can be invoked from the command line and used to explore how the structure of the Global 21-cm signal varies with the values of the astrophysical inputs.

GLoBES simulates long baseline neutrino oscillation experiments. The package features full incorporation of correlations and degeneracies in the oscillation parameter space, advanced routines for the treatment of arbitrary systematical errors, and user-defined priors, which allowsn for the inclusion of arbitrary external physical information. Its use of AEDL, the Abstract Experiment Definition Language, provides an easy way to define experimental setups. GLoBES also provides an interface for the simulation of non-standard physics, and offers predefined setups for many experiments, including Superbeams, Beta Beams, Neutrino factories, Reactors, and various detector technologies.

The Lomb-Scargle periodogram is a common tool in the frequency analysis of unequally spaced data equivalent to least-squares fitting of sine waves. GLS is a solution for the generalization to a full sine wave fit, including an offset and weights (χ2 fitting). Compared to the Lomb-Scargle periodogram, GLS is superior as it provides more accurate frequencies, is less susceptible to aliasing, and gives a much better determination of the spectral intensity.

Glue, written in Python, links visualizations of scientific datasets across many files, allowing for interactive, linked statistical graphics of multiple files. It supports many file formats including common image formats (jpg, tiff, png), ASCII tables, astronomical image and table formats (FITS, VOT, IPAC), and HDF5. Custom data loaders can also be easily added. Glue is highly scriptable and extendable.

GMCALab solves Blind Source Separation (BSS) problems from multichannel/multispectral/hyperspectral data. In essence, multichannel data provide different observations of the same physical phenomena (e.g. multiple wavelengths), which are modeled as a linear combination of unknown elementary components or sources. Written as a set of Matlab toolboxes, it provides a generic framework that can be extended to tackle different matrix factorization problems.

GMM (Gaussian Mixture Modeling) tests the existence of bimodality in globular cluster color distributions. GMM uses three indicators to distinguish unimodal and bimodal distributions: the kurtosis of the distribution, the separation of the peaks, and the probability of obtaining the same χ2 from a unimodal distribution.

gnm is an implementation of the affine-invariant sampler for Markov chain Monte Carlo (MCMC) that uses the Gauss-Newton-Metropolis (GNM) Algorithm. The GNM algorithm is specialized in sampling highly non-linear posterior probability distribution functions of the form exp(-||f(x)||^2/2). The code includes dynamic hyper-parameter optimization to increase performance of the sampling; other features include the Jacobian tester and an error bars creator.

Gnuastro (GNU Astronomy Utilities) manipulates and analyzes astronomical data. It is an official GNU package of a large collection of programs and C/C++ library functions. Command-line programs perform arithmetic operations on images, convert FITS images to common types like JPG or PDF, convolve an image with a given kernel or matching of kernels, perform cosmological calculations, crop parts of large images (possibly in multiple files), manipulate FITS extensions and keywords, and perform statistical operations. In addition, it contains programs to make catalogs from detection maps, add noise, make mock profiles with a variety of radial functions using monte-carlo integration for their centers, match catalogs, and detect objects in an image among many other operations. The command-line programs share the same basic command-line user interface for the comfort of both the users and developers. Gnuastro is written to comply fully with the GNU coding standards and integrates well with all Unix-like operating systems. This enables astronomers to expect a fully familiar experience in the source code, building, installing and command-line user interaction that they have seen in all the other GNU software that they use. Gnuastro's extensive library is included for users who want to build their own unique programs.

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.

GOSSIP fits the electro-magnetic emission of an object (the SED, Spectral Energy Distribution) against synthetic models to find the simulated one that best reproduces the observed data. It builds-up the observed SED of an object (or a large sample of objects) combining magnitudes in different bands and eventually a spectrum; then it performs a chi-square minimization fitting procedure versus a set of synthetic models. The fitting results are used to estimate a number of physical parameters like the Star Formation History, absolute magnitudes, stellar mass and their Probability Distribution Functions.

gotetra uses phase-space tesselation techniques to extract information about cosmological N-body simulations. The key applications of this Go-based code are the measurement of splashback shells around halos and the generation of high resolution images of density fields. The package includes routines to generates 3D and 2D (projected) density fields from a particle snapshot generated by a cosmological N-body simulation, measure density along lines of sight from the center of halos, and compresse the position space data from cosmological N-body simulations. Included are two helper libraries with functions for calculating cosmological quantities and computing a number of useful mathematical functions.

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.

The two-point correlation function is a simple statistic that quantifies the clustering of a given distribution of objects. In studies of the large scale structure of the Universe, it is an important tool containing information about the matter clustering and the evolution of the Universe at different cosmological epochs. A classical application of this statistic is the galaxy-galaxy correlation function to find constraints on the parameter Omega_m or the location of the baryonic acoustic oscillation peak. This calculation, however, is very expensive in terms of computer power and Graphics Processing Units provide one solution for efficient analysis of the increasingly larger galaxy surveys that are currently taking place.

GP2PCF is a public code in CUDA for performing this computation; with a single GPU board it is possible to achieve 120-fold speedups with respect to a standard implementation in C running on a single CPU. With respect to other solutions such as k-trees the improvement is of a factor of a few retaining full precision. The speedup is comparable to running in parallel in a cluster of O(100) cores.

The University of Manchester GPC library is a flexible and highly robust polygon set operations library for use with C, C#, Delphi, Java, Perl, Python, Haskell, Lua, VB.Net and other applications. It supports difference, intersection, exclusive-or and union clip operations, and polygons may be comprised of multiple disjoint contours. Contour vertices may be given in any order - clockwise or anticlockwise, and contours may be convex, concave or self-intersecting, and may be nested (i.e. polygons may have holes). Output may take the form of either polygon contours or tristrips, and hole and external contours are differentiated in the result. GPC is free for non-profit and educational use; a Commercial Use License is required for commercial use.

Internet Archive link provided for archival purposes; per its website, GPC is no longer distributed or available as of August 2020.

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.

Gaussian Process Cross-Correlation (GPCC) uses Gaussian processes to estimate time delays for reverberation mapping (RM) of Active Galactic Nuclei (AGN). This statistically principled model delivers a posterior distribution for the delay and accounts for observational noise and the non-uniform sampling of the light curves. Written in Julia, GPCC quantifies the uncertainty and propagates it to subsequent calculations of dependent physical quantities, such as black hole masses. The code delivers out-of-sample predictions, which enables model selection, and can calculate the joint posterior delay for more than two light curves. Though written for RM, the software can also be applied to other fields where cross-correlation analysis is performed.

gphist performs Bayesian inference on the cosmological expansion history using Gaussian process priors. It is written in Python and includes driver programs to run inference calculations and plot the results. The code infers the cosmological expansion history using a Gaussian process prior, reads these ouputs, and performs checks to ensure they are indeed compatible. gphist then generates a single combined output file to plot expansion history inferences.

Written in Python, gPhoton calibrates and sky-projects the ~1.1 trillion ultraviolet photon events detected by the microchannel plates on the Galaxy Evolution Explorer Spacecraft (GALEX), archives these events in a publicly accessible database at the Mikulski Archive for Space Telescopes (MAST), and provides tools for working with the database to extract scientific results, particularly over short time domains. The software includes a re-implementation of core functionality of the GALEX mission calibration pipeline to produce photon list files from raw spacecraft data as well as a suite of command line tools to generate calibrated light curves, images, and movies from the MAST database.

The GPI data pipeline allows users to reduce and calibrate raw GPI data into spectral and polarimetric datacubes, and to apply various PSF subtraction methods to those data. Written in IDL and available in a compiled version, the software includes an integrated calibration database to manage reference files and an interactive data viewer customized for high contrast imaging that allows exploration and manipulation of data.

GProtation measures stellar rotation periods with Gaussian processes.

This code is no longer being maintained. Please consider using celerite (ascl:1709.008) or exoplanet (ascl:1910.005) instead.

GPry efficiently obtains marginal quantities from computationally expensive likelihoods. It works best with smooth (continuous) likelihoods and posteriors that are slow to converge by other methods, which is dependent on the number of dimensions and expected shape of the posterior distribution. The likelihood should be low-dimensional (d<20 as a rule of thumb), though the code may still provide considerable improvements in speed in higher dimensions, despite an increase in the computational overhead of the algorithm. GPry is an alternative to samplers such as MCMC and Nested Sampling with a goal of speeding up inference in cosmology, though the software will work with any likelihood that can be called as a python function. It uses Cobaya's (ascl:1910.019) model framework so all of Cobaya's inbuilt likelihoods work, too.

GPU-D is a GPU-accelerated implementation of the inverse ray-shooting technique used to generate cosmological microlensing magnification maps. These maps approximate the source plane magnification patterns created by an ensemble of stellar-mass compact objects within a foreground macrolens galaxy. Unlike other implementations, GPU-D solves the gravitational lens equation without any approximation. Due to the high computational intensity and high degree of parallelization inherent in the algorithm, it is ideal for brute-force implementation on GPUs. GPU-D uses CUDA for GPU acceleration and require NVIDIA devices to run.

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

GR1D is based on the Eulerian formulation of GR hydrodynamics (GRHD) put forth by Romero-Ibanez-Gourgoulhon and employs radial-gauge, polar-slicing coordinates in which the 3+1 equations simplify substantially. GR1D is intended for the simulation of stellar collapse to neutron stars and black holes and will also serve as a testbed for modeling technology to be incorporated in multi-D GR codes. Its GRHD part is coupled to various finite-temperature microphysical equations of state in tabulated form that we make available with GR1D.

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

The GRACOS (GRAvitational COSmology) code, a parallel implementation of the particle-particle/particle-mesh (P3M) algorithm for distributed memory clusters, uses a hybrid method for both computation and domain decomposition. Long-range forces are computed using a Fourier transform gravity solver on a regular mesh; the mesh is distributed across parallel processes using a static one-dimensional slab domain decomposition. Short-range forces are computed by direct summation of close pairs; particles are distributed using a dynamic domain decomposition based on a space-filling Hilbert curve. A nearly-optimal method was devised to dynamically repartition the particle distribution so as to maintain load balance even for extremely inhomogeneous mass distributions. Tests using $800^3$ simulations on a 40-processor beowulf cluster showed good load balance and scalability up to 80 processes. There are limits on scalability imposed by communication and extreme clustering which may be removed by extending the algorithm to include adaptive mesh refinement.

This paper describes the generation of initial conditions for numerical simulations in cosmology with multiple levels of resolution, or multiscale simulations. We present the theory of adaptive mesh refinement of Gaussian random fields followed by the implementation and testing of a computer code package performing this refinement called GRAFIC-2.

We present a non-parametric technique to infer the projected-mass distribution of a gravitational lens system with multiple strong-lensed images. The technique involves a dynamic grid in the lens plane on which the mass distribution of the lens is approximated by a sum of basis functions, one per grid cell. We used the projected mass densities of Plummer spheres as basis functions. A genetic algorithm then determines the mass distribution of the lens by forcing images of a single source, projected back onto the source plane, to coincide as well as possible. Averaging several tens of solutions removes the random fluctuations that are introduced by the reproduction process of genomes in the genetic algorithm and highlights those features common to all solutions. Given the positions of the images and the redshifts of the sources and the lens, we show that the mass of a gravitational lens can be retrieved with an accuracy of a few percent and that, if the sources sufficiently cover the caustics, the mass distribution of the gravitational lens can also be reliably retrieved. A major advantage of the algorithm is that it makes full use of the information contained in the radial images, unlike methods that minimise the residuals of the lens equation, and is thus able to accurately reconstruct also the inner parts of the lens.

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

GRAND-HOD (GeneRalized ANd Differentiable Halo Occupation Distribution) takes a generalized Halo Occupation Distribution (HOD) prescription as input and outputs the corresponding mock galaxy catalogs in binary files. The code is differentiable and incorporates various generalizations to the standard HOD. It is written for the Abacus simulations, but the main functionalities can be easily adapted for other halo catalogs with the appropriate properties.

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.

GRASIL (which stands for GRAphite and SILicate) computes the spectral evolution of stellar systems taking into account the effects of dust, which absorbs and scatters optical and UV photons and emits in the IR-submm region. It may be used as well to do “standard” no-dust stellar spectral synthesis. The code is very well calibrated and applied to interpret galaxies at different redshifts. GRASIL can be downloaded or run online using the GALSYNTH WEB interface.

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

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

The Julia library GRASS produces realistic stellar spectra with time-variable granulation signatures. It is based on real observations of the Sun, and does not rely on magnetohydrodynamic simulations to produce its spectra. GRASS can also compute bisectors for absorption lines or CCF profiles, and provides two methods for calculating bisectors.

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

Modern applications of strong gravitational lensing require the ability to use precise and varied observational data to constrain complex lens models. Two sets of computational methods for lensing calculations are discussed. The first is a new algorithm for solving the lens equation for general mass distributions. This algorithm makes it possible to apply arbitrarily complicated models to observed lenses. The second is an evaluation of techniques for using observational data including positions, fluxes, and time delays of point-like images, as well as maps of extended images, to constrain models of strong lenses. The techniques presented here are implemented in a flexible and user-friendly software package called gravlens, which is made available to the community.

The non-parametric Jeans code GravSphere models discrete data and can be used to model dark matter distributions in galaxies. It can also recover the density ρ(r) and velocity anisotropy β(r) of spherical stellar systems, assuming only that they are in a steady state. Real or mock data are prepared by using the included binulator.py code; the repository also includes many examples for exploring the GravSphere's capabilities.

GRay is a massive parallel ordinary differential equation integrator that employs the "stream processing paradigm." It is designed to efficiently integrate billions of photons in curved spacetime according to Einstein's general theory of relativity. The code is implemented in CUDA C/C++.

GRChombo performs numerical relativity simulations. It uses Chombo (ascl:1202.008) for adaptive mesh refinement and can evolve standard spacetimes such as binary black hole mergers and scalar collapses into black holes. The code supports non-trivial many-boxes-in-many-boxes mesh hierarchies and massive parallelism and evolves the Einstein equation using the standard BSSN formalism. GRChombo is written in C++14 and uses hybrid MPI/OpenMP parallelism and vector intrinsics to achieve good performance.

A stand-alone spectral gridder and imager for the Green Bank Telescope, as well as functionality for any diameter telescope. Based around the cygrid package from Benjamin Winkel and Daniel Lenz

GRFolres performs simulations in modified theories of gravity. It is based on GRChombo (ascl:2306.039) and inherits all of the capabilities of the main GRChombo code, which makes use of the Chombo library (ascl:1202.008) for adaptive mesh refinement. The code implements the 4∂ST theory of modified gravity and the cubic Horndeski theory in (3+1)-dimensional numerical relativity. GRFolres can be used for stable gauge evolution, solving the modified energy and momentum constraints for initial conditions, and monitoring the constraint violation and calculating the energy densities associated with the different scalar terms in the action. It can also extract data for the tensor and scalar gravitational waveforms.

GrGadget merges the Particle-Mesh (PM) relativistic GEVOLUTION code (ascl:1608.014) with the TreePM GADGET-4 code (ascl:2204.014) to create a TreePM simulation code that represents metric perturbations at the scales where they are relevant while resolving non-linear structures. The better resolution of the highly non-linear regime improves the representation of the relativistic fields sampled on the mesh with respect to PM-only simulations.

GRID-core is a core-finding method using the contours of the local gravitational potential to identify core boundaries. The GRID-core method applied to 2D surface density and 3D volume density are in good agreement for bound cores. We have implemented a version of the GRID-core algorithm in IDL, suitable for core-finding in observed maps. The required input is a two-dimensional FITS file containing a map of the column density in a region of a cloud.

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

GriSPy (Grid Search in Python) uses a regular grid search algorithm for quick fixed-radius nearest-neighbor lookup. It indexes a set of k-dimensional points in a regular grid providing a fast approach for nearest neighbors queries. Optional periodic boundary conditions can be provided for each axis individually. GriSPy implements three types of queries: bubble, shell and the nth-nearest, and offers three different metrics of interest in astronomy: the Euclidean and two distance functions in spherical coordinates of varying precision, haversine and Vincenty. It also provides a custom distance function. GriSPy is particularly useful for large datasets where a brute-force search is not practical.

GRIT (Gravitational Rigid-body InTegrators) simulaties the coupled dynamics of both spin and orbit of N gravitationally interacting rigid bodies. The code supports tidal forces and general relativity correction are supported, and multiple schemes with different orders of convergences and splitting strategies are available. Multiscale splittings boost the simulation speed, and force evaluations can be parallelized. In addition, each body can be set to be a rigid body or just a point mass, and the floating-point format can be customized as float, double, or long double globally.

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

GRIZZLY simulates reionization using a 1D radiative transfer scheme. The code enables the efficient exploration of the parameter space for evaluating 21cm brightness temperature fluctuations near the cosmic dawn. GRIZZLY builds upon the BEARS algorithm for generating simulated reionization maps with density and velocity fields, which are useful for profiling dark matter halos and cosmological density fields.

grmonty is a Monte Carlo radiative transport code intended for calculating spectra of hot, optically thin plasmas in full general relativity. The code models hot accretion flows in the Kerr metric, it incorporates synchrotron emission and absorption and Compton scattering. grmonty can be readily generalized to account for other radiative processes and an arbitrary spacetime.

Growl calculates the linear growth factor Da and its logarithmic derivative dln D/dln a in expanding Friedmann-Robertson-Walker universes with arbitrary matter and vacuum densities. It permits rapid and stable numerical evaluation.

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

GRUMPY (Galaxy formation with RegUlator Model in PYthon) models the formation of dwarf galaxies. When coupled with realistic mass accretion histories of halos from simulations and reasonable choices for model parameter values, this simple regulator-type framework reproduces a broad range of observed properties of dwarf galaxies over seven orders of magnitude in stellar mass. GRUMPY matches observational constraints on the stellar mass--halo mass relation and observed relations between stellar mass and gas phase and stellar metallicities, gas mass, size, and star formation rate. It also models the general form and diversity of star formation histories (SFHs) of observed dwarf galaxies. The software can be used to predict photometric properties of dwarf galaxies hosted by dark matter haloes in N-body simulations, such as colors, surface brightnesses, and mass-to-light ratios and to forward model observations of dwarf galaxies.

The GSD library reads data written in the James Clerk Maxwell Telescope GSD format. This format uses the General Single-Dish Data model and was used at the JCMT until 2005. The library provides an API to open GSD files and read their contents. The content of the data files is self-describing and the library can return the type and name of any component. The library is used by SPECX (ascl:1310.008), JCMTDR (ascl:1406.019) and COADD (ascl:1411.020). The SMURF (ascl:1310.007) package can convert GSD heterodyne data files to ACSIS format using this library.

gsf applies Gaussian Mixture Models in the stellar kinematic space of normalized angular momentum and binding energy on NIHAO high resolution galaxies to separate the stars into multiple components. The gsf analysis package assumes that the simulation snapshot has been pre-processed with a halo finder. It is based on pynbody (ascl:1305.002) and the scikit-learnpython package for Machine Learning; after loading, orienting, and transforming a simulation snapshot to physical units, it runs the clustering algorithm and performs the direct N-body gravity force using all the particles in the given halo.

gsf fits photometric data points, simultaneously with grism spectra if provided, to get posterior probability of galaxy physical properties, such as stellar mass, dust attenuation, metallicity, as well as star formation and metallicity enrichment histories. Designed for extra-galactic science, this flexible, python-based SED fitting code involves a Markov-Chain Monte-Carlo (MCMC) process, and may take more time (depending on the number of parameters and length of MCMC chains) than other SED fitting codes based on chi-square minimization.

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

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.

GSSP (Grid Search in Stellar Parameters) is based on a grid search in the fundamental atmospheric parameters and (optionally) individual chemical abundances of the star (or binary stellar components) in question. It uses atmosphere models and spectrum synthesis, which assumes a comparison of the observations with each theoretical spectrum from the grid. The code can optimize five stellar parameters at a time (effective temperature, surface gravity, metallicity, microturbulent velocity, and projected rotational velocity of the star) and synthetic spectra can be computed in any number of wavelength ranges. GSSP builds the grid of theoretical spectra from all possible combinations of the above mentioned parameters, and delivers the set of best fit parameters, the corresponding synthetic spectrum, and the ASCII file containing the individual parameter values for all grid points and the corresponding chi-square values.

GStokes performs simple multipolar fits to circular polarization data to provide information about the field strength and geometry. It provides forward calculation of the disc-integrated Stokes parameter profiles as well as magnetic inversions under several widely used simplifying approximations of the polarized line formation. GStokes implements the Unno–Rachkovsky analytical solution of the polarized radiative transfer equation and the weak-field approximation with the Gaussian local profiles. The magnetic field geometry is described with one of the common low-order multipolar field parametrizations. Written in IDL, GStokes provides a user-friendly graphical front-end.

Guacho is a 3D hydrodynamical/magnetohydrodynamical code suited for astrophysical fluids. The hydrodynamic equations are evolved with a number of approximate Riemann solvers. Gaucho includes various modules to deal with different cooling regimes, and a radiation transfer module based on a Monte Carlo ray tracing method. The code can run sequentially or in parallel with MPI.

GUBAS (General Use Binary Asteroid Simulator) predicts binary asteroid system behaviors by implementing the Hou 2016 realization of the full two-body problem (F2BP). The F2BP models binary asteroid systems as two arbitrary mass distributions whose mass elements interact gravitationally and result in both gravity forces and torques. To account for these mass distributions and model the mutual gravity of the F2BP, GUBAS computes the inertia integrals of each body up to a user defined expansion order. This approach provides a recursive expression of the mutual gravity potential and represents a significant decrease in the computational burden of the F2BP when compared to other methods of representing the mutual potential.

The gw_pta_emulator reads in gravitational wave (GW) characteristic strain spectra from black-hole population simulations, re-bins for the user's observing baseline, and constructs new spectra. The user can train a Gaussian process to emulate the spectral behavior at all frequencies across the astrophysical parameter space of supermassive black-hole binary environments.

GWDALI focuses on parameter estimations of gravitational waves generated by compact object coalescence (CBC). This software employs both Gaussian (Fisher Matrix) and Beyond-Gaussian methods to approximate the likelihood of gravitational wave events. GWDALI also addresses the challenges posed by Fisher Matrices with zero determinants. Additionally, the Beyond-Gaussian approach incorporates the Derivative Approximation for Likelihoods (DALI) algorithm, enabling a more reliable estimation process.

gwdet computes the probability of detecting a gravitational-wave signal from compact binaries averaging over sky-location and source inclination. The code has two classes, averageangles and detectability. averageangles computes the detection probability, averaged over all angles (such as sky location, polarization, and inclination), as a function of the projection parameter. detectability computes the detection probability of a non-spinning compact binary.

GWecc computes the pulsar timing array (PTA) signals induced by eccentric supermassive binaries. Written in C++, it computes the plus/cross polarizations as well as Earth and pulsar terms of the PTA signal given the binary parameters and the sky locations of the binary and the pulsar. A python wrapper is included through which GWecc can be used to simulate, search for and constrain gravitational wave-emitting eccentric supermassive binaries using packages such as ENTERPRISE (ascl:1912.015) and libstempo (ascl:2002.017).

GWFAST forecasts the signal-to-noise ratios and parameter estimation capabilities of networks of gravitational-wave detectors, based on the Fisher information matrix approximation. It is designed for applications to third-generation gravitational-wave detectors. It is based on Automatic Differentiation, which makes use of the library JAX (ascl:2111.002). This allows efficient parallelization and numerical accuracy. The code includes a module for parallel computation on clusters.

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

The Python package GWpy analyzes and characterizes gravitational wave data. It provides a user-friendly, intuitive interface to the common time-domain and frequency-domain data produced by the LIGO and Virgo observatories and their analyses. The core Python infrastructure is influenced by, and extends the functionality of, the Astropy (ascl:1304.002) package, and its methodology has been derived from, and augmented by, the LIGO Algorithm Library Suite (LALSuite), a large collection of primarily C99 routines for analysis and manipulation of data from gravitational-wave detectors. These packages use the SWIG program to produce Python wrappings for all C modules, allowing the GWpy package to leverage both the completeness, and the speed, of these libraries.

GWSim generates mock gravitational waves (GW) events corresponding to different binary black holes (BBHs) population models. It can incorporate scenarios of GW mass models, GW spin distributions, the merger rate, and the cosmological parameters. GWSim generates samples of binary compact objects for a fixed amount of observation time, duty cycle, and configurations of the detector network; the universe created by the code is uniform in comobile volume.

GWSurrogate provides an easy to use interface to gravitational wave surrogate models. Surrogates provide a fast and accurate evaluation mechanism for gravitational waveforms which would otherwise be found through solving differential equations. These equations must be solved in the “building” phase, which was performed using other codes.

GWToolbox simulates gravitational wave observations for various detectors. The package is composed of three modules, namely the ground-based detectors (and their targets), the space-borne detectors (and their targets) and pulsar timing arrays (PTA). These three modules work independently and have different dependencies on other packages and libraries; failed dependencies met in one module will not influence the usage of another module. GWToolbox can accessed with a web interface (gw-universe.org) or as a python package (https://bitbucket.org/radboudradiolab/gwtoolbox).

GYOTO, a general relativistic ray-tracing code, aims at computing images of astronomical bodies in the vicinity of compact objects, as well as trajectories of massive bodies in relativistic environments. This code is capable of integrating the null and timelike geodesic equations not only in the Kerr metric, but also in any metric computed numerically within the 3+1 formalism of general relativity. Simulated images and spectra have been computed for a variety of astronomical targets, such as a moving star or a toroidal accretion structure. The underlying code is open source and freely available. It is user-friendly, quickly handled and very modular so that extensions are easy to integrate. Custom analytical metrics and astronomical targets can be implemented in C++ plug-in extensions independent from the main code.

GYRE is an oscillation code that solves the stellar pulsation equations (both adiabatic and non-adiabatic) using a novel Magnus Multiple Shooting numerical scheme devised to overcome certain weaknesses of the usual relaxation and shooting schemes. The code is accurate (up to 6th order in the number of grid points), robust, and makes efficient use of multiple processor cores and/or nodes.

gyrfalcON (GalaxY simulatoR using falcON) is a full-fledged N-body code using Dehnen’s force algorithm of complexity O(N) (falcON); this algorithm is approximately 10 times faster than an optimally coded tree code. The code features individual adaptive time steps and individual (but fixed) softening lengths. gyrfalcON is included in and requires NEMO to run.

gyrointerp calculates gyrochronal ages by interpolating between open cluster rotation sequences. The framework, written in Python, can be used to find the gyrochronological age posterior of single or many stars. It can also produce a visual interpolation for a star’s age to determine where the star falls in the rotation-temperature plane in comparison to known reference clusters. gyrointerp models the ensemble evolution of rotation periods for main-sequence stars with temperatures of 3800-6200 K (masses of 0.5-1.2 solar) and is not applicable for subgiant or giant stars, and should be used cautiously with binary stars, as they can observationally bias temperature and rotation period measurements.

H-FISTA (Hierarchical Fast Iterative Shrinkage Thresholding Algorithm) retrieves the phases of the wavefield from intensity measurements for pulsar spectroscopy. The code accepts input data in ASCII format as produced by PSRchive's (ascl:1105.014) psrflux function, a FITS file, or a pickle. If using a notebook, any custom reader can be used as long as the data ends up in a NumPy array. H-FISTA obtains sparse models of the wavefield in a hierarchical approach with progressively increasing depth. Once the tail of the noise distribution is reached, the hierarchy terminates with a final unregularized optimization, resulting in a fully dense model of the complex wavefield that permits the discovery of faint signals by appropriate averaging.

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

HAFFET (Hybrid Analytic Flux FittEr for Transients) analyzes supernovae photometric and spectroscopic data. It handles observational data for a set of targets, estimates their physical parameters, and visualizes the population of inferred parameters. HAFFET defines two classes, snobject for data and fittings for one specific object, and snelist to organize the overall running for a list of objects. The HAFFET package includes utilities for downloading SN data from online sources, intepolating multi band lightcurves, characterizing the first light and rising of SNe with power law fits, and matching epochs of different bands. It can also calculate colors, and/or construct the spectral energy distribution (SED), estimate bolometric LCs and host galaxy extinction, fit the constructed bolometric lightcurves to different models, and identify and fit the absorption minima of spectral lines, in addition to performing other tasks. In addition to utilizing the built-in models, users can add their own models or import models from other python packages.

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

HALOFIT provides an explanatory framework for galaxy bias and clustering and has been incorporated into CMB packages such as CMBFAST (ascl:9909.004) and CAMB (ascl:1102.026). It attains a reasonable level of precision, though the halo model does not match N-body data perfectly. The code is written in Fortran 77. HALOFIT tends to underpredict the power on the smallest scales in standard LCDM universes (although HALOFIT was designed to work for a much wider range of power spectra); its accuracy can be improved by using a supplied correction.

We perform N-body simulations of theories with infinite-volume extra dimensions, such as the Dvali-Gabadadze-Porrati (DGP) model and its higher-dimensional generalizations, where 4D gravity is mediated by massive gravitons. The longitudinal mode of these gravitons mediates an extra scalar force, which we model as a density-dependent modification to the Poisson equation. This enhances gravitational clustering, particularly on scales that have undergone mild nonlinear processing. While the standard non-linear fitting algorithm of Smith et al. overestimates this power enhancement on non-linear scales, we present a modified fitting formula that offers a remarkably good fit to our power spectra. Due to the uncertainty in galaxy bias, our results are consistent with precision power spectrum determinations from galaxy redshift surveys, even for graviton Compton wavelengths as small as 300 Mpc. Our model is sufficiently general that we expect it to capture the phenomenology of a wide class of related higher-dimensional gravity scenarios.

HALOGEN generates approximate synthetic halo catalogs. Written in C, it decomposes the problem of generating cosmological tracer distributions (eg. halos) into four steps: generating an approximate density field, generating the required number of tracers from a CDF over mass, placing the tracers on field particles according to a bias scheme dependent on local density, and assigning velocities to the tracers based on velocities of local particles. It also implements a default set of four models for these steps. HALOGEN uses 2LPTic (ascl:1201.005) and CUTE (ascl:1505.016); the software is flexible and can be adapted to varying cosmologies and simulation specifications.

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.

Halogen, written in C, generates multimass spherically symmetric initial conditions for N-body simulations. A large family of radial density profiles is supported. The initial conditions are sampled from the full distribution function.

HaloGraphNet predicts halo masses from simulations using Graph Neural Networks. Given a dark matter halo and its galaxies, this software creates a graph with information about the 3D position, stellar mass and other properties. It then trains a Graph Neural Network to predict the mass of the host halo. Data are taken from the CAMELS hydrodynamic simulations.

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.

Halotools builds and tests models of the galaxy-halo connection and analyzes catalogs of dark matter halos. The core functions of the package include fast generation of synthetic galaxy populations using HODs, abundance matching, and related methods; efficient algorithms for calculating galaxy clustering, lensing, z-space distortions, and other astronomical statistics; a modular, object-oriented framework for designing galaxy evolution models; and end-to-end support for reducing halo catalogs and caching them as hdf5 files.

HAM solves non-relativistic hyperbolic partial differential equations in conservative form using high-resolution shock-capturing techniques. This version of HAM has been configured to solve the magnetohydrodynamic equations of motion in axisymmetry to evolve a shearing box model.

The Hammurabi code is a publicly available C++ code for generating mock polarized observations of Galactic synchrotron emission with telescopes such as LOFAR, SKA, Planck, and WMAP, based on model inputs for the Galactic magnetic field (GMF), the cosmic-ray density distribution, and the thermal electron density. The Hammurabi code allows one to perform simulations of several different data sets simultaneously, providing a more reliable constraint of the magnetized ISM.

hankl implements the FFTLog algorithm in lightweight Python code. The FFTLog algorithm can be thought of as the Fast Fourier Transform (FFT) of a logarithmically spaced periodic sequence (= Hankel Transform). hankl consists of two modules, the General FFTLog module and the Cosmology one. The latter is suited for modern cosmological application and relies heavily on the former to perform the Hankel transforms. The accuracy of the method usually improves as the range of integration is enlarged; FFTlog prefers an interval that spans many orders of magnitude. Resolution is important, as low resolution introduces sharp features which in turn causes ringing.

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

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.

HARM uses a conservative, shock-capturing scheme for evolving the equations of general relativistic magnetohydrodynamics. The fluxes are calculated using the Harten, Lax, & van Leer scheme. A variant of constrained transport, proposed earlier by Tóth, is used to maintain a divergence-free magnetic field. Only the covariant form of the metric in a coordinate basis is required to specify the geometry. On smooth flows HARM converges at second order.

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.

harmonic learns an approximate harmonic mean estimator (referred to as a "learnt harmonic mean estimator") from posterior distribution samples to compute the marginal likelihood required for Bayesian model selection. Using a large number of independent Markov chain Monte Carlo (MCMC) chains from another package such as emcee (ascl:1303.002), harmonic uses importance sampling to learn a new target distribution in order to optimize an approximate harmonic estimator while minimizing its variance.

Harmony is a general numerical scheme for evaluating MBS emission and absorption coefficients for both polarized and unpolarized light in a plasma with a general distribution function.

HARMPI is a parallel, 3D version of HARM (ascl:1209.005), which solves hyperbolic partial differential equations in conservative form using high-resolution shock-capturing techniques. The code is parallelized using MPI and is fully operational in 3D. HARMPI, like HARM, is capable of using non-uniform grids and solves the relativistic magnetohydrodynamic equations of motion on a stationary black hole spacetime in Kerr-Schild coordinates to evolve an accretion disk model.

HawkingNet searches for Hawking points in large Cosmic Microwave Background (CMB) data sets. It is based on the deep residual network ResNet18 and consists of eighteen neural layers. Written in Paython, HawkingNet inputs the CMB data, processes the data through its internal network trained for data classification, and outputs the result in a form of a classification score that indicates how confident it is that a Hawking point is contained in the image patch.

HAYASHI (Halo-level AnalYsis of the Absorption Signal in HI) computes the number of absorption features of the 21cm forest using a semianalytic formalism. It includes the enhancement of the signal due to the presence of substructures within minihalos and supports non-standard cosmologies with impact in the large scale structure, such as warm dark matter and primordial black holes. HAYASHI is written in Python3 and uses the cosmological computations package Colossus (ascl:1501.016).

A big challenge in solar and stellar physics in the coming years will be to decipher the magnetism of the solar outer atmosphere (chromosphere and corona) along with its dynamic coupling with the magnetic fields of the underlying photosphere. To this end, it is important to develop rigorous diagnostic tools for the physical interpretation of spectropolarimetric observations in suitably chosen spectral lines. HAZEL is a computer program for the synthesis and inversion of Stokes profiles caused by the joint action of atomic level polarization and the Hanle and Zeeman effects in some spectral lines of diagnostic interest, such as those of the He I 1083.0 nm and 587.6 nm (or D3) multiplets. It is based on the quantum theory of spectral line polarization, which takes into account in a rigorous way all the relevant physical mechanisms and ingredients (optical pumping, atomic level polarization, level crossings and repulsions, Zeeman, Paschen-Back and Hanle effects). The influence of radiative transfer on the emergent spectral line radiation is taken into account through a suitable slab model. The user can either calculate the emergent intensity and polarization for any given magnetic field vector or infer the dynamical and magnetic properties from the observed Stokes profiles via an efficient inversion algorithm based on global optimization methods.

Hazma enables indirect detection of sub-GeV dark matter. It computes gamma-ray and electron/positron spectra from dark matter annihilations, sets limits on sub-GeV dark matter using existing gamma-ray data, and determines the discovery reach of future gamma-ray detectors. The code also derives accurate CMB constraints. Hazma comes with several sub-GeV dark matter models, for which it provides functions to compute dark matter annihilation cross sections and mediator decay widths. A variety of low-level tools are provided to make it straightforward to define new models.

HBT is a Hierarchical Bound-Tracing subhalo finder and merger tree builder, for numerical simulations in cosmology. It tracks haloes from birth and continues to track them after mergers, finding self-bound structures as subhaloes and recording their merger histories as merger trees.

HBT+ is a hybrid subhalo finder and merger tree builder for cosmological simulations. It comes as an MPI edition that can be run on distributed clusters or shared memory machines and is MPI/OpenMP parallelized, and also as an OpenMP edition that can be run on shared memory machines and is only OpenMP parallelized. This version is more memory efficient than the MPI branch on shared memory machines, and is more suitable for analyzing zoomed-in simulations that are difficult to balance on distributed clusters. Both editions support hydro simulations with gas/stars.

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.

HDMSpectra computes the decay spectrum for dark matter with masses above the scale of electroweak symmetry breaking, down to Planck scale and including all relevant electroweak interactions. The code determines the distribution of stable states for photons, neutrinos, positrons, and antiprotons.

The Hierarchical Data System (HDS) is a file-based hierarchical data system designed for the storage of a wide variety of information. It is particularly suited to the storage of large multi-dimensional arrays (with their ancillary data) where efficient access is needed. It is a key component of the Starlink software collection (ascl:1110.012) and is used by the Starlink N-Dimensional Data Format (NDF) library (ascl:1411.023).

HDS organizes data into hierarchies, broadly similar to the directory structure of a hierarchical filing system, but contained within a single HDS container file. The structures stored in these files are self-describing and flexible; HDS supports modification and extension of structures previously created, as well as functions such as deletion, copying, and renaming. All information stored in HDS files is portable between the machines on which HDS is implemented. Thus, there are no format conversion problems when moving between machines. HDS can write files in a private binary format (version 4), or be layered on top of HDF5 (version 5).

HEADSS (HiErArchical Data Splitting and Stitching) facilitates clustering at scale, unlike clustering algorithms that scale poorly with increased data volume or that are intrinsically non-distributed. HEADSS automates data splitting and stitching, allowing repeatable handling, and removal, of edge effects. Implemented in conjunction with scikit's HDBSCAN, the code achieves orders of magnitude reduction in single node memory requirements for both non-distributed and distributed implementations, with the latter offering similar order of magnitude reductions in total run times while recovering analogous accuracy. HEADSS also establishes a hierarchy of features by using a subset of clustering features to split the data.

HEALPix is an acronym for Hierarchical Equal Area isoLatitude Pixelization of a sphere. As suggested in the name, this pixelization produces a subdivision of a spherical surface in which each pixel covers the same surface area as every other pixel. Another property of the HEALPix grid is that the pixel centers occur on a discrete number of rings of constant latitude, the number of constant-latitude rings is dependent on the resolution of the HEALPix grid.

Healpix.jl is a Julia-only port of the C/C++/Fortran/Python HEALPix library (ascl:1107.018), which implements a hierarchical pixelization of the sphere in equal-area pixels. Much like the original library, Healpix.jl supports two enumeration schemes for the pixels (RING and NESTED) and implements an optimized computation of the generalized Fourier transform using spherical harmonics, binding libsharp2 (ascl:1402.033). In addition, Healpix.jl provides four additional features: 1.) it fully supports Windows systems, alongside the usual Linux and MAC OS X machines; 2.) it uses Julia's strong typesystem to prevent several bugs related to mismatches in map ordering (e.g., combining a RING map with a NESTED map); 3.) it uses a versatile memory layout so that map bytes can be stored in shared memory objects or on GPUs; and 4.) it implements an elegant and general way to signal missing values in maps.

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.

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

HEARSAY computes simulations of the causal contacts between emitters in the Galaxy. It implements the Stochastic Constrained Causal Contact Network (SC3Net) model and explores the parameter space of the model for the emergence of communicating nodes through Monte Carlo simulations and analyzes their causal connections. This model for the abundance and duration of civilizations is based on minimal assumptions and three free parameters, with focus on the statistical properties of empirical models instead of an interpretable model with variables to be determined by observation.

HEASOFT combines XANADU, high-level, multi-mission software for X-ray astronomical spectral, timing, and imaging data analysis tasks, and FTOOLS (ascl:9912.002), general and mission-specific software to manipulate FITS files, into one package. It also contains contains the NuSTAR subpackage of tasks, NuSTAR Data Analysis Software (NuSTARDAS). The source code for the software can be downloaded; precompiled executables for the most widely used computer platforms are also available for download. As an additional service, HEAsoft tasks can be directly from a web browser via WebHera.

HEATCVB is a stand-alone Fortran 77 subroutine that estimates the local volumetric coronal heating rate with four required inputs: the radial distance r, the wind speed u, the mass density ρ, and the magnetic field strength |B0|. The primary output is the heating rate Qturb at the location defined by the input parameters. HEATCVB also computes the local turbulent dissipation rate of the waves, γ = Qturb/(2UA).

HeatingRate calculates the nuclear heating rates [erg/s/g] of beta-decay, alpha-decay, and spontaneous fission of r-process nuclei, taking into account for thermalization of gamma-rays and charged decay products in r-process ejecta. It uses the half-lives and injection energy spectra from an evaluated nuclear data library (ENDF/B-VII.1). Each heating rate is computed for given abundances, ejecta mass, velocity, and density profile. HeatingRate also computes the bolometric light curve and the evolution of the effective temperature for given abundances, ejecta mass, velocity, and density profile assuming opacities independent of the wavelength.

HELA performs atmospheric retrieval on exoplanet atmospheres using a Random Forest algorithm. The code has two stages: training (which includes testing), and predicting. It requires a training set that matches the format of the data to be analyzed, with the same number of points and a sample spectrum for each parameter. The number of trees used and the number of jobs are editable. The HELA package includes a training set and data as examples.

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

HELIOS-K is an opacity calculator for exoplanetary atmospheres. It takes a line list as an input and computes the line shapes of an arbitrary number of spectral lines (~millions to billions). HELIOS-K is capable of computing 100,000 spectral lines in 1 second; it is written in CUDA, is optimized for graphics processing units (GPUs), and can be used with the HELIOS radiative transfer code (ascl:1807.009).

Helios-r2 performs atmospheric retrieval of brown dwarf and exoplanet spectra. It uses a Bayesian statistics approach by employing a nested sampling method to generate posterior distributions and calculate the Bayesian evidence. The nested sampling itself is done by Multinest (ascl:1109.006). The computationally most demanding parts of the model have been written in NVIDIA's CUDA language for an increase in computational speed. Successful applications include retrieval of brown dwarf emission spectra and secondary eclipse measurements of exoplanets.

HELIOS, a radiative transfer code, is constructed for studying exoplanetary atmospheres. The model atmospheres of HELIOS are one-dimensional and plane-parallel, and the equation of radiative transfer is solved in the two-stream approximation with non-isotropic scattering. Though HELIOS can be used alone, the opacity calculator HELIOS-K (ascl:1503.004) can be used with it to provide the molecular opacities.

HENDRICS, a rewrite and update to MaLTPyNT (ascl:1502.021), contains command-line scripts based on Stingray (ascl:1608.001) to perform a quick-look (spectral-)timing analysis of X-ray data, treating the gaps in the data due, e.g., to occultation from the Earth or passages through the SAA, properly. Despite its original main focus on NuSTAR, HENDRICS can perform standard aperiodic timing analysis on X-ray data from, in principle, any other satellite, and its features include power density and cross spectra, time lags, pulsar searches with the Epoch folding and the Z_n^2 statistics, color-color and color-intensity diagrams. The periodograms produced by HENDRICS (such as a power density spectrum or a cospectrum) can be saved in a format compatible with XSPEC (ascl:9910.005) or ISIS (ascl:1302.002).

The hera_opm package provides a convenient and flexible framework for developing data analysis pipelines for operating on a sequence of input files. Though developed for application to the Hydrogen Epoch of Reionization Array (HERA), it is a general package that can be applied to any workflow designed to apply a series of analysis steps to any type of files. It is also portable, operating both on a diversity of computer clusters with batch submission systems and local machines.

HERACLES is a 3D hydrodynamical code used to simulate astrophysical fluid flows. It uses a finite volume method on fixed grids to solve the equations of hydrodynamics, MHD, radiative transfer and gravity. This software is developed at the Service d'Astrophysique, CEA/Saclay as part of the COAST project and is registered under the CeCILL license. HERACLES simulates astrophysical fluid flows using a grid based Eulerian finite volume Godunov method. It is capable of simulating pure hydrodynamical flows, magneto-hydrodynamic flows, radiation hydrodynamic flows (using either flux limited diffusion or the M1 moment method), self-gravitating flows using a Poisson solver or all of the above. HERACLES uses cartesian, spherical and cylindrical grids.

Herculens models imaging data of strong gravitational lenses. The package supports various degrees of model complexity, ranging from standard smooth analytical profiles to pixelated models and machine learning approaches. In particular, it implements multiscale pixelated models regularized with sparsity constraints and wavelet decomposition, for modeling both the source light distribution and the lens potential. The code is fully differentiable - based on JAX (ascl:2111.002) - which enables fast convergence to the solution, access to the parameters covariance matrix, efficient exploration of the parameter space including the sampling of posterior distributions using variational inference or Hamiltonian Monte-Carlo methods.

The HERMES (High-Energy Radiative MESsengers) computational framework for line of sight integration creates sky maps in the HEALPix-compatibile format of various galactic radiative processes, including Faraday rotation, synchrotron and free-free radio emission, gamma-ray emission from pion-decay, bremsstrahlung and inverse-Compton. The code is written in C++ and provides numerous integrators, including dispersion measure, rotation measure, and Gamma-ray emissions from Dark Matter annihilation, among others.

hfof is a 3-d friends-of-friends (FoF) cluster finder with Python bindings based on a fast spatial hashing algorithm that identifies connected sets of points where the point-wise connections are determined by a fixed spatial distance. This technique sorts particles into fine cells sufficiently compact to guarantee their cohabitants are linked, and uses locality sensitive hashing to search for neighboring (blocks of) cells. Tests on N-body simulations of up to a billion particles exhibit speed increases of factors up to 20x compared with FOF via trees, and is consistently complete in less than the time of a k-d tree construction, giving it an intrinsic advantage over tree-based methods.

hfs_fit performs parameter optimization in the analysis of emission line hyperfine structure (HFS). The code uses a simulated annealing algorithm to optimize the magnetic dipole interaction constants, electric quadrupole interaction constants, Voigt profile widths and the center of gravity wavenumber for a given emission line profile. The fit can be changed visually with sliders for parameters, which is useful when HFS constants are unknown.

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

hh0 is a Bayesian hierarchical model (BHM) that describes the full distance ladder, from nearby geometric-distance anchors through Cepheids to SNe in the Hubble flow. It does not rely on any of the underlying distributions being Gaussian, allowing outliers to be modeled and obviating the need for any arbitrary data cuts.

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

hi_class implements Horndeski's theory of gravity in the modern Cosmic Linear Anisotropy Solving System (ascl:1106.020). It can be used to compute any cosmological observable at the level of background or linear perturbations, such as cosmological distances, cosmic microwave background, matter power and number count spectra (including relativistic effects). hi_class can be readily interfaced with Monte Python (ascl:1307.002) to test Gravity and Dark Energy models.

Hi-COLA runs fast approximate N-body simulations of non-linear structure formation in reduced Horndeski gravity (Horndeski theories with luminal gravitational waves). It is generic with respect to the reduced Horndeski class. Given an input Lagrangian, Hi-COLA's front-end dynamically constructs the appropriate field equations and consistently solves for the cosmological background, linear growth, and screened fifth force of that theory. This is passed to the back-end, which runs a hybrid N-body simulation at significantly reduced computational and temporal cost compared to traditional N-body codes. By analyzing the particle snapshots, one can study the formation of structure through statistics such as the matter power spectrum.

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

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

hierArc hierarchically infers strong lensing mass density profiles and the cosmological parameters, in particular the Hubble constant. The software supports lenses with imaging data and kinematics, and optionally time delays. The kinematics modeling is performed in conjunction with lenstronomy (ascl:1804.012).

HiFLEx reduces echelle data taken with a single or bifurcated fiber input. It takes a FITS image file (i.e., a CCD image) and runs data reduction steps, extracts out orders from an Echelle spectrograph (regardless of separation and curvature, as long as orders are distinguishable from one-another), applies the wavelength correction, measures the radial velocity, and performs further calibration steps.

HiGal SED Fitter fits modified blackbody SEDs to Herschel data, specifically targeted at Herschel Hi-Gal data.

HiGPUs is an implementation of the numerical integration of the classical, gravitational, N-body problem, based on a 6th order Hermite’s integration scheme with block time steps, with a direct evaluation of the particle-particle forces. The main innovation of this code is its full parallelization, exploiting both OpenMP and MPI in the use of the multicore Central Processing Units as well as either Compute Unified Device Architecture (CUDA) or OpenCL for the hosted Graphic Processing Units. We tested both performance and accuracy of the code using up to 256 GPUs in the supercomputer IBM iDataPlex DX360M3 Linux Infiniband Cluster provided by the italian supercomputing consortium CINECA, for values of N ≤ 8 millions. We were able to follow the evolution of a system of 8 million bodies for few crossing times, task previously unreached by direct summation codes.

HiGPUs is also available as part of the AMUSE project.

HII-CHI-mistry_UV derives oxygen and carbon abundances using the ultraviolet (UV) lines emitted by the gas phase ionized by massive stars. The code first fixes C/O using ratios of appropriate emission lines and, in a second step, calculates O/H and the ionization parameter from carbon lines in the UV. An optical version of this Python code, HII-CHI-mistry (ascl:1807.007), is also available.

HII-CHI-mistry calculates the oxygen abundance for gaseous nebulae ionized by massive stars using optical collisionally excited emission lines. This code takes the extinction-corrected emission line fluxes and, based on a Χ² minimization on a photoionization models grid, determines chemical-abundances (O/H, N/O) and ionization parameters. An ultraviolet version of this Python code, HII-CHI-mistry-UV (ascl:1807.008), is also available.

HIIexplorer detects and extracts the integrated spectra of HII regions from IFS datacubes. The procedure assumes H ii regions are peaky/isolated structures with a strong ionized gas emission, clearly above the continuum emission and the average ionized gas emission across the galaxy and that H ii regions have a typical physical size of about a hundred or a few hundreds of parsecs, which corresponds to a typical projected size at the distance of the galaxies of a few arcsec for galaxies at z~0.016. All input parameters can be derived from either a visual inspection and/or a statistical analysis of the Hα emission line map. The algorithm produces a segmentation FITS file describing the pixels associated to each H ii region. A newer version of this code, pyHIIexplorer (ascl:2206.010), is available.

HIIPHOT enables accurate photometric characterization of H II regions while permitting genuine adaptivity to irregular source morphology. It makes a first guess at the shapes of all sources through object recognition techniques; it then allows for departure from such idealized "seeds" through an iterative growing procedure and derives photometric corrections for spatially coincident diffuse emission from a low-order surface fit to the background after exclusion of all detected sources.

Hilal-Obs authenticates lunar crescent first visibility reports. The code, written in Python, uses PyEphem (ascl:1112.014) for astrometrics, and takes into account all the factors that affect lunar crescent visibility, including atmospheric extinction, observer physiology, sky and lunar brightness, contrast threshold, and the type of observation.

HilalPy analyzes lunar crescent visibility criteria. Written in Python, the code uses more than 8000 lunar crescent visibility records extracted from literature and websites of lunar crescent observation, descriptive statistics, contradiction rate percentage, and regression analysis in its analysis to predict the visibility of a lunar crescent.

HiLLiPoP is a multifrequency CMB likelihood for Planck data. The likelihood is a spectrum-based Gaussian approximation for cross-correlation spectra from Planck 100, 143 and 217GHz split-frequency maps, with semi-analytic estimates of the Cl covariance matrix based on the data. The cross-spectra are debiased from the effects of the mask and the beam leakage using Xpol (ascl:2301.009) before being compared to the model, which includes CMB and foreground residuals. They cover the multipoles from ℓ=30 to ℓ=2500. HiLLiPoP is interfaced with the Cobaya (ascl:1910.019) MCMC sampler.

The Herschel Space Observatory is the fourth cornerstone mission in the ESA science programme and performs photometry and spectroscopy in the 55 - 672 micron range. The development of the Herschel Data Processing System started in 2002 to support the data analysis for Instrument Level Tests. The Herschel Data Processing System was used for the pre-flight characterisation of the instruments, and during various ground segment test campaigns. Following the successful launch of Herschel 14th of May 2009 the Herschel Data Processing System demonstrated its maturity when the first PACS preview observation of M51 was processed within 30 minutes of reception of the first science data after launch. Also the first HIFI observations on DR21 were successfully reduced to high quality spectra, followed by SPIRE observations on M66 and M74. A fast turn-around cycle between data retrieval and the production of science-ready products was demonstrated during the Herschel Science Demonstration Phase Initial Results Workshop held 7 months after launch, which is a clear proof that the system has reached a good level of maturity.

HIPP (HIgh-Performance Package for scientific computation) provides elegant interfaces for some well-known HPC libraries. Some libraries are wrapped with full-OOP interfaces, and many new extensions based on those raw-interfaces are also provided. This C++ toolkit for HPC can significantly reduce the length of your code, making programming more productive.

HIPSTER (HIgh-k Power Spectrum EstimatoR) computes small-scale power spectra and isotropic bispectra for cosmological simulations and galaxy surveys of arbitrary shape. The code computes the Legendre multipoles of the power spectrum, P_ℓ(k), or bispectrum B_ℓ(k₁,k₂), by computing weighted pair counts over the simulation box or survey, truncated at some maximum radius. The code can be run either in 'aperiodic' or 'periodic' mode for galaxy surveys or cosmological simulations respectively. HIPSTER also supports weighted spectra, for example when tracer particles are weighted by their mass in a multi-species simulation. Generalization to anisotropic bispectra is straightforward (and requires no additional computing time) and can be added on request.

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

Hitomi provides a comprehensive set of codes for cosmological analysis of anisotropic galaxy distributions using two- and three-point statistics: two-point correlation function (2PCF), power spectrum, three-point correlation function (3PCF), and bispectrum. The code can measure the Legendre-expanded 2PCF and power spectrum from an observed sample of galaxies, and can measure the 3PCF and bispectrum expanded using the Tripolar spherical harmonic (TripoSH) function. Hitomi is basically a serial code, but can also implement MPI parallelization. Hitomi uses MPI to read multiple different input parameters simultaneously.

HLattice simulates scalar fields and gravity in the early universe. The code allows the user to select between symplectic integrators, descretization schemes, and metrics such as Minkowski or FRW backgrounds and adaptice schemes in an "all-in-one" configuration file.

HLINOP is a collection of codes for computing hydrogen line profiles and opacities in the conditions typical of stellar atmospheres. It includes HLINOP for approximate quick calculation of any line of neutral hydrogen (suitable for model atmosphere calculations), based on the Fortran code of Kurucz and Peterson found in ATLAS9. It also includes HLINPROF, for detailed, accurate calculation of lower Balmer line profiles (suitable for detailed analysis of Balmer lines) and HBOP, to implement the occupation probability formalism of Daeppen, Anderson and Milhalas (1987) and thus account for the merging of bound-bound and bound-free opacity (used often as a wrapper to HLINOP for model atmosphere calculations).

HMcode computes the halo-model matter power spectrum. It is written in Fortran90 and has been designed to quickly (~0.5s for 200 k-values across 16 redshifts on a single core) produce matter spectra for a wide range of cosmological models. In testing it was shown to match spectra produced by the 'Coyote Emulator' to an accuracy of 5 per cent for k less than 10h Mpc^-1. However, it can also produce spectra well outside of the parameter space of the emulator.

HMF calculates the Halo Mass Function (HMF) given any set of cosmological parameters and fitting function and serves as the backend for the web application HMFcalc. Written in Python, it allows for dynamic accurate calculation of the transfer function with CAMB (ascl:1102.026) and efficient and self-consistent parameter updates. HMF offers exploration of the effects of cosmological parameters, redshift and fitting function on the predicted HMF.

HNBody is a new set of software utilities geared to the integration of hierarchical (nearly-Keplerian) N-body systems. Our focus is on symplectic methods, and we have included explicit support for three classes of particles (heavy, light, and massless), second and fourth order methods, post-Newtonian corrections, and the use of a symplectic corrector (among other things). For testing purposes, we also provide support for more general integration schemes (Bulirsch-Stoer & Runge-Kutta). Configuration files employing an intuitive syntax allow for easy problem setup, and many simple simulations can be done without the user compiling any code. Low-level interfaces are also available, enabling extensive customization.

HO-CHUNK calculates radiative equilibrium temperature solution, thermal and PAH/vsg emission, scattering and polarization in protostellar geometries. It is useful for computing spectral energy distributions (SEDs), polarization spectra, and images.

HOCHUNK3D is an updated version of the HOCHUNK radiative equilibrium code (ascl:1711.013); the code has been converted to Fortran 95, which allows a specification of one-dimensional (1D), 2D, or 3D grids at runtime. The code is parallelized so it can be run on multiple processors on one machine, or on multiple machines in a network. It includes 3-D functionality and several other additional geometries and features. The code calculates radiative equilibrium temperature solution, thermal and PAH/vsg emission, scattering and polarization in protostellar geometries. HOCHUNK3D also computes spectral energy distributions (SEDs), polarization spectra, and images.

HoloSim-ML performs beam simulation and analysis of radio holography data from complex optical systems. The code uses machine learning to efficiently determine the position of hundreds of mirror adjusters on multiple mirrors with few micron accuracy.

HOMER (Helper Of My Eternal Retrievals) is a machine-learning-accelerated Bayesian inverse modeling code. Given some data and uncertainties, the code determines the posterior distribution of a model. HOMER uses MC³ (ascl:1610.013) for its MCMC; its forward model is a neural network surrogate model trained by MARGE (ascl:2003.010). The code produces plots of the 1D marginalized posteriors, 2D pairwise posteriors, and parameter history traces, and can also overplot the 1D and 2D posteriors for comparison with another posterior. HOMER computes the Bhattacharyya coefficient to compare the similarity of two 1D marginalized posteriors.

We describe a new method (HOP) for identifying groups of particles in N-body simulations. Having assigned to every particle an estimate of its local density, we associate each particle with the densest of the Nh particles nearest to it. Repeating this process allows us to trace a path, within the particle set itself, from each particle in the direction of increasing density. The path ends when it reaches a particle that is its own densest neighbor; all particles reaching the same such particle are identified as a group. Combined with an adaptive smoothing kernel for finding the densities, this method is spatially adaptive, coordinate-free, and numerically straight-forward. One can proceed to process the output by truncating groups at a particular density contour and combining groups that share a (possibly different) density contour. While the resulting algorithm has several user-chosen parameters, we show that the results are insensitive to most of these, the exception being the outer density cutoff of the groups.

HOPE is a specialized Python just-in-time (JIT) compiler designed for numerical astrophysical applications. HOPE focuses on a subset of the language and is able to translate Python code into C++ while performing numerical optimization on mathematical expressions at runtime. To enable the JIT compilation, the user only needs to add a decorator to the function definition. By using HOPE, the user benefits from being able to write common numerical code in Python while getting the performance of compiled implementation.

HOPS (Haystack Observatory Postprocessing System) analyzes the data generated by DiFX VLBI correlators. It is written in C for Linux computers, and emphasizes quality-control aspects of data processing. It sits between the correlator and an image-processing and/or geodetic-processing package, and performs basic fringe-fitting, data editing, problem diagnosis, and correlator support functions.

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.

HOTPANTS (High Order Transform of PSF ANd Template Subtraction) implements the Alard 1999 algorithm for image subtraction. It photometrically aligns one input image with another after they have been astrometrically aligned.

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

Generate simulated radio recombination line observations of HII regions with various internal kinematic structure. Fit single Gaussians to each pixel of the simulated observations and generate images of the fitted Gaussian center and full-width half-maximum (FWHM) linewidth.

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

Hrothgar is a parallel minimizer and Markov Chain Monte Carlo generator. It has been used to solve optimization problems in astrophysics (galaxy cluster mass profiles) as well as in experimental particle physics (hadronic tau decays).

HSIM simulates observations with HARMONI on the Extremely Large Telescope. HSIM takes high spectral and spatial resolution input data cubes, encoding physical descriptions of astrophysical sources, and generates mock observed data cubes. The simulations incorporate detailed models of the sky, telescope, instrument, and detectors to produce realistic mock data. HSIM performs in-depth simulations for several key science cases as part of the design and development of the HARMONI integral field spectrograph, including the ELT AO performance, atmospheric effects and realistic detector statistics.

The Hough Stream Spotter (HSS) is a stream finding code which transforms individual positions of stars to search for linear structure in discrete data sets. The code requires only the two-dimensional plane of galactic longitude and latitude as input.

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.

HTOF parses the intermediate data from Hipparcos and Gaia and fits astrometric solutions to those data. It computes likelihoods and parameter errors in line with the catalog and can reproduce five, seven, and nine (or higher) parameter fits to their astrometry.

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

HumVI creates a composite color image from sets of input FITS files, following the Lupton et al (2004, ascl:1511.013) composition algorithm. Written in Python, it takes three FITS files as input and returns a color composite, color-saturated png image with an arcsinh stretch. HumVI reads the zero points out of the FITS headers and uses them to put all the images on the same flux scale; photometrically calibrated images produce the best results.

We describe the first parallel implementation of an adaptive particle-particle, particle-mesh code with smoothed particle hydrodynamics. Parallelisation of the serial code, "Hydra," is achieved by using CRAFT, a Cray proprietary language which allows rapid implementation of a serial code on a parallel machine by allowing global addressing of distributed memory.

The collisionless variant of the code has already completed several 16.8 million particle cosmological simulations on a 128 processor Cray T3D whilst the full hydrodynamic code has completed several 4.2 million particle combined gas and dark matter runs. The efficiency of the code now allows parameter-space explorations to be performed routinely using $64^3$ particles of each species. A complete run including gas cooling, from high redshift to the present epoch requires approximately 10 hours on 64 processors.

HydraLens generates gravitational lens model files for Lenstool (ascl:1102.004), PixeLens (ascl:1102.007), glafic (ascl:1010.012) and Lensmodel and can also translate lens model files among these four lens model codes. Through a GUI, the user enters a new model by specifying the type of model and is then led through screens to collect the data. Written in MS Visual Basic, the code can also translate an existing model from any of the four supported codes to any of the other three.

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.

The R package Hyper-Fit fits hyperplanes (hyper.fit) and creates 2D/3D visualizations (hyper.plot2d / hyper.plot3d) to produce robust 1D linear fits for 2D x vs y type data, and robust 2D plane fits to 3D x vs y vs z type data. This hyperplane fitting works generically for any N-1 hyperplane model being fit to a N dimensional dataset. All fits include intrinsic scatter in the generative model orthogonal to the hyperplane. A web interface for online fitting is also available at http://hyperfit.icrar.org.

Hyperas is a convenience wrapper around hyperopt (ascl:2205.008) for fast prototyping with keras models (ascl:1806.022). Hyperas lets you use the power of hyperopt without having to learn the syntax of it. Instead, just define your keras model as you are used to, but use a simple template notation to define hyper-parameter ranges to tune.

Hyperion is a three-dimensional dust continuum Monte-Carlo radiative transfer code that is designed to be as generic as possible, allowing radiative transfer to be computed through a variety of three-dimensional grids. The main part of the code is problem-independent, and only requires an arbitrary three-dimensional density structure, dust properties, the position and properties of the illuminating sources, and parameters controlling the running and output of the code. Hyperion is parallelized, and is shown to scale well to thousands of processes. Two common benchmark models for protoplanetary disks were computed, and the results are found to be in excellent agreement with those from other codes. Finally, to demonstrate the capabilities of the code, dust temperatures, SEDs, and synthetic multi-wavelength images were computed for a dynamical simulation of a low-mass star formation region.

The Python library Hyperopt performs serial and parallel optimization over awkward search spaces, which may include real-valued, discrete, and conditional dimensions. Three algorithms are implemented in hyperopt: Random Search, Tree of Parzen Estimators (TPE), and Adaptive TPE. Algorithms can be parallelized in two ways, using either Apache Spark or MongoDB. To use Hyperopt, the objective function to minimize and the space over which to search, and the database in which to store all the point evaluations of the search have to be described, and the search algorithm to use has to be specified.

From a photometric catalogue, hyperz finds the redshift of each object by means of a standard SED fitting procedure, i.e. comparing the observed magnitudes with the expected ones, computed from template Spectral Energy Distributions. The set of templates used in the minimization procedure (age, metallicity, reddening, absorption in the Lyman forest, ...) is studied in detail, through both real and simulated data. The expected accuracy of photometric redshifts, as well as the fraction of catastrophic identifications and wrong detections, is given as a function of the redshift range, the set of filters considered, and the photometric accuracy. Special attention is paid to the results expected from real data.

HyPhy maps from dark matter only simulations to full hydrodynamical physics models. It uses a fully convolutional variational auto-encoder (VAE) to synthesize hydrodynamic fields conditioned on dark matter fields from N-body simulations. After training, HyPhy can probabilistically map new dark matter only simulations to corresponding full hydrodynamical outputs and generate posterior samples for studying the variance of the mapping. This conditional deep generative model is implemented in TensorFlow.

We present a state-of-the-art primordial recombination code, HyRec, including all the physical effects that have been shown to significantly affect recombination. The computation of helium recombination includes simple analytic treatments of hydrogen continuum opacity in the He I 2 1P - 1 1S line, the He I] 2 3P - 1 1S line, and treats feedback between these lines within the on-the-spot approximation. Hydrogen recombination is computed using the effective multilevel atom method, virtually accounting for an infinite number of excited states. We account for two-photon transitions from 2s and higher levels as well as frequency diffusion in Lyman-alpha with a full radiative transfer calculation. We present a new method to evolve the radiation field simultaneously with the level populations and the free electron fraction. These computations are sped up by taking advantage of the particular sparseness pattern of the equations describing the radiative transfer. The computation time for a full recombination history is ~2 seconds. This makes our code well suited for inclusion in Monte Carlo Markov chains for cosmological parameter estimation from upcoming high-precision cosmic microwave background anisotropy measurements.

This IDL library is designed to be used on astronomical images. Its main aim is to stack data to allow a statistical detection of faint signal, using a prior. For instance, you can stack 160um data using the positions of galaxies detected at 24um or 3.6um, or use WMAP sources to stack Planck data. It can estimate error bars using bootstrap, and it can perform photometry (aperture photometry, or PSF fitting, or other that you can plug). The IAS Stacking Library works with gnomonic projections (RA---TAN), and also with HEALPIX projection.

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

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

ICORE is a command-line driven co-addition, mosaicking, and resolution enhancement (HiRes) tool for creating science quality products from image data in FITS format and with World Coordinate System information following the FITS-WCS standard. It includes preparatory steps such as image background matching, photometric gain-matching, and pixel-outlier rejection. Co-addition and/or HiRes'ing can be performed in either the inertial WCS or in the rest frame of a moving object. Three interpolation methods are supported: overlap-area weighting, drizzle, and weighting by the detector Point Response Function (PRF). The latter enables the creation of matched-filtered products for optimal point-source detection, but most importantly allows for resolution enhancement using a spatially-dependent deconvolution method. This is a variant of the classic Richardson-Lucy algorithm with the added benefit to simultaneously register and co-add multiple images to optimize signal-to-noise and sampling of the instrumental PSF. It can assume real (or otherwise "flat") image priors, mitigate "ringing" artifacts, and assess the quality of image solutions using statistically-motivated convergence criteria. Uncertainties are also estimated and internally validated for all products. The software supports multithreading that can be configured for different architectures. Numerous example scripts are included (with test data) to co-add and/or HiRes image data from Spitzer-IRAC/MIPS, WISE, and Herschel-SPIRE.

What is the best way to pixelize a sphere? This question occurs in many practical applications, for instance when making maps (of the earth or the celestial sphere) and when doing numerical integrals over the sphere. This package consists of source code and documentation for a method which involves inscribing the sphere in a regular icosahedron and then equalizing the pixel areas.

iCosmo is a software package to perform interactive cosmological calculations for the low redshift universe. The computation of distance measures, the matter power spectrum, and the growth factor is supported for any values of the cosmological parameters. It also performs the computation of observables for several cosmological probes such as weak gravitational lensing, baryon acoustic oscillations and supernovae. The associated errors for these observables can be derived for customised surveys, or for pre-set values corresponding to current or planned instruments. The code also allows for the calculation of cosmological forecasts with Fisher matrices which can be manipulated to combine different surveys and cosmological probes. The code is written in the IDL language and thus benefits from the convenient interactive features and scientific library available in this language. iCosmo can also be used as an engine to perform cosmological calculations in batch mode, and forms a convenient evolutive platform for the development of further cosmological modules. With its extensive documentation, it may also serve as a useful resource for teaching and for newcomers in the field of cosmology.

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

iDealCam is an IDL GUI toolkit for processing multi-extension FITS file produced by CanariCam, the facility mid-IR instrument of Gran Telescopio CANARIAS (GTC). iDealCam is optimized for CanariCam data, but is also compatible with data generated by other instruments using similar detectors and data format (e.g., Michelle and T-ReCS at Gemini). iDealCam provides essential capabilities to examine, reduce, and analyze data obtained in the standard imaging or polarimetric imaging mode of CanariCam.

Idefix solves non-relativistic HD and MHD equations on various grid geometries. Based on a Godunov finite-volume method, this astrophysical flows code includes a wide choice of solvers and several modules, including constrained transport, orbital advection, and non-ideal MHD, to address complex astrophysical and fluid dynamics applications. Written in C++, Idefix relies on the Kokkos meta-programming library to guarantee performance portability on a wide variety of architectures.

By combining test-particle and self-consistent techniques, we have developed a method to rapidly explore the parameter space of galactic encounters. Our method, implemented in an interactive graphics program, can be used to find the parameters required to reproduce the observed morphology and kinematics of interacting disk galaxies. We test this system on an artificial data-set of 36 equal-mass merging encounters, and show that it is usually possible to reproduce the morphology and kinematics of these encounters and that a good match strongly constrains the encounter parameters. An update to this software with additional capabilities, Identikit 2 (ascl:1102.011), is available.

Using a combination of self-consistent and test-particle techniques, Identikit 1 (ascl:1011.001) provided a way to vary the initial geometry of a galactic collision and instantly visualize the outcome. Identikit 2 uses the same techniques to define a mapping from the current morphology and kinematics of a tidal encounter back to the initial conditions. By requiring that various regions along a tidal feature all originate from a single disc with a unique orientation, this mapping can be used to derive the initial collision geometry. In addition, Identikit 2 offers a robust way to measure how well a particular model reproduces the morphology and kinematics of a pair of interacting galaxies. A set of eight self-consistent simulations is used to demonstrate the algorithm's ability to search a ten-dimensional parameter space and find near-optimal matches; all eight systems are successfully reconstructed.

IDG (Image Domain Gridding) is an imager that makes w-term corrections and a-term corrections computationally very cheap. It works with WSClean (ascl:1408.023) and supports the same cleaning and data selections options that WSClean offers in normal mode (such as cotton-schwab, multi-frequency multi-scale cleaning, and auto-masking). IDG also allows gridding with a time-variable beam including the LOFAR, AARTFAAC and MWA beam and can perform full beam or differential correction. The code requires measurement sets with four polarizations (e.g. XX/XY/YX/YY), can apply a spatially varying time-variable TEC term that can additionally be different for different antennas and output channels, and performs extremely well on GPUs.

Spectrum created by energy release in the early Universe, before recombination, creates distortions which are a superposition of μ-type, y-type and intermediate-type distortions. The final spectrum can thus be constructed from the templates, once energy injection rate as a function of redshift is known. This package contains the templates spaced at dy=0.001 for y<1 and dy=0.01 for y>1 covering a range 0.001 < y < 10. Also included is a Mathematica code which can combine these templates for user-defined rate of energy injection as a function of redshift. Silk damping, particle decay and annihilation examples are also included.

IEHI, written in Fortran, outputs a simple "coronal" ionization equilibrium (i.e., collisional ionization and auto-ionization balanced by radiative and dielectronic recombination) for a plasma at a given electron temperature.

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.

IFrIT (Ionization FRont Interactive Tool) is a powerful general purpose visualization tool that can be used to visualize 3-dimensional data sets. IFrIT is written in C++ and is based on the Visualization ToolKit (VTK) and, optionally, uses a GUI toolkit Qt. IFrIT can visualize scalar, vector field, tensor, and particle data. Several visualization windows can exist at the same time, each one having a full set of visualization objects. Some visualization windows can share the data between them, while other windows can be fully independent. Images from several visualization windows can be combined into one image file on the disk, tiling some windows together, and inserting reduced versions of some windows into larger other windows. A large array of features is also available, including highly advanced animation capabilities, a complex set of lights, markers to label various points in space, and a capability to "pick" a point in the scene and retrieve information about the data at this location.

IFSCube performs analysis tasks in data cubes of integral field spectroscopy. It contains routines for fitting spectral features in 1D spectra and data cubes and rotation models to velocity fields; it also contains a routine that inspects the fit results. Though originally intended to make user scripts more concise, analysis can also be performed on the fly by using an interactive interpreter such as ipython. By default, IFSCube assumes data are in the Flexible Image Transport System (FITS) standard, but the package can be modified easily to allow use of other data formats.

IFSFIT is a general-purpose IDL library for fitting the continuum, emission lines, and absorption lines in integral field spectra. It uses PPXF (ascl:1210.002) to find the best fit stellar continuum (using a user-defined library of stellar templates and including additive polynomials), or optionally a user-defined method to find the best fit continuum. It uses MPFIT (ascl:1208.019) to simultaneously fit Gaussians to any number of emission lines and emission line velocity components. It will also fit the NaI D feature using analytic absorption and/or emission-line profiles.

IFSRED is a general-purpose library for reducing data from integral field spectrographs (IFSs). For a general IFS data cube, it contains IDL routines to: (1) find and apply a zero-point shift in a wavelength solution on a spaxel-by-spaxel basis, using sky lines; (2) find the spatial coordinates of a flux peak; (3) empirically correct for differential atmospheric refraction; (4) mosaic dithered exposures; (5) (integer) rebin; and (6) apply a telluric correction. A sky-subtraction routine for data from the Gemini Multi-Object Spectrograph and Imager (GMOS) that can be easily modified for any instrument is also included. IFSRED also contains additional software specific to reducing data from GMOS and the Gemini Near-Infrared Integral Field Spectrograph (NIFS).

The iGalFit suite of IDL routines interactively runs GALFIT whereby the various surface brightness profiles (and their associated parameters) are represented by regions, which the user is expected to place. The regions may be saved and/or loaded from the ASCII format used by ds9 or in the Hierarchical Data Format (version 5). The software has been tested to run stably on Mac OS X and Linux with IDL 7.0.4. In addition to its primary purpose of modeling galaxy images with GALFIT, this package has several ancillary uses, including a flexible image display routines, several basic photometry functions, and qualitatively assessing Source Extractor.

This document describes the publically available numerical code "IGMtransfer", capable of performing intergalactic radiative transfer (RT) of light in the vicinity of the Lyman alpha (Lya) line. Calculating the RT in a (possibly adaptively refined) grid of cells resulting from a cosmological simulation, the code returns 1) a "transmission function", showing how the intergalactic medium (IGM) affects the Lya line at a given redshift, and 2) the "average transmission" of the IGM, making it useful for studying the results of reionization simulations.

IGMtransmission is a Java graphical user interface that implements Monte Carlo simulations to compute the corrections to colors of high-redshift galaxies due to intergalactic attenuation based on current models of the Intergalactic Medium. The effects of absorption due to neutral hydrogen are considered, with particular attention to the stochastic effects of Lyman Limit Systems. Attenuation curves are produced, as well as colors for a wide range of filter responses and model galaxy spectra. Photometric filters are included for the Hubble Space Telescope, the Keck telescope, the Mt. Palomar 200-inch, the SUBARU telescope and UKIRT; alternative filter response curves and spectra may be readily uploaded.

iharm3D implements the HARM algorithm (ascl:1209.005) with modifications and enables a second-order, conservative, shock-capturing scheme for general-relativistic magnetohydrodynamics (GRMHD). Written in C, it simulates black hole accretion systems in arbitrary stationary spacetimes.

IIPImage is an advanced high-performance feature-rich image server system that enables online access to full resolution floating point (as well as other bit depth) images at terabyte scales. Paired with the VisiOmatic (ascl:1408.010) celestial image viewer, the system can comfortably handle gigapixel size images as well as advanced image features such as both 8, 16 and 32 bit depths, CIELAB colorimetric images and scientific imagery such as multispectral images. Streaming is tile-based, which enables viewing, navigating and zooming in real-time around gigapixel size images. Source images can be in either TIFF or JPEG2000 format. Whole images or regions within images can also be rapidly and dynamically resized and exported by the server from a single source image without the need to store multiple files in various sizes.

IllinoisGRMHD is an open-source, highly-extensible rewrite of the original closed-source general relativistic (ideal) magnetohydrodynamics (GRMHD) code of the Illinois Numerical Relativity (ILNR) Group. Reducing the learning curve was the primary focus of this rewrite, with the goal of facilitating community involvement in the code's use and development, as well as reducing the human effort necessary to generate new science. IllinoisGRMHD also saves computer time, generating roundoff-precision identical output to the original code on adaptive-mesh grids while being nearly twice as fast at scales of hundreds to thousands of cores.

im2shape is a Bayesian approach to the problem of accurate measurement of galaxy ellipticities for weak lensing studies, in particular cosmic shear. im2shape parameterizes galaxies as sums of Gaussians, convolved with a psf which is also a sum of Gaussians. The uncertainties in the output parameters are calculated using a Markov Chain Monte Carlo approach.

Im3shape forward-fits a galaxy model to each data image it is supplied with and reports the parameters of the best fitting model, including the ellipticity components. It uses the Discrete Fourier Transform (DFT) to render images of convolved galaxy profiles, calculates the maximum likelihood parameter values, and corrects for noise bias. IM3SHAPE is a modular C code with a significant amount of Python glue code to enable setting up new models and their options automatically.

ImageHealth (IH) is a c program that makes use of standard CFITSIO routines to examine, in an automated fashion, .FITS images with any number of extensions, find objects within those images, and determine basic parameters of those images (stellar flux, background counts, FWHM, and ellipticity, along with sky background counts) in order to provide a snapshot of the quality of those images. A variety of python wrappers have also been written to test large numbers of such images and compare the results of ImageHealth to other image analysis programs, such as SourceExtractor. Additional IH-related tools will be made available in the future.

ImageJ is a public domain Java image processing program inspired by NIH Image. It can display, edit, analyze, process, save and print 8-bit, 16-bit and 32-bit images. It can read many image formats including TIFF, GIF, JPEG, BMP, DICOM, FITS and "raw". It supports "stacks", a series of images that share a single window. It is multithreaded, so time-consuming operations such as image file reading can be performed in parallel with other operations.

IMAGINE (Interstellar MAGnetic field INference Engine) performs inference on generic parametric models of the Galaxy. The modular open source framework uses highly optimized tools and technology such as the MultiNest sampler (ascl:1109.006) and the information field theory framework NIFTy (ascl:1302.013) to create an instance of the Milky Way based on a set of parameters for physical observables, using Bayesian statistics to judge the mismatch between measured data and model prediction. The flexibility of the IMAGINE framework allows for simple refitting for newly available data sets and makes state-of-the-art Bayesian methods easily accessible particularly for random components of the Galactic magnetic field.

Imber simulates spectroscopic and photometric observations with both a gridded numerical simulation and analytical model. Written in Python, it is specifically designed to predict Extremely Large Telescope instrument (such as ELT/METIS and TMT/MODHIS) Doppler imaging performance, and has also been applied to existing, archival observations of spectroscopy and photometry.

The IMCAT software was developed initially to do faint galaxy photometry for weak lensing studies, and provides a fairly complete set of tools for this kind of work. Unlike most packages for doing data analysis, the tools are standalone unix commands which you can invoke from the shell, via shell scripts or from perl scripts. The tools are arranges in a tree of directories. One main branch is the ’imtools’. These deal only with fits files. The most important imtool is the ’image calculator’ ’ic’ which allows one to do rather general operations on fits images. A second branch is the ’catools’ which operate only on catalogues. The key cattool is ’lc’; this effectively defines the format of IMCAT catalogues, and allows one to do very general operations on and filtering of such catalogues. A third branch is the ’imcattools’. These tend to be much more specialised than the cattools and imcattools and are focussed on faint galaxy photometry.

IMCOM allows for careful treatment of aliasing in undersampled imaging data and can be used to test the feasibility of multi-exposure observing strategies for space-based survey missions. IMCOM can also been used to explore focal plane undersampling for an optical space mission such as Euclid.

imexam performs simple image examination and plotting, with similar functionality to IRAF's (ascl:9911.002) imexamine. It is a lightweight library that enables users to explore data from a command line interface, through a Jupyter notebook, or through a Jupyter console. imexam can be used with multiple viewers, such as DS9 (scl:0003.002) or Ginga (ascl:1303.020), or without a viewer as a simple library to make plots and grab quick photometry information. It has been designed so that other viewers may be easily attached in the future.

Imfit is an open-source astronomical image-fitting program specialized for galaxies but potentially useful for other sources, which is fast, flexible, and highly extensible. Its object-oriented design allows new types of image components (2D surface-brightness functions) to be easily written and added to the program. Image functions provided with Imfit include Sersic, exponential, and Gaussian galaxy decompositions along with Core-Sersic and broken-exponential profiles, elliptical rings, and three components that perform line-of-sight integration through 3D luminosity-density models of disks and rings seen at arbitrary inclinations.

Available minimization algorithms include Levenberg-Marquardt, Nelder-Mead simplex, and Differential Evolution, allowing trade-offs between speed and decreased sensitivity to local minima in the fit landscape. Minimization can be done using the standard chi^2 statistic (using either data or model values to estimate per-pixel Gaussian errors, or else user-supplied error images) or the Cash statistic; the latter is particularly appropriate for cases of Poisson data in the low-count regime.

The C++ source code for Imfit is available under the GNU Public License.

iminuit is a Jupyter-friendly Python interface for the Minuit2 C++ library maintained by CERN's ROOT team. It can be used as a general robust function minimization method, but is most commonly used for likelihood fits of models to data, and to get model parameter error estimates from likelihood profile analysis.

This software trains artificial neural networks to find non-linear functionals of data that maximize Fisher information: information maximizing neural networks (IMNNs). As compressing large data sets vastly simplifies both frequentist and Bayesian inference, important information may be inadvertently missed. Likelihood-free inference based on automatically derived IMNN summaries produces summaries that are good approximations to sufficient statistics. IMNNs are robustly capable of automatically finding optimal, non-linear summaries of the data even in cases where linear compression fails: inferring the variance of Gaussian signal in the presence of noise, inferring cosmological parameters from mock simulations of the Lyman-α forest in quasar spectra, and inferring frequency-domain parameters from LISA-like detections of gravitational waveforms. In this final case, the IMNN summary outperforms linear data compression by avoiding the introduction of spurious likelihood maxima.

ImpactModel, written in Cython, computes the accretion disc impact spectrum at given frequencies and can compute other model quantities as a function of time.

Aperture masking interferometric data analysis involves measuring phases and amplitudes of fringes formed by interference between holes in the pupil mask. These fringe observables can be measured by computing an analytic model of the point spread function and fitting the relevant set of spatial frequencies directly in the image plane, without recourse to numerical Fourier transforms. The ImPlaneIA pipeline converts aperture masking images to fringe observables by fitting fringes in the image plane, calibrates data from a target of interest with one or more point source calibrators, and contains some basic model-fitting routines. The pipeline can accept different mask geometries, instruments, and observing modes.

IMRIpy simulates an Intermediate Mass Ratio Inspiral (IMRI) by gravitational wave emission with a Dark Matter(DM) halo or a (baryonic) Accretion Disk around the central Intermediate Mass Black Hole(IMBH). It can use different density profiles (such as DM spikes), and different interactions, such as dynamical friction with and without HaloFeedback models or accretion, to produce the simulation.

The IMRPhenomD model generates gravitational wave signals for merging black hole binaries with non-precessing spins. The waveforms are produced in the frequency domain and include the inspiral, merger and ringdown parts for the dominant spherical harmonic mode of the signal. Part of LALSuite (ascl:2012.021) and also available as an independent code, IMRPhenomD is written in C and is calibrated against data from numerical relativity simulations. A re-implementation of IMRPhenomD in Python, PyIMRPhenomD (ascl:2307.023), is available.

This program measures line-strength indices in fully calibrated FITS spectra. By "fully calibrated" one should understand wavelength and relative flux-calibrated data. Note that the different types of line-strength indices that can be measured with indexf (see below) do not require absolute flux calibration. If even a relative flux-calibration is absent (or deficient), the derived indices should be transformed to an appropriate spectrophotometric system. The program can also compute index errors resulting from the propagation of random errors (e.g. photon statistics, read-out noise). This option is only available if the user provides the error spectrum as an additional input FITS file to indexf. The error spectrum must contain the unbiased standard deviation (and not the variance!) for each pixel of the data spectrum. In addition, indexf also estimates the effect of errors on radial velocity. For this purpose, the program performs Monte Carlo simulations by measuring each index using randomly drawn radial velocities (following a Gaussian distribution of a given standard deviation). If no error file is employed, the program can perform numerical simulations with synthetic error spectra, the latter generated from the original data spectra and assuming randomly generated S/N ratios.

Indri models the population of single (not in binary or hierarchical systems) neutron stars. Given a starting distribution of parameters (birth place, velocity, magnetic field, and period), the code moves a set of stars through the time (by evolving spin period and magnetic field) and the space (by propagating through the Galactic potential). Upon completion of the evolution, a set of observables is computed (radio flux, position, dispersion measure) and compared with a radio survey such as the Parkes Multibeam Survey. The models' parameters are optimised by using the Markov Chain Monte Carlo technique.

The efficiency of thin disk accretion onto black holes depends on the inner boundary condition, specifically the torque applied to the disk at the last stable orbit. This is usually assumed to vanish. This code estimates the torque on a magnetized disk using a steady magnetohydrodynamic inflow model originally developed by Takahashi et al. The efficiency e can depart significantly from the classical thin disk value. In some cases e > 1, i.e., energy is extracted from the black hole.

Infall is a code for calculating the mean initial and final density profiles around a virialized dark matter halo. The initial profile is derived from the statistics of the initial Gaussian random field, accounting for the problem of peaks within peaks using the extended Press-Schechter model. Spherical collapse then yields the typical density and velocity profiles of the gas and dark matter that surrounds the final, virialized halo. In additional to the mean profile, ±1-σ profiles are calculated and can be used as an estimate of the scatter.

Infinity sets an observer in a black hole - accretion disk system. The black hole can be either Schwarzschild (nonrotating) or Kerr (rotating) by choice of the user. This observer can be on the surface of the disk, in its exterior or its interior (if the disk is not opaque). Infinity then scans the entire sky around the observer and investigates whether photons emitted by the hot accretion disk material can reach them. After recording the incoming radiation, the program calculates the stress-energy tensor of the radiation. Afterwards, the program calculates the radiation flux and hence, the radiation force exerted on target particles of various velocity profiles.

Inflation is a numerical code to generate power spectra and other observables through numerical solutions to flow equations. The code generates tensor and scalar power spectra as a function of wavenumber and various other parameters at specific wavenumbers of interest (such as for CMB, scalar perturbations at smaller scales, gravitational wave detection at direct detection frequencies). The output can be easily ported to publicly available Markov Chain codes to constrain cosmological parameters with data.

The inhomog library provides Raychaudhuri integration of cosmological domain-wise average scale factor evolution using an analytical formula for kinematical backreaction Q_D evolution. The inhomog main program illustrates biscale examples. The library routine lib/Omega_D_precalc.c is callable by RAMSES (ascl:1011.007) using the RAMSES extension ramses-scalav.

InitialConditions finds the initial series solutions for perturbations in our Universe. This includes all scalar (1 adiabatic, 4 isocurvature and 2 magnetic modes), vector (1 vorticity mode, 1 magnetic mode), and tensor (1 gravitational wave mode and 1 magnetic mode) perturbations including terms up to second order in the neutrino mass. It can handle the standard species (cdm, baryons, photons), and two neutrino mass eigenstates (1 light, 1 heavy).

INSANE (INflationary potential Simulator and ANalysis Engine) takes either a numeric inflationary potential or a symbolic one, calculates the background evolution and then, using the Mukhanov-Sasaki equations, calculates the primordial power spectrum it yields. The package can analyze the results to extract the spectral index n_s, the index running alpha, the running of running and possibly higher moments. The package contains two main modules: BackgroundSolver solves the background equations, and the MsSolver module solves and analyses the MS equations.

INSPECTA (formerly sdhdfProc) is a software package to read, manipulate and process radio astronomy data in Spectral-Domain Hierarchical Data Format (SDHDF). It is available as part of the 'sdhdf_tools' repository.

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

Interferopy analyzes datacubes from radio-to-submm observations. It provides a homogenous interface to common tasks, making it easy to go from reduced datacubes to essential measurements and publication-quality plots. Its core functionalities are widely applicable and have been successfully tested on (but are not limited to) ALMA, NOEMA, VLA and JCMT data.

We describe a novel approach to accelerating Monte Carlo Markov Chains. Our focus is cosmological parameter estimation, but the algorithm is applicable to any problem for which the likelihood surface is a smooth function of the free parameters and computationally expensive to evaluate. We generate a high-order interpolating polynomial for the log-likelihood using the first points gathered by the Markov chains as a training set. This polynomial then accurately computes the majority of the likelihoods needed in the latter parts of the chains. We implement a simple version of this algorithm as a patch (InterpMC) to CosmoMC and show that it accelerates parameter estimatation by a factor of between two and four for well-converged chains. The current code is primarily intended as a "proof of concept", and we argue that there is considerable room for further performance gains. Unlike other approaches to accelerating parameter fits, we make no use of precomputed training sets or special choices of variables, and InterpMC is almost entirely transparent to the user.

The Beta Inverse code solves the inverse cumulative density function (CDF) of a Beta distribution, allowing one to sample from the Beta prior directly. The Beta distribution is well suited as a prior for the distribution of the orbital eccentricities of extrasolar planets; imposing a Beta prior on orbital eccentricity is valuable for any type of observation of an exoplanet where eccentricity can affect the model parameters (e.g. transits, radial velocities, microlensing, direct imaging). The Beta prior is an excellent description of the current, empirically determined distribution of orbital eccentricities and thus employing it naturally incorporates an observer’s prior experience of what types of orbits are probable or improbable. The default parameters in the code are currently set to the Beta distribution which best describes the entire population of exoplanets with well-constrained orbits.

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

ionFR calculates the amount of ionospheric Faraday rotation for a specific epoch, geographic location, and line-of-sight. The code uses a number of publicly available, GPS-derived total electron content maps and the most recent release of the International Geomagnetic Reference Field. ionFR can be used for the calibration of radio polarimetric observations; its accuracy had been demonstrated using LOFAR pulsar observations.

ipole is a ray-tracing code for covariant, polarized radiative transport particularly useful for modeling Event Horizon Telescope sources, though may also be used for other relativistic transport problems. The code extends the ibothros scheme for covariant, unpolarized transport using two representations of the polarized radiation field: in the coordinate frame, it parallel transports the coherency tensor, and in the frame of the plasma, it evolves the Stokes parameters under emission, absorption, and Faraday conversion. The transport step is as spacetime- and coordinate- independent as possible; the emission, absorption, and Faraday conversion step is implemented using an analytic solution to the polarized transport equation with constant coefficients. As a result, ipole is stable, efficient, and produces a physically reasonable solution even for a step with high optical depth and Faraday depth.

IQRM-APOLLO cleans narrow-band radio frequency interference (RFI) using the Inter-Quartile Range Mitigation (IQRM) algorithm. By masking this interference, the code reduces the number of false positive pulsar candidates and increases sensitivity for pulsar detection. The IQRM algorithm is an outlier detection algorithm that is both non-parametric and robust to the presences of trends in time series data. Using short-duration data blocks, IQRM-APOLLO computes a spectral statistic that correlates with the presence of RFI, removing high outliers from the input signal.

IQRM implements the Inter-Quartile Range Mitigation (IQRM) interference flagging algorithm for radio pulsar and transient searches. This module provides only the algorithm that infers a channel mask from some spectral statistic that measures the level of RFI contamination in a time-frequency data block. It should be useful as a reference implementation to developers who wish to integrate IQRM into an existing pipeline or search code.

The IRACpm R package applies a 7-8 order distortion correction to IRAC astrometric data from the Spitzer Space Telescope and includes a function for measuring apparent proper motions between different Epochs. These corrections are applicable only to positions measured by APEX; cryogenic images benefit from a correction for varying intra-pixel sensitivity prior to the application of the distortion.

IRACproc is a software suite that facilitates the co-addition of dithered or mapped Spitzer/IRAC data to make them ready for further analysis with application to a wide variety of IRAC observing programs. The software runs within PDL, a numeric extension for Perl available from pdl.perl.org, and as stand alone perl scripts. In acting as a wrapper for the Spitzer Science Center's MOPEX software, IRACproc improves the rejection of cosmic rays and other transients in the co-added data. In addition, IRACproc performs (optional) Point Spread Function (PSF) fitting, subtraction, and masking of saturated stars.

IRAF includes a broad selection of programs for general image processing and graphics, plus a large number of programs for the reduction and analysis of optical and IR astronomy data. Other external or layered packages are available for applications such as data acquisition or handling data from other observatories and wavelength regimes such as the Hubble Space Telescope (optical), EUVE (extreme ultra-violet), or ROSAT and AXAF (X-ray). These external packages are distributed separately from the main IRAF distribution but can be easily installed. The IRAF system also includes a complete programming environment for scientific applications, which includes a programmable Command Language scripting facility, the IMFORT Fortran/C programming interface, and the full SPP/VOS programming environment in which the portable IRAF system and all applications are written.

iragnsep performs IR SED fits separated into AGN and galaxy contributions, and measures host galaxy properties free of AGN contamination. The advantage of iragnsep is that, in addition to fitting observed broadband photometric fluxes, it also incorporates IR spectra in the fits which, if available, improves the robustness of the galaxy-AGN separation. For the galaxy component, iragnsep uses a library of galaxy templates. In terms of the AGN contribution, if the input dataset is a mixture of spectral and photometric data, iragnsep uses a combination of power-laws for the AGN continuum, and some broad features for the silicate emission. If instead the dataset contains photometric data alone, the AGN contribution is accounted for by using a library of AGN templates. The advanced fitting techniques used by iragnsep combined with the powerful model comparison tests allows iragnsep to provide a statistically robust interpretation of IR SEDs in terms of AGN-galaxy contributions, even when the AGN contribution is highly diluted by the host galaxy emission.