[ascl:1708.017]
LCC: Light Curves Classifier

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[ascl:1504.013]
kozai: Hierarchical triple systems evolution

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

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

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

[submitted]
Kliko - The Scientific Compute Container Format

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

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

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

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

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

[ascl:1502.020]
ketu: Exoplanet candidate search code

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

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

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

[submitted]
KERN

KERN is a bi-annually released set of radio astronomical software packages. It should contain most of the standard tools that a radio astronomer needs to work with radio telescope data. The goal of KERN to is to save time and frustration in setting up of scientific pipelines, and to assist in achieving scientific reproducibility.

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

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

[ascl:1706.012]
KeplerSolver: Kepler equation solver

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

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

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

[ascl:1712.001]
KDUtils: Kinematic Distance Utilities

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

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

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

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

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

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

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

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

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

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

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

[ascl:1403.022]
KAPPA: Kernel Applications Package

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

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

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

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

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

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

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

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

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

[ascl:1605.012]
K2SC: K2 Systematics Correction

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

[ascl:1607.010]
K2PS: K2 Planet search

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

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

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

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

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

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

[ascl:1503.001]
K2flix: Kepler pixel data visualizer

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

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

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

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

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

[ascl:1904.029]
JVarStar: Variable Star Analysis Library

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

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

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

[ascl:1109.024]
Jupiter: Multidimensional Astrophysical Hydrocode

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

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

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

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

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

[ascl:1511.002]
JSPAM: Interacting galaxies modeller

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

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

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

[ascl:1511.016]
JKTLD: Limb darkening coefficients

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

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

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

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

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

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

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

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

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

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

[ascl:1406.019]
JCMTDR: Applications for reducing JCMT continuum data in GSD format

JCMTDR reduces continuum on-the-fly mapping data obtained with UKT14 or the heterodyne instruments using the IFD on the James Clerk Maxwell Telescope. This program reduces archive data and heterodyne beam maps and was distributed as part of the Starlink software collection (ascl:1110.012).

[ascl:1411.020]
JCMT COADD: UKT14 continuum and photometry data reduction

COADD was used to reduce photometry and continuum data from the UKT14 instrument on the James Clerk Maxwell Telescope in the 1990s. The software can co-add multiple observations and perform sigma clipping and Kolmogorov-Smirnov statistical analysis. Additional information on the software is available in the JCMT Spring 1993 newsletter (large PDF).

[ascl:1010.007]
JAVELIN: Just Another Vehicle for Estimating Lags In Nuclei (formerly known as SPEAR)

JAVELIN (SPEAR) is a new approach to reverberation mapping that computes the lags between the AGN continuum and emission line light curves and their statistical confidence limits. It uses a damped random walk model to describe the quasar continuum variability and the ansatz that emission line variability is a scaled, smoothed and displaced version of the continuum. While currently configured only to simultaneously fit light curve means, it includes a general linear parameters formalism to fit more complex trends or calibration offsets. The noise matrix can be modified to allow for correlated errors, and the correlation matrix can be modified to use a different stochastic process. The transfer function model is presently a tophat, but this can be altered by changing the line-continuum covariance matrices. It is also able to cope with some problems in traditional reverberation mapping, such as irregular sampling, correlated errors and seasonal gaps.

[ascl:1403.018]
JAM: Jeans Anisotropic MGE modeling method

The Jeans Anisotropic MGE (JAM) modeling method uses the Multi-Gaussian Expansion parameterization for the galaxy surface brightness. The code allows for orbital anisotropy (three-integrals distribution function) and also provides the full second moment tensor, including proper motions and radial velocities.

[ascl:1209.002]
JAGS: Just Another Gibbs Sampler

JAGS analyzes Bayesian hierarchical models using Markov Chain Monte Carlo (MCMC) simulation not wholly unlike BUGS. JAGS has three aims:

- to have a cross-platform engine for the BUGS language;
- to be extensible, allowing users to write their own functions, distributions and samplers; and
- to be a platform for experimentation with ideas in Bayesian modeling.

[ascl:1801.002]
iWander: Dynamics of interstellar wanderers

iWander assesses the origin of interstellar small bodies such as asteroids and comets. It includes a series of databases and tools that can be used in general for studying the dynamics of an interstellar vagabond object (small−body, interstellar spaceship and even stars).

[ascl:1406.016]
IUEDR: IUE Data Reduction package

IUEDR reduces IUE data. It addresses the problem of working from the IUE Guest Observer tape or disk file through to a calibrated spectrum that can be used in scientific analysis and is a complete system for IUE data reduction. IUEDR was distributed as part of the Starlink software collection (ascl:1110.012).

[ascl:1307.012]
ITERA: IDL Tool for Emission-line Ratio Analysis

ITERA, the IDL Tool for Emission-line Ratio Analysis, is an IDL widget tool that allows you to plot ratios of any strong atomic and ionized emission lines as determined by standard photoionization and shock models. These "line ratio diagrams" can then be used to determine diagnostics for nebulae excitation mechanisms or nebulae parameters such as density, temperature, metallicity, etc. ITERA can also be used to determine line sensitivities to such parameters, compare observations with the models, or even estimate unobserved line fluxes.

[ascl:1010.047]
ISW and Weak Lensing Likelihood Code

ISW and Weak Lensing Likelihood code is the likelihood code that calculates the likelihood of Integrated Sachs Wolfe and Weak Lensing of Cosmic Microwave Background using the WMAP 3year CMB maps with mass tracers such as 2MASS (2-Micron All Sky Survey), SDSS LRG (Sloan Digital Sky Survey Luminous Red Galaxies), SDSS QSOs (Sloan Digital Sky Survey Quasars) and NVSS (NRAO VLA All Sky Survey) radio sources. The details of the analysis (*thus the likelihood code) can be understood by reading the papers ISW paper and Weak lensing paper. The code does brute force theoretical matter power spectrum and calculations with CAMB. See the paper for an introduction, descriptions, and typical results from some pre-WMAP data. The code is designed to be integrated into CosmoMC. For further information concerning the integration, see Code Modification for integration into COSMOMC.

[ascl:1409.006]
iSpec: Stellar atmospheric parameters and chemical abundances

iSpec is an integrated software framework written in Python for the treatment and analysis of stellar spectra and abundances. Spectra treatment functions include cosmic rays removal, continuum normalization, resolution degradation, and telluric lines identification. It can also perform radial velocity determination and correction and resampling. iSpec can also determine atmospheric parameters (i.e effective temperature, surface gravity, metallicity, micro/macroturbulence, rotation) and individual chemical abundances by using either the synthetic spectra fitting technique or equivalent widths method. The synthesis is performed with SPECTRUM (ascl:9910.002).

[ascl:1503.010]
isochrones: Stellar model grid package

Isochrones, written in Python, simplifies common tasks often done with stellar model grids, such as simulating synthetic stellar populations, plotting evolution tracks or isochrones, or estimating the physical properties of a star given photometric and/or spectroscopic observations.

[ascl:1601.021]
ISO: Isochrone construction

ISO transforms MESA history files into a uniform basis for interpolation and then constructs new stellar evolution tracks and isochrones from that basis. It is written in Fortran and requires MESA (ascl:1010.083), primarily for interpolation. Though designed to ingest MESA star history files, tracks from other stellar evolution codes can be incorporated by loading the tracks into the data structures used in the codes.

[ascl:1302.002]
ISIS: Interactive Spectral Interpretation System for High Resolution X-Ray Spectroscopy

ISIS, the Interactive Spectral Interpretation System, is designed to facilitate the interpretation and analysis of high resolution X-ray spectra. It is being developed as a programmable, interactive tool for studying the physics of X-ray spectrum formation, supporting measurement and identification of spectral features, and interaction with a database of atomic structure parameters and plasma emission models.

[ascl:9909.003]
ISIS: A method for optimal image subtraction

ISIS is a complete package to process CCD images using the image Optimal subtraction method (Alard & Lupton 1998, Alard 1999). The ISIS package can find the best kernel solution even in case of kernel variations as a function of position in the image. The relevant computing time is minimal in this case and is only slightly different from finding constant kernel solutions. ISIS includes as well a number of facilities to compute the light curves of variables objects from the subtracted images. The basic routines required to build the reference frame and make the image registration are also provided in the package.

[ascl:1708.029]
iSEDfit: Bayesian spectral energy distribution modeling of galaxies

iSEDfit uses Bayesian inference to extract the physical properties of galaxies from their observed broadband photometric spectral energy distribution (SED). In its default mode, the inputs to iSEDfit are the measured photometry (fluxes and corresponding inverse variances) and a measurement of the galaxy redshift. Alternatively, iSEDfit can be used to estimate photometric redshifts from the input photometry alone.

After the priors have been specified, iSEDfit calculates the marginalized posterior probability distributions for the physical parameters of interest, including the stellar mass, star-formation rate, dust content, star formation history, and stellar metallicity. iSEDfit also optionally computes K-corrections and produces multiple "quality assurance" (QA) plots at each stage of the modeling procedure to aid in the interpretation of the prior parameter choices and subsequent fitting results. The software is distributed as part of the impro IDL suite.

[ascl:1809.010]
Isca: Idealized global circulation modeling

Vallis, Geoffrey K.; Colyer, Greg; Geen, Ruth; Gerber, Edwin; Jucker, Martin; Maher, Penelope; Paterson, Alexander; Pietschnig, Marianne; Penn, James; Thomson, Stephen I.

Isca provides a framework for the idealized modeling of the global circulation of planetary atmospheres at varying levels of complexity and realism. Though Isca is an outgrowth of models designed for Earth's atmosphere, it may readily be extended into other planetary regimes. Various forcing and radiation options are available. At the simple end of the spectrum a Held-Suarez case is available. An idealized grey radiation scheme, a grey scheme with moisture feedback, a two-band scheme and a multi-band scheme are also available, all with simple moist effects and astronomically-based solar forcing. At the complex end of the spectrum the framework provides a direct connection to comprehensive atmospheric general circulation models.

[ascl:1403.009]
ISAP: ISO Spectral Analysis Package

Ali, Babar; Bauer, Otto; Brauher, Jim; Buckley, Mark; Harwood, Andrew; Hur, Min; Khan, Iffat; Li, Jing; Lord, Steve; Lutz, Dieter; Mazzarella, Joe; Molinari, Sergio; Morris, Pat; Narron, Bob; Seidenschwang, Karla; Sidher, Sunil; Sturm, Eckhard; Swinyard, Bruce; Unger, Sarah; Verstraete, Laurent; Vivares, Florence; Wieprecht, Ecki

ISAP, written in IDL, simplifies the process of visualizing, subsetting, shifting, rebinning, masking, combining scans with weighted means or medians, filtering, and smoothing Auto Analysis Results (AARs) from post-pipeline processing of the Infrared Space Observatory's (ISO) Short Wavelength Spectrometer (SWS) and Long Wavelength Spectrometer (LWS) data. It can also be applied to PHOT-S and CAM-CVF data, and data from practically any spectrometer. The result of a typical ISAP session is expected to be a "simple spectrum" (single-valued spectrum which may be resampled to a uniform wavelength separation if desired) that can be further analyzed and measured either with other ISAP functions, native IDL functions, or exported to other analysis package (e.g., IRAF, MIDAS) if desired. ISAP provides many tools for further analysis, line-fitting, and continuum measurements, such as routines for unit conversions, conversions from wavelength space to frequency space, line and continuum fitting, flux measurement, synthetic photometry and models such as a zodiacal light model to predict and subtract the dominant foreground at some wavelengths.

[ascl:1303.029]
iSAP: Interactive Sparse Astronomical Data Analysis Packages

iSAP consists of three programs, written in IDL, which together are useful for spherical data analysis. MR/S (MultiResolution on the Sphere) contains routines for wavelet, ridgelet and curvelet transform on the sphere, and applications such denoising on the sphere using wavelets and/or curvelets, Gaussianity tests and Independent Component Analysis on the Sphere. MR/S has been designed for the PLANCK project, but can be used for many other applications. SparsePol (Polarized Spherical Wavelets and Curvelets) has routines for polarized wavelet, polarized ridgelet and polarized curvelet transform on the sphere, and applications such denoising on the sphere using wavelets and/or curvelets, Gaussianity tests and blind source separation on the Sphere. SparsePol has been designed for the PLANCK project. MS-VSTS (Multi-Scale Variance Stabilizing Transform on the Sphere), designed initially for the FERMI project, is useful for spherical mono-channel and multi-channel data analysis when the data are contaminated by a Poisson noise. It contains routines for wavelet/curvelet denoising, wavelet deconvolution, multichannel wavelet denoising and deconvolution.

[ascl:1602.016]
IRSFRINGE: Interactive tool for fringe removal from Spitzer IRS spectra

IRSFRINGE is an IDL-based GUI package that allows observers to interactively remove fringes from IRS spectra. Fringes that originate from the detector subtrates are observed in the IRS Short-High (SH) and Long-High (LH) modules. In the Long-Low (LL) module, another fringe component is seen as a result of the pre-launch change in one of the LL filters. The fringes in the Short-Low (SL) module are not spectrally resolved. the fringes are already largely removed in the pipeline processing when the flat field is applied. However, this correction is not perfect and remaining fringes can be removed with IRSFRINGE from data in each module. IRSFRINGE is available as a stand-alone package and is also part of the Spectroscopic Modeling, Analysis and Reduction Tool (SMART, ascl:1210.021).

[ascl:1205.007]
Iris: The VAO SED Application

Iris is a downloadable Graphical User Interface (GUI) application which allows the astronomer to build and analyze wide-band Spectral Energy Distributions (SEDs). The components of Iris have been contributed by members of the VAO. Specview, contributed by STScI, provides a GUI for reading, editing, and displaying SEDs, as well as defining models and parameter values. Sherpa, contributed by the Chandra project at SAO, provides a library of models, fit statistics, and optimization methods; the underlying I/O library, SEDLib, is a VAO product written by SAO to current IVOA (International Virtual Observatory Alliance) data model standards. NED is a service provided by IPAC for easy location of data for a given extragalactic source, including SEDs. SedImporter converts non-standard SED data files into a format supported by Iris.

[ascl:1109.017]
IRDR: InfraRed Data Reduction

We describe the InfraRed Data Reduction (IRDR) software package, a small ANSI C library of fast image processing routines for automated pipeline reduction of infrared (dithered) observations. We developed the software to satisfy certain design requirements not met in existing packages (e.g., full weight map handling) and to optimize the software for large data sets (non-interactive tasks that are CPU and disk efficient). The software includes stand-alone C programs for tasks such as running sky frame subtraction with object masking, image registration and coaddition with weight maps, dither offset measurement using cross-correlation, and object mask dilation. Although we currently use the software to process data taken with CIRSI (a near-IR mosaic imager), the software is modular and concise and should be easy to adapt/reuse for other work.

[ascl:1406.015]
IRCAMDR: IRCAM3 Data Reduction Software

Aspin, Colin; McCaughrean, Mark; Bridger, Alan B.; Baines, Dave; Beard, Steven; Chan, S.; Giddings, Jack; Hartley, K. F.; Horsfield, A.P.; Kelly, B. D.; Emerson, J. P.; Currie, Malcolm J.; Economou, Frossie

The UKIRT IRCAM3 data reduction and analysis software package, IRCAMDR (formerly ircam_clred) analyzes and displays any 2D data image stored in the standard Starlink (ascl:1110.012) NDF data format. It reduces and analyzes IRCAM1/2 data images of 62x58 pixels and IRCAM3 images of 256x256 size. Most of the applications will work on NDF images of any physical (pixel) dimensions, for example, 1024x1024 CCD images can be processed.

[ascl:1406.014]
IRAS90: IRAS Data Processing

Berry, David S.; Parsons, Diana C.; Gong, Wei; Currie, Malcolm J.; Warren-Smith, Rodney F.; Morris, Huw

IRAS90 is a suite of programs for processing IRAS data. It takes advantage of Starlink's (ascl:1110.012) ADAM environment, which provides multi-platform availability of both data and the programs to process it, and the user friendly interface of the parameter entry system. The suite can determine positions in astrometric coordinates, draw grids, and offers other functions for standard astronomical measurement and standard projections.

[ascl:9911.002]
IRAF: Image Reduction and Analysis Facility

IRAF includes a broad selection of programs for general image processing and graphics, plus a large number of programs for the reduction and analysis of optical and IR astronomy data. Other external or layered packages are available for applications such as data acquisition or handling data from other observatories and wavelength regimes such as the Hubble Space Telescope (optical), EUVE (extreme ultra-violet), or ROSAT and AXAF (X-ray). These external packages are distributed separately from the main IRAF distribution but can be easily installed. The IRAF system also includes a complete programming environment for scientific applications, which includes a programmable Command Language scripting facility, the IMFORT Fortran/C programming interface, and the full SPP/VOS programming environment in which the portable IRAF system and all applications are written.

[ascl:1209.013]
IRACproc: IRAC Post-BCD Processing

IRACproc is a software suite that facilitates the co-addition of dithered or mapped Spitzer/IRAC data to make them ready for further analysis with application to a wide variety of IRAC observing programs. The software runs within PDL, a numeric extension for Perl available from pdl.perl.org, and as stand alone perl scripts. In acting as a wrapper for the Spitzer Science Center's MOPEX software, IRACproc improves the rejection of cosmic rays and other transients in the co-added data. In addition, IRACproc performs (optional) Point Spread Function (PSF) fitting, subtraction, and masking of saturated stars.

[ascl:1512.001]
IRACpm: Distortion correction for IRAC astrometric data

The IRACpm R package applies a 7-8 order distortion correction to IRAC astrometric data from the Spitzer Space Telescope and includes a function for measuring apparent proper motions between different Epochs. These corrections are applicable only to positions measured by APEX; cryogenic images benefit from a correction for varying intra-pixel sensitivity prior to the application of the distortion.

[ascl:1804.002]
ipole: Semianalytic scheme for relativistic polarized radiative transport

ipole is a ray-tracing code for covariant, polarized radiative transport particularly useful for modeling Event Horizon Telescope sources, though may also be used for other relativistic transport problems. The code extends the ibothros scheme for covariant, unpolarized transport using two representations of the polarized radiation field: in the coordinate frame, it parallel transports the coherency tensor, and in the frame of the plasma, it evolves the Stokes parameters under emission, absorption, and Faraday conversion. The transport step is as spacetime- and coordinate- independent as possible; the emission, absorption, and Faraday conversion step is implemented using an analytic solution to the polarized transport equation with constant coefficients. As a result, ipole is stable, efficient, and produces a physically reasonable solution even for a step with high optical depth and Faraday depth.

[ascl:1303.022]
ionFR: Ionospheric Faraday rotation

Sotomayor-Beltran, C.; Sobey, C.; Hessels, J. W. T.; de Bruyn, G.; Noutsos, A.; Alexov, A.; Anderson, J.; Asgekar, A.; Avruch, I. M.; Beck, R.; Bell, M. E.; Bell, M. R.; Bentum, M. J.; Bernardi, G.; Best, P.; Birzan, L.; Bonafede, A.; Breitling, F.; Broderick, J.; Brouw, W. N.; Brueggen, M.; Ciardi, B.; de Gasperin, F.; Dettmar, R.-J.; van Duin, A.; Duscha, S.; Eisloeffel, J.; Falcke, H.; Fallows, R. A.; Fender, R.; Ferrari, C.; Frieswijk, W.; Garrett, M. A.; Griessmeier, J.; Grit, T.; Gunst, A. W.; Hassall, T. E.; Heald, G.; Hoeft, M.; Horneffer, A.; Iacobelli, M.; Juette, E.; Karastergiou, A.; Keane, E.; Kohler, J.; Kramer, M.; Kondratiev, V. I.; Koopmans, L. V. E.; Kuniyoshi, M.; Kuper, G.; van Leeuwen, J.; Maat, P.; Macario, G.; Markoff, S.; McKean, J. P.; Mulcahy, D. D.; Munk, H.; Orru, E.; Paas, H.; Pandey-Pommier, M.; Pilia, M.; Pizzo, R.; Polatidis, A. G.; Reich, W.; Roettgering, H.; Serylak, M.; Sluman, J.; Stappers, B. W.; Tagger, M.; Tang, Y.; Tasse, C.; ter Veen, S.; Vermeulen, R.; van Weeren, R. J.; Wijers, R. A. M. J.; Wijnholds, S. J.; Wise, M. W.; Wucknitz, O.; Yatawatta, S.; Zarka, P.

ionFR calculates the amount of ionospheric Faraday rotation for a specific epoch, geographic location, and line-of-sight. The code uses a number of publicly available, GPS-derived total electron content maps and the most recent release of the International Geomagnetic Reference Field. ionFR can be used for the calibration of radio polarimetric observations; its accuracy had been demonstrated using LOFAR pulsar observations.

[ascl:1612.013]
InversionKit: Linear inversions from frequency data

InversionKit is an interactive Java program that performs rotational and structural linear inversions from frequency data.

[ascl:1403.010]
Inverse Beta: Inverse cumulative density function (CDF) of a Beta distribution

The Beta Inverse code solves the inverse cumulative density function (CDF) of a Beta distribution, allowing one to sample from the Beta prior directly. The Beta distribution is well suited as a prior for the distribution of the orbital eccentricities of extrasolar planets; imposing a Beta prior on orbital eccentricity is valuable for any type of observation of an exoplanet where eccentricity can affect the model parameters (e.g. transits, radial velocities, microlensing, direct imaging). The Beta prior is an excellent description of the current, empirically determined distribution of orbital eccentricities and thus employing it naturally incorporates an observer’s prior experience of what types of orbits are probable or improbable. The default parameters in the code are currently set to the Beta distribution which best describes the entire population of exoplanets with well-constrained orbits.

[ascl:1101.004]
InterpMC: Caching and Interpolated Likelihoods -- Accelerating Cosmological Monte Carlo Markov Chains

We describe a novel approach to accelerating Monte Carlo Markov Chains. Our focus is cosmological parameter estimation, but the algorithm is applicable to any problem for which the likelihood surface is a smooth function of the free parameters and computationally expensive to evaluate. We generate a high-order interpolating polynomial for the log-likelihood using the first points gathered by the Markov chains as a training set. This polynomial then accurately computes the majority of the likelihoods needed in the latter parts of the chains. We implement a simple version of this algorithm as a patch (InterpMC) to CosmoMC and show that it accelerates parameter estimatation by a factor of between two and four for well-converged chains. The current code is primarily intended as a "proof of concept", and we argue that there is considerable room for further performance gains. Unlike other approaches to accelerating parameter fits, we make no use of precomputed training sets or special choices of variables, and InterpMC is almost entirely transparent to the user.

[ascl:1907.027]
intensitypower: Spectrum multipoles modeler

intensitypower measures and models the auto- and cross-power spectrum multipoles of galaxy catalogs and radio intensity maps presented in spherical coordinates. It can also convert the multipoles to power spectrum wedges P(k,mu) and 2D power spectra P(k_perp,k_par). The code assumes the galaxy catalog is a set of discrete points and the radio intensity map is a pixelized continuous field which includes angular pixelization using healpix, binning in redshift channels, smoothing by a Gaussian telescope beam, and the addition of a Gaussian noise in each cell. The galaxy catalog and radio intensity map are transferred onto an FFT grid, and power spectrum multipoles are measured including curved-sky effects. Both maps include redshift-space distortions.

[ascl:1801.005]
InitialConditions: Initial series solutions for perturbations in our Universe

InitialConditions finds the initial series solutions for perturbations in our Universe. This includes all scalar (1 adiabatic, 4 isocurvature and 2 magnetic modes), vector (1 vorticity mode, 1 magnetic mode), and tensor (1 gravitational wave mode and 1 magnetic mode) perturbations including terms up to second order in the neutrino mass. It can handle the standard species (cdm, baryons, photons), and two neutrino mass eigenstates (1 light, 1 heavy).

[ascl:1711.002]
inhomog: Biscale kinematical backreaction analytical evolution

The inhomog library provides Raychaudhuri integration of cosmological domain-wise average scale factor evolution using an analytical formula for kinematical backreaction Q_D evolution. The inhomog main program illustrates biscale examples. The library routine lib/Omega_D_precalc.c is callable by RAMSES (ascl:1011.007) using the RAMSES extension ramses-scalav.

[ascl:1201.017]
Inflation: Monte-Carlo Code for Slow-Roll Inflation

Inflation is a numerical code to generate power spectra and other observables through numerical solutions to flow equations. The code generates tensor and scalar power spectra as a function of wavenumber and various other parameters at specific wavenumbers of interest (such as for CMB, scalar perturbations at smaller scales, gravitational wave detection at direct detection frequencies). The output can be easily ported to publicly available Markov Chain codes to constrain cosmological parameters with data.

[ascl:1007.002]
INFALL: A code for calculating the mean initial and final density profiles around a virialized dark matter halo

Infall is a code for calculating the mean initial and final density profiles around a virialized dark matter halo. The initial profile is derived from the statistics of the initial Gaussian random field, accounting for the problem of peaks within peaks using the extended Press-Schechter model. Spherical collapse then yields the typical density and velocity profiles of the gas and dark matter that surrounds the final, virialized halo. In additional to the mean profile, ±1-σ profiles are calculated and can be used as an estimate of the scatter.

[ascl:1210.023]
inf_solv: Kerr inflow solver

The efficiency of thin disk accretion onto black holes depends on the inner boundary condition, specifically the torque applied to the disk at the last stable orbit. This is usually assumed to vanish. This code estimates the torque on a magnetized disk using a steady magnetohydrodynamic inflow model originally developed by Takahashi et al. The efficiency e can depart significantly from the classical thin disk value. In some cases e > 1, i.e., energy is extracted from the black hole.

[ascl:1806.005]
Indri: Pulsar population synthesis toolset

Indri models the population of single (not in binary or hierarchical systems) neutron stars. Given a starting distribution of parameters (birth place, velocity, magnetic field, and period), the code moves a set of stars through the time (by evolving spin period and magnetic field) and the space (by propagating through the Galactic potential). Upon completion of the evolution, a set of observables is computed (radio flux, position, dispersion measure) and compared with a radio survey such as the Parkes Multibeam Survey. The models' parameters are optimised by using the Markov Chain Monte Carlo technique.

[ascl:1010.046]
indexf: Line-strength Indices in Fully Calibrated FITS Spectra

This program measures line-strength indices in fully calibrated FITS spectra. By "fully calibrated" one should understand wavelength and relative flux-calibrated data. Note that the different types of line-strength indices that can be measured with indexf (see below) do not require absolute flux calibration. If even a relative flux-calibration is absent (or deficient), the derived indices should be transformed to an appropriate spectrophotometric system. The program can also compute index errors resulting from the propagation of random errors (e.g. photon statistics, read-out noise). This option is only available if the user provides the error spectrum as an additional input FITS file to indexf. The error spectrum must contain the unbiased standard deviation (and not the variance!) for each pixel of the data spectrum. In addition, indexf also estimates the effect of errors on radial velocity. For this purpose, the program performs Monte Carlo simulations by measuring each index using randomly drawn radial velocities (following a Gaussian distribution of a given standard deviation). If no error file is employed, the program can perform numerical simulations with synthetic error spectra, the latter generated from the original data spectra and assuming randomly generated S/N ratios.

Would you like to view a random code?