GBART is an improved version of the code for determining the orbital elements for spectroscopic binaries originally written by Bertiau & Grobben (1968).

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

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

GaussFit solves least squares and robust estimation problems; written originally for reduction of NASA Hubble Space Telescope data, it includes a complete programming language designed especially to formulate estimation problems, a built-in compiler and interpreter to support the programming language, and a built-in algebraic manipulator for calculating the required partial derivatives analytically. The code can handle nonlinear models, exact constraints, correlated observations, and models where the equations of condition contain more than one observed quantity. Written in C, GaussFit includes an experimental robust estimation capability so data sets contaminated by outliers can be handled simply and efficiently.

GAUSSCLUMPS decomposes a spectral map into Gaussian-shape clumps. The clump-finding algorithm decomposes a spectral data cube by iteratively removing 3-D Gaussians as representative clumps. GAUSSCLUMPS was originally a separate code distribution but is now a contributed package in GILDAS (ascl:1305.010). A reimplementation can also be found in CUPID (ascl:1311.007).

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

Gasoline solves the equations of gravity and hydrodynamics in astrophysical problems, including simulations of planets, stars, and galaxies. It uses an SPH method that features correct mixing behavior in multiphase fluids and minimal artificial viscosity. This method is identical to the SPH method used in the ChaNGa code (ascl:1105.005), allowing users to extend results to problems requiring >100,000 cores. Gasoline uses a fast, memory-efficient O(N log N) KD-Tree to solve Poisson's Equation for gravity and avoids artificial viscosity in non-shocking compressive flows.

GASGANO is a GUI software tool for managing and viewing data files produced by VLT Control System (VCS) and the Data Flow System (DFS). It is developed and maintained by ESO to help its user community manage and organize astronomical data observed and produced by all VLT compliant telescopes in a systematic way. The software understands FITS, PAF, and ASCII files, and Reduction Blocks, and can group, sort, classify, filter, and search data in addition to allowing the user to browse, view, and manage them.

We present a new method for detecting the missing baryons by generating a template for the kinematic Sunyaev-Zel'dovich effect. The template is computed from the product of a reconstructed velocity field with a galaxy field. We provide maps of such templates constructed from SDSS Data Release 7 spectroscopic data (SDSS VAGC sample) along side with their expected two point correlation functions with CMB temperature anisotropies. Codes of generating such coefficients of the two point correlation function are also released to provide users of the gas-momentum map a way to change the parameters such as cosmological parameters, reionization history, ionization parameters, etc.

The algorithm Gaussian processes can reconstruct a function from a sample of data without assuming a parameterization of the function. The GaPP code can be used on any dataset to reconstruct a function. It handles individual error bars on the data and can be used to determine the derivatives of the reconstructed function. The data sample can consist of observations of the function and of its first derivative.

GANDALF, a successor to SEREN (ascl:1102.010), is a hybrid self-gravitating fluid dynamics and collisional N-body code primarily designed for investigating star formation and planet formation problems. GANDALF uses various implementations of Smoothed Particle Hydrodynamics (SPH) to perform hydrodynamical simulations of gas clouds undergoing gravitational collapse to form new stars (or other objects), and can perform simulations of pure N-body dynamics using high accuracy N-body integrators, model the intermediate phase of cluster evolution, and provide visualizations via its python interface as well as interactive simulations. Although based on many of the SEREN routines, GANDALF has been largely re-written from scratch in C++ using more optimal algorithms and data structures.

GANDALF (Gas AND Absorption Line Fitting) accurately separates the stellar and emission-line contributions to observed spectra. The IDL code includes reddening by interstellar dust and also returns formal errors on the position, width, amplitude and flux of the emission lines. Example wrappers that make use of pPXF (ascl:1210.002) to derive the stellar kinematics are included.

Ganalyzer is a model-based tool that automatically analyzes and classifies galaxy images. Ganalyzer works by separating the galaxy pixels from the background pixels, finding the center and radius of the galaxy, generating the radial intensity plot, and then computing the slopes of the peaks detected in the radial intensity plot to measure the spirality of the galaxy and determine its morphological class. Unlike algorithms that are based on machine learning, Ganalyzer is based on measuring the spirality of the galaxy, a task that is difficult to perform manually, and in many cases can provide a more accurate analysis compared to manual observation. Ganalyzer is simple to use, and can be easily embedded into other image analysis applications. Another advantage is its speed, which allows it to analyze ~10,000,000 galaxy images in five days using a standard modern desktop computer. These capabilities can make Ganalyzer a useful tool in analyzing large datasets of galaxy images collected by autonomous sky surveys such as SDSS, LSST or DES.

Gammapy analyzes gamma-ray data and creates sky images, spectra and lightcurves, from event lists and instrument response information; it can also determine the position, morphology and spectra of gamma-ray sources. It is used to analyze data from H.E.S.S., Fermi-LAT, and the Cherenkov Telescope Array (CTA).

The GammaLib is a versatile toolbox for the high-level analysis of astronomical gamma-ray data. It is implemented as a C++ library that is fully scriptable in the Python scripting language. The library provides core functionalities such as data input and output, interfaces for parameter specifications, and a reporting and logging interface. It implements instruments specific functionalities such as instrument response functions and data formats. Instrument specific functionalities share a common interface to allow for extension of the GammaLib to include new gamma-ray instruments. The GammaLib provides an abstract data analysis framework that enables simultaneous multi-mission analysis.

gammaALPs calculates the conversion probability between photons and axions/axion-like particles in various astrophysical magnetic fields. Though focused on environments relevant to mixing between gamma rays and ALPs, this suite, written in Python, can also be used for broader applications. The code also implements various models of astrophysical magnetic fields, which can be useful for applications beyond ALP searches.

GAMMA models relativistic hydrodynamics and non-thermal emission on a moving mesh. It uses an arbitrary Lagrangian-Eulerian approach only in the dominant direction of fluid motion to avoid mesh entanglement and associated computational costs. Shock detection, particle injection and local calculation of their evolution including radiative cooling are done at runtime. The package is modular; though it was designed with GRB physics applications in mind, new solvers and geometries can be implemented easily, making GAMMA suitable for a wide range of applications.

GAMERA handles spectral modeling of non-thermally emitting astrophysical sources in a simple and modular way. It allows the user to devise time-dependent models of leptonic and hadronic particle populations in a general astrophysical context (including SNRs, PWNs and AGNs) and to compute their subsequent photon emission. GAMERA can calculate the spectral evolution of a particle population in the presence of time-dependent or constant injection, energy losses and particle escape; it also calculates the radiation spectrum from a parent particle population.

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

GAME infers different ISM physical properties by analyzing the emission line intensities in a galaxy spectrum. The code is trained with a large library of synthetic spectra spanning many different ISM phases, including HII (ionized) regions, PDRs, and neutral regions. GAME is based on a Supervised Machine Learning algorithm called AdaBoost with Decision Trees as base learner. Given a set of input lines in a spectrum, the code performs a training on the library and then evaluates the line intensities to give a determination of the physical properties. The errors on the input emission line intensities and the uncertainties on the physical properties determinations are also taken into account. GAME infers gas density, column density, far-ultraviolet (FUV, 6–13.6 eV) flux, ionization parameter, metallicity, escape fraction, and visual extinction. A web interface for using the code is available.

GAMBIT (Global And Modular BSM Inference Tool) performs statistical global fits of generic physics models using a wide range of particle physics and astrophysics data. Modules provide native simulations of collider and astrophysics experiments, a flexible system for interfacing external codes (the backend system), a fully featured statistical and parameter scanning framework, and additional tools for implementing and using hierarchical models.

GALSVM is IDL software for automated morphology classification. It was specially designed for high redshift data but can be used at low redshift as well. It analyzes morphologies of galaxies based on a particular family of learning machines called support vector machines. The method can be seen as a generalization of the classical CAS classification but with an unlimited number of dimensions and non-linear boundaries between decision regions. It is fully automated and consequently well adapted to large cosmological surveys.

galstreams provides a compilation of spatial information for known stellar streams and overdensities in the Milky Way and includes Python tools for visualizing them. ASCII tables are also provided for quick viewing of the stream's footprints using TOPCAT (ascl:1101.010). As of 2022, the library provides celestial, distance, proper motion and radial velocity tracks for each stream (pm/vrad when available) stored as AstroPy (ascl:1304.002) SkyCoord objects and a stream's (heliocentric) coordinate frame is realized as an AstroPy reference frame. The code offers polygon footprints and pole (at mid point) and pole tracks in the heliocentric and Galactocentric (GSR) frames. It also offers angular momentum tracks in a heliocentric reference frame at rest with respect to the Galactic center, and provides uniformly reported stream length, end points and mid-point, heliocentric and Galactocentric mid-pole, track and discovery references and information flag denoting which of the 6D attributes (sky, distance, proper motions and radial velocity) are available in the track object.

galstep generates initial conditions for disk galaxy simulations with GADGET-2 (ascl:0003.001), RAMSES (ascl:1011.007) and GIZMO (ascl:1410.003), including a stellar disk, a gaseous disk, a dark matter halo and a stellar bulge. The first two components follow an exponential density profile, and the last two a Dehnen density profile with gamma=1 by default, corresponding to a Hernquist profile.

GalSim is a fast, modular software package for simulation of astronomical images. Though its primary purpose is for tests of weak lensing analysis methods, it can be used for other purposes. GalSim allows galaxies and PSFs to be represented in a variety of ways, and can apply shear, magnification, dilation, or rotation to a galaxy profile including lensing-based models from a power spectrum or NFW halo profile. It can write images in regular FITS files, FITS data cubes, or multi-extension FITS files. It can also compress the output files using various compressions including gzip, bzip2, and rice. The user interface is in python or via configuration scripts, and the computations are done in C++ for speed.

GalRotpy models the dynamical mass of disk-like galaxies and makes a parametric fit of the rotation curve by means of the composed gravitational potential of the galaxy. It can be used to check the presence of an assumed mass type component in a observed rotation curve, to determine quantitatively the main mass contribution in a galaxy by means of the mass ratios of a given set of five potentials, and to bound the contribution of each mass component given its gravitational potential parameters.

galpy is a python package for galactic dynamics. It supports orbit integration in a variety of potentials, evaluating and sampling various distribution functions, and the calculation of action-angle coordinates for all static potentials.

GALPROP is a numerical code for calculating the propagation of relativistic charged particles and the diffuse emissions produced during their propagation. The GALPROP code incorporates as much realistic astrophysical input as possible together with latest theoretical developments. The code calculates the propagation of cosmic-ray nuclei, antiprotons, electrons and positrons, and computes diffuse γ-rays and synchrotron emission in the same framework. Each run of the code is governed by a configuration file allowing the user to specify and control many details of the calculation. Thus, each run of the code corresponds to a potentially different "model." The code continues to be developed and is available to the scientific community.

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

GalPaK 3D extracts the intrinsic (i.e. deconvolved) galaxy parameters and kinematics from any 3-dimensional data. The algorithm uses a disk parametric model with 10 free parameters (which can also be fixed independently) and a MCMC approach with non-traditional sampling laws in order to efficiently probe the parameter space. More importantly, it uses the knowledge of the 3-dimensional spread-function to return the intrinsic galaxy properties and the intrinsic data-cube. The 3D spread-function class is flexible enough to handle any instrument.

GalPaK 3D can simultaneously constrain the kinematics and morphological parameters of (non-merging, i.e. regular) galaxies observed in non-optimal seeing conditions and can also be used on AO data or on high-quality, high-SNR data to look for non-axisymmetric structures in the residuals.

GalMOSS performs two-dimensional fitting of galaxy profiles. This Python-based, Torch-powered tool seamlessly enables GPU parallelization and meets the high computational demands of large-scale galaxy surveys. It incorporates widely used profiles such as the Sérsic, Exponential disk, Ferrer, King, Gaussian, and Moffat profiles, and allows for the easy integration of more complex models. Tested on over 8,000 galaxies from the Sloan Digital Sky Survey (SDSS) g-band with a single NVIDIA A100 GPU, GalMOSS completed classical Sérsic profile fitting in about 10 minutes. Benchmark tests show that GalMOSS achieves computational speeds that are significantly faster than those of default implementations.

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

GALLUMI (GALaxy LUMInosity) is a likelihood code that extracts cosmological and astrophysical parameters from the UV galaxy luminosity function. The code is implemented in the MCMC sampler MontePython (ascl:1307.002) and can be readily run in conjunction with other likelihood codes.

Gallenspy uses the gravitational lensing effect (GLE) to reconstruct mass profiles in disc-like galaxies. The algorithm inverts the lens equation for gravitational potentials with spherical symmetry, in addition to the estimation in the position of the source, given the positions of the images produced by the lens. Gallenspy also computes critical and caustic curves and the Einstein ring.

galkin is a compilation of kinematic measurements tracing the rotation curve of our Galaxy, together with a tool to treat the data. The compilation is optimized to Galactocentric radii between 3 and 20 kpc and includes the kinematics of gas, stars and masers in a total of 2780 measurements collected from almost four decades of literature. The user-friendly software provided selects, treats and retrieves the data of all source references considered. This tool is especially designed to facilitate the use of kinematic data in dynamical studies of the Milky Way with various applications ranging from dark matter constraints to tests of modified gravity.

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

Galileon-Solver adds an extra force to PMCode (ascl:9909.001) using a modified Poisson equation to provide a non-linearly transformed density field, with the operations all performed in real space. The code's implicit spherical top-hat assumption only works over fairly long distance averaging scales, where the coarse-grained picture it relies on is a good approximation of reality; it uses discrete Fourier transforms and cyclic reduction in the usual way.

GaLight (Galaxy shapes of Light) performs two-dimensional model fitting of optical and near-infrared images to characterize the light distribution of galaxies with components including a disk, bulge, bar and quasar. Light is decomposes into PSF and Sersic, and the fitting is based on lenstronomy (ascl:1804.01). GaLight's automated features including searching PSF stars in the FOV, automatically estimating the background noise level, and cutting out the target object galaxies (QSOs) and preparing the materials to model the data. It can also detect objects in the cutout stamp and quickly create Sersic keywords to model them, and model QSOs and galaxies using 2D Sersic profile and scaled point source.

GalIC (GALaxy Initial Conditions) is an implementation of an iterative method to construct steady state composite halo-disk-bulge galaxy models with prescribed density distribution and velocity anisotropy that can be used as initial conditions for N-body simulations. The code is parallelized for distributed memory based on MPI. While running, GalIC produces "snapshot files" that can be used as initial conditions files. GalIC supports the three file formats ('type1' format, the slightly improved 'type2' format, and an HDF5 format) of the GADGET (ascl:0003.001) code for its output snapshot files.

GALFORM is a semi-analytic model for calculating the formation and evolution of galaxies in hierarchical clustering cosmologies. Using a Monte Carlo algorithm to follow the merging evolution of dark matter haloes with arbitrary mass resolution, it incorporates realistic descriptions of the density profiles of dark matter haloes and the gas they contain. It follows the chemical evolution of gas and stars, and the associated production of dust and includes a detailed calculation of the sizes of discs and spheroids.

GALFIT is a two-dimensional (2-D) fitting algorithm designed to extract structural components from galaxy images, with emphasis on closely modeling light profiles of spatially well-resolved, nearby galaxies observed with the Hubble Space Telescope. The algorithm improves on previous techniques in two areas: 1.) by being able to simultaneously fit a galaxy with an arbitrary number of components, and 2.) with optimization in computation speed, suited for working on large galaxy images. 2-D models such as the "Nuker'' law, the Sersic (de Vaucouleurs) profile, an exponential disk, and Gaussian or Moffat functions are used. The azimuthal shapes are generalized ellipses that can fit disky and boxy components. Many galaxies with complex isophotes, ellipticity changes, and position-angle twists can be modeled accurately in 2-D. When examined in detail, even simple-looking galaxies generally require at least three components to be modeled accurately rather than the one or two components more often employed. This is illustrated by way of seven case studies, which include regular and barred spiral galaxies, highly disky lenticular galaxies, and elliptical galaxies displaying various levels of complexities. A useful extension of this algorithm is to accurately extract nuclear point sources in galaxies.

galfast generates catalogs for arbitrary, user-supplied Milky Way models, including empirically derived ones. The built-in model set is based on fits to SDSS stellar observations over 8000 deg² of the sky and includes a three-dimensional dust distribution map. Because of the capability to use empirically derived models, galfast typically produces closer matches to the actual observed counts and color-magnitude diagrams. In particular, galfast-generated catalogs are used to derive the stellar component of “Universe Model” catalogs used by the LSST Project. A key distinguishing characteristic of galfast is its speed. Galfast uses the GPU (with kernels written in NVIDIA C/C++ for CUDA) to offload compute intensive model sampling computations to the GPU, enabling the generation of realistic catalogs to full LSST depth in hours (instead of days or weeks), making it possible to study proposed science cases with high precision.

GALEV evolutionary synthesis models describe the evolution of stellar populations in general, of star clusters as well as of galaxies, both in terms of resolved stellar populations and of integrated light properties over cosmological timescales of > 13 Gyr from the onset of star formation shortly after the Big Bang until today.

For galaxies, GALEV includes a simultaneous treatment of the chemical evolution of the gas and the spectral evolution of the stellar content, allowing for a chemically consistent treatment using input physics (stellar evolutionary tracks, stellar yields and model atmospheres) for a large range of metallicities and consistently account for the increasing initial abundances of successive stellar generations.

The stellar classification code galclassify is a stand-alone version of Galaxia (ascl:1101.007). It classifies and generates a synthetic population for each star using input containing observables in a fixed format rather than using a precomputed population over a large field. It is suitable for individual stellar classifications, but slow if you want to classify large samples of stars.

galclaim identifies association between astrophysical transient sources and host galaxy. This association is made by estimating the chance alignment between a given transient sky localization and nearby galaxies. The code can be used with various catalogs, including Pan-STARRS, HSC, AllWISE and GLADE. galclaim also pre-checks for nearby bright galaxy using the RC3 catalog (https://heasarc.gsfc.nasa.gov/w3browse/all/rc3.html). When a nearby galaxy is found, a warning is raised and the properties of the galaxy are saved in a dedicated output file. The package can create plots displaying the computed pval for the found objects for each transient and each catalog; plots are stored in the result/plots directory.

GalCEM (GALactic Chemical Evolution Model) tracks isotope masses as a function of time in a given galaxy. The list of tracked isotopes automatically adapts to the complete set provided by the input yields. The prescription includes massive stars, low-to-intermediate mass stars, and Type Ia supernovae as enrichment channels. Multi-dimensional interpolation curves are extracted from the input yield tables with a preprocessing tool; these interpolation curves improve the computation speeds of the full convolution integrals, which are computed for each isotope and for each enrichment channel. GalCEM also provides tools to track the mass rate change of individual isotopes on a typical spiral galaxy with a final baryonic mass of 5×1010M⊙.

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

GalaxyCount calculates the number and standard deviation of galaxies in a magnitude limited observation of a given area. The methods to calculate both the number and standard deviation may be selected from different options. Variances may be computed for circular, elliptical and rectangular window functions.

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

GalaXimView (for Galaxies Simulations Viewer) is a python3+matplotlib tool designed to visualise simulations which use particles, providing notably a rotatable 3D view and corresponding projections in 2D, together with a way of navigating through snapshots of a simulation keeping the same projection.

We present here a fast code for creating a synthetic survey of the Milky Way. Given one or more color-magnitude bounds, a survey size and geometry, the code returns a catalog of stars in accordance with a given model of the Milky Way. The model can be specified by a set of density distributions or as an N-body realization. We provide fast and efficient algorithms for sampling both types of models. As compared to earlier sampling schemes which generate stars at specified locations along a line of sight, our scheme can generate a continuous and smooth distribution of stars over any given volume. The code is quite general and flexible and can accept input in the form of a star formation rate, age metallicity relation, age velocity dispersion relation and analytic density distribution functions. Theoretical isochrones are then used to generate a catalog of stars and support is available for a wide range of photometric bands. As a concrete example we implement the Besancon Milky Way model for the disc. For the stellar halo we employ the simulated stellar halo N-body models of Bullock & Johnston (2005). In order to sample N-body models, we present a scheme that disperses the stars spawned by an N-body particle, in such a way that the phase space density of the spawned stars is consistent with that of the N-body particles. The code is ideally suited to generating synthetic data sets that mimic near future wide area surveys such as GAIA, LSST and HERMES. As an application we study the prospect of identifying structures in the stellar halo with a simulated GAIA survey.

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

GALAXEV is a library of evolutionary stellar population synthesis models computed using the new isochrone synthesis code of Bruzual & Charlot (2003). This code allows one to computes the spectral evolution of stellar populations in wide ranges of ages and metallicities at a resolution of 3 Å across the whole wavelength range from 3200 Å to 9500 Å, and at lower resolution outside this range.

Galax2d computes the 2D stationary solution of the isothermal Euler equations of gas dynamics in a rotating galaxy with a weak bar. The gravitational potential represents a weak bar and controls the flow. A damped Newton method solves the second-order upwind discretization of the equations for a steady-state solution, using a consistent linearization and a direct solver. The code can be applied as a tool for generating flow models if used on not too fine meshes, up to 256 by 256 cells for half a disk in polar coordinates.

The galario library exploits the computing power of modern graphic cards (GPUs) to accelerate the comparison of model predictions to radio interferometer observations. It speeds up the computation of the synthetic visibilities given a model image (or an axisymmetric brightness profile) and their comparison to the observations.

GALAPAGOS, Galaxy Analysis over Large Areas: Parameter Assessment by GALFITting Objects from SExtractor (ascl:1010.064), automates source detection, two-dimensional light-profile Sersic modelling and catalogue compilation in large survey applications. Based on a single setup, GALAPAGOS can process a complete set of survey images. It detects sources in the data, estimates a local sky background, cuts postage stamp images for all sources, prepares object masks, performs Sersic fitting including neighbours and compiles all objects in a final output catalogue. For the initial source detection GALAPAGOS applies SExtractor, while GALFIT (ascl:1104.010) is incorporated for modelling Sersic profiles. It measures the background sky involved in the Sersic fitting by means of a flux growth curve. GALAPAGOS determines postage stamp sizes based on SExtractor shape parameters. In order to obtain precise model parameters GALAPAGOS incorporates a complex sorting mechanism and makes use of multiplexing capabilities. It combines SExtractor and GALFIT data in a single output table. When incorporating information from overlapping tiles, GALAPAGOS automatically removes multiple entries from identical sources.

GALAPAGOS is programmed in the Interactive Data Language, IDL. A C implementation of the software, GALAPAGOS-C (ascl:1408.011), is available, and a multi-band Galapagos version is also available.

GALAPAGOS-C is a C implementation of the IDL code GALAPAGOS (ascl:1203.002). It processes a complete set of survey images through automation of source detection via SExtractor (ascl:1010.064), postage stamp cutting, object mask preparation, sky background estimation and complex two-dimensional light profile Sérsic modelling via GALFIT (ascl:1104.010). GALAPAGOS-C uses MPI-parallelization, thus allowing quick processing of large data sets. The code can fit multiple Sérsic profiles to each galaxy, each representing distinct galaxy components (e.g. bulge, disc, bar), and optionally can fit asymmetric Fourier mode distortions.

Galactus, written in python, is an astronomical software tool for the modeling and fitting of galaxies from neutral hydrogen (HI) cubes. Galactus uses a uniform medium to generate a cube. Galactus can perform the full-radiative transfer for the HI, so can model self-absorption in the galaxy.

Galacticus is designed to solve the physics involved in the formation of galaxies within the current standard cosmological framework. It is of a type of model known as “semi-analytic” in which the numerous complex non-linear physics involved are solved using a combination of analytic approximations and empirical calibrations from more detailed, numerical solutions. Models of this type aim to begin with the initial state of the Universe (specified shortly after the Big Bang) and apply physical principles to determine the properties of galaxies in the Universe at later times, including the present day. Typical properties computed include the mass of stars and gas in each galaxy, broad structural properties (e.g. radii, rotation speeds, geometrical shape etc.), dark matter and black hole contents, and observable quantities such as luminosities, chemical composition etc.

GalactICS generates N-body realizations of axisymmetric galaxy models consisting of disk, bulge and halo. Some of the code is in Fortran 77, using lines longer than 72 characters in some cases. The -e flag in the makefile allow for this for a Solaris f77 compiler. Other programs are written in C. Again, the linking between these routines works on Solaris systems, but may need to be adjusted for other architectures. We have found that linking using f77 instead of ld will often automatically load the appropriate libraries.

The graphics output by some of the programs (dbh, plotforce, diskdf, plothalo) uses the PGPLOT library. Alternatively, remove all calls to routines with names starting with "PG", as well as the -lpgplot flag in the Makefile, and the programs should still run fine.

GalacticDNSMass performs Bayesian inference on Galactic double neutron stars (DNS) to investigate their mass distribution. Each DNS is comprised of two neutron stars (NS), a recycled NS and a non-recycled (slow) NS. It compares two hypotheses: A - recycled NS and non-recycled NS follow an identical mass distribution, and B - they are drawn from two distinct populations. Within each hypothesis it also explore three possible functional models: Gaussian, two-Gaussian (mixture model), and uniform mass distributions.

GALA is a freely distributed Fortran code to derive the atmospheric parameters (temperature, gravity, microturbulent velocity and overall metallicity) and abundances for individual species of stellar spectra using the classical method based on the equivalent widths of metallic lines. The abundances of individual spectral lines are derived by using the WIDTH9 code developed by R. L. Kurucz. GALA is designed to obtain the best model atmosphere, by optimizing temperature, surface gravity, microturbulent velocity and metallicity, after rejecting the discrepant lines. Finally, it computes accurate internal errors for each atmospheric parameter and abundance. The code obtains chemical abundances and atmospheric parameters for large stellar samples quickly, thus making GALA an useful tool in the epoch of the multi-object spectrographs and large surveys.

Gala is a Python package (and Astropy affiliated package) for Galactic astronomy and gravitational dynamics. The bulk of the package centers around implementations of gravitational potentials, numerical integration, nonlinear dynamics, and astronomical velocity transformations (i.e. proper motions). Gala uses the Astropy units and coordinates subpackages extensively to provide a clean, pythonic interface to these features but does any heavy-lifting in C and Cython for speed.
20221218 aa: Updated ADS links to new ADS format; updated site links from http: to https:

GAIA is an image and data-cube display and analysis tool for astronomy. It provides the usual facilities of image display tools, plus more astronomically useful ones such as aperture and optimal photometry, contouring, source detection, surface photometry, arbitrary region analysis, celestial coordinate readout, calibration and modification, grid overlays, blink comparison, defect patching and the ability to query on-line catalogues and image servers. It can also display slices from data-cubes, extract and visualize spectra as well as perform full 3D rendering. GAIA uses the Starlink software environment (ascl:1110.012) and is derived from the ESO SkyCat tool (ascl:1109.019).

gaia_tools contains codes for working with the ESA/Gaia data and related data sets (APOGEE, GALAH, LAMOST DR2, and RAVE). Written in Python, it includes tools to read catalogs, perform cross-matching, read RVS or XP spectra, and query the Gaia archive. gaia_tools also contains various matching recipes, such as matching APOGEE or APOGEE-RC to Gaia DR2, and RAVE to TGAS (taking into account the epoch difference).

Gaepsi is a PYTHON extension for visualizing cosmology simulations produced by Gadget. Visualization is the most important facet of Gaepsi, but it also allows data analysis on GADGET simulations with its growing number of physics related subroutines and constants. Unlike mesh based scheme, SPH simulations are directly visible in the sense that a splatting process is required to produce raster images from the simulations. Gaepsi produces images of 2-dimensional line-of-sight projections of the simulation. Scalar fields and vector fields are both supported.

Besides the traditional way of slicing a simulation, Gaepsi also has built-in support of 'Survey-like' domain transformation proposed by Carlson & White. An improved implementation is used in Gaepsi. Gaepsi both implements an interactive shell for plotting and exposes its API for batch processing. When complied with OpenMP, Gaepsi automatically takes the advantage of the multi-core computers. In interactive mode, Gaepsi is capable of producing images of size up to 32000 x 32000 pixels. The user can zoom, pan and rotate the field with a command in on the finger tip. The interactive mode takes full advantages of matplotlib's rich annotating, labeling and image composition facilities. There are also built-in commands to add objects that are commonly used in cosmology simulations to the figures.

GADGET-4 (GAlaxies with Dark matter and Gas intEracT) is a parallel cosmological N-body and SPH code that simulates cosmic structure formation and calculations relevant for galaxy evolution and galactic dynamics. It is massively parallel and flexible, and can be applied to a variety of different types of simulations, offering a number of sophisticated simulation algorithms. GADGET-4 supports collisionless simulations and smoothed particle hydrodynamics on massively parallel computers.

The code can be used for plain Newtonian dynamics, or for cosmological integrations in arbitrary cosmologies, both with or without periodic boundary conditions. Stretched periodic boxes, and special cases such as simulations with two periodic dimensions and one non-periodic dimension are supported as well. The modeling of hydrodynamics is optional. The code is adaptive both in space and in time, and its Lagrangian character makes it particularly suitable for simulations of cosmic structure formation. Several post-processing options such as group- and substructure finding, or power spectrum estimation are built in and can be carried out on the fly or applied to existing snapshots. Through a built-in cosmological initial conditions generator, it is also particularly easy to carry out cosmological simulations. In addition, merger trees can be determined directly by the code.

The cosmological simulation code GADGET-2, a new massively parallel TreeSPH code, is capable of following a collisionless fluid with the N-body method, and an ideal gas by means of smoothed particle hydrodynamics (SPH). The implementation of SPH manifestly conserves energy and entropy in regions free of dissipation, while allowing for fully adaptive smoothing lengths. Gravitational forces are computed with a hierarchical multipole expansion, which can optionally be applied in the form of a TreePM algorithm, where only short-range forces are computed with the `tree'-method while long-range forces are determined with Fourier techniques. Time integration is based on a quasi-symplectic scheme where long-range and short-range forces can be integrated with different timesteps. Individual and adaptive short-range timesteps may also be employed. The domain decomposition used in the parallelisation algorithm is based on a space-filling curve, resulting in high flexibility and tree force errors that do not depend on the way the domains are cut. The code is efficient in terms of memory consumption and required communication bandwidth. It has been used to compute the first cosmological N-body simulation with more than 10^10 dark matter particles, reaching a homogeneous spatial dynamic range of 10^5 per dimension in a 3D box. It has also been used to carry out very large cosmological SPH simulations that account for radiative cooling and star formation, reaching total particle numbers of more than 250 million. GADGET-2 is publicly released to the research community.

GABE (Grid And Bubble Evolver) evolves scalar fields (as well as other purposes) on an expanding background for non-canonical and non-linear classical field theory. GABE is based on the Runge-Kutta method.

GA Galaxy fits models of interacting galaxies to synthetic data using a genetic algorithm and custom fitness function. The genetic algorithm is real-coded and uses a mixed Gaussian kernel for mutation. The fitness function incorporates 1.) a direct pixel-to-pixel comparison between the target and model images and 2.) a comparison of the degree of tidal distortion present in the target and model image such that target-model pairs which are similarly distorted will have a higher relative fitness. The genetic algorithm is written in Python 2.7 while the simulation code (SPAM: Stellar Particle Animation Module) is written in Fortran 90.

Fyris Alpha is a high resolution, shock capturing, multi-phase, up-wind Godunov method hydrodynamics code that includes a variable equation of state and optional microphysics such as cooling, gravity and multiple tracer variables. The code has been designed and developed for use primarily in astrophysical applications, such as galactic and interstellar bubbles, hypersonic shocks, and a range of jet phenomena. Fyris Alpha boasts both higher performance and more detailed microphysics than its predecessors, with the aim of producing output that is closer to the observational domain, such as emission line fluxes, and eventually, detailed spectral synthesis. Fyris Alpha is approximately 75,000 lines of C code; it encapsulates the split sweep semi-lagrangian remap PPM method used by ppmlr (in turn developed from VH1, Blondin et al. 1998) but with an improved Riemann solver, which is derived from the exact solver of Gottlieb and Groth (1988), a significantly faster solution than previous solvers. It has a number of optimisations that have improved the speed so that additional calculations neeed for multi-phase simulations become practical.

Fv is an easy-to-use graphical program for viewing and editing any FITS format image or table. The Fv software is small, completely self-contained and runs on Windows PCs, most Unix platforms and Mac OS-X. Fv also provides a portal into the Hera data analysis service from the HEASARC.

Funtools is a "minimal buy-in" FITS library and utility package developed at the the High Energy Astrophysics Division of SAO. The Funtools library provides simplified access to a wide array of file types: standard astronomical FITS images and binary tables, raw arrays and binary event lists, and even tables of ASCII column data. A sophisticated region filtering library (compatible with ds9) filters images and tables using boolean operations between geometric shapes, support world coordinates, etc. Funtools also supports advanced capabilities such as optimized data searching using index files.

Because Funtools consists of a library and a set of user programs, it is most appropriately built from source. Funtools has been ported to Solaris, Linux, LinuxPPC, SGI, Alpha OSF1, Mac OSX (darwin) and Windows 98/NT/2000/XP. Once the source code tar file is retrieved, Funtools can be built and installed easily using standard commands.

FUNDPAR determines fundamental parameters of solar-type stars, by using as input the Equivalent Widths of Fe I,II lines. The code uses solar-scaled ATLAS9 model atmospheres with NEWODF opacities, together with the 2009 version of the MOOG (ascl:1202.009) program. Parameter files control different details, such as the mixing-length parameter, the overshooting, and the damping of the lines. FUNDPAR also derives the uncertainties of the parameters.

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

FTOOLS, a highly modular collection of utilities for processing and analyzing data in the FITS (Flexible Image Transport System) format, has been developed in support of the HEASARC (High Energy Astrophysics Research Archive Center) at NASA's Goddard Space Flight Center. The FTOOLS package contains many utility programs which perform modular tasks on any FITS image or table, as well as higher-level analysis programs designed specifically for data from current and past high energy astrophysics missions. The utility programs for FITS tables are especially rich and powerful, and provide functions for presentation of file contents, extraction of specific rows or columns, appending or merging tables, binning values in a column or selecting subsets of rows based on a boolean expression. Individual FTOOLS programs can easily be chained together in scripts to achieve more complex operations such as the generation and displaying of spectra or light curves. FTOOLS development began in 1991 and has produced the main set of data analysis software for the current ASCA and RXTE space missions and for other archival sets of X-ray and gamma-ray data. The FTOOLS software package is supported on most UNIX platforms and on Windows machines. The user interface is controlled by standard parameter files that are very similar to those used by IRAF. The package is self documenting through a stand alone help task called fhelp. Software is written in ANSI C and FORTRAN to provide portability across most computer systems. The data format dependencies between hardware platforms are isolated through the FITSIO library package.

FTbg performs Fourier transforms on FITS images and separates low- and high-spatial frequency components by a user-specified cut. Both components are then inverse Fourier transformed back to image domain. FTbg can remove large-scale background/foreground emission in many astrophysical applications. FTbg has been designed to identify and remove Galactic background emission in Herschel/Hi-GAL continuum images, but it is applicable to any other (e.g., Planck) images when background/foreground emission is a concern.

FSPS is a flexible SPS package that allows the user to compute simple stellar populations (SSPs) for a range of IMFs and metallicities, and for a variety of assumptions regarding the morphology of the horizontal branch, the blue straggler population, the post--AGB phase, and the location in the HR diagram of the TP-AGB phase. From these SSPs the user may then generate composite stellar populations (CSPs) for a variety of star formation histories (SFHs) and dust attenuation prescriptions. Outputs include the "observed" spectra and magnitudes of the SSPs and CSPs at arbitrary redshift. In addition to these fortran routines, several IDL routines are provided that allow easy manipulation of the output. FSPS was designed with the intention that the user would make full use of the provided fortran routines. However, the full FSPS package is quite large, and requires some time for the user to become familiar with all of the options and syntax. Some users may only need SSPs for a range of metallicities and IMFs. For such users, standard SSP sets for several IMFs, evolutionary tracks, and spectral libraries are available here.

The fake spectra flux extractor generates simulated quasar absorption spectra from a particle or adaptive mesh-based hydrodynamic simulation. It is implemented as a python module. It can produce both hydrogen and metal line spectra, if the simulation includes metals. The cloudy table for metal ionization fractions is included. Unlike earlier spectral generation codes, it produces absorption from each particle close to the sight-line individually, rather than first producing an average density in each spectral pixel, thus substantially preserving more of the small-scale velocity structure of the gas. The code supports both Gadget (ascl:0003.001) and AREPO (ascl:1909.010).

Fsclean produces 3D Faraday spectra using the Faraday synthesis method, transforming directly from multi-frequency visibility data to the Faraday depth-sky plane space. Deconvolution is accomplished using the CLEAN algorithm, and the package includes Clark and Högbom style CLEAN algorithms. Fsclean reads in MeasurementSet visibility data and produces HDF5 formatted images; it handles images and data of arbitrary size, using scratch HDF5 files as buffers for data that is not being immediately processed, and is limited only by available disk space.

Fruitbat estimates the redshift of Fast Radio Bursts (FRB) from their dispersion measure. The code combines various dispersion measure (DM) and redshift relations with the YMW16 galactic dispersion measure model into a single easy to use API.

FROG performs time series analysis and display. It provides a simple user interface for astronomers wanting to do time-domain astrophysics but still offers the powerful features found in packages such as PERIOD (ascl:1406.005). FROG includes a number of tools for manipulation of time series. Among other things, the user can combine individual time series, detrend series (multiple methods) and perform basic arithmetic functions. The data can also be exported directly into the TOPCAT (ascl:1101.010) application for further manipulation if needed.

FRISBHEE (FRIedmann Solver for Black Hole Evaporation in the Early-universe solves the Friedmann - Boltzmann equations for Primordial Black Holes + SM radiation + BSM Models. Considering the collapse of density fluctuations as the PBH formation mechanism, the code handles monochromatic and extended mass and spin distributions. FRISBHEE can return the full evolution of the PBH, SM and Dark Radiation comoving energy densities, together with the evolution of the PBH mass and spin as a function of the log₁₀ at scale factor, and can determine the relic abundance in the case of Dark Matter produced from BH evaporation for monochromatic and extended distributions.

FRIDDA forecasts the cosmological impact of measurements of the redshift drift and the fine-structure constant (alpha) as well as their combination. The code is based on Fisher Matrix Analysis techniques and works for various fiducial cosmological models. Though designed for the ArmazoNes high Dispersion Echelle Spectrograph (ANDES), it is easily adaptable to other fiducial cosmological models and to other instruments with similar scientific goals.

FRELLED (FITS Realtime Explorer of Low Latency in Every Dimension) creates 3D images in real time from 3D FITS files and is written in Python for the 3D graphics suite Blender. Users can interactively generate masks around regions of arbitrary geometry and use them to catalog sources, hide regions, and perform basic analysis (e.g., image statistics within the selected region, generate contour plots, query NED and the SDSS). World coordinates are supported and multi-volume rendering is possible. FRELLED is designed for viewing HI data cubes and provides a number of tasks to commonly-used MIRIAD (ascl:1106.007) tasks (e.g. mbspect); however, many of its features are suitable for any type of data set. It also includes an n-body particle viewer with the ability to display 3D vector information as well as the ability to render time series movies of multiple FITS files and setup simple turntable rotation movies for single files.

FreeTure monitors images from GigE all-sky cameras to detect and record falling stars and fireball. Originally, it was developed for the FRIPON (Fireball Recovery and InterPlanetary Observation Network) project, which sought to cover all of France with 100 fish eyes cameras, but can be used by any station that has a GigE camera.

FreeEOS is a Fortran library for rapidly calculating the equation of state using an efficient free-energy minimization technique that is suitable for physical conditions in stellar interiors. Converged FreeEOS solutions can be reliably determined for the first time for physical conditions occurring in stellar models with masses between 0.1 M_☉ and the hydrogen-burning limit near 0.07 M_☉ and hot brown-dwarf models just below that limit. However, an initial survey of results for those conditions showed EOS discontinuities (plasma phase transitions) and other problems which will need to be addressed in future work by adjusting the interaction radii characterizing the pressure ionization used for the FreeEOS calculations.

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

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

FRBSTATS provides a user-friendly web interface to an open-access catalog of fast radio bursts (FRBs) published up to date, along with a highly accurate statistical overview of the observed events. The platform supports the retrieval of fundamental FRB data either directly through the FRBSTATS API, or in the form of a CSV/JSON-parsed database, while enabling the plotting of parameter distributions for a variety of visualizations. These features allow researchers to conduct more thorough population studies while narrowing down the list of astrophysical models describing the origins and emission mechanisms behind these sources. Lastly, the platform provides a visualization tool that illustrates associations between primary bursts and repeaters, complementing basic repeater information provided by the Transient Name Server.

frbpoppy conducts fast radio burst population synthesis and continues the work of PSRPOP (ascl:1107.019) and PsrPopPy (ascl:1501.006) in the realm of FRBs. The code replicates observed FRB detection rates and FRB distributions in three steps. It first simulates a cosmic population of one-off FRBs and allows the user to select options such as models for source number density, cosmology, DM host/IGM/Milky Way, luminosity functions, and emission bands as well as maximum redshift and size of the FRB population. The code then generates a survey by adopting a beam pattern using various survey parameters, among them telescope gain, sampling time, receiver temperature, central frequency, channel bandwidth, number of polarizations, and survey region limits. Finally, frbpoppy convolves the generated intrinsic population with the generated survey to simulate an observed FRB population.

CHIME/FRB instrument has recently published a catalog containing about half of thousand fast radio bursts (FRB) including their spectra and several reconstructed properties, like signal widths, amplitudes, etc. We have developed a model-independent approach for the classification of these bursts using cross-correlation and clustering algorithms applied to one-dimensional intensity profiles, i.e. to amplitudes as a function of time averaged over the frequency. This approach is implemented in frbmclust package, which is used for classification of bursts featuring different waveform morphology.

frbcat queries and downloads Fast Radio Burst (FRB) data from the FRBCAT Catalogue web page, the CHIME-REPEATERS web page and the Transient Name Server (TNS). It is written in Python and can be installed using pip.

FRB performs calculations, estimations, analysis, and Bayesian inferences for Fast Radio Bursts, including dispersion measure and emission measure calculations, derived properties and spectrums, and Galactic RM.

Frankenstein (frank) fits the 1D radial brightness profile of an interferometric source given a set of visibilities. It uses a Gaussian process that performs the fit in <1 minute for a typical protoplanetary disc continuum dataset. Frankenstein can perform a fit in 2 ways, by running the code directly from the terminal or using the code as a Python module.

FragMent studies fragmentation in filaments by collating a number of different techniques, including nearest neighbour separations, minimum spanning tree, two-point correlation function, and Fourier power spectrum. It also performs model selection using a frequentist and Bayesian approach to find the best descriptor of a filament's fragmentation. While the code was designed to investigate filament fragmentation, the functions are general and may be used for any set of 2D points to study more general cases of fragmentation.

FPFS (Fourier Power Function Shaplets) is a fast, accurate shear estimator for the shear responses of galaxy shape, flux, and detection. Utilizing leading-order perturbations of shear (a vector perturbation) and image noise (a tensor perturbation), the code determines shear and noise responses for both measurements and detections. Unlike methods that distort each observed galaxy repeatedly, the software employs analytical shear responses of select basis functions, including Shapelets basis and peak basis. FPFS is efficient and can process approximately 1,000 galaxies within a single CPU second, and maintains a multiplicative shear estimation bias below 0.5% even amidst blending challenges.

fpack is a utility program for optimally compressing images in the FITS data format. The associated funpack program will restore the compressed file back to its original state. These programs may be run from the host operating system command line and are analogous to the gzip and gunzip utility programs, except that they are specifically optimized for FITS format images and offer a wider choice of compression options.

fpack uses the tiled image compression convention for storing the compressed images. This convention can in principle support any number of of different compression algorithms; currently GZIP, Rice, Hcompress, and the IRAF pixel list compression algorithms have been implemented.

The main advantages of fpack compared to the commonly used technique of externally compressing the whole FITS file with gzip are:

- It is generally faster and offers better compression than gzip.
- The FITS header keywords remain uncompressed for fast access.
- Each HDU of a multi-extension FITS file is compressed separately, so it is not necessary to uncompress the entire file to read a single image in a multi-extension file.
- Dividing the image into tiles before compression enables faster access to small subsections of the image.
- The compressed image is itself a valid FITS file and can be manipulated by other general FITS utility software.
- Lossy compression can be used for much higher compression in cases where it is not necessary to exactly preserve the original image.
- The CHECKSUM keywords are automatically updated to help verify the integrity of the files.
- Software that supports the tiled image compression technique can directly read and write the FITS images in their compressed form.

Using information theory and Bayesian inference, the foxi Python package computes a suite of expected utilities given futuristic observations in a flexible and user-friendly way. foxi requires a set of n-dim prior samples for each model and one set of n-dim samples from the current data, and can calculate the expected ln-Bayes factor between models, decisiveness between models and its maximum-likelihood averaged equivalent, the decisivity, and the expected Kullback-Leibler divergence (i.e., the expected information gain of the futuristic dataset). The package offers flexible inputs and is designed for all-in-one script calculation or an initial cluster run then local machine post-processing, which should make large jobs quite manageable subject to resources and includes features such as LaTeX tables and plot-making for post-data analysis visuals and convenience of presentation.

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

Fosite implements a method for the solution of hyperbolic conservation laws in curvilinear orthogonal coordinates. It is written in Fortran 90/95 integrating object-oriented (OO) design patterns, incorporating the flexibility of OO-programming into Fortran 90/95 while preserving the efficiency of the numerical computation. Although mainly intended for CFD simulations, Fosite's modular design allows its application to other advection problems as well. Unlike other two-dimensional implementations of finite volume methods, it accounts for local conservation of specific angular momentum. This feature turns the program into a perfect tool for astrophysical simulations where angular momentum transport is crucial. Angular momentum transport is not only implemented for standard coordinate systems with rotational symmetry (i.e. cylindrical, spherical) but also for a general set of orthogonal coordinate systems allowing the use of exotic curvilinear meshes (e.g. oblate-spheroidal). As in the case of the advection problem, this part of the software is also kept modular, therefore new geometries may be incorporated into the framework in a straightforward manner.

ForwardDiff implements methods to take derivatives, gradients, Jacobians, Hessians, and higher-order derivatives of native Julia functions (or any callable object, really) using forward mode automatic differentiation (AD).While performance can vary depending on the functions you evaluate, the algorithms implemented by ForwardDiff generally outperform non-AD algorithms in both speed and accuracy.

FORWARD forward models various coronal observables and can access and compare existing data. Given a coronal model, it can produce many different synthetic observables (including Stokes polarimetry), as well as plots of model plasma properties (density, magnetic field, etc.). It uses the CHIANTI database (ascl:9911.004) and CLE polarimetry synthesis code, works with numerical model datacubes, interfaces with the PFSS module of SolarSoft (ascl:1208.013), includes several analytic models, and connects to the Virtual Solar Observatory for downloading data in a format directly comparable to model predictions.

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

FORSTAND constructs dynamical models of galaxies using the Schwarzschild orbit-superposition method; the method is available as part of the AGAMA (ascl:1805.008) framework. The models created are constrained by line-of-sight kinematic observations and are applicable to galaxies of all morphological types, including disks and triaxial rotating bars.

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

An internally overhauled but fundamentally similar version of Forecaster by Jingjing Chen and David Kipping, originally presented in arXiv:1603.08614 and hosted at https://github.com/chenjj2/forecaster.

The model itself has not changed- no new data was included and the hyperparameter file was not regenerated. All functions were rewritten to take advantage of Numpy vectorization and some additional user features were added. Now able to be installed via pip.

FORECAST generates realistic astronomical images and galaxy surveys by forward modeling the output snapshot of any hydrodynamical cosmological simulation. It exploits the snapshot by constructing a lightcone centered on the observer's position; the code computes the observed fluxes of each simulated stellar element, modeled as a Single Stellar Population (SSP), in any chosen set of pass-band filters, including k-correction, IGM absorption, and dust attenuation. These fluxes are then used to create an image on a grid of pixels, to which observational features such as background noise and PSF blurring can be added. FORECAST provides customizable options for filters, size of the field of view, and survey parameters, thus allowing the synthetic images to be tailored for specific research requirements.

FoF-Halo-finder identifies the location and size of collapsed objects (halos) within a cosmological simulation box. These halos are the host for the luminous objects in the Universe. Written in C, it is based on the friends-of-friends (FoF) algorithm, and is designed to work with PMN-body (ascl:2107.003).

Cosmological simulations of structures and galaxies formations have played a fundamental role in the study of the origin, formation and evolution of the Universe. These studies improved enormously with the use of supercomputers and parallel systems and, recently, grid based systems and Linux clusters. Now we present the new version of the tree N-body parallel code FLY that runs on a PC Linux Cluster using the one side communication paradigm MPI-2 and we show the performances obtained. FLY is included in the Computer Physics Communication Program Library. This new version was developed using the Linux Cluster of CINECA, an IBM Cluster with 1024 Intel Xeon Pentium IV 3.0 Ghz. The results show that it is possible to run a 64 Million particle simulation in less than 15 minutes for each timestep, and the code scalability with the number of processors is achieved. This lead us to propose FLY as a code to run very large N-Body simulations with more than $10^{9}$ particles with the higher resolution of a pure tree code.

FLUXES calculates approximate topocentric positions of the planets and also integrated flux densities of five of them at several wavelengths. These provide calibration information at the effective frequencies and beam-sizes employed by the UKT14, SCUBA and SCUBA-2 receivers on the JCMT telescope based on Mauna Kea, Hawaii. FLUXES is part of the bundle that comprises the Starlink multi-purpose astronomy software package (ascl:1110.012).

Flux provides an elegant approach to machine learning. Written in Julia, it provides lightweight abstractions on top of Julia's native GPU and AD support. It has many useful tools built in, but also lets you use the full power of the Julia language where you need it. Flux has relatively few explicit APIs for features like regularization or embeddings; instead, writing down the mathematical form works and is fast. The package works well with Julia libraries from data frames and images to differential equation solvers, so building complex data processing pipelines that integrate Flux models is straightforward.

Flux Tube is a nonlinear, two-dimensional, numerical simulation of magneto-acoustic wave propagation in the photosphere and chromosphere of small-scale flux tubes with internal structure. Waves with realistic periods of three to five minutes are studied, after horizontal and vertical oscillatory perturbations are applied to the equilibrium model. Spurious reflections of shock waves from the upper boundary are minimized by a special boundary condition.

This Fortran code computes magnetohydrostatic flux tubes and sheets according to the method of Steiner, Pneuman, & Stenflo (1986) A&A 170, 126-137. The code has many parameters contained in one input file that are easily modified. Extensive documentation is provided in README files.

FLUKA (FLUktuierende KAskade) is a general-purpose tool for calculations of particle transport and interactions with matter. FLUKA can simulate with high accuracy the interaction and propagation in matter of about 60 different particles, including photons and electrons from 1 keV to thousands of TeV, neutrinos, muons of any energy, hadrons of energies up to 20 TeV (up to 10 PeV by linking FLUKA with the DPMJET code) and all the corresponding antiparticles, neutrons down to thermal energies and heavy ions. The program, written in Fortran, can also transport polarised photons (e.g., synchrotron radiation) and optical photons. Time evolution and tracking of emitted radiation from unstable residual nuclei can be performed online.

Flicker calculates the mean stellar density of a star by inputting the flicker observed in a photometric time series. Written in Fortran90, its output may be used as an informative prior on stellar density when fitting transit light curves.

Gravitational flexion is a technique for measuring 2nd order gravitational lensing signals in background galaxies and radio lobes. Unlike shear, flexion directly probes variations of the potential field. Moreover, the information contained in flexion is orthogonal to what is found in the shear. Thus, we get the information "for free."

This code combines the spectral sum-conserving methods of Weichselbaum and von Delft and of Peters, Pruschke and Anders (both relying upon the complete basis set construction of Anders and Schiller) with the use of non-Abelian symmetries in a flexible manner: Essentially any non-Abelian symmetry can be taught to the code, and any number of such symmetries can be used throughout the computation for any density of states, and to compute any local operators' correlation function's real and imaginary parts or any thermodynamical expectation value. The code works both at zero and finite temperatures.

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

FLEET (Finding Luminous and Exotic Extragalactic Transients) is a machine-learning pipeline that predicts the probability of a transient to be a superluminous supernova. With light curve and contextual host galaxy information, it uses a random forest algorithm to rapidly identify SLSN-I without the need for redshift information.

FleCSPH is a multi-physics compact application that exercises FleCSI parallel data structures for tree-based particle methods. In particular, the software implements a smoothed-particle hydrodynamics (SPH) solver for the solution of Lagrangian problems in astrophysics and cosmology. FleCSPH includes support for gravitational forces using the fast multipole method (FMM). Particle affinity and gravitation is handled using the parallel implementation of the octree data structure provided by FleCSI.

fleck simulates rotational modulation of stars due to starspots and is used to overcome the degeneracies and determine starspot coverages accurately for a sample of young stars. The code simulates starspots as circular dark regions on the surfaces of rotating stars, accounting for foreshortening towards the limb, and limb darkening. Supplied with the latitudes, longitudes, and radii of spots and the stellar inclinations from which each star is viewed, fleck takes advantage of efficient array broadcasting with numpy to return approximate light curves. For example, the code can compute rotational modulation curves sampled at ten points throughout the rotation of each star for one million stars, with two unique spots each, all viewed at unique inclinations, in about 10 seconds on a 2.5 GHz Intel Core i7 processor. This rapid computation of light curves en masse makes it possible to measure starspot distributions with techniques such as Approximate Bayesian Computation.

FLATW'RM (FLAre deTection With Ransac Method) detects stellar flares in light curves using a classical machine-learning method. The code tries to find a rotation period in the light curve and splits the data to detection windows. The light curve sections are fit with the robust fitting algorithm RANSAC (Random sample consensus); outlier points (flare candidates) above the pre-set detection level are marked for each section. For the given detection window, only those flare candidates that have at least a given number of consecutive points (three by default) are kept and marked as flares. When using FLATW’RM, the code's output should be checked to determine whether changes to the default settings are needed to account for light curve noise, data sampling frequency, and scientific needs.

flatstar is an open-source Python tool for drawing stellar disks as numpy.ndarray objects with scientifically-rigorous limb darkening. Each pixel has an accurate fractional intensity in relation to the total stellar intensity of 1.0. It is ideal for ray-tracing simulations of stars and planetary transits. The code is fast, has the most well-known limb-darkening laws, including linear, quadratic, square-root, logarithmic, and exponential, and allows the user to implement custom limb-darkening laws. flatstar also offers supersampling for situations where both coarse arrays and precision in stellar disk intensity (i.e., no hard pixel boundaries) is desired, and upscaling to save on computation time when high-resolution intensity maps are needed, though there is some precision loss in intensities.

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

The FLASH code, currently in its 4th version, is a publicly available high performance application code which has evolved into a modular, extensible software system from a collection of unconnected legacy codes. FLASH consists of inter-operable modules that can be combined to generate different applications. The FLASH architecture allows arbitrarily many alternative implementations of its components to co-exist and interchange with each other. A simple and elegant mechanism exists for customization of code functionality without the need to modify the core implementation of the source. A built-in unit test framework combined with regression tests that run nightly on multiple platforms verify the code.

FLARE, a parallel code written in Python, generates 100,000 Fast Radio Bursts (FRB) using the Monte Carlo method. The FRB population is diverse and includes sporadic FRBs, repeaters, and periodic repeaters. However, less than 200 FRBs have been detected to date, which makes understanding the FRB population difficult. To tackle this problem, FLARE uses a Monte Carlo method to generate 100,000 realistic FRBs, which can be analyzed later on for further research. It has the capability to simulate FRB distances (based on the observed FRB distance range), energies (based on the "flaring magnetar model" of FRBs), fluences, multi-wavelength counterparts (based on x-ray to radio fluence ratio of FRB 200428), and other properties. It analyzes the resulting synthetic FRB catalog and displays the distribution of their properties. It is fast (as a result of parallel code) and requires minimal human interaction. FLARE is, therefore, able to give a broad picture of the FRB population.

Flame reduces near-infrared and optical multi-object spectroscopic data. Although the pipeline was created for the LUCI instrument at the Large Binocular Telescope, Flame, written in IDL, is modular and can be adapted to work with data from other instruments. The software uses 2D transformations, thus using one interpolation step to wavelength calibrate and rectify the data. The γ(x, y) transformation also includes the spatial misalignment between frames, which can be measured from a reference star observed simultaneously with the science targets; sky subtraction can be performed via nodding and/or modelling of the sky spectrum.

FLAGLET computes flaglet transforms with arbitrary spin direction, probing the angular features of this generic wavelet transform for rapid analysis of signals from wavelet coefficients. The code enables the decomposition of a band-limited signal into a set of flaglet maps that capture all information contained in the initial band-limited map, and it can reconstruct the individual flaglets at varying resolutions. FLAGLET relies upon the SSHT (ascl:2207.034), S2LET (ascl:1211.001), and SO3 codes to provide angular transforms and sampling theorems, as well as the FFTW (ascl:1201.015) code to compute Fourier transforms.

FLAGging and CALlibration (FLAGCAL) is a software pipeline developed for automatic flagging and calibration of the GMRT data. This pipeline can be used for preprocessing (before importing the data in AIPS) any other interferromteric data also (given that the data file is in FITS format and contains multiple channels & scans).There are also a few GUI based tools which can be used for quick visualization of the data.

FLAG is a fast implementation of the Fourier-Laguerre Transform, a novel 3D transform exploiting an exact quadrature rule of the ball to construct an exact harmonic transform in 3D spherical coordinates. The angular part of the Fourier-Laguerre transform uses the MW sampling theorem and the exact spherical harmonic transform implemented in the SSHT code (ascl:2207.034). The radial sampling scheme arises from an exact quadrature of the radial half-line using damped Laguerre polynomials. The radial transform can in fact be used to compute the spherical Bessel transform exactly, and the Fourier-Laguerre transform is thus closely related to the Fourier-Bessel transform.

Most high energy sources detected with Fermi-LAT are blazars, which are highly variable sources. High cadence long-term monitoring simultaneously at different wavelengths being prohibitive, the study of their transient activities can help shed light on our understanding of these objects. The early detection of such potentially fast transient events is the key for triggering follow-up observations at other wavelengths. FLaapLUC (Fermi-LAT automatic aperture photometry Light C↔Urve) uses the simple aperture photometry approach to effectively detect relative flux variations in a set of predefined sources and alert potential users. Such alerts can then be used to trigger observations of these sources with other facilities. The FLaapLUC pipeline is built on top of the Science Tools provided by the Fermi-LAT collaboration and quickly generates short- or long-term Fermi-LAT light curves.

fkpt computes the 1-loop redshift space power spectrum for tracers using perturbation theory for LCDM and Modified Gravity theories using "fk"-Kernels. Though implemented for the Hu-Sawicky f(R) modified gravity model, it is straightforward to use it for other models.

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

FitsMap visualizes astronomical image and catalog data. Implemented in Python, the software is a simple, lightweight tool, requires only a simple web server, and can scale to over gigapixel images with tens of millions of sources. Further, the web-based visualizations can be viewed performantly on mobile devices.

With the increase of personal storage capacity, it is easy to find hundreds to thousands of FITS files in the personal computer of an astrophysicist. Because Flexible Image Transport System (FITS) is a professional data format initiated by astronomers and used mainly in the small community, data management toolkits for FITS files are very few. Astronomers need a powerful tool to help them manage their local astronomical data. Although Virtual Observatory (VO) is a network oriented astronomical research environment, its applications and related technologies provide useful solutions to enhance the management and utilization of astronomical data hosted in an astronomer's personal computer. FITSManager is such a tool to provide astronomers an efficient management and utilization of their local data, bringing VO to astronomers in a seamless and transparent way. FITSManager provides fruitful functions for FITS file management, like thumbnail, preview, type dependent icons, header keyword indexing and search, collaborated working with other tools and online services, and so on. The development of the FITSManager is an effort to fill the gap between management and analysis of astronomical data.

FITSH provides a standalone environment for analysis of data acquired by imaging astronomical detectors. The package provides utilities both for the full pipeline of subsequent related data processing steps (including image calibration, astrometry, source identification, photometry, differential analysis, low-level arithmetic operations, multiple image combinations, spatial transformations and interpolations, etc.) and for aiding the interpretation of the (mainly photometric and/or astrometric) results. The package also features a consistent implementation of photometry based on image subtraction, point spread function fitting and aperture photometry and provides easy-to-use interfaces for comparisons and for picking the most suitable method for a particular problem. The utilities in the package are built on the top of the commonly used UNIX/POSIX shells (hence the name of the package), therefore both frequently used and well-documented tools for such environments can be exploited and managing massive amount of data is rather convenient.

FITSFH derives star formation histories from photometry of resolved stellar populations by populating theoretical isochrones according to a chosen stellar initial mass function (IMF) and searching for the linear combination of isochrones with different ages and metallicities that best matches the data. In comparing the synthetic and real data, observational errors and incompleteness are taken into account, and a rudimentary treatment of the effect of unresolved binaries is also implemented. The code also allows for an age-dependent range of extinction values to be included in the modelling.

fitScalingRelation fits galaxy cluster scaling relations using orthogonal or bisector regression and MCMC. It takes into account errors on both variables and intrinsic scatter. Although it geared for fitting galaxy cluster scaling relations of all kinds, it can be used for any kind of regression problem with errors on both variables and intrinsic scatter.

fits2hdf ports FITS files to Hierarchical Data Format (HDF5) files in the HDFITS format. HDFITS allows faster reading of data, higher compression ratios, and higher throughput. HDFITS formatted data can be presented transparently as an in-memory FITS equivalent by changing the import lines in Python-based FITS utilities. fits2hdf includes a utility to port MeasurementSets (MS) to HDF5 files.

The ESA/ESO/NASA FITS Liberator makes it possible to process and edit astronomical science data in the FITS format to produce stunning images of the universe. Formerly a plugin for Adobe Photoshop, the current version of FITS Liberator is a stand-alone application and no longer requires Photoshop. This image processing software makes it possible to create color images using raw observations from a range of telescopes; the FITS Liberator continues to support the FITS and PDS formats, preferred by astronomers and planetary scientists respectively, which enables data to be processed from a wide range of telescopes and planetary probes, including ESO’s Very Large Telescope, the NASA/ESA Hubble Space Telescope, NASA’s Spitzer Space Telescope, ESA’s XMM–Newton Telescope and Cassini–Huygens or Mars Reconnaissance Orbiter.

The fitOmatic model-fitting prototyping tool tests multi-wavelength model-fitting and exploits VLTI data. It provides tools to define simple geometrical models and conveniently adjust the model's parameters. Written in Yorick, it takes optical interferometry FITS (oifits) files as input and allows the user to define a model of the source from a set of pre-defined models, which can be combined to make more complicated models. fitOmatic then computes the Fourier Transform of the modeled brightness distribution and synthetic observables are computed at the wavelengths and projected baselines of the observations. fitomatic's strength is its ability to define vector-parameters, i.e., parameters that may depend on wavelength and/or time. The self-cal (ascl:2301.006) component of fitOmatic is also available as a separate code.

FITDisk models accretion disk phenomena using a fully three-dimensional hydrodynamics calculation, and data can either be visualized as they are computed or stored to hard drive for later playback at a fast frame rate. Simulations are visualized using OpenGL graphics and the viewing angle can be changed interactively. Pseudo light curves of simulated systems can be plotted along with the associated Fourier amplitude spectrum. It provides an easy to use graphical user interface as well as 3-D interactive graphics. The code computes the evolution of a CV accretion disk, visualizes results in real time, records and plays back simulations, and generates and plots pseudo light curves and associated power spectra. FITDisk is the Windows executable form of this software; its Fortran source code is also available as DiskSim (ascl:1811.013).

FitCov estimates the covariance of two-point correlation functions in a way that requires fewer mocks than the standard mock-based covariance. Rather than using an analytically fixed correction to some terms that enter the jackknife covariance matrix, the code fits the correction to a mock-based covariance obtained from a small number of mocks. The fitted jackknife covariance remains unbiased, an improvement over other methods, performs well both in terms of precision (unbiased constraints) and accuracy (similar uncertainties), and requires significant less computational power. In addition, FitCov can be easily implemented on top of the standard jackknife covariance computation.

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

Fit kinematic PA measures the global kinematic position-angle (PA) from integral field observations of a galaxy stellar or gas kinematics; the code is available in IDL and Python.

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

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

FishLSS computes the Fisher information matrix for a set of observables and model parameters. It can model the redshift-space power spectrum of any biased tracer of the CDM+baryon field and the post-reconstruction galaxy power spectrum. The code also models the projected cross-correlation of galaxies with the CMB lensing convergence, the projected galaxy power spectrum, and the CMB lensing convergence power spectrum. FishLSS requires pyFFTW (ascl:2109.009), velocileptors (ascl:2308.014), and CLASS (ascl:1106.020).

The Fisher4Cast suite, which requires MatLab, provides a standard, tested tool set for general Fisher Information matrix prediction and forecasting for use in both research and education. The toolbox design is robust and modular, allowing for easy additions and adaptation while keeping the user interface intuitive and easy to use. Fisher4Cast is completely general but the default is coded for cosmology. It provides parameter error forecasts for cosmological surveys providing distance, Hubble expansion and growth measurements in a general, curved FLRW background.

Fisher.py allows you to combine constraints from multiple experiments (e.g., weak lensing + supernovae) and add priors (e.g., a flat universe) simply and easily. Calculate parameter uncertainties and plot confidence ellipses. Fisher matrix expectations for several experiments are included as calculated by myself (time delays) and the Dark Energy Task Force (WL/SN/BAO/CL/CMB), or provide your own.

FISA (Fast Integrated Spectra Analyzer) permits fast and reasonably accurate age and reddening determinations for small angular diameter open clusters by using their integrated spectra in the (3600-7400) AA range and currently available template spectrum libraries. This algorithm and its implementation help to achieve astrophysical results in shorter times than from other methods. FISA has successfully been applied to integrated spectroscopy of open clusters, both in the Galaxy and in the Magellanic Clouds, to determine ages and reddenings.

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

Firefly provides interactive exploration of particle-based data in the browser. The user can filter, display vector fields, and toggle the visibility of their customizable datasets all on-the-fly. Different Firefly visualizations, complete with preconfigured data and camera view-settings, can be shared by URL. As Firefly is written in WebGL, it can be hosted online, though Firefly can also be used locally, without an internet connection. Firefly was developed with simulations of galaxy formation in mind but is flexible enough to display any particle-based data. Other features include a stereoscopic 3D picture mode and mobile compatibility.

FIREFLY (Fitting IteRativEly For Likelihood analYsis) derives stellar population properties of stellar systems, whether observed galaxy or star cluster spectra or model spectra from simulations. The code fits combinations of single-burst stellar population models to spectroscopic data following an iterative best-fitting process controlled by the Bayesian Information Criterion without applying priors. Solutions within a statistical cut are retained with their weight, which is arbitrary. No additive or multiplicative polynomia are used to adjust the spectral shape and no regularization is imposed. This fitting freedom allows mapping of the effect of intrinsic spectral energy distribution (SED) degeneracies, such as age, metallicity, dust reddening on stellar population properties, and quantifying the effect of varying input model components on such properties.

FIRE Studio is a Python interface for C libraries that project Smoothed Particle Hydrodynamic (SPH) datasets. These C libraries can, in principle, be applied to any SPH dataset; the Python interface is specialized to conveniently load and format Gadget-derivative datasets such as GIZMO (ascl:1410.003). FIRE Studio is fast, memory efficient, and parallelizable. In addition to producing "1-color" projection maps for SPH datasets, the interface can produce "2-color" maps, where the pixel saturation is set by one projected quantity and the hue is set by another, and "3-color" maps, where three quantities are projected simultaneously and remapped into an RGB colorspace. FIRE Studio can model stellar emission and dust extinction to produce mock Hubble images (by default) or to model surface brightness maps for thirteen of the most common bands (plus the bolometric luminosity). It produces publication quality static images of simulation datasets and provides interpolation scripts to create movies that smoothly evolve in time (provided multiple snapshots in time of the data exist), view the dataset from different perspectives (taking advantage of shared memory buffers to allow massive parallelization), or both.

FIPS is a cross-platform FITS viewer with a responsive user interface. Unlike other FITS viewers, FIPS uses GPU hardware via OpenGL to provide functionality such as zooming, panning and level adjustments. OpenGL 2.1 and later is supported. FIPS supports all 2D image formats except floating point formats on OpenGL 2.1. FITS image extension has basic limited support.

Finesse is a numeric simulation for laser interferometers and models parametric instabilities, easily providing the required mechanical-to-optical transfer functions in imperfect and arbitrary interferometer configurations using Hermite-Gaussian beams. The code has been used to apply limits to the number and type of higher order modes used in simulation and investigate the potential use of higher order Laguerre-Gauss modes to reduce thermal noise in future gravitational wave detector designs. The PyKat wrapper (ascl:2004.014) helps automate complex Finesse tasks.

Finder_charts creates multi-band finder charts from image data of various partial- and all-sky surveys such as DSS, 2MASS, WISE, UKIDSS, VHS, Pan-STARRS, and DES. It also creates a WISE time series of image data acquired between 2010 and 2021. All images are reprojected so that north is up and east is to the left. The resulting finder charts can be overplotted with corresponding catalog positions. All catalog entries within the specified field of view can be saved in a variety of formats, including ipac, csv, and tex, as can the finder charts in png, pdf, eps, and other common graphics formats. Finder_charts consists of a single Python module, which depends only on well-known packages, making it easy to install.

Find_Orb takes a set of observations of an asteroid, comet, or natural or artificial satellite given in the MPC (Minor Planet Center) format, the ADES astrometric format, and/or the NEODyS or AstDyS formats, and finds the corresponding orbit.

FilTER (Filament Trait-Evaluated Reconstruction) post-processes output from DisPerSE (ascl:1302.015 ) to produce a set of filaments that are well-defined and have measured properties (e.g. width), then cuts the profiles, fits and assesses them to reconstruct new filaments according to defined criteria.

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

Figaro (sometimes referred to as "standalone Figaro") is a data reduction system that originated at Caltech and whose development continued at the Anglo-Australian Observatory. Although it is intended to be able to deal with any sort of data, almost all its applications to date are geared towards processing optical and infrared data. Figaro uses hierarchical data structures to provide flexibility in its data file formats. Figaro was originally written to run under DEC's VMS operating system, but is now available both for VAX/VMS (by special request) and for various flavors of UNIX including Linux and MacOS.

A variant of Figaro (ascl:1411.022) is incorporated into the Starlink package (ascl:1110.012).

FIEStool automatically reduces data obtained with the FIber-fed Echelle Spectrograph (FIES) at the Nordic Optical Telescope, a high-resolution spectrograph available on a stand-by basis, while also allowing the basic properties of the reduction to be controlled in real time by the user. It provides a Graphical User Interface and offers bias subtraction, flat-fielding, scattered-light subtraction, and specialized reduction tasks from the external packages IRAF (ascl:9911.002) and NumArray. The core of FIEStool is instrument-independent; the software, written in Python, could with minor modifications also be used for automatic reduction of data from other instruments.

FieldInf is a collection of fast modern Fortran routines for computing exactly the background evolution and primordial power spectra of any single field inflationary models. It implements reheating without any assumptions through the "reheating parameter" R allowing robust inflationary parameter estimations and inference on the reheating energy scale. The underlying perturbation code actually deals with N fields minimally-coupled and/or non-minimally coupled to gravity and works for flat FLRW only.

fiducial_flare generates a reasonable approximation of the UV emission of M dwarf stars over a single flare or a series of them. The simulated radiation is resolved in both wavelength and time. The intent is to provide consistent input for applications requiring time-dependent stellar UV radiation fields that balances simplicity with realism, namely for simulations of exoplanet atmospheres.

The FIBRE-pac (FMOS image-based reduction package) is an IRAF-based reduction tool for the fiber multiple-object spectrograph (FMOS) of the Subaru telescope. To reduce FMOS images, a number of special techniques are necessary because each image contains about 200 separate spectra with airglow emission lines variable in spatial and time domains, and with complicated throughput patterns for the airglow masks. In spite of these features, almost all of the reduction processes except for a few steps are carried out automatically by scripts in text format making it easy to check the commands step by step. Wavelength- and flux-calibrated images together with their noise maps are obtained using this reduction package.

fibmeasure finds the precise locations of the centers of back-illuminated optical fibers in images. It was developed for astronomical fiber positioning feedback via machine vision cameras and is optimized for high-magnification images where fibers appear as resolvable circles. It was originally written during the design of the WEAVE pick-and-place fiber positioner for the William Herschel Telescope.

FHD is an open-source imaging algorithm for radio interferometers and is written in IDL. The three main use-cases for FHD are efficient image deconvolution for general radio astronomy, fast-mode Epoch of Reionization analysis, and simulation. FHD inputs beam models, calibration files, and sky model catalogs and requires input data to be in uvfits format.

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

FGBuster (ForeGroundBuster) separates frequency maps into component maps and forecasts component separation both when the model is correct and when it is incorrect. FGBuster can be used for SED evaluation, intermediate component separation, multi-resolution separation, and forecasting, among other tasks.

FFTW is a C subroutine library for computing the discrete Fourier transform (DFT) in one or more dimensions, of arbitrary input size, and of both real and complex data (as well as of even/odd data, i.e. the discrete cosine/sine transforms or DCT/DST).

Benchmarks performed on a variety of platforms show that FFTW's performance is typically superior to that of other publicly available FFT software, and is even competitive with vendor-tuned codes. In contrast to vendor-tuned codes, however, FFTW's performance is portable: the same program will perform well on most architectures without modification.

The FFTW library is required by other codes such as StarCrash (ascl:1010.074) and Hammurabi (ascl:1201.014).

FFTLog is a set of Fortran subroutines that compute the fast Fourier or Hankel (= Fourier-Bessel) transform of a periodic sequence of logarithmically spaced points. FFTLog can be regarded as a natural analogue to the standard Fast Fourier Transform (FFT), in the sense that, just as the normal FFT gives the exact (to machine precision) Fourier transform of a linearly spaced periodic sequence, so also FFTLog gives the exact Fourier or Hankel transform, of arbitrary order m, of a logarithmically spaced periodic sequence.

FFTLog-and-beyond takes the FFTLog algorithm for single-Bessel integrals and generalizes it for integrals containing a derivative of the Bessel function to solve the non-Limber integrals. The full non-Limber angular power spectrum integral is simplified by noting the small contribution from unequal-time nonlinear terms; this significantly reduces the computation and avoids the double-Bessel integral. The original FFTLog algorithm is also extended to compute integrals containing derivatives of Bessel functions, which can be used to efficiently compute angular power spectra including redshift-space distortions (RSD) and Doppler effects. C and Python versions of the code are available.

FFD (Flare Frequency Distribution) fits power-laws to FFDs. FFDs relate the frequency (i.e., occurrence rate) of flares to their energy, peak flux, photometric equivalent width, or other parameters. This module was created to handle disparate datasets between which the flare detection limit varies; in essence, the number of flares detected is treated as following a Poisson distribution while the flare energies are treated as following a power law.

FFANCY uses the Fast Folding Algorithm (FFA) on a distributed-computing framework to search for pulsars in time-domain series data. This enables the algorithm to be applied to all-sky blind pulsar surveys. The package runs an implementation of the FFA on real or simulated pulsar time series data in either SIGPROC (ascl:1107.016) or PRETSO (ascl:1107.017) format with a choice of additional algorithms to be used in the evaluation of each folded profile and outputs a periodogram along with other output threads used for testing. It also contains routines that convert the periodogram output into a list of pulsar candidates with options for candidate grouping and harmonic matching, generate simulated pulsar profiles for use in testing profile evaluation algorithms independent of the FFA, provide basic statistics for the folded profiles produced by progeny, test individual profiles using profiles produced by progeny, and other complementary functions.

Fewbody is a numerical toolkit for simulating small-N gravitational dynamics. It is a general N-body dynamics code, although it was written for the purpose of performing scattering experiments, and therefore has several features that make it well-suited for this purpose. Fewbody uses the 8th-order Runge-Kutta Prince-Dormand integration method with 9th-order error estimate and adaptive timestep to advance the N-body system forward in time. It integrates the usual formulation of the N-body equations in configuration space, but allows for the option of global pairwise Kustaanheimo-Stiefel (K-S) regularization (Heggie 1974; Mikkola 1985). The code uses a binary tree algorithm to classify the N-body system into a set of independently bound hierarchies, and performs collisions between stars in the “sticky star” approximation. Fewbody contains a collection of command line utilities that can be used to perform individual scattering and N-body interactions, but is more generally a library of functions that can be used from within other codes.

FETCH (Fast Extragalactic Transient Candidate Hunter) provides real-time classification of candidates from single pulse search pipelines. The package takes in a candidate file of frequency-time and DM-time data and, for each candidate and choice of model, provides the probability that the candidate is an FRB. FETCH also provides a framework for fine-tuning the models to further improve its performance for particular backends.

FERRE matches physical models to observed data, taking a set of observations and identifying the model parameters that best reproduce the data, in a chi-squared sense. It solves the common problem of having numerical parametric models that are costly to evaluate and need to be used to interpret large data sets. FERRE provides flexibility to search for all model parameters, or hold constant some of them while searching for others. The code is written to be truly N-dimensional and fast. Model predictions are to be given as an array whose values are a function of the model parameters, i.e., numerically. FERRE holds this array in memory, or in a direct-access binary file, and interpolates in it. The code returns, in addition to the optimal set of parameters, their error covariance, and the corresponding model prediction. The code is written in FORTRAN90.

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

Fermipy facilitates analysis of data from the Large Area Telescope (LAT) with the Fermi Science Tools. It is built on the pyLikelihood interface of the Fermi Science Tools and provides a set of high-level tools for performing common analysis tasks, including data and model preparation with the gt-tools, extracting a spectral energy distribution (SED) of a source, and generating TS and residual maps for a region of interest. Fermipy also finds new source candidates and can localize a source or fit its spatial extension. The package uses a configuration-file driven workflow in which the analysis parameters (data selection, IRFs, and ROI model) are defined in a YAML configuration file. Analysis is executed through a python script that calls the methods of GTAnalysis to perform different analysis operations.

fermi-gce-flows uses a machine learning-based technique to characterize the contribution of modeled components, including unresolved point sources, to the GCE. It can perform posterior parameter estimation while accounting for pixel-to-pixel spatial correlations in the gamma-ray map. On application to Fermi data, the method generically attributes a smaller fraction of the GCE flux to unresolved point source-like emission when compared to traditional approaches.

Bandpass shifting and the (1+z)5 surface brightness dimming (for a fixed width filter) make standard tools for the extraction of structural parameters of galaxies wavelength dependent. If only few (or one) observed high-res bands exist, this dependence has to be corrected to make unbiased statements on the evolution of structural parameters or on galaxy subsamples defined by morphology. FERENGI artificially redshifts low-redshift galaxy images to different redshifts by applying the correct cosmological corrections for size, surface brightness and bandpass shifting. A set of artificially redshifted galaxies in the range 0.1<z<1.1 using a set of ~100 SDSS low-redshift (v<7000 km s-1) images as input has been created to use as a training set of realistic images of galaxies of diverse morphologies and a large range of redshifts for the GEMS and COSMOS galaxy evolution projects. This training set allows other studies to investigate and quantify the effects of cosmological redshift on the determination of galaxy morphologies, distortions, and other galaxy properties that are potentially sensitive to resolution, surface brightness, and bandpass issues. The data sets are also available for download from the FERENGI website.

FEniCS solves partial differential equations (PDEs) and enables users to quickly translate scientific models into efficient finite element code. With the high-level Python and C++ interfaces to FEniCS, it is easy to get started, but FEniCS offers also powerful capabilities for more experienced programmers. FEniCS runs on a multitude of platforms ranging from laptops to high-performance clusters, and each component of the FEniCS platform has been fundamentally designed for parallel processing. This framework allows for rapid prototyping of finite element formulations and solvers on laptops and workstations, and the same code may then be deployed on large high-performance computers.

feets characterizes and analyzes light-curves from astronomical photometric databases for modelling, classification, data cleaning, outlier detection and data analysis. It uses machine learning algorithms to determine the numerical descriptors that characterize and distinguish the different variability classes of light-curves; these range from basic statistical measures such as the mean or standard deviation to complex time-series characteristics such as the autocorrelation function. The library is not restricted to the astronomical field and could also be applied to any kind of time series. This project is a derivative work of FATS (ascl:1711.017).

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

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

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

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

fcmaker creates astronomical finding charts for Observing Blocks (OBs) on the p2 web server from the European Southern Observatory (ESO). It automates the creation of ESO-compliant finding charts for Service Mode and/or Visitor Mode OBs at the Very Large Telescope (VLT). The design of the fcmaker finding charts, based on an intimate knowledge of VLT observing procedures, is fine-tuned to best support night time operations. As an automated tool, fcmaker also allows observers to independently check visually, for the first time, the observing sequence coded inside an OB. This includes, for example, the signs of telescope and position angle offsets.

FCLC (Featureless Classification of Light Curves) software describes the static behavior of a light curve in a probabilistic way. Individual data points are converted to densities and consequently probability density are compared instead of features. This gives rise to an independent classification which can corroborate the usefulness of the selected features.

FCFC (Fast Correlation Function Calculator) computes correlation functions from pair counts. It supports the isotropic 2-point correlation function, anisotropic 2PCF, 2-D 2PCF, and 2PCF Legendre multipoles, among others. Written in C, FCFC takes advantage of three parallelisms that can be used simultaneously, distributed-memory processes via Message Passing Interface (MPI), shared-memory threads via Open Multi-Processing (OpenMP), and single instruction, multiple data (SIMD).

FBEYE, the "Flares By-Eye" detection suite, is written in IDL and analyzes Kepler light curves and validates flares. It works on any 3-column light curve that contains time, flux, and error. The success of flare identification is highly dependent on the smoothing routine, which may not be suitable for all sources.

The fragmentation and bulk composition tracking package contains two codes. The fragmentation code models fragmentation in collisions for the C version of REBOUND (ascl:1110.016). This code requires setting two global parameters. It automatically produces a collision report that details the time of every collision, the bodies involved, how the collision was resolved, and how many fragments were produced; collision outcomes are assigned a numerical value. The bulk composition tracking code tracks the composition change as a function of mass exchange for bodies with a homogenous composition. It is a post-processing code that works in conjunction with the fragmentation code, and requires the collision report generated by the fragmentation code.

FATS facilitates and standardizes feature extraction for time series data; it quickly and efficiently calculates a compilation of many existing light curve features. Users can characterize or analyze an astronomical photometric database, though this library is not necessarily restricted to the astronomical domain and can also be applied to any kind of time series data.

FAT (Fully Automated TiRiFiC) is an automated procedure that fits tilted-ring models to Hi data cubes of individual, well-resolved galaxies. The method builds on the 3D Tilted Ring Fitting Code (TiRiFiC, ascl:1208.008). FAT accurately models the kinematics and the morphologies of galaxies with an extent of eight beams across the major axis in the inclination range 20°-90° without the need for priors such as disc inclination. FAT's performance allows us to model the gas kinematics of many thousands of well-resolved galaxies, which is essential for future HI surveys, with the Square Kilometre Array and its pathfinders.

FastSpecFit models the observed-frame optical spectroscopy and broadband photometry of extragalactic targets using physically grounded stellar continuum and emission-line templates. The code handles data from the Dark Energy Spectroscopic Instrument (DESI) Survey, which is amassing spectrophotometry for an unprecedented 40 million extragalactic targets, although the algorithms are general enough to accommodate other upcoming, massively multiplexed spectroscopic surveys. FastSpecFit extracts nearly 800 observed- and rest-frame quantities from each target, including light-weighted ages and stellar velocity dispersions based on the underlying stellar continuum; line-widths, velocity shifts, integrated fluxes, and equivalent widths for nearly 40 rest-frame ultraviolet, optical, and near-infrared emission lines arising from both star formation and active galactic nuclear activity; and K-corrections and rest-frame absolute magnitudes and colors. Moreover, FastSpecFit is designed with speed and parallelism in mind, enabling it to deliver robust model fits to tens of millions of targets.

fastSHT performs spherical harmonic transforms on a large number of spherical maps. It converts massive SHT operations to a BLAS level 3 problem and uses the highly optimized matrix multiplication toolkit to accelerate the computation. GPU acceleration is supported and can be very effective. The core code is written in Fortran, but a Python wrapper is provided and recommended.

Fastrometry is a Python implementation of the fast world coordinate solution solver for the FITS standard astronomical image. When supplied with the approximate field center (+-25%) and the approximate field scale (+-10%) of the telescope and detector system the astronomical image is from, fastrometry provides WCS solutions almost instantaneously. The algorithm is also originally implemented with parallelism enabled in the Windows FITS image processor and viewer CCDLAB (ascl:2206.021).

FastQSL calculate the squashing factor Q at the photosphere, a cross section, or a box volume, given a 3D magnetic field with Cartesian, uniform or stretched grids. It is available in IDL and in an optimized version using Fortran for calculations and field line tracing. Use of a GPU accelerates a step-size adaptive scheme for the most computationally intensive part, the field line tracing, making the code fast and efficient.

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

PSF fitting photometry allows a simultaneously fit of a PSF profile on the sources. Many routines use PSF fitting photometry, including IRAF/allstar, Strarfinder, and Convphot. These routines are in general complex to use and slow. FASTPHOT is optimized for prior extraction (the position of the sources is known) and is very fast and simple.

The analysis of weak lensing data requires to account for missing data such as masking out of bright stars. To date, the majority of lensing analyses uses the two point-statistics of the cosmic shear field. These can either be studied directly using the two-point correlation function, or in Fourier space, using the power spectrum. The two-point correlation function is unbiased by missing data but its direct calculation will soon become a burden with the exponential growth of astronomical data sets. The power spectrum is fast to estimate but a mask correction should be estimated. Other statistics can be used but these are strongly sensitive to missing data. The solution that is proposed by FASTLens is to properly fill-in the gaps with only NlogN operations, leading to a complete weak lensing mass map from which one can compute straight forwardly and with a very good accuracy any kind of statistics like power spectrum or bispectrum.

The FastJet package provides fast native implementations of many sequential recombination algorithms, including the longitudinally invariant kt longitudinally invariant inclusive Cambridge/Aachen and anti-kt jet finders. It also provides a uniform interface to external jet finders via a plugin mechanism. FastJet also includes tools for calculating jet areas and performing background (pileup/UE) subtraction and for jet substructure analyses.

Because of their simplicity, axisymmetric mass distributions are often used to model gravitational lenses. Since galaxies are usually observed to have elliptical light distributions, mass distributions with elliptical density contours offer more general and realistic lens models. They are difficult to use, however, since previous studies have shown that the deflection angle (and magnification) in this case can only be obtained by rather expensive numerical integrations. We present a family of lens models for which the deflection can be calculated to high relative accuracy (10-5) with a greatly reduced numerical effort, for small and large ellipticity alike. This makes it easier to use these distributions for modeling individual lenses as well as for applications requiring larger computing times, such as statistical lensing studies. FASTELL is a code to calculate quickly and accurately the lensing deflection and magnification matrix for the softened power-law elliptical mass distribution (SPEMD) lens galaxy model. The SPEMD consists of a softened power-law radial distribution with elliptical isodensity contours.

FastDF (Fast Distribution Function) integrates relativistic particles along geodesics in a comoving periodic volume with forces determined by cosmological linear perturbation theory. Its main application is to set up accurate particle realizations of the linear phase-space distribution of massive relic neutrinos by starting with an analytical solution deep in radiation domination. Such particle realizations are useful for Monte Carlo experiments and provide consistent initial conditions for cosmological N-body simulations. Gravitational forces are calculated from three-dimensional potential grids, which are obtained by convolving random phases with linear transfer functions using Fast Fourier Transforms. The equations of motion are solved using a symplectic leapfrog integration scheme to conserve phase-space density and prevent the build-up of errors. Particles can be exported in different gauges and snapshots are provided in the HDF5 format, compatible with N-body codes like SWIFT (ascl:1805.020) and Gadget-4 (ascl:2204.014). The code has an interface with CLASS (ascl:1106.020) for calculating transfer functions and with monofonIC (ascl:2008.024) for setting up initial conditions with dark matter, baryons, and neutrinos.

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

The Fast Chi-Squared Algorithm is a fast, powerful technique for detecting periodicity. It was developed for analyzing variable stars, but is applicable to many of the other applications where the Fast Fourier Transforms (FFTs) or other periodograms (such as Lomb-Scargle) are currently used. The Fast Chi-squared technique takes a data set (e.g. the brightness of a star measured at many different times during a series of observations) and finds the periodic function that has the best frequency and shape (to an arbitrary number of harmonics) to fit the data. Among its advantages are:

• Statistical efficiency: all of the data are used, weighted by their individual error bars, giving a result with a significance calibrated in well-understood Chi-squared statistics.
• Sensitivity to harmonic content: many conventional techniques look only at the significance (or the amplitude) of the fundamental sinusoid and discard the power of the higher harmonics.
• Insensitivity to the sample timing: you won't find a period of 24 hours just because you take your observations at night. You do not need to window your data.
• The frequency search is gridded more tightly than the traditional "integer number of cycles over the span of observations", eliminating power loss from peaks that fall between the grid points.
• Computational speed: The complexity of the algorithm is O(NlogN), where N is the number of frequencies searched, due to its use of the FFT.

FastChem is an equilibrium chemistry code that calculates the chemical composition of the gas phase for given temperatures and pressures. Written in C++, it is based on a semi-analytic approach and is optimized for extremely fast and accurate calculations.

Fastcc returns color corrections for different spectra for various Cosmic Microwave Background experiments. Available in both Python and IDL, the script is easy to use when analyzing radio spectra of sources with data from multiple wide-survey CMB experiments in a consistent way across multiple experiments.

FAST (Fitting and Assessment of Synthetic Templates) fits stellar population synthesis templates to broadband photometry and/or spectra. FAST is compatible with the photometric redshift code EAzY (ascl:1010.052) when fitting broadband photometry; it uses the photometric redshifts derived by EAzY, and the input files (for examply, photometric catalog and master filter file) are the same. FAST fits spectra in combination with broadband photometric data points or simultaneously fits two components, allowing for an AGN contribution in addition to the host galaxy light. Depending on the input parameters, FAST outputs the best-fit redshift, age, dust content, star formation timescale, metallicity, stellar mass, star formation rate (SFR), and their confidence intervals. Though some of FAST's functions overlap with those of HYPERZ (ascl:1108.010), it differs by fitting fluxes instead of magnitudes, allows the user to completely define the grid of input stellar population parameters and easily input photometric redshifts and their confidence intervals, and calculates calibrated confidence intervals for all parameters. Note that FAST is not a photometric redshift code, though it can be used as one.

FAST-PT calculates 1-loop corrections to the matter power spectrum in cosmology. The code utilizes Fourier methods combined with analytic expressions to reduce the computation time down to scale as N log N, where N is the number of grid point in the input linear power spectrum. FAST-PT is extremely fast, enabling mode-coupling integral computations fast enough to embed in Monte Carlo Markov Chain parameter estimation.

We place functional constraints on the shape of the inflaton potential from the cosmic microwave background through a variant of the generalized slow roll approximation that allows large amplitude, rapidly changing deviations from scale-free conditions. Employing a principal component decomposition of the source function G'~3(V'/V)^2 - 2V''/V and keeping only those measured to better than 10% results in 5 nearly independent Gaussian constraints that maybe used to test any single-field inflationary model where such deviations are expected. The first component implies < 3% variations at the 100 Mpc scale. One component shows a 95% CL preference for deviations around the 300 Mpc scale at the ~10% level but the global significance is reduced considering the 5 components examined. This deviation also requires a change in the cold dark matter density which in a flat LCDM model is disfavored by current supernova and Hubble constant data and can be tested with future polarization or high multipole temperature data. Its impact resembles a local running of the tilt from multipoles 30-800 but is only marginally consistent with a constant running beyond this range. For this analysis, we have implemented a ~40x faster WMAP7 likelihood method which we have made publicly available.

FASMA delivers the atmospheric stellar parameters (effective temperature, surface gravity, metallicity, microturbulence, macroturbulence, and rotational velocity) based on the spectral synthesis technique. This technique relies on the comparison of synthetic spectra with observations to yield the best-fit parameters under a χ2 minimization process. FASMA also delivers chemical abundances of 13 elements. Written in Python, the code is wrapped around MOOG (ascl:1202.009) which calculates the synthetic spectra. FASMA includes two grids of models in MOOG readable format, Kurucz and marcs, that cover the parameter space for both dwarf and giant stars with metallicity limit of -5.0 dex.

A successor of FARGO (ascl:1102.017), FARGO3D is a versatile HD/MHD code that runs on clusters of CPUs or GPUs, with special emphasis on protoplanetary disks. FARGO3D offers Cartesian, cylindrical or spherical geometry; 1-, 2- or 3-dimensional calculations; and orbital advection (aka FARGO) for HD and MHD calculations. As in FARGO, a simple Runge-Kutta N-body solver may be used to describe the orbital evolution of embedded point-like objects. There is no need to know CUDA; users can develop new functions in C and have them translated to CUDA automatically to run on GPUs.

FARGO is an efficient and simple modification of the standard transport algorithm used in explicit eulerian fixed polar grid codes, aimed at getting rid of the average azimuthal velocity when applying the Courant condition. This results in a much larger timestep than the usual procedure, and it is particularly well-suited to the description of a Keplerian disk where one is traditionally limited by the very demanding Courant condition on the fast orbital motion at the inner boundary. In this modified algorithm, the timestep is limited by the perturbed velocity and by the shear arising from the differential rotation. The speed-up resulting from the use of the FARGO algorithm is problem dependent. In the example presented in the code paper below, which shows the evolution of a Jupiter sized protoplanet embedded in a minimum mass protoplanetary nebula, the FARGO algorithm is about an order of magnitude faster than a traditional transport scheme, with a much smaller numerical diffusivity.

FAMIAS (Frequency Analysis and Mode Identification for Asteroseismology) is a package of software tools programmed in C++ for the analysis of photometric and spectroscopic time-series data. FAMIAS provides analysis tools that are required for the steps between the data reduction and the seismic modeling. Two main sets of tools are incorporated in FAMIAS. The first set permits to search for periodicities in the data using Fourier and non-linear least-squares fitting techniques. The other set permits to carry out a mode identification for the detected pulsation frequencies to determine their harmonic degree l, and azimuthal order m. FAMIAS is applicable to main-sequence pulsators hotter than the Sun. This includes Gamma Dor, Delta Sct stars, slowly pulsating B (SPB)-stars and Beta Cep stars - basically all stars for which empirical mode identification is required to successfully carry out asteroseismology.

The FAMED (Fast and AutoMated pEak bagging with Diamonds) pipeline is a multi-platform parallelized software that performs and automates extraction and mode identification of oscillation frequencies for solar-like pulsators. The pipeline can be applied to a large variety of stars, ranging from hot F-type main sequence, up to stars evolving along the red giant branch, settled into the core-Helium-burning main sequence, and even evolved beyond towards the early asymptotic giant branch. FAMED is based on DIAMONDS (ascl:1410.001), a Bayesian parameter estimation and model comparison by means of the nested sampling Monte Carlo (NSMC) algorithm.

FAMA (Fast Automatic MOOG Analysis), written in Perl, computes the atmospheric parameters and abundances of a large number of stars using measurements of equivalent widths (EWs) automatically and independently of any subjective approach. Based on the widely-used MOOG code, it simultaneously searches for three equilibria, excitation equilibrium, ionization balance, and the relationship between logn(FeI) and the reduced EWs. FAMA also evaluates the statistical errors on individual element abundances and errors due to the uncertainties in the stellar parameters. Convergence criteria are not fixed "a priori" but instead are based on the quality of the spectra.

FalconIC generates discrete particle positions, velocities, masses and pressures based on linear Boltzmann solutions that are computed by libraries such as CLASS and CAMB. FalconIC generates these initial conditions for any species included in the selection, including Baryons, Cold Dark Matter and Dark Energy fluids. Any species can be set in Eulerian (on a fixed grid) or Lagrangian (particle motion) representation, depending on the gauge and reality chosen. That is, for relativistic initial conditions in the synchronous comoving gauge, Dark Matter can only be described in an Eulerian representation. For all other choices (Relativistic in Longitudinal gauge, Newtonian with relativistic expansion rates, Newtonian without any notion of radiation), all species can be treated in all representations. The code also computes spectra. FalconIC is useful for comparative studies on initial conditions.

FAlCon-DNS (Framework of time schemes for direct numerical simulation of annular convection) solves for 2-D convection in an annulus and analyzes different time integration schemes. The framework contains a suite of IMEX, IMEXRK and RK time integration schemes. The code uses a pseudospectral method for spatial discretization. The governing equations contain both numerically stiff (diffusive) and non-stiff (advective) components for time discretization. The software offers OpenMP for parallelization.

FALCO (Fast Linearized Coronagraph Optimizer) performs coronagraphic focal plane wavefront correction. It includes routines for pair-wise probing estimation of the complex electric field and Electric Field Conjugation (EFC) control. FALCO utilizes and builds upon PROPER (ascl:1405.006) and rapidly computes the linearized response matrix for each DM, which facilitates re-linearization after each control step for faster DM-integrated coronagraph design and wavefront correction experiments. A MATLAB implementation of FALCO (ascl:2304.004) is also available.

FALCO (Fast Linearized Coronagraph Optimizer) performs coronagraphic focal plane wavefront correction. It includes routines for pair-wise probing estimation of the complex electric field and Electric Field Conjugation (EFC) control. FALCO utilizes and builds upon PROPER (ascl:1405.006) and rapidly computes the linearized response matrix for each DM, which facilitates re-linearization after each control step for faster DM-integrated coronagraph design and wavefront correction experiments. A Python 3 implementation of FALCO (ascl:2304.005) is also available.

The CASA (1107.013) task FAKEOBS generates model visibilities from already-existing measurement sets. This task can be used to substitute all the visibilities of the target with simulations computed from any model image. The measurement can either be with real or simulated data, the target can have been observed in mosaic mode, and there can be several sources (e.g., bandpass calibrator, flux/phase calibrator, and target).

The Faiss library performs efficient similarity search and clustering of dense vectors. It contains algorithms that search in sets of vectors of any size, up to ones that possibly do not fit in RAM. It also contains supporting code for evaluation and parameter tuning. Faiss is written in C++ with complete wrappers for Python/numpy. Some of the most useful algorithms are implemented on the GPU.

FacetClumps extracts and analyses clumpy structure in molecular clouds. Written in Python and based on the Gaussian Facet model, FacetClumps extracts signal regions using morphology, and segments the signal regions into local regions with a gradient-based method. It then applies a connectivity-based minimum distance clustering method to cluster the local regions to the clump centers. FacetClumps automatically adjusts its parameters to local situations to improve adaptability, and is optimized to detect faint and overlapping clumps.

FAC calculates various atomic radiative and collisional processes, including radiative transition rates, collisional excitation and ionization by electron impact, energy levels, photoionization, and autoionization, and their inverse processes radiative recombination and dielectronic capture. The package also includes a collisional radiative model to construct synthetic spectra for plasmas under different physical conditions.

FABADA (Fully Adaptive Bayesian Algorithm for Data Analysis) performs non-parametric noise reduction using Bayesian inference. It iteratively evaluates possible smoothed models of the data to estimate the underlying signal that is statistically compatible with the noisy measurements. Iterations stop based on the evidence E and the χ² statistic of the last smooth model, and the expected value of the signal is computed as a weighted average of the smooth models. Though FABADA was written for astronomical data, such as spectra (1D) or images (2D), it can be used as a general noise reduction algorithm for any one- or two-dimensional data; the only requisite of the input data is an estimation of its associated variance.

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

EzTao models time series as a continuous-time autoregressive moving-average (CARMA) process. EzTao utilizes celerite (ascl:1709.008), a fast and scalable Gaussian Process Regression library, to evaluate the likelihood function. On average, EzTao is ten times faster than other tools relying on a Kalman filter for likelihood computation.

EzGal is a flexible Python program which generates observable parameters (magnitudes, colors, and mass-to-light ratios) for arbitrary input stellar population synthesis (SPS) models; it enables simple, direct comparison of different model sets so that the uncertainty introduced by choice of model set can be quantified. EzGal is also capable of generating composite stellar population models (CSPs) for arbitrary input star-formation histories and reddening laws, and can be used to interpolate between metallicities for a given model set.

EZ (Easy-Z) estimates redshifts for extragalactic objects. It compares the observed spectrum with a set of (user given) spectral templates to find out the best value for the redshift. To accomplish this task, it uses a highly configurable set of algorithms. EZ is easily extendible with new algorithms. It is implemented as a set of C programs and a number of python classes. It can be used as a standalone program, or the python classes can be directly imported by other applications.

EZ_Ages is an IDL code package that computes the mean, light-weighted stellar population age, [Fe/H], and abundance enhancements [Mg/Fe], [C/Fe], [N/Fe], and [Ca/Fe] for unresolved stellar populations. This is accomplished by comparing Lick index line strengths between the data and the stellar population models of Schiavon (2007), using a method described in Graves & Schiavon (2008). The algorithm uses the inversion of index-index model grids to determine ages and abundances, and exploits the sensitivities of the various Lick indices to measure Mg, C, N, and Ca enhancements over their solar abundances with respect to Fe.

In EyE (Enhance Your Extraction) an artificial neural network connected to pixels of a moving window (retina) is trained to associate these input stimuli to the corresponding response in one or several output image(s). The resulting filter can be loaded in SExtractor (ascl:1010.064) to operate complex, wildly non-linear filters on astronomical images. Typical applications of EyE include adaptive filtering, feature detection and cosmetic corrections.

Extreme-deconvolution is a general algorithm to infer a d-dimensional distribution function from a set of heterogeneous, noisy observations or samples. It is fast, flexible, and treats the data's individual uncertainties properly, to get the best description possible for the underlying distribution. It performs well over the full range of density estimation, from small data sets with only tens of samples per dimension, to large data sets with hundreds of thousands of data points.

extrapops simulates extra-galactic populations of gravitational waves sources and models their emission during the inspiral phase. The code approximately assesses the detectability of individual sources by LISA and computes the background due to unresolved sources in the LISA band using different methods. The simulated populations can be saved in a format compatible with LISA LDC. Simulations are well calibrated to produce accurate background calculations and fair random generation at the tails of the distributions, which is important for accurate probability of detectable events. extrapops uses a number of ad-hoc techniques for rapid simulation and allows room for further optimization up to almost 1 order of magnitude.

ExtLaw_H18 generates the extinction law between 0.8 - 2.2 microns. The law is derived using the Westerlund 1 (Wd1) main sequence (A_Ks ~ 0.6 mag) and Arches cluster field Red Clump at the Galactic Center (A_Ks ~ 2.7 mag). To derive the law a Wd1 cluster age of 5 Myr is assumed, though changing the cluster age between 4 Myr -- 7 Myr has no effect on the law. This extinction law can be applied to highly reddened stellar populations that have similar foreground material as Wd1 and the Arches RC, namely dust from the spiral arms of the Milky Way in the Galactic Plane.

extinction is an implementation of fast interstellar dust extinction laws in Python. It contains Cython-optimized implementations of empirical dust extinction laws found in the literature. Flux values can be reddened or dereddened using included functions, and all extinction laws accept a unit keyword to change the interpretation of the wavelength array from Angstroms to inverse microns. Part of this code originated in the specutils package (ascl:1902.012).

Extinction-distances uses the number of foreground stars and a Galactic model of the stellar distribution to estimate the distance to dark clouds. It exploits the relatively narrow range of intrinsic near-infrared colors of stars to separate foreground from background stars. An advantage of this method is that the distribution of stellar colors in the Galactic model need not be precisely correct, only the number density as a function of distance from the Sun.

The program EXTINCT.FOR is a FORTRAN subroutine summarizing a three-dimensional visual Galactic extinction model, based on a number of published studies. INPUTS: Galactic latitude (degrees), Galactic longitude (degrees), and source distance (kpc). OUTPUTS (magnitudes): Extinction, extinction error, a statistical correction term, and an array containing extinction and extinction error from each subroutine. The model is useful for correcting visual magnitudes of Galactic sources (particularly in statistical models), and has been used to find Galactic extinction of extragalactic sources. The model's limited angular resolution (subroutine-dependent, but with a minimum resolution of roughly 2 degrees) is necessitated by its ability to describe three-dimensional structure.

EXSdetect is a python implementation of an X-ray source detection algorithm which is optimally designed to detected faint extended sources and makes use of Voronoi tessellation and Friend-of-Friend technique. It is a flexible tool capable of detecting extended sources down to the lowest flux levels attainable within instrumental limitations while maintaining robust photometry, high completeness, and low contamination, regardless of source morphology. EXSdetect was developed mainly to exploit the ever-increasing wealth of archival X-ray data, but is also ideally suited to explore the scientific capabilities of future X-ray facilities, with a strong focus on investigations of distant groups and clusters of galaxies.

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

exoVista generates a "universe" of planetary systems, creating thousands of models of quasi-self-consistent planetary systems around known nearby stars at scattered light wavelengths. It efficiently records the position, velocity, spectrum, and physical parameters of all bodies as functions of time. exoVista models can be used for simulating surveys using the direct imaging, transit, astrometric, and radial velocity techniques.

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

EXOTIC (EXOplanet Transit Interpretation Code) analyzes photometric data of transiting exoplanets into lightcurves and retrieves transit epochs and planetary radii. The software reduces images of a transiting exoplanet into a lightcurve, and fits a model to the data to extract planetary information crucial to increasing the efficiency of larger observational platforms. EXOTIC is written in Python and supports the citizen science project Exoplanet Watch. The software runs on Windows, Macintosh, and Linux/Unix computer, and can also be used via Google Colab.

ExoTETHyS models exoplanetary transits, eclipsing binaries, and related phenomena. The package calculates stellar limb-darkening coefficients down to <10 parts per million (ppm) and generates an exact transit light-curve based on the entire stellar intensity profile rather than limb-darkening coefficients.

ExoSOFT provides orbital analysis of exoplanets and binary star systems. It fits any combination of astrometric and radial velocity data, and offers four parameter space exploration techniques, including MCMC. It is packaged with an automated set of post-processing and plotting routines to summarize results, and is suitable for performing orbital analysis during surveys with new radial velocity and direct imaging instruments.

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

ExoSim models host star and planet transit events, simulating the temporal change in stellar flux due to the light curve. It is wavelength-dependent, using an input planet spectrum to determine the light curve depth for any given wavelength and can capture temporal effects, such as correlated noise. ExoSim's star spot simulator produces simulated observations that include spot and facula contamination. The code is flexible and can be generically applied to different instruments that simulate specific time-dependent processes.

ExoRT is a flexible, two-stream radiative transfer code that interfaces with CAM/CESM (http://www.cesm.ucar.edu/models/current.html) or 1D offline; it is also used with ExoCAM (ascl:2002.020). Quadrature is used for shortwave and hemispheric mean is used for longwave. The gas phase optical depths are calculate using a correlated K-distribution method, with overlapping bands treated using an amount weighted scheme. Cloud optics are treated using mie scattering for both liquid and ice clouds, and cloud overlap is treated using Monte Carlo Independent Column Approximation.