Results 1501-1600 of 3034 (2961 ASCL, 73 submitted)

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

[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: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: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: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: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: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: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: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: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.

[ascl:1709.010]
MagIC: Fluid dynamics in a spherical shell simulator

MagIC simulates fluid dynamics in a spherical shell. It solves for the Navier-Stokes equation including Coriolis force, optionally coupled with an induction equation for Magneto-Hydro Dynamics (MHD), a temperature (or entropy) equation and an equation for chemical composition under both the anelastic and the Boussinesq approximations. MagIC uses either Chebyshev polynomials or finite differences in the radial direction and spherical harmonic decomposition in the azimuthal and latitudinal directions. The time-stepping scheme relies on a semi-implicit Crank-Nicolson for the linear terms of the MHD equations and a Adams-Bashforth scheme for the non-linear terms and the Coriolis force.

[ascl:1604.004]
magicaxis: Pretty scientific plotting with minor-tick and log minor-tick support

The R suite magicaxis makes useful and pretty plots for scientific plotting and includes functions for base plotting, with particular emphasis on pretty axis labelling in a number of circumstances that are often used in scientific plotting. It also includes functions for generating images and contours that reflect the 2D quantile levels of the data designed particularly for output of MCMC posteriors where visualizing the location of the 68% and 95% 2D quantiles for covariant parameters is a necessary part of the post MCMC analysis, can generate low and high error bars, and allows clipping of values, rejection of bad values, and log stretching.

[ascl:1303.009]
MAGIX: Modeling and Analysis Generic Interface for eXternal numerical codes

MAGIX provides an interface between existing codes and an iterating engine that minimizes deviations of the model results from available observational data; it constrains the values of the model parameters and provides corresponding error estimates. Many models (and, in principle, not only astrophysical models) can be plugged into MAGIX to explore their parameter space and find the set of parameter values that best fits observational/experimental data. MAGIX complies with the data structures and reduction tools of Atacama Large Millimeter Array (ALMA), but can be used with other astronomical and with non-astronomical data.

[ascl:2003.002]
MAGNETAR: Histogram of relative orientation calculator for MHD observations

MAGNETAR is a set of tools for the study of the magnetic field in simulations of MHD turbulence and polarization observations. It calculates the histogram of relative orientation between density structure in the magnetic field in data cubes from simulations of MHD turbulence and observations of polarization using the method of histogram of relative orientations (HRO).

[ascl:1010.054]
MagnetiCS.c: Cosmic String Loop Evolution and Magnetogenesis

Large-scale coherent magnetic fields are observed in galaxies and clusters, but their ultimate origin remains a mystery. We reconsider the prospects for primordial magnetogenesis by a cosmic string network. We show that the magnetic flux produced by long strings has been overestimated in the past, and give improved estimates. We also compute the fields created by the loop population, and find that it gives the dominant contribution to the total magnetic field strength on present-day galactic scales. We present numerical results obtained by evolving semi-analytic models of string networks (including both one-scale and velocity-dependent one-scale models) in a Lambda-CDM cosmology, including the forces and torques on loops from Hubble redshifting, dynamical friction, and gravitational wave emission. Our predictions include the magnetic field strength as a function of correlation length, as well as the volume covered by magnetic fields. We conclude that string networks could account for magnetic fields on galactic scales, but only if coupled with an efficient dynamo amplification mechanism.

[ascl:2008.011]
Magnetizer: Computing magnetic fields of evolving galaxies

Magnetizer computes time and radial dependent magnetic fields for a sample of galaxies in the output of a semi-analytic model of galaxy formation. The magnetic field is obtained by numerically solving the galactic dynamo equations throughout history of each galaxy. Stokes parameters and Faraday rotation measure can also be computed along a random line-of-sight for each galaxy.

[ascl:1502.014]
Magnetron: Fitting bursts from magnetars

Magnetron, written in Python, decomposes magnetar bursts into a superposition of small spike-like features with a simple functional form, where the number of model components is itself part of the inference problem. Markov Chain Monte Carlo (MCMC) sampling and reversible jumps between models with different numbers of parameters are used to characterize the posterior distributions of the model parameters and the number of components per burst.

[ascl:1106.010]
MAGPHYS: Multi-wavelength Analysis of Galaxy Physical Properties

MAGPHYS is a self-contained, user-friendly model package to interpret observed spectral energy distributions of galaxies in terms of galaxy-wide physical parameters pertaining to the stars and the interstellar medium. MAGPHYS is optimized to derive statistical constraints of fundamental parameters related to star formation activity and dust content (e.g. star formation rate, stellar mass, dust attenuation, dust temperatures) of large samples of galaxies using a wide range of multi-wavelength observations. A Bayesian approach is used to interpret the SEDs all the way from the ultraviolet/optical to the far-infrared.

[ascl:2203.024]
Magrathea-Pathfinder: 3D AMR ray-tracing in simulations

Magrathea-Pathfinder propagates photons within cosmological simulations to construct observables. This high-performance framework uses a 3D Adaptive-Mesh Refinement and is built on top of the MAGRATHEA metalibrary (ascl:2203.023).

[ascl:2203.023]
MAGRATHEA: Multi-processor Adaptive Grid Refinement Analysis for THEoretical Astrophysics

MAGRATHEA (Multi-processor Adaptive Grid Refinement Analysis for THEoretical Astrophysics) is a foundational cosmological library and a relativistic raytracing code. Classical linear algebra libraries come with their own operations and can be difficult to leverage for new data types. Instead of providing basic types, MAGRATHEA provides tools to generate base types such as scalar quantities, points, vectors, or tensors.

[ascl:2201.012]
MAGRATHEA: Planet interior structure code

MAGRATHEA solves planet interiors and considers the case of fully differentiated interiors. The code integrates the hydrostatic equation in order to determine the correct planet radius given the mass in each layer. The code returns the pressure, temperature, density, phase, and radius at steps of enclosed mass. The code support four layers: core, mantle, hydrosphere, and atmosphere. Each layer has a phase diagram with equations of state chosen for each phase.

[ascl:2012.025]
Magritte: 3D radiative transfer library

De Ceuster, Frederik; Bolte, Jan; Homan, Ward; Maes, Silke; Malfait, Jolien; Decin, Leen; Yates, Jeremy; Boyle, Peter; Hetherington, James

Magritte performs 3D radiative transfer modeling; though focused on astrophysics and cosmology, the techniques can also be applied more generally. The code uses a deterministic ray-tracer with a formal solver that currently focuses on line radiative transfer. Magritte can either be used as a C++ library or as a Python package.

[ascl:1307.009]
MAH: Minimum Atmospheric Height

MAH calculates the posterior distribution of the "minimum atmospheric height" (MAH) of an exoplanet by inputting the joint posterior distribution of the mass and radius. The code collapses the two dimensions of mass and radius into a one dimensional term that most directly speaks to whether the planet has an atmosphere or not. The joint mass-radius posteriors derived from a fit of some exoplanet data (likely using MCMC) can be used by MAH to evaluate the posterior distribution of R_MAH, from which the significance of a non-zero R_MAH (i.e. an atmosphere is present) is calculated.

[ascl:2106.011]
MakeCloud: Turbulent GMC initial conditions for GIZMO

MakeCloud makes turbulent giant molecular cloud (GMC) initial conditions for GIZMO (ascl:1410.003). It generates turbulent velocity fields on the fly and stores that data in a user-specified path for efficiency. The code is flexible, allowing the user control through various parameters, including the radius of the cloud, number of gas particles, type of initial turbulent velocity (Gaussian or full), and magnetic energy as a fraction of the binding energy, among other options. With an additional file, it can also create glassy initial conditions.

[ascl:1502.021]
MaLTPyNT: Quick look timing analysis for NuSTAR data

MaLTPyNT (Matteo's Libraries and Tools in Python for NuSTAR Timing) provides a quick-look timing analysis of NuSTAR data, properly treating orbital gaps and exploiting the presence of two independent detectors by using the cospectrum as a proxy for the power density spectrum. The output of the analysis is a cospectrum, or a power density spectrum, that can be fitted with XSPEC (ascl:9910.005) or ISIS (ascl:1302.002). The software also calculates time lags. Though written for NuSTAR data, MaLTPyNT can also perform standard spectral analysis on X-ray data from other satellite such as XMM-Newton and RXTE.

[submitted]
MALU IFS visualisation tool

MALU visualizes integral field spectroscopy (IFS) data such as CALIFA, MANGA, SAMI or MUSE data producing fully interactive plots. The tool is not specific to any instrument. It is available in Python and no installation is required.

[ascl:2203.020]
MAMPOSSt: Mass/orbit modeling of spherical systems

MAMPOSSt (Modeling Anisotropy and Mass Profiles of Observed Spherical Systems) is a Bayesian code to perform mass/orbit modeling of spherical systems. It determines marginal parameter distributions and parameter covariances of parametrized radial distributions of dark or total matter, as well as the mass of a possible central black hole, and the radial profiles of density and velocity anisotropy of one or several tracer components, all of which are jointly fit to the discrete data in projected phase space. It is based upon the MAMPOSSt likelihood function for the distribution of individual tracers in projected phase space (projected radius and line-of-sight velocity) and the CosmoMC Markov Chain Monte Carlo code (ascl:1106.025), run in generic mode. MAMPOSSt is not based on the 6D distribution function (which would require triple integrals), but on the assumption that the local 3D velocity distribution is an (anisotropic) Gaussian (requiring only a single integral).

[ascl:2106.010]
Maneage: Managing data lineage

Akhlaghi, Mohammad; Infante-Sainz, Raúl; Roukema, Boudewijn; Khellat, Mohammadreza; Valls-Gabaud, David; Baena-Gallé, Roberto

The Maneage (Managing data lineage; ending pronounced like "lineage") framework produces fully reproducible computational research. It provides full control on building the necessary software environment from a low-level C compiler, the shell and LaTeX, all the way up to the high-level science software in languages such as Python without a third-party package manager. Once the software environment is built, adding analysis steps is as easy as defining "Make" rules to allow parallelized operations, and not repeating operations that do not need to be recreated. Make provides control over data provenance. A Maneage'd project also contains the narrative description of the project in LaTeX, which helps prepare the research for publication. All results from the analysis are passed into the report through LaTeX macros, allowing immediate dynamic updates to the PDF paper when any part of the analysis has changed. All information is stored in plain text and is version-controlled in Git. Maneage itself is actually a Git branch; new projects start by defining a new Git branch over it and customizing it for a new project. Through Git merging of branches, it is possible to import infrastructure updates to projects.

[ascl:2203.017]
MaNGA-DAP: MaNGA Data Analysis Pipeline

Westfall, Kyle B.; Cappellari, Michele; Bershady, Matthew A.; Bundy, Kevin; Belfiore, Francesco; Ji, Xihan; Law, David R.; Schaefer, Adam; Shetty, Shravan; Tremonti, Christy A.; Yan, Renbin; Andrews, Brett H.; Brownstein, Joel R.; Cherinka, Brian; Coccato, Lodovico; Drory, Niv; Maraston, Claudia; Parikh, Taniya; Sánchez-Gallego, José R.; Thomas, Daniel; Weijmans, Anne-Marie; Barrera-Ballesteros, Jorge; Du, Cheng; Goddard, Daniel; Li, Niu; Masters, Karen; Ibarra Medel, Héctor Javier; Sánchez, Sebastián F.; Yang, Meng; Zheng, Zheng; Zhou, Shuang

The MaNGA data analysis pipeline (MaNGA DAP) analyzes the data produced by the MaNGA data-reduction pipeline (ascl:2203.016) to produced physical properties derived from the MaNGA spectroscopy. All survey-provided properties are currently derived from the log-linear binned datacubes (*i.e.*, the LOGCUBE files).

[ascl:2203.016]
MaNGA-DRP: MaNGA Data Reduction Pipeline

Law, David R.; Cherinka, Brian; Yan, Renbin; Andrews, Brett H.; Bershady, Matthew A.; Bizyaev, Dmitry; Blanc, Guillermo A.; Blanton, Michael R.; Bolton, Adam S.; Brownstein, Joel R.; Bundy, Kevin; Chen, Yanmei; Drory, Niv; D'Souza, Richard; Fu, Hai; Jones, Amy; Kauffmann, Guinevere; MacDonald, Nicholas; Masters, Karen L.; Newman, Jeffrey A.; Parejko, John K.; Sánchez-Gallego, José R.; Sánchez, Sebastian F.; Schlegel, David J.; Thomas, Daniel; Wake, David A.; Weijmans, Anne-Marie; Westfall, Kyle B.; Zhang, Kai

The MaNGA Data Reduction Pipeline (DRP) processes the raw data to produce flux calibrated, sky subtracted, coadded data cubes from each of the individual exposures for a given galaxy. The DRP consists of two primary parts: the 2d stage that produces flux calibrated fiber spectra from raw individual exposures, and the 3d stage that combines multiple flux calibrated exposures with astrometric information to produce stacked data cubes. These science-grade data cubes are then processed by the MaNGA Data Analysis Pipeline (ascl:2203.017), which measures the shape and location of various spectral features, fits stellar population models, and performs a variety of other analyses necessary to derive astrophysically meaningful quantities from the calibrated data cubes.

[ascl:1202.005]
Mangle: Angular Mask Software

Mangle deals accurately and efficiently with complex angular masks, such as occur typically in galaxy surveys. Mangle performs the following tasks: converts masks between many handy formats (including HEALPix); rapidly finds the polygons containing a given point on the sphere; rapidly decomposes a set of polygons into disjoint parts; expands masks in spherical harmonics; generates random points with weights given by the mask; and implements computations for correlation function analysis. To mangle, a mask is an arbitrary union of arbitrarily weighted angular regions bounded by arbitrary numbers of edges. The restrictions on the mask are only (1) that each edge must be part of some circle on the sphere (but not necessarily a great circle), and (2) that the weight within each subregion of the mask must be constant. Mangle is complementary to and integrated with the HEALPix package (ascl:1107.018); mangle works with vector graphics whereas HEALPix works with pixels.

[ascl:1305.012]
MapCUMBA: Multi-grid map-making algorithm for CMB experiments

The MapCUMBA package applies a multigrid fast iterative Jacobi algorithm for map-making in the context of CMB experiments.

[ascl:1308.003]
MapCurvature: Map Projections

MapCurvature, written in IDL, can create map projections with Goldberg-Gott indicatrices. These indicatrices measure the flexion and skewness of a map, and are useful for determining whether features are faithfully reproduced on a particular projection.

[ascl:1306.008]
MAPPINGS III: Modelling And Prediction in PhotoIonized Nebulae and Gasdynamical Shocks

MAPPINGS III is a general purpose astrophysical plasma modelling code. It is principally intended to predict emission line spectra of medium and low density plasmas subjected to different levels of photoionization and ionization by shockwaves. MAPPINGS III tracks up to 16 atomic species in all stages of ionization, over a useful range of 102 to 108 K. It treats spherical and plane parallel geometries in equilibrium and time-dependent models. MAPPINGS III is useful for computing models of HI and HII regions, planetary nebulae, novae, supernova remnants, Herbig-Haro shocks, active galaxies, the intergalactic medium and the interstellar medium in general. The present version of MAPPINGS III is a large FORTRAN program that runs with a simple TTY interface for historical and portability reasons. A newer version of this software, MAPPINGS V (ascl:1807.005), is available.

[ascl:1807.005]
MAPPINGS V: Astrophysical plasma modeling code

MAPPINGS V is a update of the MAPPINGS code (ascl:1306.008) and provides new cooling function computations for optically thin plasmas based on the greatly expanded atomic data of the CHIANTI 8 database. The number of cooling and recombination lines has been expanded from ~2000 to over 80,000, and temperature-dependent spline-based collisional data have been adopted for the majority of transitions. The expanded atomic data set provides improved modeling of both thermally ionized and photoionized plasmas; the code is now capable of predicting detailed X-ray spectra of nonequilibrium plasmas over the full nonrelativistic temperature range, increasing its utility in cosmological simulations, in modeling cooling flows, and in generating accurate models for the X-ray emission from shocks in supernova remnants.

[ascl:2108.003]
MAPS: Multi-frequency Angular Power Spectrum estimator

MAPS (Multi-frequency Angular Power Spectrum) extracts two-point statistical information from Epoch of Reionization (EoR) signals observed in three dimensions, with two directions on the sky and the wavelength (or frequency) constituting the third dimension. Rather than assume that the signal has the same statistical properties in all three directions, as the spherically averaged power spectrum (SAPS) does, MAPS does not make these assumptions, making it more natural for radio interferometric observations than SAPS.

[ascl:2003.010]
MARGE: Machine learning Algorithm for Radiative transfer of Generated Exoplanets

MARGE (Machine learning Algorithm for Radiative transfer of Generated Exoplanets) generates exoplanet spectra across a defined parameter space, processes the output, and trains, validates, and tests machine learning models as a fast approximation to radiative transfer. It uses BART (ascl:1608.004) for spectra generation and modifies BART’s Bayesian sampler (MC^{3}, ascl:1610.013) with a random uniform sampler to propose models within a defined parameter space. More generally, MARGE provides a framework for training neural network models to approximate a forward, deterministic process.

[ascl:1011.004]
MARS: The MAGIC Analysis and Reconstruction Software

Moralejo, R. A.; Gaug, M.; Carmona, E.; Colin, P.; Delgado, C.; Lombardi, S.; Mazin, D.; Scalzotto, V.; Sitarek, J.; Tescaro, D.

With the commissioning of the second MAGIC gamma-ray Cherenkov telescope situated close to MAGIC-I, the standard analysis package of the MAGIC collaboration, MARS, has been upgraded in order to perform the stereoscopic reconstruction of the detected atmospheric showers. MARS is a ROOT-based code written in C++, which includes all the necessary algorithms to transform the raw data recorded by the telescopes into information about the physics parameters of the observed targets. An overview of the methods for extracting the basic shower parameters is presented, together with a description of the tools used in the background discrimination and in the estimation of the gamma-ray source spectra.

[ascl:1910.015]
MarsLux: Illumination Mars maps generator

MarsLux generates illumination maps of Mars from Digital Terrain Model (DTM), permitting users to investigate in detail the illumination conditions on Mars based on its topography and the relative position of the Sun. MarsLux consists of two Python codes, SolaPar and MarsLux. SolaPar calculates the matrix with solar parameters for one date or a range between the two. The Marslux code generates the illumination maps using the same DTM and the files generated by SolaPar. The resulting illumination maps show areas that are fully illuminated, areas in total shadow, and areas with partial shade, and can be used for geomorphological studies to examine gullies, thermal weathering, or mass wasting processes as well as for producing energy budget maps for future exploration missions.

[ascl:1911.005]
MARTINI: Mock spatially resolved spectral line observations of simulated galaxies

MARTINI (Mock APERTIF-like Radio Telescope Interferometry of the Neutal ISM) creates synthetic resolved HI line observations (data cubes) of smoothed-particle hydrodynamics simulations of galaxies. The various aspects of the mock-observing process are divided logically into sub-modules handling the data cube, source, beam, noise, spectral model and SPH kernel. MARTINI is object-oriented: each sub-module provides a class (or classes) which can be configured as desired. For most sub-modules, base classes are provided to allow for straightforward customization. Instances of each sub-module class are then given as parameters to the Martini class. A mock observation is then constructed by calling a handful of functions to execute the desired steps in the mock-observing process.

[ascl:2106.005]
Marvin: Data access and visualization for MaNGA

Cherinka, Brian; Andrews, Brett H.; Sánchez-Gallego, José; Brownstein, Joel; Argudo-Fernández, María; Blanton, Michael; Bundy, Kevin; Jones, Amy; Masters, Karen; Law, David R.; Rowlands, Kate; Weijmans, Anne-Marie; Westfall, Kyle; Yan, Renbin

Marvin searches, accesses, and visualizes data from the Mapping Nearby Galaxies at Apache Point Observatory (MaNGA) survey. Written in Python, it provides tools for easy efficient interaction with the MaNGA data via local files, files retrieved from the Science Archive Server, or data directly grabbed from the database. The tools come mainly in the form of convenience functions and classes for interacting with the data. Also available is a web app, Marvin-web, offers an easily accessible interface for searching the MaNGA data and visual exploration of individual MaNGA galaxies or of the entire sample, and a powerful query functionality that uses the API to query the MaNGA databases and return the search results to your python session. Marvin-API is the critical link that allows Marvin-tools and Marvin-web to interact with the databases, which enables users to harness the statistical power of the MaNGA data set.

[ascl:1302.001]
MARX: Model of AXAF Response to X-rays

MARX (Model of AXAF Response to X-rays) is a suite of programs designed to enable the user to simulate the on-orbit performance of the Chandra satellite. MARX provides a detailed ray-trace simulation of how Chandra responds to a variety of astrophysical sources and can generate standard FITS events files and images as output. It contains models for the HRMA mirror system onboard Chandra as well as the HETG and LETG gratings and all focal plane detectors.

[ascl:1711.020]
MARXS: Multi-Architecture Raytrace Xray mission Simulator

MARXS (Multi-Architecture-Raytrace-Xraymission-Simulator) simulates X-ray observatories. Primarily designed to simulate X-ray instruments on astronomical X-ray satellites and sounding rocket payloads, it can also be used to ray-trace experiments in the laboratory. MARXS performs polarization Monte-Carlo ray-trace simulations from a source (astronomical or lab) through a collection of optical elements such as mirrors, baffles, and gratings to a detector.

[ascl:1605.001]
MARZ: Redshifting Program

MARZ analyzes objects and produces high quality spectroscopic redshift measurements. Spectra not matched correctly by the automatic algorithm can be redshifted manually by cycling automatic results, manual template comparison, or marking spectral features. The software has an intuitive interface and powerful automatic matching capabilities on spectra, and can be run interactively or from the command line, and runs as a Web application. MARZ can be run on a local server; it is also available for use on a public server.

[ascl:2101.007]
Mask galaxy: Machine learning pipeline for morphological segmentation of galaxies

Mask galaxy is an automatic machine learning pipeline for detection, segmentation and morphological classification of galaxies. The model is based on the Mask R-CNN Deep Learning architecture. This model of instance segmentation also performs image segmentation at the pixel level, and has shown a Mean Average Precision (mAP) of 0.93 in morphological classification of spiral or elliptical galaxies.

[ascl:1101.009]
MasQU: Finite Differences on Masked Irregular Stokes Q,U Grids

MasQU extracts polarization information in the CMB by reducing contamination from so-called "ambiguous modes" on a masked sky, which contain leakage from the larger E-mode signal and utilizing derivative operators on the real-space Stokes Q and U parameters. In particular, the package can perform finite differences on masked, irregular grids and is applied to a semi-regular spherical pixellization, the HEALPix grid. The formalism reduces to the known finite-difference solutions in the case of a regular grid. On a masked sphere, the software represents a considerable reduction in B-mode noise from limited sky coverage.

[ascl:1104.004]
MASSCLEAN: MASSive CLuster Evolution and ANalysis Package

MASSCLEAN is a sophisticated and robust stellar cluster image and photometry simulation package. This package is able to create color-magnitude diagrams and standard FITS images in any of the traditional optical and near-infrared bands based on cluster characteristics input by the user, including but not limited to distance, age, mass, radius and extinction. At the limit of very distant, unresolved clusters, we have checked the integrated colors created in MASSCLEAN against those from other simple stellar population (SSP) models with consistent results. Because the algorithm populates the cluster with a discrete number of tenable stars, it can be used as part of a Monte Carlo Method to derive the probabilistic range of characteristics (integrated colors, for example) consistent with a given cluster mass and age.

[ascl:1401.008]
massconvert: Halo Mass Conversion

massconvert, written in Fortran, provides driver and fitting routines for converting halo mass definitions from one spherical overdensity to another assuming an NFW density profile. In surveys that probe ever lower cluster masses and temperatures, sample variance is generally comparable to or greater than shot noise and thus cannot be neglected in deriving precision cosmological constraints; massconvert offers an accurate fitting formula for the conversion between different definitions of halo mass.

[ascl:2207.035]
massmappy: Mapping dark matter on the celestial sphere

massmappy recovers convergence mass maps on the celestial sphere from weak lensing cosmic shear observations. It relies on SSHT (ascl:2207.034) and HEALPix (ascl:1107.018) to handle sampled data on the sphere. The spherical Kaiser-Squires estimator is implemented.

[ascl:1406.010]
MATCH: A program for matching star lists

MATCH matches up items in two different lists, which can have two different systems of coordinates. The program allows the two sets of coordinates to be related by a linear, quadratic, or cubic transformation. MATCH was designed and written to work on lists of stars and other astronomical objects but can be applied to other types of data. In order to match two lists of N points, the main algorithm calls for O(N^6) operations; though not the most efficient choice, it does allow for arbitrary translation, rotation, and scaling.

[ascl:1601.018]
MATPHOT: Stellar photometry and astrometry with discrete point spread functions

A discrete Point Spread Function (PSF) is a sampled version of a continuous two-dimensional PSF. The shape information about the photon scattering pattern of a discrete PSF is typically encoded using a numerical table (matrix) or a FITS image file. MATPHOT shifts discrete PSFs within an observational model using a 21-pixel- wide damped sinc function and position partial derivatives are computed using a five-point numerical differentiation formula. MATPHOT achieves accurate and precise stellar photometry and astrometry of undersampled CCD observations by using supersampled discrete PSFs that are sampled two, three, or more times more finely than the observational data.

[ascl:2008.018]
maxsmooth: Derivative constrained function fitting

maxsmooth fits derivative constrained functions (DCF) such as Maximally Smooth Functions (MSFs) to data sets. MSFs are functions for which there are no zero crossings in derivatives of order m >= 2 within the domain of interest. They are designed to prevent the loss of signals when fitting out dominant smooth foregrounds or large magnitude signals that mask signals of interest. Here "smooth" means that the foregrounds follow power law structures and do not feature turning points in the band of interest. maxsmooth uses quadratic programming implemented with CVXOPT (ascl:2008.017) to fit data subject to a fixed linear constraint, Ga <= 0, where the product Ga is a matrix of derivatives. The code tests the <= 0 constraint multiplied by a positive or negative sign and can test every available sign combination but by default, it implements a sign navigating algorithm.

[ascl:1205.008]
Mayavi2: 3D Scientific Data Visualization and Plotting

Mayavi provides general-purpose 3D scientific visualizations. It offers easy interactive tools for data visualization that fit with the scientific user's workflow. Mayavi provides several entry points: a full-blown interactive application; a Python library with both a MATLAB-like interface focused on easy scripting and a feature-rich object hierarchy; widgets associated with these objects for assembling in a domain-specific application, and plugins that work with a general purpose application-building framework.

[ascl:2204.009]
MAYONNAISE: ADI data imaging processing pipeline

MAYONNAISE (Morphological Analysis Yielding separated Objects iN Near infrAred usIng Sources Estimation), or MAYO for short, is a pipeline for exoplanet and disk high-contrast imaging from ADI datasets. The pipeline is mostly automated; the package also loads the data and injects synthetic data if needed. MAYONNAISE parameters are written in a json file called parameters_algo.json and placed in a working_directory.

[ascl:1602.020]
mbb_emcee: Modified Blackbody MCMC

Mbb_emcee fits modified blackbodies to photometry data using an affine invariant MCMC. It has large number of options which, for example, allow computation of the IR luminosity or dustmass as part of the fit. Carrying out a fit produces a HDF5 output file containing the results, which can either be read directly, or read back into a mbb_results object for analysis. Upper and lower limits can be imposed as well as Gaussian priors on the model parameters. These additions are useful for analyzing poorly constrained data. In addition to standard Python packages scipy, numpy, and cython, mbb_emcee requires emcee (ascl:1303.002), Astropy (ascl:1304.002), h5py, and for unit tests, nose.

[ascl:2010.001]
MBF: MOLSCAT 2020, BOUND, and FIELD for atomic and molecular collisions

MOLSCAT, which supercedes MOLSCAT version 14 (ascl:1206.004), performs non-reactive quantum scattering calculations for atomic and molecular collisions using coupled-channel methods. Simple atom-molecule and molecule-molecule collision types are coded internally and additional ones may be handled with plug-in routines. Plug-in routines may include external magnetic, electric or photon fields (and combinations of them).

The package also includes BOUND, which performs calculations of bound-state energies in weakly bound atomic and molecular systems using coupled-channel methods, and FIELD, a development of BOUND that locates values of external fields at which a bound state exists with a specified energy. Though the three programs have different applications, they use closely related methods, share many subroutines, and are released with a single code base.

[ascl:1705.008]
MBProj2: Multi-Band x-ray surface brightness PROJector 2

MBProj2 obtains thermodynamic profiles of galaxy clusters. It forward-models cluster X-ray surface brightness profiles in multiple bands, optionally assuming hydrostatic equilibrium. The code is a set of Python classes the user can use or extend. When modelling a cluster assuming hydrostatic equilibrium, the user chooses a form for the density profile (e.g. binning or a beta model), the metallicity profile, and the dark matter profile (e.g. NFW). If hydrostatic equilibrium is not assumed, a temperature profile model is used instead of the dark matter profile. The code uses the emcee Markov Chain Monte Carlo code (ascl:1303.002) to sample the model parameters, using these to produce chains of thermodynamic profiles.

[ascl:1703.014]
MC-SPAM: Monte-Carlo Synthetic-Photometry/Atmosphere-Model

MC-SPAM (Monte-Carlo Synthetic-Photometry/Atmosphere-Model) generates limb-darkening coefficients from models that are comparable to transit photometry; it extends the original SPAM algorithm by Howarth (2011) by taking in consideration the uncertainty on the stellar and transit parameters of the system under analysis.

[ascl:1610.013]
MC^{3}: Multi-core Markov-chain Monte Carlo code

Cubillos, Patricio; Harrington, Joseph; Lust, Nate; Foster, AJ; Stemm, Madison; Loredo, Tom; Stevenson, Kevin; Campo, Chris; Hardin, Matt; Hardy, Ryan

MC^{3} (Multi-core Markov-chain Monte Carlo) is a Bayesian statistics tool that can be executed from the shell prompt or interactively through the Python interpreter with single- or multiple-CPU parallel computing. It offers Markov-chain Monte Carlo (MCMC) posterior-distribution sampling for several algorithms, Levenberg-Marquardt least-squares optimization, and uniform non-informative, Jeffreys non-informative, or Gaussian-informative priors. MC^{3} can share the same value among multiple parameters and fix the value of parameters to constant values, and offers Gelman-Rubin convergence testing and correlated-noise estimation with time-averaging or wavelet-based likelihood estimation methods.

[ascl:1204.005]
MC3D: Monte-Carlo 3D Radiative Transfer Code

MC3D is a 3D continuum radiative transfer code; it is based on the Monte-Carlo method and solves the radiative transfer problem self-consistently. It is designed for the simulation of dust temperatures in arbitrary geometric configurations and the resulting observables: spectral energy distributions, wavelength-dependent images, and polarization maps. The main objective is the investigation of "dust-dominated" astrophysical systems such as young stellar objects surrounded by an optically thick circumstellar disk and an optically thin(ner) envelope, debris disks around more evolved stars, asymptotic giant branch stars, the dust component of the interstellar medium, and active galactic nuclei.

[ascl:1511.008]
MCAL: M dwarf metallicity and temperature calculator

MCAL calculates high precision metallicities and effective temperatures for M dwarfs; the method behaves properly down to R = 40 000 and S/N = 25, and results were validated against a sample of stars in common with SOPHIE high resolution spectra.

[ascl:2105.008]
MCALF: Velocity information from spectral imaging observations

MCALF (Multi-Component Atmospheric Line Fitting) accurately constrains velocity information from spectral imaging observations using machine learning techniques. It is useful for solar physicists trying to extract line-of-sight (LOS) Doppler velocity information from spectral imaging observations (Stokes I measurements) of the Sun. A toolkit is provided that can be used to define a spectral model optimized for a particular dataset. MCALF is particularly suited for extracting velocity information from spectral imaging observations where the individual spectra can contain multiple spectral components. Such multiple components are typically present when active solar phenomenon occur within an isolated region of the solar disk. Spectra within such a region will often have a large emission component superimposed on top of the underlying absorption spectral profile from the quiescent solar atmosphere.

[ascl:2210.022]
MCCD: Multi-CCD Point Spread Function Modelling

MCCD (Multi-CCD) generates a Point Spread Function (PSF) model based on stars observations in the field of view. After defining the MCCD model parameters and running and validating the training, the model can recover the PSF at any position in the field of view. Written in Python, MCCD also calculates various statistics and can plot a random test star and its model reconstruction.

[ascl:1906.017]
mcfit: Multiplicatively Convolutional Fast Integral Transforms

mcfit computes integral transforms, inverse transforms without analytic inversion, and integral kernels as derivatives. It can also transform input array along any axis, output the matrix form, an is easily extensible for other kernels.

[ascl:2207.023]
MCFOST: Radiative transfer code

Pinte, C.; Ménard, F.; Duchêne, G.; Bastien, P.; Harries, T. J.; Min, M.; Watson, A. M.; Dullemond, C. P.; Woitke, P.; Durán-Rojas, M. C.

MCFOST is a 3D continuum and line radiative transfer code based on an hybrid Monte Carlo and ray-tracing method. It is mainly designed to study the circumstellar environment of young stellar objects, but has been used for a wide range of astrophysical problems. The calculations are done exactly within the limitations of the Monte Carlo noise and machine precision, *i.e.*, no approximation are used in the calculations. The code has been strongly optimized for speed.

MCFOST is primarily designed to study protoplanetary disks. The code can reproduce most of the observations of disks, including SEDs, scattered light images, IR and mm visibilities, and atomic and molecular line maps. As the Monte Carlo method is generic, any complex structure can be handled by MCFOST and its use can be extended to other astrophysical objects. For instance, calculations have succesfully been performed on infalling envelopes and AGB stars. MCFOST also includes a non-LTE line transfer module, and NLTE level population are obtained via iterations between Monte Carlo radiative transfer calculations and statistical equilibrium.

[ascl:1107.015]
McLuster: A Tool to Make a Star Cluster

The tool McLuster is an open source code that can be used to either set up initial conditions for N-body computations or, alternatively, to generate artificial star clusters for direct investigation. There are two different versions of the code, one basic version for generating all kinds of unevolved clusters (in the following called mcluster) and one for setting up evolved stellar populations at a given age. The former is completely contained in the C file main.c. The latter (dubbed mcluster_sse) is more complex and requires additional FORTRAN routines, namely the Single-Star Evolution (SSE) routines by Hurley, Pols & Tout (ascl:1303.015) that are provided with the McLuster code.

[ascl:1407.004]
MCMAC: Monte Carlo Merger Analysis Code

Monte Carlo Merger Analysis Code (MCMAC) aids in the study of merging clusters. It takes observed priors on each subcluster's mass, radial velocity, and projected separation, draws randomly from those priors, and uses them in a analytic model to get posterior PDF's for merger dynamic properties of interest (e.g. collision velocity, time since collision).

[ascl:2011.004]
MCMCDiagnostics: Markov Chain Monte Carlo convergence diagnostics

MCMCDiagnostics contains two diagnostics, written in Julia, for Markov Chain Monte Carlo. The first is potential_scale_reduction(chains...), which estimates the potential scale reduction factor, also known as Rhat, for multiple scalar chains . The second, effective_sample_size(chain), calculates the effective sample size for scalar chains. These diagnostics are intended as building blocks for use by other libraries.

[ascl:2001.012]
MCMCI: Markov Chain Monte Carlo + Isochrones method for characterizing exoplanetary systems

MCMCI (Markov chain Monte Carlo + isochrones) characterizes a whole exoplanetary system directly by modeling the star and its planets simultaneously. The code, written in Fortran, uses light curves and basic stellar parameters with a transit analysis algorithm that interacts with stellar evolutionary models, thus using both model-dependent and empirical age indicators to characterize the system.

[ascl:1210.017]
McPHAC: McGill Planar Hydrogen Atmosphere Code

The McGill Planar Hydrogen Atmosphere Code (McPHAC) v1.1 calculates the hydrostatic equilibrium structure and emergent spectrum of an unmagnetized hydrogen atmosphere in the plane-parallel approximation at surface gravities appropriate for neutron stars. McPHAC incorporates several improvements over previous codes for which tabulated model spectra are available: (1) Thomson scattering is treated anisotropically, which is shown to result in a 0.2%-3% correction in the emergent spectral flux across the 0.1-5 keV passband; (2) the McPHAC source code is made available to the community, allowing it to be scrutinized and modified by other researchers wishing to study or extend its capabilities; and (3) the numerical uncertainty resulting from the discrete and iterative solution is studied as a function of photon energy, indicating that McPHAC is capable of producing spectra with numerical uncertainties <0.01%. The accuracy of the spectra may at present be limited to ~1%, but McPHAC enables researchers to study the impact of uncertain inputs and additional physical effects, thereby supporting future efforts to reduce those inaccuracies. Comparison of McPHAC results with spectra from one of the previous model atmosphere codes (NSA) shows agreement to lsim1% near the peaks of the emergent spectra. However, in the Wien tail a significant deficit of flux in the spectra of the previous model is revealed, determined to be due to the previous work not considering large enough optical depths at the highest photon frequencies. The deficit is most significant for spectra with T eff < 105.6 K, though even there it may not be of much practical importance for most observations.

[ascl:2107.025]
MCPM: Modified CPM method

MCPM extracts K2 photometry in dense stellar regions; the code is a modification and extension of the K2-CPM package (ascl:2107.024), which was developed for less-crowded fields. MCPM uses the pixel response function together with accurate astrometric grids, combining signals from a few pixels, and simultaneously fits for an astrophysical model to produce extracted more precise K2 photometry.

[ascl:2005.019]
MCRaT: Monte Carlo Radiation Transfer

MCRaT (Monte Carlo Radiation Transfer) analyzes the radiation signature expected from astrophysical outflows. MCRaT injects photons in a FLASH (ascl:1010.082) simulation and individually propagates and compton scatters the photons through the fluid until the end of the simulation. This process of injection and propagating occurs for a user specified number of times until there are no more photons to be injected. Users can then construct light curves and spectra with the MCRaT calculated results. The hydrodynamic simulations used with this version of MCRaT must be in 2D; however, the photon propagation and scattering is done in 3D by assuming cylindrical symmetry. Additionally, MCRaT uses the full Klein–Nishina cross section including the effects of polarization, which can be fully simulated in the code. MCRaT works with FLASH hydrodynamic simulations and PLUTO (ascl:1010.045) AMR simulations, with both 2D spherical (r, equation) and 2D cartesian ((x,y) and (r,z)).

Would you like to view a random code?