Lensed performs forward parametric modelling of strong lenses. Using a provided model, Lensed renders the expected image of the lensing event for a large number of parameter settings, thereby exploring the space of possible realizations of the observation. It compares the expectation to the observed image by calculating the likelihood that the observation was indeed produced by the assumed model, thus reconstructing the probability distribution over the parameter space of the model. Written in C, the code uses a massively parallel ray-tracing kernel to perform the necessary calculations on a graphics processing unit (GPU), making the precise rendering of the background lensed sources fast and allowing the simultaneous optimization of tens of parameters for the selected model.

The LensCNN (Convolutional Neural Network) identifies images containing gravitational lensing systems after being trained and tested on simulated images, recovering most systems that are identifiable by eye.

Lemon solves the radiative transfer (RT) processes that contain scattering. These processes are described by differentio-integral equations with given initial or boundary conditions; Lemon solves these differentio-integral equations, which can be converted into the second kind integral equations of Fredholm. The code then obtains the Neumman solution (a series that consists of infinite terms of multiple integrals) from the Fredholm integral equation, and uses the Monte Carlo (MC) method to evaluate these integrals. Lemon is written in Fortran; IDL programs are included for plotting the results.

LEMON is a differential-photometry pipeline, written in Python, that determines the changes in the brightness of astronomical objects over time and compiles their measurements into light curves. This code makes it possible to completely reduce thousands of FITS images of time series in a matter of only a few hours, requiring minimal user interaction.

LEGWORK (LISA Evolution and Gravitational Wave ORbit Kit) is a simple package for gravitational wave calculations. It evolves binaries and computes signal-to-noise ratios for binary systems potentially observable with LISA; it also visualizes the results. LEGWORK can also compare different detector sensitivity curves, compute the horizon distance for a collection of sources, and tracks signal-to-noise evolution over time.

Legolas (Large Eigensystem Generator for One-dimensional pLASmas) is a finite element code for MHD spectroscopy of 1D Cartesian/cylindrical equilibria with flow that balance pressure gradients, enriched with various non-adiabatic effects. The code's capabilities range from full spectrum calculations to eigenfunctions of specific modes to full-on parametric studies of various equilibrium configurations in different geometries.

The Python module legacystamps provides easy retrieval, both standalone and scripted, of FITS and JPEG cutouts from the DESI Legacy Imaging Surveys through URLs provided by the Legacy Survey viewer.

LEFTfield forward models cosmological matter density fields and biased tracers of large-scale structure. The model, written in C++ code, is centered around classes encapsulating scalar, vector, and tensor grids. It includes the complete bias expansion at any order in perturbations and captures general expansion histories without relying on the EdS approximation; however, the latter is also implemented and results in substantially smaller computational demands. LEFTfield includes a subset of the nonlinear higher-derivative terms in the bias expansion of general tracers.

LECTOR is a Fortran 77 code that measures line-strengths in one dimensional ascii spectra. The code returns the values of the Lick indices as well as those of Vazdekis & Arimoto 1999, Vazdekis et al. 2001, Rose 1994, Jones & Worthey 1995 and Cenarro et al. 2001. The code measures as many indices as you wish if the limits of two pseudocontinua (at each side of the feature) and the feature itself (i.e. Lick-style index definition) are provided. The Lick-style indices could be either expressed in pseudo-equivalent widths or in magnitudes. If requested the program provides index error estimates on the basis of photon statistics.

Least Asymmetry finds the center of a distribution of light in an image using the least asymmetry method; the code also contains center of light and fitting a Gaussian routines. All functions in Least Asymmetry are designed to take optional weights.

LDC3 samples physically permissible limb darkening coefficients for the Sing et al. (2009) three-parameter law. It defines the physically permissible intensity profile as being everywhere-positive, monotonically decreasing from center to limb and having a curl at the limb. The approximate sampling method is analytic and thus very fast, reproducing physically permissible samples in 97.3% of random draws (high validity) and encompassing 94.4% of the physically permissible parameter volume (high completeness).

ld-exosim selects the optimal (i.e. best estimator in a MSE sense) limb-darkening law for a given transiting exoplanet lightcurve and calculates the limb-darkening induced biases on various exoplanet parameters. Limb-darkening laws include linear, quadratic, logarithmic, square-root and three-parameter laws.

lcsim creates artificial light curves using two algorithms. The first simulates Gaussian distributed light curves following a specific power spectral density (PSD) freely selectable by the user. The second algorithm simulates light curves following a specific PSD and matching a specific probability density function (PDF). The package provides methods to resample the simulated light curves and add "observational" noise. Furthermore, the package provides an interface to a SQLite3-based database to store and access the simulations.

lcps searches for transit-like features (i.e., dips) in photometric data. Its main purpose is to restrict large sets of light curves to a number of files that show interesting behavior, such as drops in flux. While lcps is adaptable to any format of time series, its I/O module is designed specifically for photometry of the Kepler spacecraft. It extracts the pre-conditioned PDCSAP data from light curves files created by the standard Kepler pipeline. It can also handle csv-formatted ascii files. lcps uses a sliding window technique to compare a section of flux time series with its surroundings. A dip is detected if the flux within the window is lower than a threshold fraction of the surrounding fluxes.

Light Curves Classifier uses data mining and machine learning to obtain and classify desired objects. This task can be accomplished by attributes of light curves or any time series, including shapes, histograms, or variograms, or by other available information about the inspected objects, such as color indices, temperatures, and abundances. After specifying features which describe the objects to be searched, the software trains on a given training sample, and can then be used for unsupervised clustering for visualizing the natural separation of the sample. The package can be also used for automatic tuning parameters of used methods (for example, number of hidden neurons or binning ratio).

Trained classifiers can be used for filtering outputs from astronomical databases or data stored locally. The Light Curve Classifier can also be used for simple downloading of light curves and all available information of queried stars. It natively can connect to OgleII, OgleIII, ASAS, CoRoT, Kepler, Catalina and MACHO, and new connectors or descriptors can be implemented. In addition to direct usage of the package and command line UI, the program can be used through a web interface. Users can create jobs for ”training” methods on given objects, querying databases and filtering outputs by trained filters. Preimplemented descriptors, classifier and connectors can be picked by simple clicks and their parameters can be tuned by giving ranges of these values. All combinations are then calculated and the best one is used for creating the filter. Natural separation of the data can be visualized by unsupervised clustering.

LBLRTM (Line-By-Line Radiative Transfer Model) is an accurate line-by-line model that is efficient and highly flexible. LBLRTM attributes provide spectral radiance calculations with accuracies consistent with the measurements against which they are validated and with computational times that greatly facilitate the application of the line-by-line approach to current radiative transfer applications. LBLRTM has been extensively validated against atmospheric radiance spectra from the ultra-violet to the sub-millimeter.

LBLRTM's heritage is in FASCODE [Clough et al., 1981, 1992].

LBL derives velocity measurements from high-resolution (R>50 000) datasets by accounting for outliers in the spectra data. It is tailored for fiber-fed multi-order spectrographs, both in optical and near-infrared (up to 2.5µm) domains. The domain is split into individual units (lines) and the velocity and its associated uncertainty are measured within each line and combined through a mixture model to allow for the presence of spurious values. In addition to the velocity, other quantities are also derived, the most important being a value (dW) that can be understood (for a Gaussian line) as a change in the line FWHM. These values provide useful stellar activity indicators. LBL works on data from a variety of instruments, including SPIRou, NIRPS, HARPS, and ESPRESSO. The code's output is an rdb table that can be uploaded to the online DACE pRV analysis tool.

LavAtmos performs gas-melt equilibrium calculations for a given temperature and melt composition. The thermodynamics of the melt are modeled by the MELTS code as presented in the Thermoengine package (ascl:2208.006). In combination with atmospheric chemistry codes, LavAtmos enables the characterization of interior compositions through atmospheric signatures.

The Lattimer-Swesty Equation of State code is rapid enough to use directly in hydrodynamical simulations such as stellar collapse calculations. It contains an adjustable nuclear force that accurately models both potential and mean-field interactions and allows for the input of various nuclear parameters, including the bulk incompressibility parameter, the bulk and surface symmetry energies, the symmetric matter surface tension, and the nucleon effective masses. This permits parametric studies of the equation of state in astrophysical situations. The equation of state is modeled after the Lattimer, Lamb, Pethick, and Ravenhall (LLPR) compressible liquid drop model for nuclei, and includes the effects of interactions and degeneracy of the nucleon outside nuclei.

LATTICEEASY creates lattice simulations of the evolution of interacting scalar fields in an expanding universe. The program can do runs with different parameters and new models can be easily introduced for evaluation. Simulations can be done in one, two, or three dimensions by resetting a single variable. Mathematica notebooks for plotting the output and a range of models are also available for download; a parallel processing version of LATTICEEASY called CLUSTEREASY (ascl:1911.016) is also available.

LATTE identifies, vets and characterizes signals in TESS lightcurves to weed out instrumental and astrophysical false positives. The program performs a fast in-depth analysis of targets that have already been identified as promising candidates by the main TESS pipelines or via alternative methods such as citizen science. The code automatically downloads the data products for any chosen TIC ID (short or long cadence TESS data) and produces a number of diagnostic plots that are compiled in a concise report.

lasso_spectra fits Lasso regression models to data, specifically galaxy spectra. It contains two classes for performing the actual model fitting. GeneralizedLasso is a tensorflow implementation of Lasso regression, which includes the ability to use link functions. SKLasso is a wrapper around the scikit-learn Lasso implementation intended to give the same syntax as GeneralizedLasso. It is much faster and more reliable, but does not support generalized linear models.

LaSSI produces forecasts for the LSST 3x2 point functions analysis, or the LSSTxCMB S4 and LSSTxSO 6x2 point functions analyses using a Fisher matrix. It computes the auto and cross correlations of galaxy number density, galaxy shear and CMB lensing convergence. The software includes the effect of Gaussian and outlier photo-z errors, shear multiplicative bias, linear galaxy bias, and extensions to ΛCDM.

LASR removes stellar variability in the light curves of δ-Scuti and similar stars. It subtracts oscillations from a time series by minimizing their statistical significance in frequency space.

Lare3d is a Lagrangian-remap code for solving the non-linear MHD equations in three spatial dimensions.

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

LAPACK provides routines for solving systems of simultaneous linear equations, least-squares solutions of linear systems of equations, eigenvalue problems, and singular value problems. The associated matrix factorizations (LU, Cholesky, QR, SVD, Schur, generalized Schur) are also provided, as are related computations such as reordering of the Schur factorizations and estimating condition numbers. Dense and banded matrices are handled, but not general sparse matrices. In all areas, similar functionality is provided for real and complex matrices, in both single and double precision. The list of LAPACK Contributors is available online.

LANL* calculates the magnetic drift invariant L*, used for modeling radiation belt dynamics and other space weather applications, six orders of magnitude (~ one million times) faster than convectional approaches that require global numerical field lines tracing and integration. It is based on a modern machine learning technique (feed-forward artificial neural network) by supervising a large data pool obtained from the IRBEM library, which is the traditional source for numerically calculating the L* values. The pool consists of about 100,000 samples randomly distributed within the magnetosphere (r: [1.03, 11.5] Re) and within a whole solar cycle from 1/1/1994 to 1/1/2005. There are seven LANL* models, each corresponding to its underlying magnetic field configuration that is used to create the data sample pool. This model has applications to real-time radiation belt forecasting, analysis of data sets involving tens of satellite-years of observations, and other problems in space weather.

LAMDA provides users of radiative transfer codes with the basic atomic and molecular data needed for the excitation calculation. Line data of a number of astrophysically interesting species are summarized, including energy levels, statistical weights, Einstein A-coefficients and collisional rate coefficients. Available collisional data from quantum chemical calculations and experiments are in some cases extrapolated to higher energies. Currently the database contains atomic data for 3 species and molecular data for 28 different species. In addition, several isotopomers and deuterated versions are available. This database should form an important tool in analyzing observations from current and future infrared and (sub)millimetre telescopes. Databases such as these rely heavily on the efforts by the chemical physics community to provide the relevant atomic and molecular data. Further efforts in this direction are strongly encouraged so that the current extrapolations of collisional rate coefficients can be replaced by actual calculations in future releases.

RADEX (ascl:1010.075), a computer program for performing statistical equilibrium calculations, is made publicly available as part of the data base.

LAMBDAR measures galaxy fluxes from an arbitrary FITS image, covering an arbitrary photometric wave-band, when provided all parameters needed to construct galactic apertures at the required locations for multi-band matched aperture galactic photometry. Through sophisticated matched aperture photometry, the package develops robust Spectral Energy Distributions (SEDs) and accurately establishes the physical properties of galactic objects. LAMBDAR was based on a package detailed in Bourne et al. (2012) that determined galactic fluxes in low resolution Herschel images.

LALSuite contains numerous gravitational wave analysis libraries. Written primarily in C, the libraries include math and signal analysis packages such as for vector manipulation, FFT, statistics, time-domain filtering, and numerical and signal injection routines. The libraries also include date and time and datatype factory routines, in addition to general and support tools and a variety of Python packages. Also included are packages for gravitational waveform and noise generation, burst gravitational wave data analysis, inspiral and ringdown CBC gravitational wave data analysis, pulsar and continuous wave gravitational wave data analysis, and Bayesian inference data analysis. Various wrappers and other tools are also included.

The NASA Langley Fu-Liou radiative transfer code (also known as Ed4 LaRC Fu-Liou) computes broadband solar shortwave and thermal long wave profiles of down-welling and up-welling flux accounting for gas absorption by H2O, CO2, O3, O2, CH4, N2O and CFCs and absorption and scattering by clouds and aerosols. Longwave has options of a four-stream or 2/4 stream solver, while shortwave has options for two-stream, four-stream or Gamma weighted two-stream (GWTSA) which treats the inhomogeniety of cloud optical depth. A delta-Eddington approximation is used to treat the forward scattering peak. Water cloud properties are based on Mie calculations and ice cloud properties or the ice particle aspect ratio. Aerosol properties are given for 25 types.

LACEwING (LocAting Constituent mEmbers In Nearby Groups) uses the kinematics (positions and motions) of stars to determine if they are members of one of 10 nearby young moving groups or 4 nearby open clusters within 100 parsecs. It is written for Python 2.7 and depends upon Numpy, Scipy, and Astropy (ascl:1304.002) modules. LACEwING can be used as a stand-alone code or as a module in other code. Additional python programs are present in the repository for the purpose of recalibrating the code and producing other analyses, including a traceback analysis.

The l1 periodogram searches for periodicities in unevenly sampled time series. It can be used similarly as a Lomb-Scargle periodogram, and retrieves a figure which has a similar aspect but has fewer peaks due to aliasing. It is primarily designed for the search of exoplanets in radial velocity data, but can be also used for other purposes. The principle of the algorithm is to search for a representation of the input signal as a sum of a small number of sinusoidal components, that is a representation which is sparse in the frequency domain. Here, "small number" means small compared to the number of observations.

Conventional algorithms for rejecting cosmic rays in single CCD exposures rely on the contrast between cosmic rays and their surroundings and may produce erroneous results if the point-spread function is smaller than the largest cosmic rays. This code uses a robust algorithm for cosmic-ray rejection, based on a variation of Laplacian edge detection. The algorithm identifies cosmic rays of arbitrary shapes and sizes by the sharpness of their edges and reliably discriminates between poorly sampled point sources and cosmic rays. Examples of its performance are given for spectroscopic and imaging data, including Hubble Space Telescope Wide Field Planetary Camera 2 images, in the code paper.

L-PICOLA generates and evolves a set of initial conditions into a dark matter field and can include primordial non-Gaussianity in the simulation and simulate the past lightcone at run-time, with optional replication of the simulation volume. It is a fast, distributed-memory, planar-parallel code. L-PICOLA is extremely useful for both current and next generation large-scale structure surveys.

The KvW code applies the Kwee Van Woerden (KvW) method for eclipse or transit minimum timing, with an improved error calculation that avoids underestimated errors in minimum times that may appear in the original method. This is particularly the case for low-noise eclipse or transit lightcurves from space or from modern ground instrumentation. The code requires an input light curve of near-equidistant points that contains only the eclipse, without any off-eclipse points, and is available in python and IDL. Both implementaitons return an eclipse minimum time with its error and provide optional text output and plots, as well as several levels of debug information.

kungifu is a set of IDL software routines designed for the calibration and reduction of fiber-fed integral-field unit (IFU) astronomical spectroscopy. These routines can perform optimal extraction of IFU data and allow relative and absolute wavelength calibration to within a few hundredths of a pixel (for unbinned data) across 1200-2000 fibers. kungifu does nearly Poisson-limited sky subtraction, even in the I band, and can rebin in wavelength. The Princeton IDLUTILS and IDLSPEC2D packages must be installed for kungifu to run.

The routines in ktransit create and fit a transiting planet model. The underlying model is a Fortran implementation of the Mandel & Agol (2002) limb darkened transit model. The code calculates a full orbital model and eccentricity can be allowed to vary; radial velocity data can also be calculated via the model and included in the fit.

KSTAT calculates the 2 and 3-point correlation functions in discreet point data. These include the two-point correlation function in 2 and 3-dimensions, the anisotripic 2PCF decomposed in either sigma-pi or Kazin's dist. mu projection. The 3-point correlation function can also work in anisotropic coordinates. The code is based on kd-tree structures and is parallelized using a mixture of MPI and OpenMP.

KS Intergration solves for mutual photometric effects produced by planets and spots allowing for analysis of planetary occultations of spots and spots regions. It proceeds by identifying integrable and non integrable arcs on the objects profiles and analytically calculates the solution exploiting the power of Kelvin-Stokes theorem. It provides the solution up to the second degree of the limb darkening law.

KROME, given a chemical network (in CSV format), automatically generates all the routines needed to solve the kinetics of the system modeled as a system of coupled Ordinary Differential Equations. It provides a large set of physical processes connected to chemistry, including photochemistry, cooling, heating, dust treatment, and reverse kinetics. KROME is flexible and can be used for a wide range of astrophysical simulations. The package contains a network for primordial chemistry, a small metal network appropriate for the modeling of low metallicities environments, a detailed network for the modeling of molecular clouds, and a network for planetary atmospheres as well as a framework for the modelling of the dust grain population.

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

kplr provides a lightweight Pythonic interface to the catalog of planet candidates (Kepler Objects of Interest [KOIs]) in the NASA Exoplanet Archive and the data stored in the Barbara A. Mikulski Archive for Space Telescopes (MAST). kplr automatically supports loading Kepler data using pyfits (ascl:1207.009) and supports two types of data: light curves and target pixel files.

The kozai Python package evolves hierarchical triple systems in the secular approximation. As its name implies, the kozai package is useful for studying Kozai-Lidov oscillations. The kozai package can represent and evolve hierarchical triples using either the Delaunay orbital elements or the angular momentum and eccentricity vectors. kozai contains functions to calculate the period of Kozai-Lidov oscillations and the maximum eccentricity reached; it also contains a module to study octupole order effects by averaging over individual Kozai-Lidov oscillations.

Korg computes stellar spectra from 1D model atmospheres and linelists assuming local thermodynamic equilibrium and implements both plane-parallel and spherical radiative transfer. The code is generally faster than other codes, and is compatible with automatic differentiation libraries and easily extensible, making it ideal for statistical inference and parameter estimation applied to large data sets.

kombine is an ensemble sampler built for efficiently exploring multimodal distributions. By using estimates of ensemble’s instantaneous distribution as a proposal, it achieves very fast burnin, followed by sampling with very short autocorrelation times.

KOBE (Kepler Observes Bern Exoplanets) adds the geometrical limitations and the physical detection biases of the transit method to a given population of theoretical planets. In addition, it also adds the completeness and reliability of a transit survey.

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

KLLR (Kernel Localized Linear Regression) generates estimates of conditional statistics in terms of the local slope, normalization, and covariance. This method provides a more nuanced description of population statistics appropriate for very large samples with non-linear trends. The code uses a bootstrap re-sampling technique to estimate the uncertainties and also provides tools to seamlessly generate visualizations of the model parameters.

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

The use of graphics processing units offers an attractive alternative to specialized hardware, like GRAPE. The Kirin library mimics the behavior of the GRAPE hardware and uses the GPU to execute the force calculations. It is compatible with the GRAPE6 library; existing code that uses the GRAPE6 library can be recompiled and relinked to use the GPU equivalents of the GRAPE6 functions. All functions in the GRAPE6 library have an equivalent GPU implementation. Kirin can be used for direct N-body simulations as well as for treecodes; it can be run with shared-time steps or with block time-steps and allows non-softened potentials. As Kirin makes use of CUDA, it works only on NVIDIA GPUs.

The KinMS (KINematic Molecular Simulation) package simulates observations of arbitrary molecular/atomic cold gas distributions from interferometers and line observations from integral field units. This modeling tool is optimized for situations where one has analytic forms for e.g. the rotation curve and/or surface brightness profiles (and may want to fit the parameters of these parametric models). It can, however, also be used as a tilted-ring modelling code. The routines are flexible and have been used in various different applications, including investigating the kinematics of molecular gas in early-type galaxies and determining supermassive black-hole masses from CO interferometric observations. They are also useful for creating mock observations from hydrodynamic simulations, and input data-cubes for further simulation in, for example, CASA's (ascl:1107.013) sim_observe tool. Interactive Data Language (IDL) and Python versions of the code are available.

Kinesis fits the internal kinematics of a star cluster with astrometry and (incomplete) radial velocity data of its members. In the most general model, the stars can be a mixture of background (contamination) and the cluster, for which the (3,3) velocity dispersion matrix and velocity gradient (i.e., dv_x/dx and dv_y/dx) are included. There are also simpler versions of the most general model and utilities to generate mock clusters and mock observations.

KINEMETRY, written in IDL, analyzes 2D maps of the moments of the line-of-sight velocity distribution (LOSVD). It generalizes the surface photometry to all moments of the LOSVD. It performs harmonic expansion of 2D maps of observed moments (surface brightness, velocity, velocity dispersion, h3, h4, etc.) along the best fitting ellipses (either fixed or free to change along the radii) to robustly quantify maps of the LOSVD moments, describe trends in structures, and detect morphological and kinematic sub-components.

kinematic_scaleheight uses MCMC methods to kinematically estimate the vertical distribution of clouds in the Galactic plane, including the least squares analysis of Crovisier (1978), an updated least squares analysis using a modern Galactic rotation model, and a Bayesian model sampled via MCMC as described in Wenger et al. (2024).

kima fits Keplerian curves to a set of RV measurements, using the Diffusive Nested Sampling (ascl:1010.029) algorithm to sample the posterior distribution for the model parameters. Additionally, the code can calculate the fully marginalized likelihood of a model with a given number of Keplerians and also infer the number of Keplerian signals detected in a given dataset. kima implements dedicated models for different analyses of a given dataset. The models share a common organization, but each has its own parameters (and thus priors) and settings.

kilopop produces binary neutron star kilonovae in the grey-body approximation. It can also create populations of these objects useful for forecasting detection and testing observing scenarios. Additionally, it uses an emulator for the grey-opacity of the material calibrated against a suite of numerical radiation transport simulations with the code SuperNu (ascl:2103.019).

killMS implements two very efficient algorithms for solving the Direction-Dependent calibration problem (also known as third generation calibration). This problem naturally arises in the Radio Interferometry Measurement Equation (RIME), but only became overwhelmingly problematic with the construction of the SKA precursors and pathfinders. Solving for the DDE calibration problem basically consists in inverting a number of non-linear equations, while the system is very large and often subject to ill conditioning. The two algorithms killMS uses are based on complex optimization techniques and exploit algorithmic shortcuts; killMS also runs an extended Kalman filter.

Kiauhoku interacts with, manipulates, and interpolates between stellar evolutionary tracks in a model grid. It was built for interacting with YREC models, but other stellar evolution model grids, including MIST, Dartmouth, and GARSTEC, are also available.

ketu, written in Python, searches K2 light curves for evidence of exoplanets; the code simultaneously fits for systematic effects caused by small (few-pixel) drifts in the telescope pointing and other spacecraft issues and the transit signals of interest. Though more computationally expensive than standard search algorithms, it can be efficiently implemented and used to discover transit signals.

KERTAP computes the strong lensing effects of Kerr black holes, including the effects on polarization. The key ingredients of KERTAP are a graphic user interface, a backward ray-tracing algorithm, a polarization propagator dealing with gravitational Faraday rotation, and algorithms computing observables such as flux magnification and polarization angles.

KERN contains most of the standard tools needed to work with radio telescope data. The suite saves time and reduces frustration in setting up of scientific pipelines, and also improves scientific reproducibility. It includes a wide variety of packages, including 21cmfast (ascl:1102.023), BRATS (ascl:1806.025), CARTA (ascl:2103.031), casacore (ascl:1912.002), CubiCal (ascl:1805.031), DDFacet (ascl:2305.008), PyBDSF (ascl:1502.007),TiRiFiC (ascl:1208.008), WSClean (ascl:1408.023), and many others. KERN can be run on a supported platform such as Ubuntu, with Docker and Singularity, or in a virtual machine.

Keras is a high-level neural networks API written in Python and capable of running on top of TensorFlow, CNTK, or Theano. It focuses on enabling fast experimentation.

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

KeplerPORTS calculates the detection efficiency of the DR25 Kepler Pipeline. It uses a detection contour model to quantify the recoverability of transiting planet signals due to the Kepler pipeline, and accurately portrays the ability of the Kepler pipeline to generate a Threshold Crossing Event (TCE) for a given hypothetical planet.

KeplerFit fits a Keplerian velocity distribution model to position-velocity (PV) data to obtain an estimate of the enclosed mass. The code extracts the scales of the pixels in both directions, spatial and spectral, then extracts the most extreme velocity at each position; this returns two arrays of positions and velocities. KeplerFit then models the extracted PV data and returns a set of the best-fit parameters, the standard deviations in each of the parameters, and the total residual of the fit.

Kepler's Goat Herd solves Kepler's equation using contour integration to solve the "geometric goat problem". The C++ code implements a variety of solution: 1.) Newton-Raphson: The quadratic Newton-Raphson root finder; 2.) Danby: The quartic root; 3.) Series: An elliptical series method; and 4.) Contour: A new method based on contour integration. Given an array of mean anomalies, an eccentricity and a desired precision, the code estimates the eccentric anomaly using each method. The accuracy of each approach is increased until the desired precision is reached, and timing is performed using the C++ chrono package.

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

The Kinematic Distance utilities (KDUtils) calculate kinematic distances and kinematic distance uncertainties. The package includes methods to calculate "traditional" kinematic distances as well as a Monte Carlo method to calculate kinematic distances and uncertainties.

kderp (KCWI Data Extraction and Reduction Pipeline) reduces data for the Keck Cosmic Web Imager. Written in IDL, it performs basic CCD reduction on raw images to produce bias and overscan subtracted, gain-corrected, trimmed and cosmic ray removed images; it can also subtract the sky. It defines the geometric transformations required to map each pixel in the 2d image into slice, postion, and wavelength, and performs flat field and illumination corrections. It generates cubes, applying the transformations previously solved to the object intensity, variance and mask images output from any of the previous stages, and uses a standard star observation to generate an inverse sensitivity curve which is applied to the corresponding observations to flux calibrate them.

This pipeline has been superseded by KCWI_DRP (ascl:2301.019).

Kd-match matches stellar catalogs for which the transformation between the coordinate systems of the two catalogs is unknown and might include shearing. The code uses the ratio of sides as the invariant under a coordinate transformation and searches for several triangles with similar transformations by building quadrilaterals from sets of four objects in each catalog and calculating the ratio of areas of the triangles that comprise the quadrilaterals. The k-d tree accelerates this quadrilateral search dramatically and is significantly faster than the customary direct search over triangles.

KCWIKit extends the official KCWI DRP (ascl:2301.019) with a variety of stacking tools and DRP improvements. The software offers masking and median filtering scripts to be used while running the KCWI DRP, and a step-by-step KCWI_DRP implementation for finer control over the reduction process. Once the DRP has finished, KCWIKit can be used to stack the output cubes via the Montage package. Various functions cross-correlate and mosaic the constituent cubes and the final stacked cubes are WCS corrected. Helper functions can then be used to deproject the stacked cube into lower-dimensional representations should the user desire.

KCWI_DRP, written in Python and based on kderp (ascl:2301.018), is the official DRP for the Keck Cosmic Web Imager at the W. M. Keck Observatory. It provides all of the functionality of the older pipeline and has three execution modes: multi-threading for CPU intensive tasks such as wavelength calibration, and multi-processing for large datasets. It offers vacuum to air and heliocentric or barycentric correction and the ability to use KOA file names or original file names. KCWI_DRP also improves the provenance and traceability of DRP versions and execution steps in the headers over kderp, and has versatile sky subtraction modes including using external sky frames and ability of masking regions.

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

The analytic propagator Kepler-Collisions calculates collisions for Keplerian systems. The algorithm maintains a list of collision possibilities and jumps from one collision to the next; since collisions are rare in astronomical scales, jumping from collision to collision and calculating each one is more efficient than calculating all the time steps that are between collisions.

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

Katu evolves the interaction of particles (photons, protons, neutrons, leptons, pions and neutrinos) in plasma. The package comes with wrappers for emcee (ascl:1303.002) and pymultinest (ascl:1606.005) for Bayesian analysis, making the software applicable to blazars and able to extract relevant statistical information from their electromagnetic (and neutrino, if applicable) flux. The code is optimized for fast performance, and can be easily modified and extended.

katdal interacts with the chunk stores and HDF5 files produced by the MeerKAT radio telescope and its predecessors (KAT-7 and Fringe Finder), which are collectively known as MeerKAT Visibility Format (MVF) data sets. The library uses memory carefully, allowing data sets to be inspected and partially loaded into memory. Data sets may be concatenated and split via a flexible selection mechanism. In addition, katdal provides a script to convert these data sets to CASA MeasurementSets.

KaRMMa (Kappa Reconstruction for Mass MApping) performs curved-sky mass map reconstruction using a lognormal prior from weak-lensing surveys. It uses a fully Bayesian approach with a physically motivated lognormal prior to sample from the posterior distribution of convergence maps. The posterior distribution of KaRMMa maps are nearly unbiased in one-point and two-point functions and peak/void counts. KaRMMa successfully captures the non-Gaussian nature of the distribution of κ values in the simulated maps, and KaRMMa posteriors correctly characterize the uncertainty in summary statistics.

Karma is a toolkit for interprocess communications, authentication, encryption, graphics display, user interface and manipulating the Karma network data structure. It contains KarmaLib (the structured libraries and API) and a large number of modules (applications) to perform many standard tasks. A suite of visualisation tools are distributed with the library.

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

Based on the freely available CHIANTI (ascl:9911.004) database and software, KAPPA synthesizes line and continuum spectra from the optically thin spectra that arise from collisionally dominated astrophysical plasmas that are the result of non-Maxwellian κ-distributions detected in the solar transition region and flares. Ionization and recombination rates together with the ionization equilibria are provided for a range of κ values. Distribution-averaged collision strengths for excitation are obtained by an approximate method for all transitions in all ions available within CHIANTI; KAPPA also offers tools for calculating synthetic line and continuum intensities.

KAPPA comprising about 180 general-purpose commands for image processing, data visualization, and manipulation of the standard Starlink data format--the NDF. It works with Starlink's various specialized packages; in addition to the NDF, KAPPA can also process data in other formats by using the "on-the-fly" conversion scheme. Many commands can process data arrays of arbitrary dimension, and others work on both spectra and images. KAPPA operates from both the UNIX C-shell and the ICL command language. KAPPA uses the Starlink environment (ascl:1110.012).

Kalman models an inhomogeneous time series of measurements at different frequencies as noisy sampling from a finite mixture of Gaussian Ornstein-Uhlenbeck processes to try to reproduce the variability of the fluxes and of the spectral indices of the quasars used as calibrators in the Atacama Large Millimeter/Sub-millimeter Array (ALMA), assuming sensible parameters are provided to the model (obtained, for example, from maximum likelihood estimation). One routine in the Kalman Perl module calculates best forecast estimations based on a state space representation of the stochastic model using Kalman recursions, and another routine calculates the smoothed estimation (or interpolations) of the measurements and of the state space also using Kalman recursions. The code does not include optimization routines to calculate best fit parameters for the stochastic processes.

Kalkayotl obtains samples of the joint posterior distribution of cluster parameters and distances to the cluster stars from Gaia parallaxes using Bayesian inference. The code is designed to deal with the parallax spatial correlations of Gaia data, and can accommodate different values of parallax zero point and spatial correlation functions.

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

Kadenza enables time-critical data analyses to be carried out using NASA's Kepler Space Telescope. It enables users to convert Kepler's raw data files into user-friendly Target Pixel Files upon downlink from the spacecraft. The primary motivation for this tool is to enable the microlensing, supernova, and exoplanet communities to create quicklook lightcurves for transient events which require rapid follow-up.

The Kadath library implements spectral methods in the context of theoretical physics. It is fully parallel; a sequential version can be installed. The library is written in C++, and solves a wide variety of problems. Several coordinates systems are implemented and additional geometries can be easily encoded. Partial differential equations of various types are discretized by means of spectral methods. The resulting system is solved using a Newton-Raphson iteration, allowing KADATH to deal with strongly non-linear situations. An optimized version of Kadath is available that improves memory management (reducing the number of uses of new and delete), inlines several member functions, and provides better management of the accessors for the arrays.

K3Match is a C library with Python bindings for fast matching of points in 3D space. It uses an implementation of three dimensional binary trees to efficiently find matches between points in 3D space. Two lists of points are compared and match indices as well as distances are given. K3Match can find either the nearest neighbour or all matches within a given search distance in 3D Cartesian space or on the surface of the 2D unit sphere in standard spherical or celestial coordinates.

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

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

k2photometry reads, reduces and detrends K2 photometry and searches for transiting planets. MAST database pixel files are used as input; the output includes raw lightcurves, detrended lightcurves and a transit search can be performed as well. Stellar variability is not typically well-preserved but parameters can be tweaked to change that. The BLS algorithm used to detect periodic events is a Python implementation by Ruth Angus and Dan Foreman-Mackey (https://github.com/dfm/python-bls).

K2mosaic stitches the postage stamp-sized pixel masks obtained by NASA's Kepler and K2 missions together into CCD-sized mosaics and movies. The command-line tool's principal use is to take a set of Target Pixel Files (TPF) and turn them into more traditional FITS image files -- one per CCD channel and per cadence. K2mosaic can also be used to create animations from these mosaics. The mosaics produced by K2mosaic also makes the analysis of certain Kepler/K2 targets, such as clusters and asteroids, easier. Moreover such mosaics are useful to reveal the context of single-star observations, e.g., they enable users to check for the presence of instrumental noise or nearby bright objects.

K2fov allows users to transform celestial coordinates into K2's pixel coordinate system for the purpose of preparing target proposals and field of view visualizations. In particular, the package, written in Python, adds the "K2onSilicon" and "K2findCampaigns" tools to the command line, allowing the visibility of targets to be checked in a user-friendly way.

K2flix makes it easy to inspect the CCD pixel data obtained by NASA's Kepler space telescope. The two-wheeled extended Kepler mission, K2, is affected by new sources of systematics, including pointing jitter and foreground asteroids, that are easier to spot by eye than by algorithm. The code takes Kepler's Target Pixel Files (TPF) as input and turns them into contrast-stretched animated gifs or MPEG-4 movies. K2flix can be used both as a command-line tool or using its Python API.

Since early 2018, the Kepler/K2 project has been performing a uniform global reprocessing of data from K2 Campaigns 0 through 14. Subsequent K2 campaigns (C15-C19) are being processed using the same processing pipeline. One of the major benefits of the reprocessing effort is that, for the first time, short-cadence (1-min) light curves are produced in addition to the standard long-cadence (30-min) light curves. Users have been cautioned that the Kepler pipeline detrending module (PDC), developed for use on original Kepler data, has not been tailored for use on short-cadence K2 observations. Systematics due to events on fast timescales, such as thruster firings, are sometimes poorly corrected for many short-cadence targets. A Python data visualization and manipulation tool, called Kepler-K2 Cadence Events, has been developed that identifies and removes cadences associated with problematic thruster events, thus producing better light curves. Kepler-K2 Cadence Events can be used to visualize and manipulate light curve files and target pixel files from the Kepler, K2, and TESS missions. This software is available at the following NASA GitHub repository https://github.com/nasa/K2CE .

K2-CPM captures variability while preserving transit signals in Kepler data. Working at the pixel level, the model captures very fine-grained information about the variation of the spacecraft. The CPM models the systematic effects in the time series of a pixel using the pixels of many other stars and the assumption that any shared signal in these causally disconnected light curves is caused by instrumental effects. The target star's future and past are used and the data points are separated into training and test sets to ensure that information about any transit is perfectly isolated from the model. The method has four tuning parameters, the number of predictor stars or pixels, the autoregressive window size, and two L2-regularization amplitudes for model components, and consistently produces low-noise light curves.

Inpainting is a technique for dealing with gaps in time series data, as frequently occurs in asteroseismology data, that may generate spurious peaks in the power spectrum, thus limiting the analysis of the data. The inpainting method, based on a sparsity prior, judiciously fills in gaps in the data, preserving the asteroseismic signal as far as possible. This method can be applied both on ground and space-based data. The inpainting technique improves the oscillation modes detection and estimation, the impact of the observational window function is reduced, and the interpretation of the power spectrum is simplified. K-Inpainting can be used to study very long time series of many stars because its computation is very fast.

JWST_Simulation generates a novel geometric-focused deep field simulation of the expected JWST future deep field image. Galaxies are represented by ellipses with randomly-generated positions and orientations. Three scripts are included: a deterministic simulation, an ensemble simulation, and a more-realistic monochrome image simulation. The following initial conditions can be perturbed in these codes: H0, Ωm, ΩΛ, the dark energy equation of state parameter, the number of unseen galaxies in the Hubble Ultra Deep Field Image (HUDF), the increase in effective radius due to the JWST’s higher sensitivity, the anisotropy of dark energy, and the maximum redshift reached by the JWST. Galaxy number densities are estimated using integration over comoving volume with an integration constant calibrated with the Hubble Ultra Deep Field. A galaxy coverage percentage is calculated for each image to determine the percentage of the background occupied by galaxies.