Results 1501-1600 of 3361 (3279 ASCL, 82 submitted)

[ascl:1702.005]
JetCurry: Modeling 3D geometry of AGN jets from 2D images

Written in Python, JetCurry models the 3D geometry of jets from 2-D images. JetCurry requires NumPy and SciPy and incorporates emcee (ascl:1303.002) and AstroPy (ascl:1304.002), and optionally uses VPython. From a defined initial part of the jet that serves as a reference point, JetCurry finds the position of highest flux within a bin of data in the image matrix and fits along the *x* axis for the general location of the bends in the jet. A spline fitting is used to smooth out the resulted jet stream.

[ascl:1810.003]
JETGET: Hydrodynamic jet simulation visualization and analysis

JETGET accesses, visualizes, and analyses (magnetized-)fluid dynamics data stored in Hierarchical Data Format (HDF) and ASCII files. Although JETGET has been optimized to handle data output from jet simulations using the Zeus code (ascl:1306.014) from NCSA, it is also capable of analyzing other data output from simulations using other codes. JETGET can select variables from the data files, render both two- and three-dimensional graphics and analyze and plot important physical quantities. Graphics can be saved in encapsulated Postscript, JPEG, VRML, or saved into an MPEG for later visualization and/or presentations. The strength of JETGET in extracting the physics underlying such phenomena is demonstrated as well as its capabilities in visualizing the 3-dimensional features of the simulated magneto-hydrodynamic jets. The JETGET tool is written in Interactive Data Language (IDL) and uses a graphical user interface to manipulate the data. The tool was developed on a LINUX platform and can be run on any platform that supports IDL.

[ascl:2009.001]
JetSeT: Numerical modeling and SED fitting tool for relativistic jets

JetSeT reproduces radiative and accelerative processes acting in relativistic jets and fits the numerical models to observed data. This C/Python framework re-bins observed data, can define data sets, and binds to astropy tables and quantities. It can use Synchrotron Self-Compton (SSC), external Compton (EC) and EC against the CMB when defining complex numerical radiative scenarios. JetSeT can constrain the model in the pre-fitting stage based on accurate and already published phenomenological trends starting from parameters such as spectral indices, peak fluxes and frequencies, and spectral curvatures. The package fits multiwavelength SEDs using both frequentist approach and Bayesian MCMC sampling, and also provides self-consistent temporal evolution of the plasma under the effect of radiative and accelerative processes for both first order and second order (stochastic acceleration) processes.

[ascl:2112.027]
JexoSim 2.0: JWST Exoplanet Observation Simulator

JexoSim 2.0 (JWST Exoplanet Observation Simulator) simulates exoplanet transit observations using all four instruments of the James Webb Space Telescope, and is designed for the planning and validation of science cases for JWST. The code generates synthetic spectra that capture the full impact of complex noise sources and systematic trends, allowing for assessment of both accuracy and precision in the final spectrum. JexoSim does not contain all known systematics for the various instruments, but is a good starting point to investigate the effects of systematics, and has the framework to incorporate more systematics in the future.

[ascl:1308.016]
JHelioviewer: Visualization software for solar physics data

Mueller, Daniel; Dimitoglou, George; Caplins, Benjamin; Garcia Ortiz, Juan Pablo; Wamsler, Benjamin; Hughitt, Keith; Alexanderian, Alen; Ireland, Jack; Amadigwe, Desmond; Fleck, Bernhard

JHelioview is open source visualization software for solar physics data. The JHelioviewer client application enables users to browse petabyte-scale image archives; the JHelioviewer server integrates a JPIP server, metadata catalog, and an event server. JHelioview uses the JPEG 2000 image compression standard, which provides efficient access to petabyte-scale image archives; JHelioviewer also allows users to locate and manipulate specific data sets.

[ascl:1207.013]
JKTEBOP: Analyzing light curves of detached eclipsing binaries

The JKTEBOP code is used to fit a model to the light curves of detached eclipsing binary stars in order to derive the radii of the stars as well as various other quantities. It is very stable and includes extensive Monte Carlo or bootstrapping error analysis algorithms. It is also excellent for transiting extrasolar planetary systems. All input and output is done by text files; JKTEBOP is written in almost-standard FORTRAN 77 using first the g77 compiler and now the ifort compiler.

[ascl:1511.016]
JKTLD: Limb darkening coefficients

JKTLD outputs theoretically-calculated limb darkening (LD) strengths for equations (LD laws) which predict the amount of LD as a function of the part of the star being observed. The coefficients of these laws are obtained by bilinear interpolation (in effective temperature and surface gravity) in published tables of coefficients calculated from stellar model atmospheres by several researchers. Many observations of stars require the strength of limb darkening (LD) to be estimated, which can be done using theoretical models of stellar atmospheres; JKTLD can help in these circumstances.

[ascl:2006.013]
JoXSZ: Joint X-ray and SZ fitting for galaxy clusters in Python

JoXSZ jointly fits the thermodynamic profiles of galaxy clusters from both SZ and X-ray data using a Markov chain Monte Carlo fitting algorithm. It is an enhanced version of preprofit (ascl:1910.002), which fits only SZ data. JoXSZ parameterizes the pressure and electron density profile of a galaxy cluster with a given center and derives the temperature profile as the ratio of these quantities through the ideal gas law. The X-ray and SZ-based temperatures can be similar or different, which allows study of the cluster elongation along line of sight, gas clumping, or calibration uncertainties.

[submitted]
JPFITS (C# .Net FITS File Interaction)

FITS File interaction written in Visual Studio C# .Net.

JPFITS is not based upon any other implementation and is written from the ground-up, consistent with the FITS standard, designed to interact with FITS files as object-oriented structures.

JPFITS provides functionality to interact with FITS images and binary table extensions, as well as providing common mathematical methods for the manipulation of data, data reductions, profile fitting, photometry, etc.

JPFITS also implements object-oriented classes for Point Source Extraction, World Coordinate Solutions (WCS), WCS automated field solving, FITS Headers and Header Keys, etc.

The automatic world coordinate solver is based on the trigonometric algorithm as described here:

https://iopscience.iop.org/article/10.1088/1538-3873/ab7ee8

All function parameters, methods, properties, etc., are coded with XML descriptions which will function with Visual Studio. Other code editors may or may not read the XML files.

Everything which is reasonable to parallelize in order to benefit from the computation speed increase for multi-threaded systems has been done so. In all such cases function options are given in order to specify the use of parallelism or not. Generally, most image manipulation functions are highly amenable to parallelism. No parallelism is forced, i.e., any code which may execute parallelized is given a user option to do so or not.

[ascl:1908.017]
JPLephem: Jet Propulsion Lab ephemerides package

JPLephem loads and uses standard Jet Propulsion Laboratory (JPL) ephemerides for predicting the position and velocity of a planet or other Solar System body. It is one of the foundations of the Skyfield (ascl:1907.024) astronomy library for Python, and can also be used as a standalone package to generate raw vectors.

[ascl:1511.002]
JSPAM: Interacting galaxies modeller

JSPAM models galaxy collisions using a restricted n-body approach to speed up computation. Instead of using a softened point-mass potential, the software supports a modified version of the three component potential created by Hernquist (1994, ApJS 86, 389). Although spherically symmetric gravitationally potentials and a Gaussian model for the bulge are used to increase computational efficiency, the potential mimics that of a fully consistent n-body model of a galaxy. Dynamical friction has been implemented in the code to improve the accuracy of close approaches between galaxies. Simulations using this code using thousands of particles over the typical interaction times of a galaxy interaction take a few seconds on modern desktop workstations, making it ideal for rapidly prototyping the dynamics of colliding galaxies. Extensive testing of the code has shown that it produces nearly identical tidal features to those from hierarchical tree codes such as Gadget but using a fraction of the computational resources. This code was used in the Galaxy Zoo: Mergers project and is very well suited for automated fitting of galaxy mergers with automated pattern fitting approaches such as genetic algorithms. Java and Fortran versions of the code are available.

[ascl:1607.007]
JUDE: An Utraviolet Imaging Telescope pipeline

JUDE (Jayant's UVIT Data Explorer) converts the Level 1 data (FITS binary table) from the Ultraviolet Imaging Telescope (UVIT) on ASTROSAT into three output files: a photon event list as a function of frame number (FITS binary table); a FITS image file with two extensions; and a PNG file created from the FITS image file with an automated scaling.

[ascl:1812.016]
Juliet: Transiting and non-transiting exoplanetary systems modelling tool

Juliet essentially serves as a wrapper of other tools, including Batman (ascl:1510.002), George (ascl:1511.015), Dynesty (ascl:1809.013) and AstroPy (ascl:1304.002), to analyze and model transits, radial-velocities, or both from multiple instruments at the same time. Using nested sampling algorithms, it performs a thorough sampling of the parameter space and a model comparison via Bayesian evidences. Juliet also fits transiting and non-transiting multi-planetary systems, and Gaussian Processes (GPs) which might share hyperparameters between the photometry and radial-velocities simultaneously (e.g., stellar rotation periods).

[ascl:1109.024]
Jupiter: Multidimensional Astrophysical Hydrocode

Jupiter is a multidimensional astrophysical hydrocode. It is based on a Godunov method, and it is parallelized with MPI. The mesh geometry can either be cartesian, cylindrical or spherical. It allows mesh refinement and includes special features adapted to the description of planets embedded in disks and nearly steady states.

[ascl:1702.003]
juwvid: Julia code for time-frequency analysis

Juwvid performs time-frequency analysis. Written in Julia, it uses a modified version of the Wigner distribution, the pseudo Wigner distribution, and the short-time Fourier transform from MATLAB GPL programs, tftb-0.2. The modification includes the zero-padding FFT, the non-uniform FFT, the adaptive algorithm by Stankovic, Dakovic, Thayaparan 2013, the S-method, the L-Wigner distribution, and the polynomial Wigner-Ville distribution.

[ascl:1904.029]
JVarStar: Variable Star Analysis Library

JVarStar (Java Variable Star Analysis) performs pattern classification by analyzing variable star data. This all-in-one library package includes machine learning techniques, fundamental mathematical methods, and digital signal processing functions that can be externally referenced (i.e., from Python), or can be used for further Java development. This library has dependencies on several open source packages that, along with the developed functionality, provides a developer with an easily accessible library from which to construct stable variable star analysis and classification code.

[ascl:1504.017]
JWFront: Wavefronts and Light Cones for Kerr Spacetimes

JWFront visualizes wavefronts and light cones in general relativity. The interactive front-end allows users to enter the initial position values and choose the values for mass and angular momentum per unit mass. The wavefront animations are available in 2D and 3D; the light cones are visualized using the coordinate systems *(t, x, y)* or *(t, z, x)*. JWFront can be easily modified to simulate wavefronts and light cones for other spacetime by providing the Christoffel symbols in the program.

[ascl:2110.001]
JWSTSim: Geometric-Focused JWST Deep Field Image Simulation

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

[ascl:1507.013]
K-Inpainting: Inpainting for Kepler

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

[ascl:2107.024]
K2-CPM: Causal Pixel Model for K2 data

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

[submitted]
K2CE: Kepler-K2 Cadence Events

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

[ascl:1503.001]
K2flix: Kepler pixel data visualizer

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

[ascl:1601.009]
K2fov: Field of view software for NASA's K2 mission

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

[ascl:2107.026]
K2mosaic: Mosaic Kepler pixel data

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

[ascl:1602.014]
k2photometry: Read, reduce and detrend K2 photometry

Van Eylen, Vincent; Nowak, Grzegorz; Albrecht, Simon; Palle, Enric; Ribas, Ignasi; Bruntt, Hans; Perger, Manuel; Gandolfi, Davide; Hirano, Teriyuki; Sanchis-Ojeda, Roberto; Kiilerich, Amanda; Arranz, Jorge P.; Badenas, Mariona; Dai, Fei; Deeg, Hans J.; Guenther, Eike W.; Montanes-Rodriguez, Pilar; Narita, Norio; Rogers, Leslie A.; Bejar, Victor J. S.; Shrotriya, Tushar S.; Winn, Joshua N.; Sebastian, Daniel

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

[ascl:1607.010]
K2PS: K2 Planet search

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

[ascl:1605.012]
K2SC: K2 Systematics Correction

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

[ascl:1307.003]
K3Match: Point matching in 3D space

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

[ascl:2106.013]
Kadath: Spectral solver

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

[ascl:1803.005]
Kadenza: Kepler/K2 Raw Cadence Data Reader

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

[ascl:1607.013]
Kālī: Time series data modeler

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

[ascl:2011.003]
Kalkayotl: Inferring distances to stellar clusters from Gaia parallaxes

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

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

[ascl:1906.005]
Kalman: Forecasts and interpolations for ALMA calibrator variability

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

[ascl:1403.022]
KAPPA: Kernel Applications Package

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

[ascl:1502.008]
KAPPA: Optically thin spectra synthesis for non-Maxwellian kappa-distributions

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

[ascl:1611.010]
Kapteyn Package: Tools for developing astronomical applications

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

[ascl:1102.018]
Karma: Visualisation Test-Bed Toolkit

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

[ascl:2209.006]
KaRMMa: Curved-sky mass map reconstruction

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

[ascl:2305.004]
katdal: MeerKAT Data Access Library

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

[ascl:2106.026]
Katu: Interaction of particles in plasma simulator

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

[ascl:1701.005]
KAULAKYS: Inelastic collisions between hydrogen atoms and Rydberg atoms

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

[ascl:2211.002]
KC: Analytical propagator with collision detection for Keplerian systems

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

[ascl:1701.010]
kcorrect: Calculate K-corrections between observed and desired bandpasses

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

[ascl:2301.019]
KCWI_DRP: Keck Cosmic Web Imager Data Reduction Pipeline in Python

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

[ascl:2107.022]
Kd-match: Correspondences of objects between two catalogs through pattern matching

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

[ascl:2301.018]
kderp: Keck Cosmic Web Imager Data Extraction and Reduction Pipeline in IDL

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

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

[ascl:1712.001]
KDUtils: Kinematic Distance Utilities

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

[ascl:1702.007]
KEPLER: General purpose 1D multizone hydrodynamics code

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

[ascl:2105.021]
Kepler's Goat Herd: Solving Kepler's equation via contour integration

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

[ascl:2308.012]
KeplerFit: Keplerian velocity distribution model fitter

Bosco, Felix; Beuther, H.; Ahmadi, A.; Mottram, J. C; Kuiper, R.; Linz, H.; Maud, L.; Winters, J. M.; Henning, T.; Feng, S.; Peters, T.; Semenov, D.; Klaassen, P. D.; Schilke, P.; Urquhart, J. S.; Beltrán, M. T.; Lumsden, S. L.; Leurini, S.; Moscadelli, L.; Cesaroni, R.; Sánchez-Monge, Á.; Palau, A.; Pudritz, R.; Wyrowski, F.; Longmore, S.

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

[ascl:2107.027]
KeplerPORTS: Kepler Planet Occurrence Rate Tools

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

[ascl:1706.012]
KeplerSolver: Kepler equation solver

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

[ascl:1806.022]
Keras: The Python Deep Learning library

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

[ascl:2305.012]
KERN: Radio telescope toolkit

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

[ascl:1708.021]
KERTAP: Strong lensing effects of Kerr black holes

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

[ascl:1502.020]
ketu: Exoplanet candidate search code

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

[ascl:2011.027]
kiauhoku: Stellar model grid interpolation

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

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

[ascl:2305.005]
killMS: Direction-dependent radio interferometric calibration package

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

[ascl:2306.052]
kilopop: Binary neutron star population of optical kilonovae

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

[ascl:2302.014]
kima: Exoplanet detection in RVs with DNest4 and GPs

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

[ascl:1403.019]
KINEMETRY: Analysis of 2D maps of kinematic moments of LOSVD

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

[ascl:2008.001]
kinesis: Kinematic modeling of clusters

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

[ascl:2006.003]
KinMS: Three-dimensional kinematic modeling of arbitrary gas distributions

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

[ascl:1401.001]
Kirin: N-body simulation library for GPUs

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

[submitted]
Kliko - The Scientific Compute Container Format

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

[ascl:2008.003]
KLLR: Kernel Localized Linear Regression

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

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

[ascl:1606.012]
KMDWARFPARAM: Parameters estimator for K and M dwarf stars

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

[ascl:2106.001]
KOBE: Kepler Observes Bern Exoplanets

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

[ascl:2004.010]
kombine: Kernel-density-based parallel ensemble sampler

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

[ascl:2211.016]
Korg: 1D local thermodynamic equilibrium stellar spectral synthesis

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

[ascl:1504.013]
kozai: Hierarchical triple systems evolution

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

[ascl:1807.027]
kplr: Tools for working with Kepler data using Python

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

[ascl:1609.003]
Kranc: Cactus modules from Mathematica equations

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

[ascl:1402.011]
KROME: Chemistry package for astrophysical simulations

Grassi, Tommaso; Bovino, Stefano; Prieto, Joaquín; Seifried, Daniel; Simoncini, Eugenio; Gianturco, Francesco; Schleicher, Dominik

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

[ascl:1505.004]
KS Integration: Kelvin-Stokes integration

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

[ascl:1804.026]
KSTAT: KD-tree Statistics Package

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

[ascl:1807.028]
ktransit: Exoplanet transit modeling tool in python

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

[ascl:1407.011]
kungifu: Calibration and reduction of fiber-fed IFU astronomical spectroscopy

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

[ascl:2311.004]
KvW: Modified Kwee–Van Woerden method for eclipse minimum timing with reliable error estimates

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

[ascl:1507.004]
L-PICOLA: Fast dark matter simulation code

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

[ascl:1207.005]
L.A.Cosmic: Laplacian Cosmic Ray Identification

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

[ascl:2112.024]
l1p: Python implementation of the l1 periodogram

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

[ascl:1601.011]
LACEwING: LocAting Constituent mEmbers In Nearby Groups

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

[ascl:2104.008]
LaFuLi: NASA Langley Fu-Liou radiative transfer code

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

[ascl:2012.021]
LALSuite: LIGO Scientific Collaboration Algorithm Library Suite

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

[ascl:1604.003]
LAMBDAR: Lambda Adaptive Multi-Band Deblending Algorithm in R

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

[ascl:1010.077]
LAMDA: Leiden Atomic and Molecular Database

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

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

[ascl:1409.003]
LANL*: Radiation belt drift shell modeling

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

[ascl:2104.020]
LAPACK: Linear Algebra PACKage

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

[ascl:1703.001]
Larch: X-ray Analysis for Synchrotron Applications using Python

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

[ascl:1208.015]
Lare3d: Lagrangian-Eulerian remap scheme for MHD

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

[ascl:1806.021]
LASR: Linear Algorithm for Significance Reduction

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

[ascl:2010.006]
LaSSI: Large-Scale Structure Information

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

[ascl:2306.033]
lasso_spectra: Predict properties from galaxy spectra using Lasso regression

Jensen, Hannes; Zackrisson, Erik; Pelckmans, Kristiaan; Binggeli, Christian; Ausmees, Kristiina; Lundholm, Ulrika

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

[ascl:2205.006]
LATTE: Lightcurve Analysis Tool for Transiting Exoplanet

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

[ascl:1911.015]
LATTICEEASY: Lattice simulator for evolving interacting scalar fields in an expanding universe

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

[ascl:1202.011]
Lattimer-Swesty Equation of State Code

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

[ascl:2210.018]
LavAtmos: Gas-melt equilibrium calculations for a given temperature and melt composition

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

[ascl:2301.014]
LBL: Line-by-line velocity measurements

Artigau, Étienne; Cadieux, Charles; Cook, Neil J.; Doyon, René; Vandal, Thomas; Donati, Jean-François; Moutou, Claire; Delfosse, Xavier; Fouqué, Pascal; Martioli, Eder; Bouchy, François; Parsons, Jasmine; Carmona, Andres; Dumusque, Xavier; Astudillo-Defru, Nicola; Bonfils, Xavier; Mignon, Lucille

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

[ascl:1405.001]
LBLRTM: Line-By-Line Radiative Transfer Model

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

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

Would you like to view a random code?