Results 1701-1800 of 3553 (3462 ASCL, 91 submitted)

[ascl:2102.021]
lensingGW: Lensing of gravitational waves

lensingGW simulates lensed gravitational waves in ground-based interferometers from arbitrary compact binaries and lens models. Its algorithm resolves strongly lensed images and microimages simultaneously, such as the images resulting from hundreds of microlenses embedded in galaxies and galaxy clusters. It is based on Lenstronomy (ascl:1804.012),

[ascl:2404.008]
LensIt: CMB lensing delensing tools

LensIt enables CMB lensing and CMB delensing using the flat-sky approximation. The package can find the maximum posterior estimation of CMB lensing deflection maps from temperature and/or polarization maps and perform Wiener filtering of masked CMB data and allow for inhomogenous noise, including lensing deflections, using a multigrid preconditioner. It contains fast and accurate simulation libraries for lensed CMB skies, and standard quadratic estimator lensing reconstruction tools. LensIt also includes CMB internal delensing tools, including internal delensing biases calculation for temperature and/or polarization maps.

[ascl:9903.001]
LENSKY: Galactic Microlensing Probability

Given a model for the Galaxy, this program computes the microlensing rate in any direction. Program features include the ability to include the brightness of the lens and to compute the probability of lens detection at any level of lensing amplification. The program limits itself to lensing by single stars of single sources. The program is currently setup to accept input from the Galactic models of Bahcall and Soniera (1982, 1986).

There are three files needed for LENSKY, the Fortran file lensky.for and two input files: galmod.dsk (15 Megs) and galmod.sph (22 Megs). The zip file available below contains all three files. The program generates output to the file lensky.out. The program is pretty self-explanatory past that.

[ascl:1010.050]
LensPerfect: Gravitational Lens Massmap Reconstructions Yielding Exact Reproduction of All Multiple Images

LensPerfect is a new approach to the massmap reconstruction of strong gravitational lenses. Conventional methods iterate over possible lens models which reproduce the observed multiple image positions well but not exactly. LensPerfect only produces solutions which fit all of the data exactly. Magnifications and shears of the multiple images can also be perfectly constrained to match observations.

[ascl:1102.025]
LensPix: Fast MPI full sky transforms for HEALPix

Modelling of the weak lensing of the CMB will be crucial to obtain correct cosmological parameter constraints from forthcoming precision CMB anisotropy observations. The lensing affects the power spectrum as well as inducing non-Gaussianities. We discuss the simulation of full sky CMB maps in the weak lensing approximation and describe a fast numerical code. The series expansion in the deflection angle cannot be used to simulate accurate CMB maps, so a pixel remapping must be used. For parameter estimation accounting for the change in the power spectrum but assuming Gaussianity is sufficient to obtain accurate results up to Planck sensitivity using current tools. A fuller analysis may be required to obtain accurate error estimates and for more sensitive observations. We demonstrate a simple full sky simulation and subsequent parameter estimation at Planck-like sensitivity.

[ascl:1705.009]
LensPop: Galaxy-galaxy strong lensing population simulation

LensPop simulates observations of the galaxy-galaxy strong lensing population in the Dark Energy Survey (DES), the Large Synoptic Survey Telescope (LSST), and Euclid surveys.

[ascl:2010.010]
lenspyx: Curved-sky python lensed CMB maps simulation package

lenspyx creates curved-sky python lensed CMB maps simulations; the software allows those familiar with healpy (ascl:2008.022) to build very easily lensed CMB simulations. Parallelization is done with openmp. The numerical cost is approximately that of an high-res harmonic transform. lenspyx provides two methods to build a simulation; one method computes a deflected spin-0 healpix map from its alm and deflection field alm, and the other computes a deflected spin-weight Healpix map from its gradient and curl modes and deflection field alm. lenspyx can be used in conjunction with the Planck 2018 CMB lensing pipeline plancklens (ascl:2010.009) to reproduce the published map and band-powers.

[ascl:1905.017]
LensQuEst: CMB Lensing QUadratic Estimator

LensQuEst forecasts the signal-to-noise of CMB lensing estimators (standard, shear-only, magnification-only), generates mock maps, lenses them, and applies various lensing estimators to them. It can manipulate flat sky maps in various ways, including FFT, filtering, power spectrum, generating Gaussian random field, and applying lensing to a map, and evaluate these estimators on flat sky maps.

[ascl:1102.004]
LENSTOOL: A Gravitational Lensing Software for Modeling Mass Distribution of Galaxies and Clusters (strong and weak regime)

We describe a procedure for modelling strong lensing galaxy clusters with parametric methods, and to rank models quantitatively using the Bayesian evidence. We use a publicly available Markov chain Monte-Carlo (MCMC) sampler ('Bayesys'), allowing us to avoid local minima in the likelihood functions. To illustrate the power of the MCMC technique, we simulate three clusters of galaxies, each composed of a cluster-scale halo and a set of perturbing galaxy-scale subhalos. We ray-trace three light beams through each model to produce a catalogue of multiple images, and then use the MCMC sampler to recover the model parameters in the three different lensing configurations. We find that, for typical Hubble Space Telescope (HST)-quality imaging data, the total mass in the Einstein radius is recovered with ~1-5% error according to the considered lensing configuration. However, we find that the mass of the galaxies is strongly degenerated with the cluster mass when no multiple images appear in the cluster centre. The mass of the galaxies is generally recovered with a 20% error, largely due to the poorly constrained cut-off radius. Finally, we describe how to rank models quantitatively using the Bayesian evidence. We confirm the ability of strong lensing to constrain the mass profile in the central region of galaxy clusters in this way. Ultimately, such a method applied to strong lensing clusters with a very large number of multiple images may provide unique geometrical constraints on cosmology.

[ascl:1602.009]
LensTools: Weak Lensing computing tools

LensTools implements a wide range of routines frequently used in Weak Gravitational Lensing, including tools for image analysis, statistical processing and numerical theory predictions. The package offers many useful features, including complete flexibility and easy customization of input/output formats; efficient measurements of power spectrum, PDF, Minkowski functionals and peak counts of convergence maps; survey masks; artificial noise generation engines; easy to compute parameter statistical inferences; ray tracing simulations; and many others. It requires standard numpy and scipy, and depending on tools used, may require Astropy (ascl:1304.002), emcee (ascl:1303.002), matplotlib, and mpi4py.

[ascl:1804.012]
Lenstronomy: Multi-purpose gravitational lens modeling software package

Lenstronomy is a multi-purpose open-source gravitational lens modeling python package. Lenstronomy reconstructs the lens mass and surface brightness distributions of strong lensing systems using forward modelling and supports a wide range of analytic lens and light models in arbitrary combination. The software is also able to reconstruct complex extended sources as well as point sources. Lenstronomy is flexible and numerically accurate, with a clear user interface that could be deployed across different platforms. Lenstronomy has been used to derive constraints on dark matter properties in strong lenses, measure the expansion history of the universe with time-delay cosmography, measure cosmic shear with Einstein rings, and decompose quasar and host galaxy light.

[ascl:1307.005]
LENSVIEW: Resolved gravitational lens images modeling

Lensview models resolved gravitational lens systems based on LensMEM but using the Skilling & Bryan MEM algorithm. Though its primary purpose is to find statistically acceptable lens models for lensed images and to reconstruct the surface brightness profile of the source, LENSVIEW can also be used for more simple tasks such as projecting a given source through a lens model to generate a “true” image by conserving surface brightness. The user can specify complicated lens models based on one or more components, such as softened isothermal ellipsoids, point masses, exponential discs, and external shears; LENSVIEW generates a best-fitting source matching the observed data for each specific combination of model parameters.

[ascl:1910.011]
LEO-Py: Likelihood Estimation of Observational data with Python

LEO-Py uses a novel technique to compute the likelihood function for data sets with uncertain, missing, censored, and correlated values. It uses Gaussian copulas to decouple the correlation structure of variables and their marginal distributions to compute likelihood functions, thus mitigating inconsistent parameter estimates and accounting for non-normal distributions in variables of interest or their errors.

[ascl:2404.026]
LEO-vetter: Automated vetting for TESS planet candidates

LEO-vetter automatically vets transit signals found in light curve data. Inspired by the Kepler Robovetter (ascl:2012.006), LEO-vetter computes vetting metrics to be compared to a series of pass-fail thresholds. If a signal passes all tests, it is considered a planet candidate (PC). If a signal fails at least one test, it may be either an astrophysical false positive (FP; *e.g.*, eclipsing binary, nearby eclipsing signal) or false alarm (FA; *e.g.*, systematic, stellar variability). Pass-fail thresholds can be changed to suit individual research purposes, and LEO-vetter produces vetting reports for manual inspection of signals. Flux-level vetting can be applied to any light curve dataset (such as Kepler, K2, and TESS), including light curves with mixes of cadences, while pixel-level vetting has been implemented for TESS.

[ascl:1108.009]
LePHARE: Photometric Analysis for Redshift Estimate

LePHARE is a set of Fortran commands to compute photometric redshifts and to perform SED fitting. The latest version includes new features with FIR fitting and a more complete treatment of physical parameters and uncertainties based on PÉGASE and Bruzual & Charlot population synthesis models. The program is based on a simple chi2 fitting method between the theoretical and observed photometric catalogue. A simulation program is also available in order to generate realistic multi-colour catalogues taking into account observational effects.

[ascl:2208.009]
LeXInt: Leja Exponential Integrators

LeXInt (Leja interpolation for eXponential Integrators) is a temporal exponential integration package using the method of polynomial interpolation at Leja points. Exponential Rosenbrock (EXPRB) and Exponential Propagation Iterative Runge-Kutta (EPIRK) methods use the Leja interpolation method to compute the functions. For linear PDEs, one can get the exact solution (in time) by directly computing the matrix exponential.

[ascl:1711.018]
LExTeS: Link Extraction and Testing Suite

LExTeS (Link Extraction and Testing Suite) extracts hyperlinks from PDF documents, tests the extracted links to see which are broken, and tabulates the results. Though written to support a particular set of PDF documents, the dataset and scripts can be edited for use on other documents.

[ascl:1804.024]
LFlGRB: Luminosity function of long gamma-ray bursts

LFlGRB models the luminosity function (LF) of long Gamma Ray Bursts (lGRBs) by using a sample of Swift and Fermi lGRBs to re-derive the parameters of the Yonetoku correlation and self-consistently estimate pseudo-redshifts of all the bursts with unknown redshifts. The GRB formation rate is modeled as the product of the cosmic star formation rate and a GRB formation efficiency for a given stellar mass.

[ascl:1804.023]
LFsGRB: Binary neutron star merger rate via the luminosity function of short gamma-ray bursts

LFsGRB models the luminosity function (LF) of short Gamma Ray Bursts (sGRBs) by using the available catalog data of all short GRBs (sGRBs) detected till 2017 October, estimating the luminosities via pseudo-redshifts obtained from the Yonetoku correlation, and then assuming a standard delay distribution between the cosmic star formation rate and the production rate of their progenitors. The data are fit well both by exponential cutoff powerlaw and broken powerlaw models. Using the derived parameters of these models along with conservative values in the jet opening angles seen from afterglow observations, the true rate of short GRBs is derived. Assuming a short GRB is produced from each binary neutron star merger (BNSM), the rate of gravitational wave (GW) detections from these mergers are derived for the past, present and future configurations of the GW detector networks.

[ascl:1710.016]
LGMCA: Local-Generalized Morphological Component Analysis

LGMCA (Local-Generalized Morphological Component Analysis) is an extension to GMCA (ascl:1710.015). Similarly to GMCA, it is a Blind Source Separation method which enforces sparsity. The novel aspect of LGMCA, however, is that the mixing matrix changes across pixels allowing LGMCA to deal with emissions sources which vary spatially. These IDL scripts compute the CMB map from WMAP and Planck data; running LGMCA on the WMAP9 temperature products requires the main script and a selection of mandatory files, algorithm parameters and map parameters.

[ascl:1712.016]
LgrbWorldModel: Long-duration Gamma-Ray Burst World Model

LgrbWorldModel is written in Fortran 90 and attempts to model the population distribution of the Long-duration class of Gamma-Ray Bursts (LGRBs) as detected by the NASA's now-defunct Burst And Transient Source Experiment (BATSE) onboard the Compton Gamma Ray Observatory (CGRO). It is assumed that the population distribution of LGRBs is well fit by a multivariate log-normal distribution. The best-fit parameters of the distribution are then found by maximizing the likelihood of the observed data by BATSE detectors via a native built-in Adaptive Metropolis-Hastings Markov-Chain Monte Carlo (AMH-MCMC) Sampler.

[ascl:1408.002]
LIA: LWS Interactive Analysis

The Long Wavelength Spectrometer (LWS) was one of two complementary spectrometers on the Infrared Space Observatory (ISO). LIA (LWS Interactive Analysis) is used for processing data from the LWS. It provides access to the different processing steps, including visualization of intermediate products and interactive manipulation of the data at each stage.

[ascl:1206.009]
Libimf

Libimf provides a collection of programming functions based on the general IMF-algorithm by Pflamm-Altenburg & Kroupa (2006).

[ascl:1502.016]
libnova: Celestial mechanics, astrometry and astrodynamics library

libnova is a general purpose, double precision, celestial mechanics, astrometry and astrodynamics library. Among many other calculations, it can calculate aberration, apparent position, proper motion, planetary positions, orbit velocities and lengths, angular separation of bodies, and hyperbolic motion of bodies.

[ascl:1604.002]
libpolycomp: Compression/decompression library

Libpolycomp compresses and decompresses one-dimensional streams of numbers by means of several algorithms. It is well-suited for time-ordered data acquired by astronomical instruments or simulations. One of the algorithms, called "polynomial compression", combines two widely-used ideas (namely, polynomial approximation and filtering of Fourier series) to achieve substantial compression ratios for datasets characterized by smoothness and lack of noise. Notable examples are the ephemerides of astronomical objects and the pointing information of astronomical telescopes. Other algorithms implemented in this C library are well known and already widely used, e.g., RLE, quantization, deflate (via libz) and Burrows-Wheeler transform (via libbzip2). Libpolycomp can compress the timelines acquired by the Planck/LFI instrument with an overall compression ratio of ~9, while other widely known programs (gzip, bzip2) reach compression ratios less than 1.5.

[ascl:1612.003]
libprofit: Image creation from luminosity profiles

libprofit is a C++ library for image creation based on different luminosity profiles. It offers fast and accurate two-dimensional integration for a useful number of profiles, including Sersic, Core-Sersic, broken-exponential, Ferrer, Moffat, empirical King, point-source and sky, with a simple mechanism for adding new profiles. libprofit provides a utility to read the model and profile parameters from the command-line and generate the corresponding image. It can output the resulting image as text values, a binary stream, or as a simple FITS file. It also provides a shared library exposing an API that can be used by any third-party application. R and Python interfaces are available: ProFit (ascl:1612.004) and PyProfit (ascl:1612.005).

[ascl:1010.020]
Libpsht: Algorithms for Efficient Spherical Harmonic Transforms

Libpsht (or "library for Performing Spherical Harmonic Transforms") is a collection of algorithms for efficient conversion between spatial-domain and spectral-domain representations of data defined on the sphere. The package supports transforms of scalars as well as spin-1 and spin-2 quantities, and can be used for a wide range of pixelisations (including HEALPix, GLESP and ECP). It will take advantage of hardware features like multiple processor cores and floating-point vector operations, if available. Even without this additional acceleration, the employed algorithms are among the most efficient (in terms of CPU time as well as memory consumption) currently being used in the astronomical community.

The library is written in strictly standard-conforming C90, ensuring portability to many different hard- and software platforms, and allowing straightforward integration with codes written in various programming languages like C, C++, Fortran, Python etc.

Libpsht is distributed under the terms of the GNU General Public License (GPL) version 2.

Development on this project has ended; its successor is libsharp (ascl:1402.033).

[ascl:2104.002]
Librarian: The HERA Librarian

The HERA Librarian system keeps track of all the primary data products for the telescope at a given site. The Librarian supports large data volumes and automated data processing capabilities. A web-based application handles human user and automatic requests and interfaces with a backing database and data storage servers. The system supports the long-term data storage of all relevant telescope data, as well as staging data to individual users' directories for processing.

[ascl:1402.033]
libsharp: Library for spherical harmonic transforms

Libsharp is a collection of algorithms for efficient conversion between maps on the sphere and their spherical harmonic coefficients. It supports a wide range of pixelisations (including HEALPix, GLESP, and ECP). This library is a successor of libpsht (ascl:1010.020); it adds MPI support for distributed memory systems and SHTs of fields with arbitrary spin, and also supports new developments in CPU instruction sets like the Advanced Vector Extensions (AVX) or fused multiply-accumulate (FMA) instructions. libsharp is written in portable C99; it provides an interface accessible to other programming languages such as C++, Fortran, and Python.

[ascl:2002.017]
libstempo: Python wrapper for Tempo2

libstempo uses the Tempo2 library (ascl:1210.015) to load a pulsar's tim/par files, providing Python access to the TOAs, the residuals, the timing-model parameters, the fit procedure, and more.

[ascl:2209.018]
libTheSky: Compute positions of celestial bodies and events

libTheSky compute the positions of celestial bodies, such as the Moon, planets, and stars, and events, including conjunctions and eclipses, with great accuracy. Written in Fortran, libTheSky can use different reference frames (heliocentric, geocentric, topocentric) and coordinate systems (ecliptic, equatorial, galactic; spherical, rectangular), and the user can choose low- or high-accuracy calculations, depending on need.

[ascl:2012.008]
LIFELINE: LIne proFiles in massivE coLliding wInd biNariEs

LIFELINE (LIne proFiles in massivE coLliding wInd biNariEs) simulates the X-ray lines profile in colliding wind binaries. The code is self-consistent and computes the distribution of the wind velocity, the characterization of the wind shock region, and the line profile. In addition to perform the overall computation, LIFELINE can use a pre-computed velocity distribution to compute the shock characteristics and the line profile, or use pre-computed shock characteristics and velocity distributions to compute only the line profile.

[ascl:2107.001]
light-curve: Light curve analysis toolbox

light-curve implements the extraction of numerous light curve features suitable for processing alert and archival data for the current ZTF and future Vera Rubin Observatory LSST photometric surveys. These high-performance irregular time series processing tools are written in Rust and Python.

[ascl:2102.006]
Lightbeam: Simulate light through weakly-guiding waveguides

Lightbeam simulates the 3D propagation of light through waveguides of arbitrary geometries. This code package is based off of the finite-differences beam propagation method, and employs a transverse adaptive mesh for extra computational efficiency. Also included are tools to simulate adaptive optics systems for use in conjunction with waveguides, useful in astronomical contexts for simulating coupling devices which transfer telescope light to the science instrument.

[ascl:1403.004]
Lightcone: Light-cone generating script

Lightcone works with simulated galaxy data stored in a relational database to rearrange the data in a shape of a light-cone; simulated galaxy data is expected to be in a box volume. The light-cone constructing script works with output from the SAGE semi-analytic model (ascl:1601.006), but will work with any other model that has galaxy positions (and other properties) saved per snapshots of the simulation volume distributed in time. The database configuration file is set up for PostgreSQL RDBMS, but can be modified for use with any other SQL database.

[ascl:1408.012]
LightcurveMC: An extensible lightcurve simulation program

LightcurveMC is a versatile and easily extended simulation suite for testing the performance of time series analysis tools under controlled conditions. It is designed to be highly modular, allowing new lightcurve types or new analysis tools to be introduced without excessive development overhead. The statistical tools are completely agnostic to how the lightcurve data is generated, and the lightcurve generators are completely agnostic to how the data will be analyzed. The use of fixed random seeds throughout guarantees that the program generates consistent results from run to run.

LightcurveMC can generate periodic light curves having a variety of shapes and stochastic light curves having a variety of correlation properties. It features two error models (Gaussian measurement and signal injection using a randomized sample of base light curves), testing of C1 shape statistic, periodograms, ΔmΔt plots, autocorrelation function plots, peak-finding plots, and Gaussian process regression. The code is written in C++ and R.

[ascl:1812.013]
Lightkurve: Kepler and TESS time series analysis in Python

Lightkurve Collaboration; Cardoso, José Vinícius de Miranda; Hedges, Christina; Gully-Santiago, Michael; Saunders, Nicholas; Cody, Ann Marie; Barclay, Thomas; Hall, Oliver; Sagear, Sheila; Turtelboom, Emma; Zhang, Johnny; Tzanidakis, Andy; Mighell, Ken; Coughlin, Jeff; Bell, Keaton; Berta-Thompson, Zach; Williams, Peter; Dotson, Jessie; Barentsen, Geert

Lightkurve analyzes astronomical flux time series data, in particular the pixels and light curves obtained by NASA’s Kepler, K2, and TESS exoplanet missions. This community-developed Python package is designed to be user friendly to lower the barrier for students, astronomers, and citizen scientists interested in analyzing data from these missions. Lightkurve provides easy tools to download, inspect, and analyze time series data and its documentation is supported by a large syllabus of tutorials.

[ascl:1711.009]
Lightning: SED Fitting Package

Lightning is a spectral energy distribution (SED) fitting procedure that quickly and reliably recovers star formation history (SFH) and extinction parameters. The SFH is modeled as discrete steps in time. The code consists of a fully vectorized inversion algorithm to determine SFH step intensities and combines this with a grid-based approach to determine three extinction parameters.

[ascl:1906.007]
limb-darkening: Limb-darkening coefficients generator

Limb-darkening generates limb-darkening coefficients from ATLAS and PHOENIX model atmospheres using arbitrary response functions. The code uses PyFITS (ascl:1207.009) and has several other dependencies, and produces a folder of results with descriptions of the columns contained in each file.

[ascl:2312.017]
LimberJack.jl: Auto-differentiable methods for cosmology

Ruiz-Zapatero, J.; Alonso, D.; García-García, C.; Nicola, A.; Mootoovaloo, A.; Sullivan, J. M.; Bonici, M.; Ferreira, P. G.

LimberJack.jl performs cosmological analyses of 2 point auto- and cross-correlation measurements from galaxy clustering, CMB lensing and weak lensing data. Written in Julia, it obtains gradients for its outputs faster than traditional finite difference methods, making the code greatly synergistic with gradient-based sampling methods such as Hamiltonian Monte Carlo. LimberJack.jl can efficiently exploring parameter spaces with hundreds of dimensions.

[ascl:1107.012]
LIME: Flexible, Non-LTE Line Excitation and Radiation Transfer Method for Millimeter and Far-infrared Wavelengths

LIME solves the molecular and atomic excitation and radiation transfer problem in a molecular gas and predicting emergent spectra. The code works in arbitrary three dimensional geometry using unstructured Delaunay latices for the transport of photons. Various physical models can be used as input, ranging from analytical descriptions over tabulated models to SPH simulations. To generate the Delaunay grid we sample the input model randomly, but weigh the sample probability with the molecular density and other parameters, and thereby we obtain an average grid point separation that scales with the local opacity. Slow convergence of opaque models becomes traceable; when convergence between the level populations, the radiation field, and the point separation has been obtained, the grid is ray-traced to produced images that can readily be compared to observations. LIME is particularly well suited for modeling of ALMA data because of the high dynamic range in scales that can be resolved using this type of grid, and can furthermore deal with overlapping lines of multiple molecular and atomic species.

[ascl:1710.023]
LIMEPY: Lowered Isothermal Model Explorer in PYthon

LIMEPY solves distribution function (DF) based lowered isothermal models. It solves Poisson's equation used on input parameters and offers fast solutions for isotropic/anisotropic, single/multi-mass models, normalized DF values, density and velocity moments, projected properties, and generates discrete samples.

[ascl:2307.042]
LIMpy: Line Intensity Mapping in Python

Roy, Anirban; Valentín-Martínez, Dariannette; Wang, Kailai; Battaglia, Nicholas; van Engelen, Alexander

LIMpy models and analyzes multi-line intensity maps of CII (158 µ), OIII (88 µ), and CO (1-0) to CO (13-12) transitions. It can be used as an analytic model for star formation rate, to simulate line intensity maps based on halo catalogs, and to calculate the power spectrum from simulated maps and the cross-correlated signal between two separate lines. Among other things, LIMpy can also create multi-line luminosity models and determine the multi-line intensity power spectrum.

[ascl:2303.002]
line_selections: Automatic line detection for large spectroscopic surveys

The Python code line_selections reads synthetic "full" spectra and elemental spectra, automatically identifies the detectable lines at a given resolution (provided the linelist used to compute the spectra), and returns a table containing various properties of the lines (*e.g.*, purity, central wavelength, and depth). The code then stores the information in a pandas DataFrame. line_selections demonstrates where chemical information is present in a stellar spectrum, and allows the user to optimize observational strategies, such as choosing resolution and spectra windows, as well as analysis codes with the application of high-quality masks.

[ascl:2007.012]
Line-Stacker: Spectral lines stacking

Line-Stacker stacks both 3D cubes or already extracted spectra and is an extension of Stacker (ascl:1912.019). It is an ensemble of both CASA tasks and native python tasks. Line-Stacker supports image stacking and some additional tools, allowing further analysis of the stack product, are also included in the module.

[ascl:2104.027]
linemake: Line list generator

Placco, Vinicius M.; Sneden, Christopher; Roederer, Ian U.; Lawler, James E.; Den Hartog, Elizabeth A.; Hejazi, Neda; Maas, Zachary; Bernath, Peter

linemake generates formatted and curated atomic and molecular line lists suitable for spectral synthesis work. It is lightweight and easy-to-use. The code requires that the requested beginning and ending wavelengths not bridge the divide between two files of atomic line data; in such cases, run the code twice, once on either side of the divide, to generate the desired lists.

[ascl:1504.019]
LineProf: Line Profile Indicators

LineProf implements a series of line-profile analysis indicators and evaluates its correlation with RV data. It receives as input a list of Cross-Correlation Functions and an optional list of associated RV. It evaluates the line-profile according to the indicators and compares it with the computed RV if no associated RV is provided, or with the provided RV otherwise.

[ascl:1602.006]
LIRA: LInear Regression in Astronomy

LIRA (LInear Regression in Astronomy) performs Bayesian linear regression that accounts for heteroscedastic errors in both the independent and the dependent variables, intrinsic scatters (in both variables), time evolution of slopes, normalization and scatters, Malmquist and Eddington bias, and break of linearity. The posterior distribution of the regression parameters is sampled with a Gibbs method exploiting the JAGS (ascl:1209.002) library.

[ascl:1601.007]
LIRA: Low-counts Image Reconstruction and Analysis

LIRA (Low-counts Image Reconstruction and Analysis) deconvolves any unknown sky components, provides a fully Poisson 'goodness-of-fit' for any best-fit model, and quantifies uncertainties on the existence and shape of unknown sky. It does this without resorting to χ2 or rebinning, which can lose high-resolution information. It is written in R and requires the FITSio package.

[ascl:2205.017]
LiSA: LIghtweight Source finding Algorithms for analysis of HI spectral data

The LIghtweight Source finding Algorithms (LiSA) library finds HI sources in next generation radio surveys. LiSA can analyze input data cubes of any size with pipelines that automatically decompose data into different domains for parallel distributed analysis. For source finding, the library contains python modules for wavelet denoising of 3D spatial and spectral data, and robust automatic source finding using null-hypothesis testing. The source-finding algorithms all have options to automatically choose parameters, minimizing the need for manual fine tuning. Finally, LiSA also contains neural network architectures for classification and characterization of 3D spectral data.

[ascl:1112.009]
LISACode: A scientific simulator of LISA

LISACode is a simulator of the LISA mission. Its ambition is to achieve a new degree of sophistication allowing to map, as closely as possible, the impact of the different subsystems on the measurements. Its also a useful tool for generating realistic data including several kind of sources (Massive Black Hole binaries, EMRIs, cosmic string cusp, stochastic background, etc) and for preparing their analysis. It’s fully integrated to the Mock LISA Data Challenge. LISACode is not a detailed simulator at the engineering level but rather a tool whose purpose is to bridge the gap between the basic principles of LISA and a future, sophisticated end-to-end simulator.

[ascl:1902.005]
LiveData: Data reduction pipeline

LiveData is a multibeam single-dish data reduction system for bandpass calibration and gridding. It is used for processing Parkes multibeam and Mopra data.

[ascl:1906.011]
Lizard: An extensible Cyclomatic Complexity Analyzer

Lizard is an extensible Cyclomatic Complexity Analyzer for imperative programming languages including C/C++/C#, Python, Java, and Javascript. It counts the nloc (lines of code without comments) and CCN (cyclomatic complexity number), and takes a token count of functions and a parameter count of functions. It also does copy-paste detection (code clone detection/code duplicate detection) and many other forms of static code analysis. Lizard is often used in software-related research and calculates how complex the code looks rather than how complex the code really is; thought it's often very hard to get all the included folders and files right when they are complicated, that accuracy is not needed to determine cyclomatic complexity, which can be useful for measuring the maintainability of a software package.

[ascl:1906.020]
LIZARD: Particle initial conditions for cosmological simulations

LIZARD (Lagrangian Initialization of Zeldovich Amplitudes for Resimulations of Displacements) creates particle initial conditions for cosmological simulations using the Zel'dovich approximation for the matter and velocity power spectrum.

[ascl:1706.005]
LMC: Logarithmantic Monte Carlo

LMC is a Markov Chain Monte Carlo engine in Python that implements adaptive Metropolis-Hastings and slice sampling, as well as the affine-invariant method of Goodman & Weare, in a flexible framework. It can be used for simple problems, but the main use case is problems where expensive likelihood evaluations are provided by less flexible third-party software, which benefit from parallelization across many nodes at the sampling level. The parallel/adaptive methods use communication through MPI, or alternatively by writing/reading files, and mostly follow the approaches pioneered by CosmoMC (ascl:1106.025).

[ascl:1606.014]
Lmfit: Non-Linear Least-Square Minimization and Curve-Fitting for Python

Newville, Matthew; Stensitzki, Till; Allen, Daniel B; Rawlik, Michal; Ingargiola, Antonino; Nelson, Andrew

Lmfit provides a high-level interface to non-linear optimization and curve fitting problems for Python. Lmfit builds on and extends many of the optimization algorithm of scipy.optimize, especially the Levenberg-Marquardt method from optimize.leastsq. Its enhancements to optimization and data fitting problems include using Parameter objects instead of plain floats as variables, the ability to easily change fitting algorithms, and improved estimation of confidence intervals and curve-fitting with the Model class. Lmfit includes many pre-built models for common lineshapes.

[submitted]
loci: Smooth Cubic Multivariate Local Interpolations

loci is a shared library for interpolations in up to 4 dimensions. It is written in C and can be used with C/C++, Python and others. In order to calculate the coefficients of the cubic polynom, only local values are used: The data itself and all combinations of first-order derivatives, i.e. in 2D f_x, f_y and f_xy. This is in contrast to splines, where the coefficients are not calculated using derivatives, but non-local data, which can lead to over-smoothing the result.

[ascl:2004.001]
Locus: Optimized differential photometry

Locus implements the Locus Algorithm, which maximizes the performance of differential photometry systems by optimizing the number and quality of reference stars in the Field of View with the target.

[submitted]
LOFAR H5plot

Calibration solutions for the LOFAR radio telescope are stored in a 5-dimensional (time, frequency, station, polarisation and direction in the sky) HDF5 table. H5plot is a GUI application focussing on interactive visual inspection of these calibration solutions.

[ascl:2104.030]
lofti_gaiaDR2: Orbit fitting with Gaia astrometry

Lofti_gaia fits orbital parameters for one wide stellar binary relative to the other, when both objects are resolved in Gaia DR2. It takes as input only the Gaia DR2 source id of the two components, and their masses. It retrieves the relevant parameters from the Gaia archive, computes observational constraints for them, and fits orbital parameters to those measurements. It assumes the two components are bound in an elliptical orbit.

[ascl:2301.007]
LoLLiPoP: Low-L Likelihood Polarized for Planck

Tristram, Matthieu; Garrido, Xavier; Hamimeche, Samira; Lewis, Antony; Mangilli, A.; Plaszczynski, S.

LoLLiPoP is a Planck low-l polarization likelihood based on cross-power-spectra for which the bias is zero when the noise is uncorrelated between maps. It uses a modified approximation to apply to cross-power spectra and is interfaced with the Cobaya (ascl:1910.019) MCMC sampler. Cross-spectra are computed on the CMB maps from Commander component separation applied on each detset-split Planck frequency maps.

[ascl:2401.014]
LoRD: Locate Reconnection Distribution

LoRD (Locate Reconnection Distribution) identifies the locations and structures of 3D magnetic reconnection within discrete magnetic field data. The toolkit contains three main functions; the first, ARD (Analyze Reconnection Distribution) locates the grids undergoing reconnection without null points and also recognizes the local configurations of reconnection sites. ANP (Analyze Null Points) locates and classifies the 3D null points, and APNP (Analyze Projected Null Points) analyzes the 2D neutral points projected on a plane near a cell. LoRD is written in Matlab and the toolkit contains demo scripts.

[ascl:1608.018]
LORENE: Spectral methods differential equations solver

LORENE (Langage Objet pour la RElativité NumériquE) solves various problems arising in numerical relativity, and more generally in computational astrophysics. It is a set of C++ classes and provides tools to solve partial differential equations by means of multi-domain spectral methods. LORENE classes implement basic structures such as arrays and matrices, but also abstract mathematical objects, such as tensors, and astrophysical objects, such as stars and black holes.

[ascl:2401.006]
LoSoTo: LOFAR solutions tool

de Gasperin, F.; Dijkema, T. J.; Drabent, A.; Mevius, M.; Rafferty, D.; van Weeren, R.; Brüggen, M.; Callingham, J. R.; Emig, K. L.; Heald, G.; Intema, H. T.; Morabito, L. K.; Offringa, A. R.; Oonk, R.; Orrù, E.; Röttgering, H.; Sabater, J.; Shimwell, T.; Shulevski, A.; Williams, W.

LoSoTo (LOFAR Solution Tool) performs a variety of operations on H5parm data, which is based on the HDF5 format; it isolates direction independent systematic effects and can therefore be transferred to the target field. Subsets of data can be selected for each operation using lists of axes values, regular expressions, or intervals. The LoSoTo package stores solutions in arrays organized in a hierarchical fashion; this provides flexibility and preserves performance. The code can, for example, extract Faraday rotation from RR/LL phase solutions or a rotation matrix, clip solutions around the median, and calculate the ionospheric structure function. LoSoTo includes an outlier flagging procedure, normalizes solutions to a given value, and offers an advanced plotting routine, and many other operations.

[ascl:1309.003]
LOSP: Liège Orbital Solution Package

LOSP is a FORTRAN77 numerical package that computes the orbital parameters of spectroscopic binaries. The package deals with SB1 and SB2 systems and is able to adjust either circular or eccentric orbits through a weighted fit.

[ascl:1308.002]
LOSSCONE: Capture rates of stars by a supermassive black hole

LOSSCONE computes the rates of capture of stars by supermassive black holes. It uses a stationary and time-dependent solutions for the Fokker-Planck equation describing the evolution of the distribution function of stars due to two-body relaxation, and works for arbitrary spherical and axisymmetric galactic models that are provided by the user in the form of M(r), the cumulative mass as a function of radius.

[ascl:2207.017]
LOTUS: 1D Non-LTE stellar parameter determination via Equivalent Width method

LOTUS (non-LTE Optimization Tool Utilized for the derivation of atmospheric Stellar parameters) derives stellar parameters via Equivalent Width (EW) method with the assumption of 1D non-local thermodynamic equilibrium. It mainly applies on the spectroscopic data from high resolution spectral survey. It can provide extremely accurate measurement of stellar parameters compared with non-spectroscopic analysis from benchmark stars. LOTUS provides a fast optimizer for obtaining stellar parameters based on Differential Evolution algorithm, well constrained uncertainty of derived stellar parameters from slice-sampling MCMC from PyMC3 (ascl:1610.016), and can interpolate the Curve of Growth from theoretical EW grid under the assumptions of LTE and Non-LTE. It also visualizes excitation and ionization balance when at the optimal combination of stellar parameters.

[ascl:1010.038]
Low Resolution Spectral Templates For AGNs and Galaxies From 0.03 -- 30 microns

Assef, R. J.; Kochanek, C. S.; Brodwin, M.; Cool, R.; Forman, W.; Gonzalez, A. H.; Hickox, R. C.; Jones, C.; Le Floc'h, E.; Moustakas, J.; Murray, S. S.; Stern, D.

We present a set of low resolution empirical SED templates for AGNs and galaxies in the wavelength range from 0.03 to 30 microns based on the multi-wavelength photometric observations of the NOAO Deep-Wide Field Survey Bootes field and the spectroscopic observations of the AGN and Galaxy Evolution Survey. Our training sample is comprised of 14448 galaxies in the redshift range 0<~z<~1 and 5347 likely AGNs in the range 0<~z<~5.58. We use our templates to determine photometric redshifts for galaxies and AGNs. While they are relatively accurate for galaxies, their accuracies for AGNs are a strong function of the luminosity ratio between the AGN and galaxy components. Somewhat surprisingly, the relative luminosities of the AGN and its host are well determined even when the photometric redshift is significantly in error. We also use our templates to study the mid-IR AGN selection criteria developed by Stern et al.(2005) and Lacy et al.(2004). We find that the Stern et al.(2005) criteria suffers from significant incompleteness when there is a strong host galaxy component and at z =~ 4.5, when the broad Halpha emission line is redshifted into the [3.6] band, but that it is little contaminated by low and intermediate redshift galaxies. The Lacy et al.(2004) criterion is not affected by incompleteness at z =~ 4.5 and is somewhat less affected by strong galaxy host components, but is heavily contaminated by low redshift star forming galaxies. Finally, we use our templates to predict the color-color distribution of sources in the upcoming WISE mission and define a color criterion to select AGNs analogous to those developed for IRAC photometry. We estimate that in between 640,000 and 1,700,000 AGNs will be identified by these criteria, but will have serious completeness problems for z >~ 3.4.

[ascl:1501.007]
LP-VIcode: La Plata Variational Indicators Code

LP-VIcode computes variational chaos indicators (CIs) quickly and easily. The following CIs are included:

- Lyapunov Indicators, also known as Lyapunov Characteristic Exponents, Lyapunov Characteristic Numbers or Finite Time Lyapunov Characteristic Numbers (LIs)

- Mean Exponential Growth factor of Nearby Orbits (MEGNO)

- Slope Estimation of the largest Lyapunov Characteristic Exponent (SElLCE)

- Smaller ALignment Index (SALI)

- Generalized ALignment Index (GALI)

- Fast Lyapunov Indicator (FLI)

- Orthogonal Fast Lyapunov Indicator (OFLI)

- Spectral Distance (SD)

- dynamical Spectra of Stretching Numbers (SSNs)

- Relative Lyapunov Indicator (RLI)

[ascl:2103.015]
LPF: Real-time detection of transient sources in radio data streams

LPF (Live Pulse Finder) provides real-time automated analysis of the radio image data stream at multiple frequencies. The fully automated GPU-based machine-learning backed pipeline performs source detection, association, flux measurement and physical parameter inference. At the end of the pipeline, an alert of a significant detection of a transient event can be sent out and the data saved for further investigation.

[ascl:1902.002]
LPNN: Limited Post-Newtonian N-body code for collisionless self-gravitating systems

The Limited Post-Newtonian N-body code (LPNN) simulates post-Newtonian interactions between a massive object and many low-mass objects. The interaction between one massive object and low-mass objects is calculated by post-Newtonian approximation, and the interaction between low-mass objects is calculated by Newtonian gravity. This code is based on the sticky9 code, and can be accelerated with the use of GPU in a CUDA (version 4.2 or earlier) environment.

[ascl:1306.012]
LRG DR7 Likelihood Software

This software computes likelihoods for the Luminous Red Galaxies (LRG) data from the Sloan Digital Sky Survey (SDSS). It includes a patch to the existing CAMB software (ascl:1102.026; the February 2009 release) to calculate the theoretical LRG halo power spectrum for various models. The code is written in Fortran 90 and has been tested with the Intel Fortran 90 and GFortran compilers.

[ascl:1602.005]
LRGS: Linear Regression by Gibbs Sampling

LRGS (Linear Regression by Gibbs Sampling) implements a Gibbs sampler to solve the problem of multivariate linear regression with uncertainties in all measured quantities and intrinsic scatter. LRGS extends an algorithm by Kelly (2007) that used Gibbs sampling for performing linear regression in fairly general cases in two ways: generalizing the procedure for multiple response variables, and modeling the prior distribution of covariates using a Dirichlet process.

[ascl:1807.033]
LSC: Supervised classification of time-series variable stars

LSC (LINEAR Supervised Classification) trains a number of classifiers, including random forest and K-nearest neighbor, to classify variable stars and compares the results to determine which classifier is most successful. Written in R, the package includes anomaly detection code for testing the application of the selected classifier to new data, thus enabling the creation of highly reliable data sets of classified variable stars.

[ascl:1209.003]
LSD: Large Survey Database framework

The Large Survey Database (LSD) is a Python framework and DBMS for distributed storage, cross-matching and querying of large survey catalogs (>10^9 rows, >1 TB). The primary driver behind its development is the analysis of Pan-STARRS PS1 data. It is specifically optimized for fast queries and parallel sweeps of positionally and temporally indexed datasets. It transparently scales to more than >10^2 nodes, and can be made to function in "shared nothing" architectures.

[ascl:1612.002]
LSDCat: Line Source Detection and Cataloguing Tool

LSDCat is a conceptually simple but robust and efficient detection package for emission lines in wide-field integral-field spectroscopic datacubes. The detection utilizes a 3D matched-filtering approach for compact single emission line objects. Furthermore, the software measures fluxes and extents of detected lines. LSDCat is implemented in Python, with a focus on fast processing of large data-volumes.

[ascl:1505.012]
LSSGALPY: Visualization of the large-scale environment around galaxies on the 3D space

LSSGALPY provides visualization tools to compare the 3D positions of a sample (or samples) of isolated systems with respect to the locations of the large-scale structures galaxies in their local and/or large scale environments. The interactive tools use different projections in the 3D space (right ascension, declination, and redshift) to study the relation of the galaxies with the LSS. The tools permit visualization of the locations of the galaxies for different values of redshifts and redshift ranges; the relationship of isolated galaxies, isolated pairs, and isolated triplets to the galaxies in the LSS can be visualized for different values of the declinations and declination ranges.

[ascl:2405.013]
LTdwarfIndices: Variable brown dwarf identifier

Oliveros-Gomez, Natalia; Manjavacas, Elena; Bardalez Gagliuffi, Daniella C.; Karalidi, Theodora; Vos, Johanna; Faherty, Jacqueline K.

LTdwarfIndices studies spectral indices to determine whether one or more brown dwarfs are photometric variable candidates. For a single brown dwarf, it analyzes a given set of indices and outputs the number of graphs the object appears in in the variable area, whether it is a variable or non-variable candidate, and, optionally, an index-index or histogram plot. Using another code module, LTdwarftIndices can also analyze a set of sample indices for many brown dwarfs.

[ascl:1312.006]
LTL: The Little Template Library

LTL provides dynamic arrays of up to 7-dimensions, subarrays and slicing, support for fixed-size vectors and matrices including basic linear algebra operations, expression templates-based evaluation, and I/O facilities for ascii and FITS format files. Utility classes for command-line processing and configuration-file processing are provided as well.

[ascl:1404.001]
LTS_LINEFIT & LTS_PLANEFIT: LTS fit of lines or planes

LTS_LINEFIT and LTS_PLANEFIT are IDL programs to robustly fit lines and planes to data with intrinsic scatter. The code combines the Least Trimmed Squares (LTS) robust technique, proposed by Rousseeuw (1984) and optimized in Rousseeuw & Driessen (2006), into a least-squares fitting algorithm which allows for intrinsic scatter. This method makes the fit converge to the correct solution even in the presence of a large number of catastrophic outliers, where the much simpler σ-clipping approach can converge to the wrong solution. The code is also available in Python as ltsfit.

[ascl:2403.011]
LtU-ILI: Robust machine learning in astro

Ho, Matthew; Bartlett, Deaglan J.; Chartier, Nicolas; Cuesta-Lazaro, Carolina; Ding, Simon; Lapel, Axel; Lemos, Pablo; Lovell, Christopher C.; Makinen, T. Lucas; Modi, Chirag; Pandya, Viraj; Pandey, Shivam; Perez, Lucia A.; Wandelt, Benjamin; Bryan, Greg L.

LtU-ILI (Learning the Universe Implicit Likelihood Inference) performs machine learning parameter inference. Given labeled training data or a stochastic simulator, the LtU-ILI piepline automatically trains state-of-the-art neural networks to learn the data-parameter relationship and produces robust, well-calibrated posterior inference. The package comes with a wide range of customizable complexity, including posterior-, likelihood-, and ratio-estimation methods for ILI, including sequential learning analogs, and various neural density estimators, including mixture density networks, conditional normalizing flows, and ResNet-like ratio classifiers. It offers fully-customizable, exotic embedding networks, including CNNs and Graph Neural Networks, and a unified interface for multiple ILI backends such as sbi, pydelfi, and lampe. LtU-ILI also handles multiple marginal and multivariate posterior coverage metrics, and offers Jupyter and command-line interfaces and a parallelizable configuration framework for efficient hyperparameter tuning and production runs.

[ascl:1201.016]
LumFunc: Luminosity Function Modeling

LumFunc is a numerical code to model the Luminosity Function based on central galaxy luminosity-halo mass and total galaxy luminosity-halo mass relations. The code can handle rest b_J-band (2dFGRS), r'-band (SDSS), and K-band luminosities, and any redshift with redshift dependences specified by the user. It separates the luminosity function (LF) to conditional luminosity functions, LF as a function of halo mass, and also to galaxy types. By specifying a narrow mass range, the code will return the conditional luminosity functions. The code returns luminosity functions for galaxy types as well (broadly divided to early-type and late-type). The code also models the cluster luminosity function, either mass averaged or for individual clusters.

[ascl:2401.003]
LUNA: Forward model luna simulator

LUNA generates dynamically accurate lightcurves from a planet-moon pair, analytically accounting for shadow overlaps, stellar limb darkening, and planet-moon dynamical motion. The code takes transit timing/duration variations and ingress/egress asymmetries into consideration not only for the planet, but also the moon. LUNA was designed to be analytical and dynamical and to incorporate limb darkening (including non-linear laws) and account for all orbital elements, including eccentricity and longitude of the ascending node. Because the software is precise and analytic, LUNA is a highly potent tool for exomoon detection.

[ascl:1803.012]
LWPC: Long Wavelength Propagation Capability

Long Wavelength Propagation Capability (LWPC), written as a collection of separate programs that perform unique actions, generates geographical maps of signal availability for coverage analysis. The program makes it easy to set up these displays by automating most of the required steps. The user specifies the transmitter location and frequency, the orientation of the transmitting and receiving antennae, and the boundaries of the operating area. The program automatically selects paths along geographic bearing angles to ensure that the operating area is fully covered. The diurnal conditions and other relevant geophysical parameters are then determined along each path. After the mode parameters along each path are determined, the signal strength along each path is computed. The signal strength along the paths is then interpolated onto a grid overlying the operating area. The final grid of signal strength values is used to display the signal-strength in a geographic display. The LWPC uses character strings to control programs and to specify options. The control strings have the same meaning and use among all the programs.

[ascl:2312.005]
LyaCoLoRe: Generate simulated Lyman alpha forest spectra

Farr, James; Font-Ribera, Andreu; du Mas des Bourboux, Hélion; Muñoz-Gutiérrez, Andrea; Sánchez, F. Javier; Pontzen, Andrew; Xochitl González-Morales, Alma; Alonso, David; Brooks, David; Doel, Peter; Etourneau, Thomas; Guy, Julien; Le Goff, Jean-Marc; de la Macorra, Axel; Palanque-Delabrouille, Nathalie; Pérez-Ràfols, Ignasi; Rich, James; Slosar, Anže; Tarle, Gregory; Yutong, Duan; Zhang, Kai

LyaCoLoRe uses CoLoRe (ascl:2111.009) simulations to generate simulated Lyman alpha forest spectra. The code takes the output files from CoLoRe as an input, carries out several stages of processing, and produces realistic skewers of transmitted flux fraction as an output. The repository includes tools to tune the parameters within LyaCoLoRe's transformation, and to measure the 1D power spectrum of output skewers quickly.

[ascl:1607.018]
LZIFU: IDL emission line fitting pipeline for integral field spectroscopy data

LZIFU (LaZy-IFU) is an emission line fitting pipeline for integral field spectroscopy (IFS) data. Written in IDL, the pipeline turns IFS data to 2D emission line flux and kinematic maps for further analysis. LZIFU has been applied and tested extensively to various IFS data, including the SAMI Galaxy Survey, the Wide-Field Spectrograph (WiFeS), the CALIFA survey, the S7 survey and the MUSE instrument on the VLT.

[ascl:2212.019]
m2mcluster: Star clusters made-to-measure modeling

m2mcluster performs made-to-measure modeling of star clusters, and can fit target observations of a Galactic globular cluster's 3D density profile and individual kinematic properties, including proper motion velocity dispersion, and line of sight velocity dispersion. The code uses AMUSE (ascl:1107.007) to model the gravitational *N*-body evolution of the system between time steps; GalPy (ascl:1411.008) is also required.

[ascl:1407.005]
MAAT: MATLAB Astronomy and Astrophysics Toolbox

The MATLAB Astronomy and Astrophysics Toolbox (MAAT) is a collection of software tools and modular functions for astronomy and astrophysics written in the MATLAB environment. It includes over 700 MATLAB functions and a few tens of data files and astronomical catalogs. The scripts cover a wide range of subjects including: astronomical image processing, ds9 control, astronomical spectra, optics and diffraction phenomena, catalog retrieval and searches, celestial maps and projections, Solar System ephemerides, planar and spherical geometry, time and coordinates conversion and manipulation, cosmology, gravitational lensing, function fitting, general utilities, plotting utilities, statistics, and time series analysis.

[ascl:1209.006]
macula: Rotational modulations in the photometry of spotted stars

Photometric rotational modulations due to starspots remain the most common and accessible way to study stellar activity. Modelling rotational modulations allows one to invert the observations into several basic parameters, such as the rotation period, spot coverage, stellar inclination and differential rotation rate. The most widely used analytic model for this inversion comes from Budding (1977) and Dorren (1987), who considered circular, grey starspots for a linearly limb darkened star. That model is extended to be more suitable in the analysis of high precision photometry such as that by Kepler. Macula, a Fortran 90 code, provides several improvements, such as non-linear limb darkening of the star and spot, a single-domain analytic function, partial derivatives for all input parameters, temporal partial derivatives, diluted light compensation, instrumental offset normalisations, differential rotation, starspot evolution and predictions of transit depth variations due to unocculted spots. The inclusion of non-linear limb darkening means macula has a maximum photometric error an order-of-magnitude less than that of Dorren (1987) for Sun-like stars observed in the Kepler-bandpass. The code executes three orders-of-magnitude faster than comparable numerical codes making it well-suited for inference problems.

[ascl:1306.010]
MADCOW: Microwave Anisotropy Dataset Computational softWare

MADCOW is a set of parallelized programs written in ANSI C and Fortran 77 that perform a maximum likelihood analysis of visibility data from interferometers observing the cosmic microwave background (CMB) radiation. This software has been used to produce power spectra of the CMB with the Very Small Array (VSA) telescope.

[ascl:2302.019]
MADCUBA: MAdrid Data CUBe Analysis

MADCUBA analyzes astronomical datacubes and multiple spectra from various astronomical facilities, including ALMA, Herschel, VLA, IRAM 30m, APEX, GBT, and others. These telescopes, and in particular ALMA, generate extremely large datacubes (spatial, spectral and polarization). This software combines a user-friendly interface and powerful data analysis system to derive the physical conditions of molecular gas, its chemical complexity and the kinematics from datacubes. Built using the ImageJ (ascl:1206.013) infrastructure, MADCUBA visualizes astronomical datacubes with thousands on spectral channels, and datasets with thousands of spectra; it also identifies molecular species using publicly available molecular catalogs. It can automatically derive the physical parameters of the molecular species: column density, excitation temperature, velocity and linewidths and provides the best non-linear least-squared fit using the Levenberg-Marquardt algorithm, among other tasks.

[ascl:1712.012]
MadDM: Computation of dark matter relic abundance

MadDM computes dark matter relic abundance and dark matter nucleus scattering rates in a generic model. The code is based on the existing MadGraph 5 architecture and as such is easily integrable into any MadGraph collider study. A simple Python interface offers a level of user-friendliness characteristic of MadGraph 5 without sacrificing functionality. MadDM is able to calculate the dark matter relic abundance in models which include a multi-component dark sector, resonance annihilation channels and co-annihilations. The direct detection module of MadDM calculates spin independent / spin dependent dark matter-nucleon cross sections and differential recoil rates as a function of recoil energy, angle and time. The code provides a simplified simulation of detector effects for a wide range of target materials and volumes.

[ascl:2009.009]
MADHAT: Gamma-ray emission analyzer

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

MADHAT (Model-Agnostic Dark Halo Analysis Tool) analyzes gamma-ray emission from dwarf satellite galaxies and dwarf galaxy candidates due to dark matter annihilation, dark matter decay, or other nonstandard or unknown astrophysics. The tool is data-driven and model-independent, and provides statistical upper bounds on the number of observed photons in excess of the number expected using a stacked analysis of any selected set of dwarf targets. MADHAT also calculates the resulting bounds on the properties of dark matter under any assumptions the user makes regarding dark sector particle physics or astrophysics.

[ascl:2012.010]
MADLens: Differentiable lensing simulator

MADLens produces non-Gaussian cosmic shear maps at arbitrary source redshifts. A MADLens simulation with only 256^3 particles produces convergence maps whose power agree with theoretical lensing power spectra up to scales of L=10000. The code is based on a highly parallelizable particle-mesh algorithm and employs a sub-evolution scheme in the lensing projection and a machine-learning inspired sharpening step to achieve these high accuracies.

[ascl:1110.018]
MADmap: Fast Parallel Maximum Likelihood CMB Map Making Code

MADmap produces maximum-likelihood images of the sky from time-ordered data which include correlated noise, such as those gathered by Cosmic Microwave Background (CMB) experiments. It works efficiently on platforms ranging from small workstations to the most massively parallel supercomputers. Map-making is a critical step in the analysis of all CMB data sets, and the maximum-likelihood approach is the most accurate and widely applicable algorithm; however, it is a computationally challenging task. This challenge will only increase with the next generation of ground-based, balloon-borne and satellite CMB polarization experiments. The faintness of the B-mode signal that these experiments seek to measure requires them to gather enormous data sets. MADmap has the ability to address problems typically encountered in the analysis of realistic CMB data sets. The massively parallel and distributed implementation is detailed and scaling complexities are given for the resources required. MADmap is capable of analyzing the largest data sets now being collected on computing resources currently available.

[ascl:2206.018]
MADYS: Isochronal parameter determination for young stellar and substellar objects

MADYS (Manifold Age Determination for Young Stars) determines the age and mass of young stellar and substellar objects. The code automatically retrieves and cross-matches photometry from several catalogs, estimates interstellar extinction, and derives age and mass estimates for individual objects through isochronal fitting. MADYS harmonizes the heterogeneity of publicly-available isochrone grids and the user can choose amongst several models, some of which have customizable astrophysical parameters. Particular attention has been dedicated to the categorization of these models, labeled through a four-level taxonomical classification.

[ascl:2205.005]
maelstrom: Forward modeling of pulsating stars in binaries

Hey, Daniel R.; Murphy, Simon J.; Foreman-Mackey, Dan; Bedding, Timothy R.; Pope, Benjamin J.S.; Hogg, David W.

maelstrom models binary orbits through the phase modulation technique. This set of custom PyMC3 models and solvers fit each individual datapoint in the time series by forward modeling the time delay onto the light curve. This approach fully captures variations in a light curve caused by an orbital companion.

[ascl:1010.044]
MAESTRO: An Adaptive Low Mach Number Hydrodynamics Algorithm for Stellar Flows

MAESTRO, a low Mach number stellar hydrodynamics code, simulates long-time, low-speed flows that would be prohibitively expensive to model using traditional compressible codes. MAESTRO is based on an equation set derived using low Mach number asymptotics; this equation set does not explicitly track acoustic waves and thus allows a significant increase in the time step. MAESTRO is suitable for two- and three-dimensional local atmospheric flows as well as three-dimensional full-star flows, and adaptive mesh refinement (AMR) has been incorporated into the code. The expansion of the base state for full-star flows using a novel mapping technique between the one-dimensional base state and the Cartesian grid is also available.

NOTE: MAESTRO is no longer being actively developed. Users should switch to MAESTROeX (ascl:1908.019) to take advantage of the latest capabilities.

[ascl:1908.019]
MAESTROeX: Low Mach number stellar hydrodynamics code

MAESTROeX solves the equations of low Mach number hydrodynamics for stratified atmospheres or stars with a general equation of state. It includes reactions and thermal diffusion and can be used on anything from a single core to 100,000s of processor cores with MPI + OpenMP. MAESTROeX maintains the accuracy of its predecessor MAESTRO (ascl:1010.044) while taking advantage of a simplified temporal integration scheme and leveraging the AMReX software framework for block-structured adaptive mesh refinement (AMR) applications.

[ascl:2007.015]
MAGI: Initial-condition generator for galactic N-body simulations

MAGI (MAny-component Galaxy Initializer) generates initial conditions for numerical simulations of galaxies that resemble observed galaxies and are dynamically stable for time-scales longer than their characteristic dynamical times, taking into account galaxy bulges, discs, and haloes. MAGI adopts a distribution-function-based method and supports various kinds of density models, including custom-tabulated inputs and the presence of more than one disc, and is fast and easy to use.

Would you like to view a random code?