[ascl:1508.006]
SExSeg: SExtractor segmentation

SExSeg forces SExtractor (ascl:1010.064) to run using a pre-defined segmentation map (the definition of objects and their borders). The defined segments double as isophotal apertures. SExSeg alters the detection image based on a pre-defined segmenation map while preparing your "analysis image" by subtracting the background in a separate SExtractor run (using parameters you specify). SExtractor is then run in "double-image" mode with the altered detection image and background-subtracted analysis image.

[ascl:1010.064]
SExtractor: Source Extractor

This new software optimally detects, de-blends, measures and classifies sources from astronomical images: SExtractor (Source Extractor). A very reliable star/galaxy separation can be achieved on most images using a neural network trained with simulated images. Salient features of SExtractor include its ability to work on very large images, with minimal human intervention, and to deal with a wide variety of object shapes and magnitudes. It is therefore particularly suited to the analysis of large extragalactic surveys.

[ascl:1304.013]
SFH: Star Formation History

SFH is an efficient IDL tool that quickly computes accurate predictions for the baryon budget history in a galactic halo.

[ascl:1712.007]
SFoF: Friends-of-friends galaxy cluster detection algorithm

SFoF is a friends-of-friends galaxy cluster detection algorithm that operates in either spectroscopic or photometric redshift space. The linking parameters, both transverse and along the line-of-sight, change as a function of redshift to account for selection effects.

[ascl:1210.005]
SGNAPS: Software for Graphical Navigation, Analysis and Plotting of Spectra

SGNAPS allows the user to plot a one-dimensional spectrum, together with the corresponding two-dimensional and a reference spectrum (for example the sky spectrum). This makes it possible to check on the reality of spectral features that are present in the one-dimensional spectrum, which could be due to bad sky subtraction or fringing residuals. It is also possible to zoom in and out all three spectra, edit the one-dimensional spectrum, smooth it with a simple square window function, measure the signal to noise over a selected wavelength interval, and fit the position of a selected spectral line. SGNAPS also allows the astronomer to obtain quick redshift estimates by providing a tool to fit or mark the position of a spectral line, and a function that will compute a list of possible redshifts based on a list of known lines in galaxy spectra. SGNAPS is derived from the plotting tools of VIPGI and contains almost all of their capabilities.

[ascl:1712.015]
SgrbWorldModel: Short-duration Gamma-Ray Burst World Model

SgrbWorldModel, written in Fortran 90, presents an attempt at modeling the population distribution of the Short-duration class of Gamma-Ray Bursts (SGRBs) as detected by the NASA's now-defunct Burst And Transient Source Experiment (BATSE) onboard the Compton Gamma Ray Observatory (CGRO). It is assumed that the population distribution of SGRBs is well fit by a multivariate log-normal distribution, whose differential cosmological rate of occurrence follows the Star-Formation-Rate (SFR) convolved with a log-normal binary-merger delay-time distribution. The best-fit parameters of the model are then found by maximizing the likelihood of the observed data by the BATSE detectors via a native built-in Adaptive Metropolis-Hastings Markov-Chain Monte Carlo (AMH-MCMC)Sampler that is part of the code. A model for the detection algorithm of the BATSE detectors is also provided.

[ascl:1605.003]
Shadowfax: Moving mesh hydrodynamical integration code

Shadowfax simulates galaxy evolution. Written in object-oriented modular C++, it evolves a mixture of gas, subject to the laws of hydrodynamics and gravity, and any collisionless fluid only subject to gravity, such as cold dark matter or stars. For the hydrodynamical integration, it makes use of a (co-) moving Lagrangian mesh. The code has a 2D and 3D version, contains utility programs to generate initial conditions and visualize simulation snapshots, and its input/output is compatible with a number of other simulation codes, e.g. Gadget2 (ascl:0003.001) and GIZMO (ascl:1410.003).

[ascl:1011.005]
Shape of Cosmic String Loops

Complicated cosmic string loops will fragment until they reach simple, non-intersecting ("stable") configurations. Through extensive numerical study we characterize these attractor loop shapes including their length, velocity, kink, and cusp distributions. We find that an initial loop containing $M$ harmonic modes will, on average, split into 3M stable loops. These stable loops are approximately described by the degenerate kinky loop, which is planar and rectangular, independently of the number of modes on the initial loop. This is confirmed by an analytic construction of a stable family of perturbed degenerate kinky loops. The average stable loop is also found to have a 40% chance of containing a cusp. We examine the properties of stable loops of different lengths and find only slight variation. Finally we develop a new analytic scheme to explicitly solve the string constraint equations.

[ascl:1204.010]
Shape: A 3D Modeling Tool for Astrophysics

Shape is a flexible interactive 3D morpho-kinematical modeling application for astrophysics. It reduces the restrictions on the physical assumptions, data type and amount required for a reconstruction of an object's morphology. It applies interactive graphics and allows astrophysicists to provide a-priori knowledge about the object by interactively defining 3D structural elements. By direct comparison of model prediction with observational data, model parameters can then be automatically optimized to fit the observation.

[ascl:1307.014]
Shapelets: Image Modelling

Shapelets are a complete, orthonormal set of 2D basis functions constructed from Laguerre or Hermite polynomials weighted by a Gaussian. A linear combination of these functions can be used to model any image, in a similar way to Fourier or wavelet synthesis. The shapelet decomposition is particularly efficient for images localized in space, and provide a high level of compression for individual galaxies in astronomical data. The basis has many elegant mathematical properties that make it convenient for image analysis and processing.

[ascl:1811.005]
Shark: Flexible semi-analytic galaxy formation model

Lagos, Claudia del P.; Tobar, Rodrigo J.; Robotham, Aaron S. G.; Obreschkow, Danail; Mitchell, Peter D.; Power, Chris; Elahi, Pascal J.

Shark is a flexible semi-analytic galaxy formation model for easy exploration of different physical processes. Shark has been implemented with several models for gas cooling, active galactic nuclei, stellar and photo-ionization feedback, and star formation (SF). The software can determine the stellar mass function and stellar–halo mass relation at z=0–4; cosmic evolution of the star formation rate density, stellar mass, atomic and molecular hydrogen; local gas scaling relations; and structural galaxy properties. It performs particularly well for the mass–size relation for discs/bulges, the gas–stellar mass and stellar mass–metallicity relations. Shark is written in C++11 and has been parallelized with OpenMP.

[ascl:1508.010]
SHDOM: Spherical Harmonic Discrete Ordinate Method for atmospheric radiative transfer

The Spherical Harmonic Discrete Ordinate Method (SHDOM) radiative transfer model computes polarized monochromatic or spectral band radiative transfer in a one, two, or three-dimensional medium for either collimated solar and/or thermal emission sources of radiation. The model is written in a variant of Fortran 77 and in Fortran90 and requires a Fortran 90 compiler. Also included are programs for generating the optical property files input to SHDOM from physical properties of water cloud particles and aerosols.

[ascl:1108.017]
SHELLSPEC: Simple Radiative Transfer along Line of Sight in Moving Media

SHELLSPEC is designed to calculate lightcurves, spectra and images of interacting binaries and extrasolar planets immersed in a moving circumstellar environment which is optically thin. It solves simple radiative transfer along the line of sight in moving media. The assumptions include LTE and optional known state quantities and velocity fields in 3D. Optional (non)transparent objects such as a spot, disc, stream, jet, shell or stars as well as an empty space may be defined (embedded) in 3D and their composite synthetic spectrum calculated. Roche model can be used as a boundary condition for the radiative tranfer. The program does not solve the inverse problem of finding the stellar and orbital parameters.

[ascl:1108.002]
SHERA: SHEar Reconvolution Analysis

Current and upcoming wide-field, ground-based, broad-band imaging surveys promise to address a wide range of outstanding problems in galaxy formation and cosmology. Several such uses of ground-based data, especially weak gravitational lensing, require highly precise measurements of galaxy image statistics with careful correction for the effects of the point-spread function (PSF). The SHERA (SHEar Reconvolution Analysis) software simulates ground-based imaging data with realistic galaxy morphologies and observing conditions, starting from space-based data (from COSMOS, the Cosmological Evolution Survey) and accounting for the effects of the space-based PSF. This code simulates ground-based data, optionally with a weak lensing shear applied, in a model-independent way using a general Fourier space formalism. The utility of this pipeline is that it allows for a precise, realistic assessment of systematic errors due to the method of data processing, for example in extracting weak lensing galaxy shape measurements or galaxy radial profiles, given user-supplied observational conditions and real galaxy morphologies. Moreover, the simulations allow for the empirical test of error estimates and determination of parameter degeneracies, via generation of many noise maps. The public release of this software, along with a large sample of cleaned COSMOS galaxy images (corrected for charge transfer inefficiency), should enable upcoming ground-based imaging surveys to achieve their potential in the areas of precision weak lensing analysis, galaxy profile measurement, and other applications involving detailed image analysis.

This code is no longer maintained and has been superseded by GalSim (ascl:1402.009).

[ascl:1107.005]
Sherpa: CIAO Modeling and Fitting Package

Sherpa is the CIAO (ascl:1311.006) modeling and fitting application made available by the Chandra X-ray Center (CXC). It can be used for analysis of images, spectra and time series from many telescopes, including optical telescopes such as Hubble. Sherpa is flexible, modular and extensible. It has an IPython user interface and it is also an importable Python module. Sherpa models, optimization and statistic functions are available via both C++ and Python for software developers wishing to link such functions directly to their own compiled code.

The CIAO 4.3 Sherpa release supports fitting of 1-D X-ray spectra from Chandra and other X-ray missions, as well as 1-D non-X-ray data, including ASCII data arrays, radial profiles, and lightcurves. The options for grating data analysis include fitting the spectrum with multiple response files required for overlapping orders in LETG observations. Modeling of 2-D spatial data is fully supported, including the PSF and exposure maps. User specified models can be added to Sherpa with advanced "user model" functionality.

[ascl:1110.004]
SHTOOLS: Tools for Working with Spherical Harmonics

SHTOOLS is an archive of fortran 95 based software that can be used to perform (among others) spherical harmonic transforms and reconstructions, rotations of spherical harmonic coefficients, and multitaper spectral analyses on the sphere. The package accommodates any standard normalization of the spherical harmonic functions ("geodesy" 4π normalized, Schmidt semi-normalized, orthonormalized, and unnormalized), and either real or complex spherical harmonics can be employed. Spherical harmonic transforms are calculated by exact quadrature rules using either (1) the sampling theorem of Driscoll and Healy (1994) where data are equally sampled (or spaced) in latitude and longitude, or (2) Gauss-Legendre quadrature. A least squares inversion routine for irregularly sampled data is included as well. The Condon-Shortley phase factor of (-1)m can be used or excluded with the associated Legendre functions. The spherical harmonic transforms are accurate to approximately degree 2800, corresponding to a spatial resolution of better than 4 arc minutes. Routines are included for performing localized multitaper spectral analyses and standard gravity calculations, such as computation of the geoid, and the determination of the potential associated with finite-amplitude topography. The routines are fast. Spherical harmonic transforms and reconstructions take on the order of 1 second for bandwidths less than 600 and about 3 minutes for bandwidths close to 2800.

[ascl:1704.003]
Shwirl: Meaningful coloring of spectral cube data with volume rendering

Shwirl visualizes spectral data cubes with meaningful coloring methods. The program has been developed to investigate transfer functions, which combines volumetric elements (or voxels) to set the color, and graphics shaders, functions used to compute several properties of the final image such as color, depth, and/or transparency, as enablers for scientific visualization of astronomical data. The program uses Astropy (ascl:1304.002) to handle FITS files and World Coordinate System, Qt (and PyQt) for the user interface, and VisPy, an object-oriented Python visualization library binding onto OpenGL.

[ascl:1411.026]
sic: Sparse Inpainting Code

Feeney, Stephen M.; Marinucci, Domenico; McEwen, Jason D.; Peiris, Hiranya V.; Wandelt, Benjamin D.; Cammarota, Valentina

sic (Sparse Inpainting Code) generates Gaussian, isotropic CMB realizations, masks them, and recovers the large-scale masked data using sparse inpainting; it is written in Fortran90.

[ascl:1706.009]
sick: Spectroscopic inference crank

sick infers astrophysical parameters from noisy observed spectra. Phenomena that can alter the data (e.g., redshift, continuum, instrumental broadening, outlier pixels) are modeled and simultaneously inferred with the astrophysical parameters of interest. This package relies on emcee (ascl:1303.002); it is best suited for situations where a grid of model spectra already exists, and one would like to infer model parameters given some data.

[ascl:1703.007]
sidm-nbody: Monte Carlo N-body Simulation for Self-Interacting Dark Matter

Self-Interacting Dark Matter (SIDM) is a hypothetical model for cold dark matter in the Universe. A strong interaction between dark matter particles introduce a different physics inside dark-matter haloes, making the density profile cored, reduce the number of subhaloes, and trigger gravothermal collapse. sidm-nbody is an N-body simulation code with Direct Simulation Monte Carlo scattering for self interaction, and some codes to analyse gravothermal collapse of isolated haloes. The N-body simulation is based on GADGET 1.1.

[ascl:1110.023]
SiFTO: An Empirical Method for Fitting SN Ia Light Curves

SiFTO is an empirical method for modeling Type Ia supernova (SN Ia) light curves by manipulating a spectral template. We make use of high-redshift SN data when training the model, allowing us to extend it bluer than rest-frame U. This increases the utility of our high-redshift SN observations by allowing us to use more of the available data. We find that when the shape of the light curve is described using a stretch prescription, applying the same stretch at all wavelengths is not an adequate description. SiFTO therefore uses a generalization of stretch which applies different stretch factors as a function of both the wavelength of the observed filter and the stretch in the rest-frame B band. SiFTO has been compared to other published light-curve models by applying them to the same set of SN photometry, and it's been demonstrated that SiFTO and SALT2 perform better than the alternatives when judged by the scatter around the best-fit luminosity distance relationship. When SiFTO and SALT2 are trained on the same data set the cosmological results agree.

[ascl:1107.016]
SIGPROC: Pulsar Signal Processing Programs

SIGPROC is a package designed to standardize the initial analysis of the many types of fast-sampled pulsar data. Currently recognized machines are the Wide Band Arecibo Pulsar Processor (WAPP), the Penn State Pulsar Machine (PSPM), the Arecibo Observatory Fourier Transform Machine (AOFTM), the Berkeley Pulsar Processors (BPP), the Parkes/Jodrell 1-bit filterbanks (SCAMP) and the filterbank at the Ooty radio telescope (OOTY). The SIGPROC tools should help users look at their data quickly, without the need to write (yet) another routine to read data or worry about big/little endian compatibility (byte swapping is handled automatically).

[ascl:1603.001]
SILSS: SPHERE/IRDIS Long-Slit Spectroscopy pipeline

The ESO's VLT/SPHERE instrument includes a unique long-slit spectroscopy (LSS) mode coupled with Lyot coronagraphy in its infrared dual-band imager and spectrograph (IRDIS) for spectral characterization of young, giant exoplanets detected by direct imaging. The SILSS pipeline is a combination of the official SPHERE pipeline and additional custom IDL routines developed within the SPHERE consortium for the speckle subtraction and spectral extraction of a companion's spectrum; it offers a complete end-to-end pipeline, from raw data (science+calibrations) to a final spectrum of the companion. SILSS works on both the low-resolution (LRS) and medium-resolution (MRS) data, and allows correction for some of the known biases of the instrument. Documentation is included in the header of the main routine of the pipeline.

[ascl:1811.011]
SIM5: Library for ray-tracing and radiation transport in general relativity

The SIM5 library contains routines for relativistic raytracing and radiation transfer in GR. Written C with a Python interface, it has a special focus on raytracing from accretion disks, tori, hot spots or any other 3D configuration of matter in Kerr geometry, but it can be used with any other metric as well. It handles both optically thick and thin sources as well as transport of polarization of the radiation and calculates the propagation of light rays from the source to an observer through a curved spacetime. It supports parallelization and runs on GPUs.

[ascl:1010.025]
SimFast21: Simulation of the Cosmological 21cm Signal

SimFast 21 generates a simulation of the cosmological 21cm signal. While limited to low spatial resolution, the next generation low-frequency radio interferometers that target 21 cm observations during the era of reionization and prior will have instantaneous fields-of-view that are many tens of square degrees on the sky. Predictions related to various statistical measurements of the 21 cm brightness temperature must then be pursued with numerical simulations of reionization with correspondingly large volume box sizes, of order 1000 Mpc on one side. The authors pursued a semi-numerical scheme to simulate the 21 cm signal during and prior to Reionization by extending a hybrid approach where simulations are performed by first laying down the linear dark matter density field, accounting for the non-linear evolution of the density field based on second-order linear perturbation theory as specified by the Zel'dovich approximation, and then specifying the location and mass of collapsed dark matter halos using the excursion-set formalism. The location of ionizing sources and the time evolving distribution of ionization field is also specified using an excursion-set algorithm. They account for the brightness temperature evolution through the coupling between spin and gas temperature due to collisions, radiative coupling in the presence of Lyman-alpha photons and heating of the intergalactic medium, such as due to a background of X-ray photons. The method is capable of producing the required large volume simulations with adequate resolution in a reasonable time so a large number of realizations can be obtained with variations in assumptions related to astrophysics and background cosmology that govern the 21 cm signal.

[ascl:1110.022]
simple_cosfitter: Supernova-centric Cosmological Fitter

This is an implementation of a fairly simple-minded luminosity distance fitter, intended for use with supernova data. The calculational technique is based on evaluating the $chi^2$ of the model fit on a grid and marginalization over various nuisance parameters. Of course, the nature of these things is that this code has gotten steadily more complex, so perhaps the simple moniker is no longer justified.

[ascl:1606.010]
SimpLens: Interactive gravitational lensing simulator

SimpLens illustrates some of the theoretical ideas important in gravitational lensing in an interactive way. After setting parameters for elliptical mass distribution and external mass, SimpLens displays the mass profile and source position, the lens potential and image locations, and indicate the image magnifications and contours of virtual light-travel time. A lens profile can be made shallower or steeper with little change in the image positions and with only total magnification affected.

[ascl:1307.013]
SIMX: Event simulator

SIMX simulates a photon-counting detector's response to an input source, including a simplified model of any telescope. The code is not a full ray-trace, but a convolution tool that uses standard descriptions of telescope PSF (via either a simple Gaussian parameter, an energy-dependent encircled-energy function, or an image of the PSF) and the detector response (using the OGIP response function) to model how sources will appear. simx uses a predefined set of PSFs, vignetting information, and instrumental responses and outputs to make the simulation. It is designed to be a 'approximation' tool to estimate issues such as source confusion, background effects, pileup, and other similar issues.

[ascl:1708.019]
SINFONI Pipeline: Data reduction pipeline for the Very Large Telescope SINFONI spectrograph

The SINFONI pipeline reduces data from the Very Large Telescope's SINFONI (Spectrograph for INtegral Field Observations in the Near Infrared) instrument. It can evaluate the detector linearity and generate a corresponding non linear pixel map, create a master dark and a hot-pixel map, a master flat and a map of pixels which have intensities greater than a given threshold. It can also compute the optical distortions and slitlets distances, and perform wavelength calibration, PSF, telluric standard and other science data reduction, and can coadd bad pixel maps, collapse a cube to an image over a given wavelength range, perform cube arithmetics, among other useful tasks.

[ascl:1010.026]
SingLe: A F90-package devoted to Softened Gravity in gaseous discs

**S**often**ingLe**ngth: Because Newton's law of Gravitation diverges as the relative separations |r'-r| tends to zero, it is common to add a positive constant λ also known as the "softening length", i.e. :

|r'-r|² ← |r'-r|² + λ².

SingLe determines the appropriate value of this Softening Length λ for a given disc local structure (thickness 2h and vertical stratification ρ), in the axially symmetric, flat disc limit, preserving at best the Newtonian character of the gravitational potential and associated forces. Mass density ρ(z) is assumed to be locally expandable in the z-direction according to:

ρ(z)= ρ_{0}[1 + a_{1}(z/h)^{2}+...+a_{q} (z/h)^{2q}+...+a_{N} (z/h)^{2 N}].

[ascl:1609.018]
SIP: Systematics-Insensitive Periodograms

SIP (Systematics-Insensitive Periodograms) extends the generative model used to create traditional sine-fitting periodograms for finding the frequency of a sinusoid by including systematic trends based on a set of eigen light curves in the generative model in addition to using a sum of sine and cosine functions over a grid of frequencies, producing periodograms with vastly reduced systematic features. Acoustic oscillations in giant stars and measurement of stellar rotation periods can be recovered from the SIP periodograms without detrending. The code can also be applied to detection other periodic phenomena, including eclipsing binaries and short-period exoplanet candidates.

[ascl:1212.008]
SIR: Stokes Inversion based on Response functions

SIR is a general-purpose code capable of dealing with gradients of the physical quantities with height. It admits one and two-component model atmospheres. It allows the recovery of the stratification of the temperature, the magnetic field vector, and the line of sight velocity through the atmosphere, and the micro- and macroturbulence velocities - which are assumed to be constant with depth. It is based on the response functions, which enter a Marquardt nonlinear least-squares algorithm in a natural way. Response functions are calculated at the same time as the full radiative transfer equation for polarized light is integrated, which determines values of many free parameters in a reasonable computation time. SIR demonstrates high stability, accuracy, and uniqueness of results, even when simulated observations present signal-to-noise ratios of the order of the lowest acceptable values in real observations.

[ascl:1111.008]
SITools2: A Framework for Archival Systems

SITools2 is a CNES generic tool performed by a joint effort between CNES and scientific laboratories. SITools provides a self-manageable data access layer deployed on already existing scientific laboratory databases. This new version of SITools is a JAVA-based framework, under open source license, that provides a portable archive system, highly configurable, easy to use by laboratories, with a plugin mechanism so developers can add their own applications.

[ascl:1102.020]
SKID: Finding Gravitationally Bound Groups in N-body Simulations

SKID finds gravitationally bound groups in N-body simulations. The SKID program will group different types of particles depending on the type of input binary file. This could be either dark matter particles, gas particles, star particles or gas and star particles depending on what is in the input tipsy binary file. Once groups with at least a certain minimum number of members have been determined, SKID will remove particles which are not bound to the group. SKID must use the original positions of all the particles to determine whether or not particles are bound. This procedure which we call unbinding, is again dependent on the type of grouping we are dealing with. There are two cases, one for dark matter only or star particles only (case 1 unbinding), the other for inputs including gas (also stars in a dark matter environment this is case 2 unbinding).

Skid version 1.3 is a much improved version of the old denmax-1.1 version. The new name was given to avoid confusion with the DENMAX program of Gelb & Bertschinger, and although it is based on the same idea it represents a substantial evolution in the method.

[ascl:1109.003]
SKIRT: Stellar Kinematics Including Radiative Transfer

SKIRT is a radiative transfer code based on the Monte Carlo technique. The name SKIRT, acronym for Stellar Kinematics Including Radiative Transfer, reflects the original motivation for its creation: it has been developed to study the effects of dust absorption and scattering on the observed kinematics of dusty galaxies. In a second stage, the SKIRT code was extended with a module to self-consistently calculate the dust emission spectrum under the assumption of local thermal equilibrium. This LTE version of SKIRT has been used to model the dust extinction and emission of various types of galaxies, as well as circumstellar discs and clumpy tori around active galactic nuclei. A new, extended version of SKIRT code can perform efficient 3D radiative transfer calculations including a self-consistent calculation of the dust temperature distribution and the associated FIR/submm emission with a full incorporation of the emission of transiently heated grains and PAH molecules.

[ascl:1609.014]
Sky3D: Time-dependent Hartree-Fock equation solver

Written in Fortran 90, Sky3D solves the static or dynamic equations on a three-dimensional Cartesian mesh with isolated or periodic boundary conditions and no further symmetry assumptions. Pairing can be included in the BCS approximation for the static case. The code can be easily modified to include additional physics or special analysis of the results and requires LAPACK and FFTW3.

[ascl:1109.019]
SkyCat: Visualization and Catalog and Data Access Tool

ESO's Data Management; Very Large Telescope (VLT) Project Divisions; Canadian Astronomical Data Center (CADC)

SkyCat is a tool that combines visualization of images and access to catalogs and archive data for astronomy. The tool, developed in Tcl/Tk, was originally conceived as a demo of the capabilities of the class library that was developed for the VLT. The Skycat sources currently consist of five packages:

- Tclutil - Generic Tcl and C++ utilities
- Astrotcl - Astronomical Tcl and C++ utilities
- RTD - Real-time Display classes and widgets
- Catlib - Catalog library and widgets
- Skycat - Skycat application and library package

[ascl:1408.007]
Skycorr: Sky emission subtraction for observations without plain sky information

Noll, S.; Kausch, W.; Kimeswenger, S.; Barden, M.; Jones, A. M.; Modigliani, A.; Szyszka, C.; Taylor, J.

Skycorr is an instrument-independent sky subtraction code that uses physically motivated line group scaling in the reference sky spectrum by a fitting approach for an improved sky line removal in the object spectrum. Possible wavelength shifts between both spectra are corrected by fitting Chebyshev polynomials and advanced rebinning without resolution decrease. For the correction, the optimized sky line spectrum and the automatically separated sky continuum (without scaling) is subtracted from the input object spectrum. Tests show that Skycorr performs well (per cent level residuals) for data in different wavelength regimes and of different resolution, even in the cases of relatively long time lags between the object and the reference sky spectrum. Lower quality results are mainly restricted to wavelengths not dominated by airglow lines or pseudo continua by unresolved strong emission bands.

[ascl:1010.066]
SkyMaker: Astronomical Image Simulations Made Easy

SkyMaker is a program that simulates astronomical images. It accepts object lists in ASCII generated by the Stuff program to produce realistic astronomical fields. SkyMaker is part of the EFIGI development project.

[ascl:1710.005]
SkyNet: Modular nuclear reaction network library

The general-purpose nuclear reaction network SkyNet evolves the abundances of nuclear species under the influence of nuclear reactions. SkyNet can be used to compute the nucleosynthesis evolution in all astrophysical scenarios where nucleosynthesis occurs. Any list of isotopes can be evolved and SkyNet supports various different types of nuclear reactions. SkyNet is modular, permitting new or existing physics, such as nuclear reactions or equations of state, to be easily added or modified.

[ascl:1312.007]
SkyNet: Neural network training tool for machine learning in astronomy

SkyNet is an efficient and robust neural network training code for machine learning. It is able to train large and deep feed-forward neural networks, including autoencoders, for use in a wide range of supervised and unsupervised learning applications, such as regression, classification, density estimation, clustering and dimensionality reduction. SkyNet is implemented in C/C++ and fully parallelized using MPI.

[ascl:1511.003]
SkyView Virtual Telescope

The SkyView Virtual telescope provides access to survey datasets ranging from radio through the gamma-ray regimes. Over 100 survey datasets are currently available. The SkyView library referenced here is used as the basis for the SkyView web site (at http://skvyiew.gsfc.nasa.gov) but is designed for individual use by researchers as well.

SkyView's approach to access surveys is distinct from most other toolkits. Rather than providing links to the original data, SkyView attempts to immediately re-render the source data in the user-requested reference frame, projection, scaling, orientation, etc. The library includes a set of geometry transformation and mosaicking tools that may be integrated into other applications independent of SkyView.

[ascl:1312.014]
SL1M: Synthesis through L1 Minimization

SL1M deconvolves radio synthesis images based on direct inversion of the measured visibilities that can deal with the non-coplanar base line effect and can be applied to telescopes with direction dependent gains. The code is more computationally demanding than some existing methods, but is highly parallelizable and scale well to clusters of CPUs and GPUs. The algorithm is also extremely flexible, allowing the solution of the deconvolution problem on arbitrarily placed pixels.

[ascl:1403.025]
SLALIB: A Positional Astronomy Library

SLALIB is a library of routines that make accurate and reliable positional-astronomy applications easier to write. Most SLALIB routines are concerned with astronomical position and time, but a number have wider trigonometrical, numerical or general applications. A Fortran implementation of SLALIB under GPL licensing is available as part of Starlink (ascl:1110.012).

[ascl:1611.021]
SlicerAstro: Astronomy (HI) extension for 3D Slicer

SlicerAstro extends 3D Slicer, a multi-platform package for visualization and medical image processing, to provide a 3-D interactive viewer with 3-D human-machine interaction features, based on traditional 2-D input/output hardware, and analysis capabilities.

[ascl:1105.004]
SLiM: A Code for the Simulation of Wave Propagation through an Inhomogeneous, Magnetised Solar Atmosphere

The semi-spectral linear MHD (SLiM) code follows the interaction of linear waves through an inhomogeneous three-dimensional solar atmosphere. The background model allows almost arbitrary perturbations of density, temperature, sound speed as well as magnetic and velocity fields. The code is useful in understanding the helioseismic signatures of various solar features, including sunspots.

[ascl:1409.010]
Slim: Numerical data compression for scientific data sets

Slim performs lossless compression on binary data files. Written in C++, it operates very rapidly and achieves better compression on noisy physics data than general-purpose tools designed primarily for text.

[ascl:1507.005]
slimplectic: Discrete non-conservative numerical integrator

slimplectic is a python implementation of a numerical integrator that uses a fixed time-step variational integrator formalism applied to the principle of stationary nonconservative action. It allows nonconservative effects to be included in the numerical evolution while preserving the major benefits of normally conservative symplectic integrators, particularly the accurate long-term evolution of momenta and energy. slimplectic is appropriate for exploring cosmological or celestial N-body dynamics problems where nonconservative interactions, e.g. dynamical friction or dissipative tides, can play an important role.

[ascl:9906.001]
SLOPES: Least-squares linear regression lines for bivariate datasets

SLOPES computes six least-squares linear regression lines for bivariate datasets of the form (x_i,y_i) with unknown population distributions. Measurement errors, censoring (nondetections) or other complications are not treated. The lines are: the ordinary least-squares regression of y on x, OLS(Y|X); the inverse regression of x on y, OLS(X_Y); the angular bisector of the OLS lines; the orthogonal regression line; the reduced major axis, and the mean-OLS line. The latter four regressions treat the variables symmetrically, while the first two regressions are asymmetrical. Uncertainties for the regression coefficients of each method are estimated via asymptotic formulae, bootstrap resampling, and bivariate normal simulation. These methods, derivation of the regression coefficient uncertainties, and discussions of their use are provided in three papers listed below. The user is encouraged to read and reference these studies.

[ascl:1010.035]
SLR: Stellar Locus Regression

Stellar Locus Regression (SLR) is a simple way to calibrate colors at the 1-2% level, and magnitudes at the sub-5% level as limited by 2MASS, without the traditional use of standard stars. With SLR, stars in any field are "standards." This is an entirely new way to calibrate photometry. SLR exploits the simple fact that most stars lie along a well defined line in color-color space called the stellar locus. Cross-match point-sources in flattened images taken through different passbands and plot up all color vs color combinations, and you will see the stellar locus with little effort. SLR calibrates colors by fitting these colors to a standard line. Cross-match with 2MASS on top of that, and SLR will deliver calibrated magnitudes as well.

[ascl:1106.012]
SLUG: Stochastically Lighting Up Galaxies

The effects of stochasticity on the luminosities of stellar populations are an often neglected but crucial element for understanding populations in the low mass or low star formation rate regime. To address this issue, we present SLUG, a new code to "Stochastically Light Up Galaxies". SLUG synthesizes stellar populations using a Monte Carlo technique that treats stochastic sampling properly including the effects of clustering, the stellar initial mass function, star formation history, stellar evolution, and cluster disruption. This code produces many useful outputs, including i) catalogs of star clusters and their properties, such as their stellar initial mass distributions and their photometric properties in a variety of filters, ii) two dimensional histograms of color-magnitude diagrams of every star in the simulation, iii) and the photometric properties of field stars and the integrated photometry of the entire simulated galaxy. After presenting the SLUG algorithm in detail, we validate the code through comparisons with starburst99 in the well-sampled regime, and with observed photometry of Milky Way clusters. Finally, we demonstrate the SLUG's capabilities by presenting outputs in the stochastic regime.

[ascl:1210.021]
SMART: Spectroscopic Modeling Analysis and Reduction Tool

SMART is an IDL-based software tool, developed by the IRS Instrument Team at Cornell University, that allows users to reduce and analyze Spitzer data from all four modules of the Infrared Spectrograph, including the peak-up arrays. The software is designed to make full use of the ancillary files generated in the Spitzer Science Center pipeline so that it can either remove or flag artifacts and corrupted data and maximize the signal-to-noise ratio in the extraction routines. It can be run in both interactive and batch modes. SMART includes visualization tools for assessing data quality, basic arithmetic operations for either two-dimensional images or one-dimensional spectra, extraction of both point and extended sources, and a suite of spectral analysis tools.

[ascl:1603.007]
SMARTIES: Spheroids Modelled Accurately with a Robust T-matrix Implementation for Electromagnetic Scattering

SMARTIES calculates the optical properties of oblate and prolate spheroidal particles, with comparable capabilities and ease-of-use as Mie theory for spheres. This suite of MATLAB codes provides a fully documented implementation of an improved T-matrix algorithm for the theoretical modelling of electromagnetic scattering by particles of spheroidal shape. Included are scripts that cover a range of scattering problems relevant to nanophotonics and plasmonics, including calculation of far-field scattering and absorption cross-sections for fixed incidence orientation, orientation-averaged cross-sections and scattering matrix, surface-field calculations as well as near-fields, wavelength-dependent near-field and far-field properties, and access to lower-level functions implementing the T-matrix calculations, including the T-matrix elements which may be calculated more accurately than with competing codes.

[ascl:1202.013]
SME: Spectroscopy Made Easy

Spectroscopy Made Easy (SME) is IDL software and a compiled external library that fits an observed high-resolution stellar spectrum with a synthetic spectrum to determine stellar parameters. The SME external library is available for Mac, Linux, and Windows systems. Atomic and molecular line data formatted for SME may be obtained from VALD. SME can solve for empirical log(gf) and damping parameters, using an observed spectrum of a star (usually the Sun) as a constraint.

[ascl:1804.010]
SMERFS: Stochastic Markov Evaluation of Random Fields on the Sphere

SMERFS (Stochastic Markov Evaluation of Random Fields on the Sphere) creates large realizations of random fields on the sphere. It uses a fast algorithm based on Markov properties and fast Fourier Transforms in 1d that generates samples on an n *X* n grid in O(*n*^{2} log *n*) and efficiently derives the necessary conditional covariance matrices.

[ascl:1308.001]
SMILE: Orbital analysis and Schwarzschild modeling of triaxial stellar systems

SMILE is interactive software for studying a variety of 2D and 3D models, including arbitrary potentials represented by a basis-set expansion, a spherical-harmonic expansion with coefficients being smooth functions of radius (splines), or a set of fixed point masses. Its main features include:

- orbit integration in various 2d and 3d potentials (including N-body and basis-set representations of an arbitrary potential);
- methods for analysis of orbital class, fundamental frequencies, regular or chaotic nature of an orbit, computation of Lyapunov exponents;
- Poincaré sections (in 2d) and frequency maps (in 3d) for analyzing orbital structure of potential;
- construction of self-consistent Schwarzschild models; and
- convenient visualization and integrated GUI environment, and a console scriptable version.

[ascl:1303.005]
SMMOL: Spherical Multi-level MOLecular line radiative transfer

SMMOL (Spherical Multi-level MOLecular line radiative transfer) is a molecular line radiative transfer code that uses Accelerated Lambda Iteration to solve the coupled level population and line transfer problem in spherical geometry. The code uses a discretized grid and a ray tracing methodology. SMMOL is designed for high optical depth regimes and can cope with maser emission as long as the spatial-velocity sampling is fine enough.

[ascl:1310.007]
SMURF: SubMillimeter User Reduction Facility

Jenness, Tim; Chapin, Edward L.; Berry, David S.; Gibb, Andy G.; Tilanus, Remo P. J.; Balfour, Jennifer; Tilanus, Vincent; Currie, Malcolm J.

SMURF reduces submillimeter single-dish continuum and heterodyne data. It is mainly targeted at data produced by the James Clerk Maxwell Telescope but data from other telescopes have been reduced using the package. SMURF is released as part of the bundle that comprises Starlink (ascl:1110.012) and most of the packages that use it. The two key commands are MAKEMAP for the creation of maps from sub millimeter continuum data and MAKECUBE for the creation of data cubes from heterodyne array instruments. The software can also convert data from legacy JCMT file formats to the modern form to allow it to be processed by MAKECUBE. SMURF is a core component of the ORAC-DR (ascl:1310.001) data reduction pipeline for JCMT.

[ascl:1010.027]
SNANA: A Public Software Package for Supernova Analysis

Kessler, Richard; Bernstein, Joseph P.; Cinabro, David; Dilday, Benjamin; Frieman, Joshua A.; Jha, Saurabh; Kuhlmann, Stephen; Miknaitis, Gajus; Sako, Masao; Taylor, Matt; VanderPlas, Jake

SNANA is a general analysis package for supernova (SN) light curves that contains a simulation, light curve fitter, and cosmology fitter. The software is designed with the primary goal of using SNe Ia as distance indicators for the determination of cosmological parameters, but it can also be used to study efficiencies for analyses of SN rates, estimate contamination from non-Ia SNe, and optimize future surveys. Several SN models are available within the same software architecture, allowing technical features such as K-corrections to be consistently used among multiple models, and thus making it easier to make detailed comparisons between models. New and improved light-curve models can be easily added. The software works with arbitrary surveys and telescopes and has already been used by several collaborations, leading to more robust and easy-to-use code. This software is not intended as a final product release, but rather it is designed to undergo continual improvements from the community as more is learned about SNe.

[ascl:1611.017]
SNCosmo: Python library for supernova cosmology

Barbary, Kyle; Barclay, Tom; Biswas, Rahul; Craig, Matt; Feindt, Ulrich; Friesen, Brian; Goldstein, Danny; Jha, Saurabh; Rodney, Steve; Sofiatti, Caroline; Thomas, Rollin C.; Wood-Vasey, Michael

SNCosmo synthesizes supernova spectra and photometry from SN models, and has functions for fitting and sampling SN model parameters given photometric light curve data. It offers fast implementations of several commonly used extinction laws and can be used to construct SN models that include dust. The SNCosmo library includes supernova models such as SALT2, MLCS2k2, Hsiao, Nugent, PSNID, SNANA and Whalen models, as well as a variety of built-in bandpasses and magnitude systems, and provides convenience functions for reading and writing peculiar data formats used in other packages. The library is extensible, allowing new models, bandpasses, and magnitude systems to be defined using an object-oriented interface.

[ascl:1505.033]
SNEC: SuperNova Explosion Code

SNEC (SuperNova Explosion Code) is a spherically-symmetric Lagrangian radiation-hydrodynamics code that follows supernova explosions through the envelope of their progenitor star, produces bolometric (and approximate multi-color) light curve predictions, and provides input to spectral synthesis codes for spectral modeling. SNEC's features include 1D (spherical) Lagrangian Newtonian hydrodynamics with artificial viscosity, stellar equation of state with a Saha solver ionization/recombination, equilibrium flux-limited photon diffusion with OPAL opacities and low-temperature opacities, and prediction of bolometric light curves and multi-color lightcurves (in the blackbody approximation).

[ascl:1107.001]
SNID: Supernova Identification

We present an algorithm to identify the type of an SN spectrum and to determine its redshift and age. This algorithm, based on the correlation techniques of Tonry & Davis, is implemented in the Supernova Identification (SNID) code. It is used by members of ongoing high-redshift SN searches to distinguish between type Ia and type Ib/c SNe, and to identify "peculiar" SNe Ia. We develop a diagnostic to quantify the quality of a correlation between the input and template spectra, which enables a formal evaluation of the associated redshift error. Furthermore, by comparing the correlation redshifts obtained using SNID with those determined from narrow lines in the SN host galaxy spectrum, we show that accurate redshifts (with a typical error less than 0.01) can be determined for SNe Ia without a spectrum of the host galaxy. Last, the age of an input spectrum is determined with a typical 3-day accuracy, shown here by using high-redshift SNe Ia with well-sampled light curves. The success of the correlation technique confirms the similarity of some SNe Ia at low and high redshifts. The SNID code, which is available to the community, can also be used for comparative studies of SN spectra, as well as comparisons between data and models.

[ascl:1505.022]
Snoopy: General purpose spectral solver

Snoopy is a spectral 3D code that solves the MHD and Boussinesq equations, such as compressibility, particles, and Braginskii viscosity, and several other physical effects. It's useful for turbulence study involving shear and rotation. Snoopy requires the FFTW library (ascl:1201.015), and can run on parallel machine using MPI OpenMP or both at the same time.

[ascl:1505.023]
SNooPy: TypeIa supernovae analysis tools

Burns, Christopher R.; Stritzinger, Maximilian; Phillips, M. M.; Kattner, ShiAnne; Persson, S. E.; Madore, Barry F.; Freedman, Wendy L.; Boldt, Luis; Campillay, Abdo; Contreras, Carlos; Folatelli, Gaston; Gonzalez, Sergio; Krzeminski, Wojtek; Morrell, Nidia; Salgado, Francisco; Suntzeff, Nicholas B.

The SNooPy package (also known as SNpy), written in Python, contains tools for the analysis of TypeIa supernovae. It offers interactive plotting of light-curve data and models (and spectra), computation of reddening laws and K-corrections, LM non-linear least-squares fitting of light-curve data, and various types of spline fitting, including Diercx and tension. The package also includes a SNIa lightcurve template generator in the CSP passbands, estimates of Milky-Way Extinction, and a module for dealing with filters and spectra.

[ascl:1703.006]
SNRPy: Supernova remnant evolution modeling

SNRPy (Super Nova Remnant Python) models supernova remnant (SNR) evolution and is useful for understanding SNR evolution and to model observations of SNR for obtaining good estimates of SNR properties. It includes all phases for the standard path of evolution for spherically symmetric SNRs and includes alternate evolutionary models, including evolution in a cloudy ISM, the fractional energy loss model, and evolution in a hot low-density ISM. The graphical interface takes in various parameters and produces outputs such as shock radius and velocity vs. time, SNR surface brightness profile and spectrum.

[ascl:1805.017]
SNSEDextend: SuperNova Spectral Energy Distributions extrapolation toolkit

Pierel, Justin D. R.; Rodney, Steven A.; Avelino, Arturo; Bianco, Federica; Foley, Ryan J.; Friedman, Andrew; Hicken, Malcolm; Hounsell, Rebekah; Jha, Saurabh W.; Kessler, Richard; Kirshner, Robert; Mandel, Kaisey; Narayan, Gautham; Filippenko, Alexei V.; Scolnic, Daniel; Strolger, Louis-Gregory

SNSEDextend extrapolates core-collapse and Type Ia Spectral Energy Distributions (SEDs) into the UV and IR for use in simulations and photometric classifications. The user provides a library of existing SED templates (such as those in the authors' SN SED Repository) along with new photometric constraints in the UV and/or NIR wavelength ranges. The software then extends the existing template SEDs so their colors match the input data at all phases. SNSEDextend can also extend the SALT2 spectral time-series model for Type Ia SN for a "first-order" extrapolation of the SALT2 model components, suitable for use in survey simulations and photometric classification tools; as the code does not do a rigorous re-training of the SALT2 model, the results should not be relied on for precision applications such as light curve fitting for cosmology.

[ascl:1902.001]
SNTD: Supernova Time Delays

Supernova Time Delays (SNTD) simulates and measures time delay of multiply-imaged supernovae, and offers an improved characterization of the uncertainty caused by microlensing. Lensing time delays can be determined by fitting the multiple light curves of these objects; measuring these delays provide precise tests of lens models or constraints on the Hubble constant and other cosmological parameters that are independent of the local distance ladder. Fitting the effects of microlensing without an accurate prior often leads to biases in the time delay measurement and over-fitting to the data; this can be mitigated by using a Gaussian Process Regression (GPR) technique to determine the uncertainty due to microlensing. SNTD can produce accurate simulations for wide-field time domain surveys such as LSST and WFIRST.

[ascl:1504.021]
SOAP 2.0: Spot Oscillation And Planet 2.0

SOAP (Spot Oscillation And Planet) 2.0 simulates the effects of dark spots and bright plages on the surface of a rotating star, computing their expected radial velocity and photometric signatures. It includes the convective blueshift and its inhibition in active regions.

[ascl:1403.026]
SOFA: Standards of Fundamental Astronomy

SOFA (Standards Of Fundamental Astronomy) is a collection of subprograms, in source-code form, that implement official IAU algorithms for fundamental astronomy computations. SOFA offers more than 160 routines for fundamental astronomy, including time scales (including dealing with leap seconds), Earth rotation, sidereal time, precession, nutation, polar motion, astrometry and transforms between various reference systems (e.g. BCRS, ICRS, GCRS, CIRS, TIRS, ITRS). The subprograms are supported by 55 vector/matrix routines, and are available in both Fortran77 and C implementations.

[ascl:1412.001]
SoFiA: Source Finding Application

Serra, Paolo; Westmeier, Tobias; Giese, Nadine; Jurek, Russell; Flöer, Lars; Popping, Attila; Winkel, Benjamin; van der Hulst, Thijs; Meyer, Martin; Koribalski, Bärbel; Staveley-Smith, Lister; Courtois, Hélène

SoFiA is a flexible source finding pipeline designed to detect and parameterise sources in 3D spectral-line data cubes. SoFiA combines several powerful source finding and parameterisation algorithms, including wavelet denoising, spatial and spectral smoothing, source mask optimisation, spectral profile fitting, and calculation of the reliability of detections. In addition to source catalogues in different formats, SoFiA can also generate a range of output data cubes and images, including source masks, moment maps, sub-cubes, position-velocity diagrams, and integrated spectra. The pipeline is controlled by simple parameter files and can either be invoked on the command line or interactively through a modern graphical user interface.

[ascl:1208.013]
SolarSoft: Programming and data analysis environment for solar physics

SolarSoft is a set of integrated software libraries, data bases, and system utilities which provide a common programming and data analysis environment for Solar Physics. The SolarSoftWare (SSW) system is built from Yohkoh, SOHO, SDAC and Astronomy libraries and draws upon contributions from many members of those projects. It is primarily an IDL based system, although some instrument teams integrate executables written in other languages. The SSW environment provides a consistent look and feel at widely distributed co-investigator institutions to facilitate data exchange and to stimulate coordinated analysis. Commonalities and overlap in solar data and analysis goals are exploited to permit application of fundamental utilities to the data from many different solar instruments. The use of common libraries, utilities, techniques and interfaces minimizes the learning curve for investigators who are analyzing new solar data sets, correlating results from multiple experiments or performing research away from their home institution.

[ascl:1701.012]
SONG: Second Order Non-Gaussianity

SONG computes the non-linear evolution of the Universe in order to predict cosmological observables such as the bispectrum of the Cosmic Microwave Background (CMB). More precisely, it is a second-order Boltzmann code, as it solves the Einstein and Boltzmann equations up to second order in the cosmological perturbations.

[ascl:1412.014]
SOPHIA: Simulations Of Photo Hadronic Interactions in Astrophysics

SOPHIA (Simulations Of Photo Hadronic Interactions in Astrophysics) solves problems connected to photohadronic processes in astrophysical environments and can also be used for radiation and background studies at high energy colliders such as LEP2 and HERA, as well as for simulations of photon induced air showers. SOPHIA implements well established phenomenological models, symmetries of hadronic interactions in a way that describes correctly the available exclusive and inclusive photohadronic cross section data obtained at fixed target and collider experiments.

[ascl:1810.017]
SOPHISM: Software Instrument Simulator

Blanco Rodríguez, J.; del Toro Iniesta, J. C.; Orozco Suárez, D.; Martínez Pillet, V.; Bonet, J. A.; Feller, A.; Hirzberger, J.; Lagg, A.; Piqueras, J.; Gasent Blesa, J. L.

SOPHISM models astronomical instrumentation from the entrance of the telescope to data acquisition at the detector, along with software blocks dealing with, for example, demodulation, inversion, and compression. The code performs most analyses done with light in astronomy, such as differential photometry, spectroscopy, and polarimetry. The simulator offers flexibility and implementation of new effects and subsystems, making it user-adaptable for a wide variety of instruments. SOPHISM can be used for all stages of instrument definition, design, operation, and lifetime tracking evaluation.

[ascl:1607.014]
SOPIE: Sequential Off-Pulse Interval Estimation

SOPIE (Sequential Off-Pulse Interval Estimation) provides functions to non-parametrically estimate the off-pulse interval of a source function originating from a pulsar. The technique is based on a sequential application of P-values obtained from goodness-of-fit tests for the uniform distribution, such as the Kolmogorov-Smirnov, Cramér-von Mises, Anderson-Darling and Rayleigh goodness-of-fit tests.

[ascl:1307.020]
SOPT: Sparse OPTimisation

SOPT (Sparse OPTimisation) is a C implementation of the Sparsity Averaging Reweighted Analysis (SARA) algorithm. The approach relies on the observation that natural images exhibit strong average sparsity; average sparsity outperforms state-of-the-art priors that promote sparsity in a single orthonormal basis or redundant frame, or that promote gradient sparsity.

[ascl:1805.028]
SP_Ace: Stellar Parameters And Chemical abundances Estimator

SP_Ace (Stellar Parameters And Chemical abundances Estimator) estimates the stellar parameters Teff, log g, [M/H], and elemental abundances. It employs 1D stellar atmosphere models in Local Thermodynamic Equilibrium (LTE). The code is highly automated and suitable for analyzing the spectra of large spectroscopic surveys with low or medium spectral resolution (R = 2000-20 000). A web service for calculating these values with the software is also available.

[ascl:1504.002]
SPA: Solar Position Algorithm

The Solar Position Algorithm (SPA) calculates the solar zenith and azimuth angles in the period from the year -2000 to 6000, with uncertainties of +/- 0.0003 degrees based on the date, time, and location on Earth. SPA is implemented in C; in addition to being available for download, an online calculator using this code is available at http://www.nrel.gov/midc/solpos/spa.html.

[ascl:1401.002]
SpacePy: Python-Based Tools for the Space Science Community

SpacePy provides data analysis and visualization tools for the space science community. Written in Python, it builds on the capabilities of the NumPy and MatPlotLib packages to make basic data analysis, modeling and visualization easier. It contains modules for handling many complex time formats, obtaining data from the OMNI database, and accessing the powerful Onera library. It contains a library of commonly used empirical relationships, performs association analysis, coordinate transformations, radiation belt modeling, and CDF reading, and creates publication quality plots.

[ascl:1806.010]
SpaghettiLens: Web-based gravitational lens modeling tool

SpaghettiLens allows citizen scientists to model gravitational lenses collaboratively; the software should also be easily adaptable to any other, reasonably similar problem. It lets volunteers execute a computer intensive task that cannot be easily executed client side and relies on citizen scientists collaborating. SpaghettiLens makes survey data available to citizen scientists, manages the model configurations generated by the volunteers, stores the resulting model configuration, and delivers the actual model. A model can be shared and discussed with other volunteers and revised, and new child models can be created, resulting in a branching version tree of models that explore different possibilities. Scientists can choose a collection of models; discussion among volunteers and scientists prune the tree to determine which models will receive further analysis.

[ascl:1408.006]
SPAM: Source Peeling and Atmospheric Modeling

SPAM is a extension to AIPS for reducing high-resolution, low-frequency radio interferometric observations. Direction-dependent ionospheric calibration and image-plane ripple suppression are among the features that help to make high-quality sub-GHz images. Data reductions are captured in well-tested Python scripts that execute AIPS tasks directly (mostly during initial data reduction steps), call high-level functions that make multiple AIPS or ParselTongue calls, and require few manual operations.

[ascl:1812.005]
SPAMCART: Smoothed PArticle Monte CArlo Radiative Transfer

SPAMCART generates synthetic spectral energy distributions and intensity maps from smoothed particle hydrodynamics simulation snapshots. It follows discrete luminosity packets as they propagate through a density field, and computes the radiative equilibrium temperature of the ambient dust from their trajectories. The sources can be extended and/or embedded, and discrete and/or diffuse. The density is not mapped on to a grid, and therefore the calculation is performed at exactly the same resolution as the hydrodynamics. The code strictly adheres to Kirchhoff's law of radiation. The algorithm is based on the Lucy Monte Carlo radiative transfer method and is fairly simple to implement, as it uses data structures that are already constructed for other purposes in modern particle codes

[ascl:1105.006]
SPARC: Seismic Propagation through Active Regions and Convection

The Seismic Propagation through Active Regions and Convection (SPARC) code was developed by S. Hanasoge. The acoustic wavefield in SPARC is simulated by numerically solving the linearised 3-D Euler equations in Cartesian geometry (e.g., see Hanasoge, Duvall and Couvidat (2007)). Spatial derivatives are calculated using sixth-order compact finite differences (Lele,1992) and time evolution is achieved through the repeated application of an optimized second-order five-stage Runge-Kutta scheme (Hu, 1996). Periodic horizontal boundaries are used.

[ascl:1511.011]
SparsePZ: Sparse Representation of Photometric Redshift PDFs

SparsePZ uses sparse basis representation to fully represent individual photometric redshift probability density functions (PDFs). This approach requires approximately half the parameters for the same multi-Gaussian fitting accuracy, and has the additional advantage that an entire PDF can be stored by using a 4-byte integer per basis function. Only 10-20 points per galaxy are needed to reconstruct both the individual PDFs and the ensemble redshift distribution, N(z), to an accuracy of 99.9 per cent when compared to the one built using the original PDFs computed with a resolution of δz = 0.01, reducing the required storage of 200 original values by a factor of 10-20. This basis representation can be directly extended to a cosmological analysis, thereby increasing computational performance without losing resolution or accuracy.

[ascl:1711.001]
SpcAudace: Spectroscopic processing and analysis package of Audela software

SpcAudace processes long slit spectra with automated pipelines and performs astrophysical analysis of the latter data. These powerful pipelines do all the required steps in one pass: standard preprocessing, masking of bad pixels, geometric corrections, registration, optimized spectrum extraction, wavelength calibration and instrumental response computation and correction. Both high and low resolution long slit spectra are managed for stellar and non-stellar targets. Many types of publication-quality figures can be easily produced: pdf and png plots or annotated time series plots. Astrophysical quantities can be derived from individual or large amount of spectra with advanced functions: from line profile characteristics to equivalent width and periodogram. More than 300 documented functions are available and can be used into TCL scripts for automation. SpcAudace is based on Audela open source software.

[ascl:1010.016]
SpDust/SpDust.2: Code to Calculate Spinning Dust Spectra

SpDust is an IDL program that evaluates the spinning dust emissivity for user-provided environmental conditions. A new version of the code became available in March, 2010.

[ascl:1203.003]
spec2d: DEEP2 DEIMOS Spectral Pipeline

The DEEP2 DEIMOS Data Reduction Pipeline ("spec2d") is an IDL-based, automated software package designed to reduce Keck/DEIMOS multi-slit spectroscopic observations, collected as part of the DEEP2 Galaxy Redshift Survey. The pipeline is best suited for handling data taken with the 1200 line/mm grating tilted towards the red (lambda_c ~ 7800Å). The spec2d reduction package takes the raw DEIMOS data as its input and produces a variety of outputs including 2-d slit spectra and 1-d object spectra.

[ascl:1407.003]
SPECDRE: Spectroscopy Data Reduction

Specdre performs spectroscopy data reduction and analysis. General features of the package include data cube manipulation, arc line calibration, resampling and spectral fitting. Particular care is taken with error propagation, including tracking covariance. SPECDRE is distributed as part of the Starlink software collection (ascl:1110.012).

[ascl:1404.014]
SpecPro: Astronomical spectra viewer and analyzer

SpecPro is an interactive program for viewing and analyzing spectra, particularly in the context of modern imaging surveys. In addition to displaying the 1D and 2D spectrum, SpecPro can simultaneously display available stamp images as well as the spectral energy distribution of a source. This extra information can help significantly in assessing a spectrum.

[ascl:1111.005]
SPECTCOL: Spectroscopic and Collisional Data Retrieval

Studies of astrophysical non-LTE media require the combination of atomic and molecular spectroscopic and collisional data often described differently in various databases. SPECTCOL is a tool that implements VAMDC standards, retrieve relevant information from different databases such as CDMS, HITRAN, BASECOL, and can upload local files. All transfer of data between the client and the databases use the VAMDC-XSAMS schema. The spectroscopic and collisional information is combined and useful outputs (ascii or xsams) are provided for the study of the interstellar medium.

[ascl:1701.003]
Spectra: Time series power spectrum calculator

Spectra calculates the power spectrum of a time series equally spaced or not based on the Spectral Correlation Coefficient (Ferraz-Mello 1981, Astron. Journal 86 (4), 619). It is very efficient for detection of low frequencies.

[ascl:1609.017]
spectral-cube: Read and analyze astrophysical spectral data cubes

Spectral-cube provides an easy way to read, manipulate, analyze, and write data cubes with two positional dimensions and one spectral dimension, optionally with Stokes parameters. It is a versatile data container for building custom analysis routines. It provides a uniform interface to spectral cubes, robust to the wide range of conventions of axis order, spatial projections, and spectral units that exist in the wild, and allows easy extraction of cube sub-regions using physical coordinates. It has the ability to create, combine, and apply masks to datasets and is designed to work with datasets too large to load into memory, and provide basic summary statistic methods like moments and array aggregates.

[ascl:1202.010]
SPECTRE: Manipulation of single-order spectra

SPECTRE's chief purpose is the manipulation of single-order spectra, and it performs many of the tasks contained in such IRAF routines as "splot" and "rv". It is not meant to replace the much more general capabilities of IRAF, but does some functions in a manner that some might find useful. A brief list of SPECTRE tasks are: spectrum smoothing; equivalent width calculation; continuum rectification; noise spike excision; and spectrum comparison. SPECTRE was written to manipulate coude spectra, and thus is probably most useful for working on high dispersion spectra. Echelle spectra can be gathered from various observatories, reduced to singly-dimensioned spectra using IRAF, then written out as FITS files, thus becoming accessible to SPECTRE. Three different spectra may be manipulated and displayed simultaneously. SPECTRE, written in standard FORTRAN77, can be used only with the SM graphics package.

[ascl:9910.002]
SPECTRUM: A stellar spectral synthesis program

SPECTRUM ((C) Richard O. Gray, 1992-2008) is a stellar spectral synthesis program which runs on a number of platforms, including most flavors of UNIX and LINUX. It will also run under Windwos 9x/ME/NT/2000/XP using the Cygwin tools or the distributed Windows binaries. The code for SPECTRUM has been written in the "C" language. SPECTRUM computes the LTE synthetic spectrum given a stellar atmosphere model. SPECTRUM can use as input the fully blanketed stellar atmosphere models of Robert Kurucz including the new models of Castelli and Kurucz, but any other stellar atmosphere model which can be cast into the format of Kurucz's models can be used as well. SPECTRUM can be programmed with "command-line switches" to give a number of different outputs. In the default mode, SPECTRUM computes the stellar-disk-integrated normalized-intensity spectrum, but in addition, SPECTRUM will compute the absolute monochromatic flux from the stellar atmosphere or the specific intensity from any point on the stellar surface.

[ascl:1902.012]
Specutils: Spectroscopic analysis and reduction

Specutils provides a basic interface for the loading, manipulation, and common forms of analysis of spectroscopic data. Its generic data containers and accompanying modules can be used to build a particular scientific workflow or higher-level analysis tool. It is an AstroPy (ascl:1304.002) affiliated package, and SpecViz (ascl:1902.011), which is built on top of Specutils, provides a visual, interactive interface to its analysis capabilities.

[ascl:1210.016]
Specview: 1-D spectral visualization and analysis of astronomical spectrograms

Specview is a tool for 1-D spectral visualization and analysis of astronomical spectrograms. Written in Java, it is capable of reading all the Hubble Space Telescope spectral data formats as well as data from several other instruments (such as IUE, FUSE, ISO, FORS and SDSS), preview spectra from MAST, and data from generic FITS and ASCII tables. It can read data from Virtual Observatory servers, and read and write spectrogram data in Virtual Observatory SED format. It can also read files in the SPC Galactic format used in the chemistry field. Once ingested, data can be plotted and examined with a large selection of custom settings. Specview supports instrument-specific data quality handling, flexible spectral units conversions, custom plotting attributes, plot annotations, tiled plots, hardcopy to JPEG files and PostScript file or printer, etc. Specview can be used to build wide-band SEDs, overplotting or combining data from the same astronomical source taken with different instruments and/or spectral bands. Data can be further processed with averaging, splicing, detrending, and Fourier filtering tools. Specview has a spectral model fitting capability that enables the user to work with multi-component models (including user-defined models) and fit models to data.

[ascl:1902.011]
SpecViz: 1D Spectral Visualization Tool

SpecViz interactively visualizes and analyzes 1D astronomical spectra. It reads data from FITS and ASCII tables and allows spectra to be easily plotted and examined. It supports instrument-specific data quality handling, flexible spectral units conversions, custom plotting attributes, plot annotations, tiled plots, among other features. SpecViz includes a measurement tool for spectral lines for performing and recording measurements and a model fitting capability for creating simple (e.g., single Gaussian) or multi-component models (e.g., multiple Gaussians for emission and absorption lines in addition to regions of flat continua). SpecViz is built on top of the Specutils (ascl:1902.012) Astropy-affiliated python library, providing a visual, interactive interface to the analysis capabilities in that library.

[ascl:1310.008]
SPECX: Spectral Line Data Reduction Package

SPECX is a general purpose line data reduction system. It can read and write FITS data cubes but has specialist support for the GSD format data from the James Clerk Maxwell Telescope. It includes commands to store and retrieve intermediate spectra in storage registers and perform the fitting and removal of polynomial, harmonic and Gaussian baselines.

SPECX can filter and edit spectra and list and display spectra on a graphics terminal. It is able to perform Fourier transform and power spectrum calculations, process up to eight spectra (quadrants) simultaneously with either the same or different center, and assemble a number of reduced individual spectra into a map file and contour or greyscale any plane or planes of the resulting cube.

Two versions of SPECX are distributed. Version 6.x is the VMS and Unix version and is distributed as part of the Starlink software collection. Version 7.x is a complete rewrite of SPECX distributed for Windows.

[ascl:1807.014]
SPEGID: Single-Pulse Event Group IDentification

SPEGID (Single-Pulse Event Group IDentification) identifies astrophysical pulse candidates as trial single-pulse event groups (SPEGs) by first applying Density Based Spatial Clustering of Applications with Noise (DBSCAN) on trial single-pulse events and then merging the clusters that fall within the expected DM (Dispersion Measure) and time span of astrophysical pulses. SPEGID also calculates the peak score for each SPEG in the S/N versus DM space to identify the expected peak-like shape in the signal-to-noise (S/N) ratio versus DM curve of astrophysical pulses. Additionally, SPEGID groups SPEGs that appear at a consistent DM and therefore are likely emitted from the same source. After running SPEGID, periocity.py can be used to find (or verify) the underlying periodicity among a group of SPEGs (i.e., astrophysical pulse candidates).

[ascl:1308.014]
SPEX: High-resolution cosmic X-ray spectra analysis

SPEX is optimized for the analysis and interpretation of high-resolution cosmic X-ray spectra. The software is especially suited for fitting spectra obtained by current X-ray observatories like XMM-Newton, Chandra, and Suzaku. SPEX can fit multiple spectra with different model components simultaneously and handles highly complex models with many free parameters.

[ascl:1404.017]
Spextool: Spectral EXtraction tool

Spextool (Spectral EXtraction tool) is an IDL-based data reduction package for SpeX, a medium resolution near-infrared spectrograph on the NASA IRTF. It performs all of the steps necessary to produce spectra ready for analysis and publication including non-linearity corrections, flat fielding, wavelength calibration, telluric correction, flux calibration, and order merging.

[ascl:9912.001]
SPH_1D: Hierarchical gravity/SPH treecode for simulations of interacting galaxies

We describe a fast tree algorithm for gravitational N-body simulation on SIMD parallel computers. The tree construction uses fast, parallel sorts. The sorted lists are recursively divided along their x, y and z coordinates. This data structure is a completely balanced tree (i.e., each particle is paired with exactly one other particle) and maintains good spatial locality. An implementation of this tree-building algorithm on a 16k processor Maspar MP-1 performs well and constitutes only a small fraction (approximately 15%) of the entire cycle of finding the accelerations. Each node in the tree is treated as a monopole. The tree search and the summation of accelerations also perform well. During the tree search, node data that is needed from another processor is simply fetched. Roughly 55% of the tree search time is spent in communications between processors. We apply the code to two problems of astrophysical interest. The first is a simulation of the close passage of two gravitationally, interacting, disk galaxies using 65,636 particles. We also simulate the formation of structure in an expanding, model universe using 1,048,576 particles. Our code attains speeds comparable to one head of a Cray Y-MP, so single instruction, multiple data (SIMD) type computers can be used for these simulations. The cost/performance ratio for SIMD machines like the Maspar MP-1 make them an extremely attractive alternative to either vector processors or large multiple instruction, multiple data (MIMD) type parallel computers. With further optimizations (e.g., more careful load balancing), speeds in excess of today's vector processing computers should be possible.

[ascl:1806.023]
Spheral++: Coupled hydrodynamical and gravitational numerical simulations

Spheral++ provides a steerable parallel environment for performing coupled hydrodynamical and gravitational numerical simulations. Hydrodynamics and gravity are modeled using particle-based methods (SPH and N-Body). It uses an Adaptive Smoothed Particle Hydrodynamics (ASPH) algorithm, provides a total energy conserving compatible hydro mode, and performs fluid and solid material modeling and damage and fracture modeling in solids.

[ascl:1309.004]
Spherical: Geometry operations and searches on spherical surfaces

The Spherical Library provides an efficient and accurate mathematical representation of shapes on the celestial sphere, such as sky coverage and footprints. Shapes of arbitrary complexity and size can be dynamically created from simple building blocks, whose exact area is also analytically computed. This methodology is also perfectly suited for censoring problematic parts of datasets, e.g., bad seeing, satellite trails or diffraction spikes of bright stars.

[ascl:1311.005]
Spheroid: Electromagnetic Scattering by Spheroids

Spheroid determines the size distribution of polarizing interstellar dust grains based on electromagnetic scattering by spheroidal particles. It contains subroutines to treat the case of complex refractive indices, and also includes checks for some limiting cases.

[ascl:1502.012]
SPHGR: Smoothed-Particle Hydrodynamics Galaxy Reduction

SPHGR (Smoothed-Particle Hydrodynamics Galaxy Reduction) is a python based open-source framework for analyzing smoothed-particle hydrodynamic simulations. Its basic form can run a baryonic group finder to identify galaxies and a halo finder to identify dark matter halos; it can also assign said galaxies to their respective halos, calculate halo & galaxy global properties, and iterate through previous time steps to identify the most-massive progenitors of each halo and galaxy. Data about each individual halo and galaxy is collated and easy to access.

SPHGR supports a wide range of simulations types including N-body, full cosmological volumes, and zoom-in runs. Support for multiple SPH code outputs is provided by pyGadgetReader (ascl:1411.001), mainly Gadget (ascl:0003.001) and TIPSY (ascl:1111.015).

[ascl:1103.009]
SPHRAY: A Smoothed Particle Hydrodynamics Ray Tracer for Radiative Transfer

SPHRAY, a Smoothed Particle Hydrodynamics (SPH) ray tracer, is designed to solve the 3D, time dependent, radiative transfer (RT) equations for arbitrary density fields. The SPH nature of SPHRAY makes the incorporation of separate hydrodynamics and gravity solvers very natural. SPHRAY relies on a Monte Carlo (MC) ray tracing scheme that does not interpolate the SPH particles onto a grid but instead integrates directly through the SPH kernels. Given initial conditions and a description of the sources of ionizing radiation, the code will calculate the non-equilibrium ionization state (HI, HII, HeI, HeII, HeIII, e) and temperature (internal energy/entropy) of each SPH particle. The sources of radiation can include point like objects, diffuse recombination radiation, and a background field from outside the computational volume. The MC ray tracing implementation allows for the quick introduction of new physics and is parallelization friendly. A quick Axis Aligned Bounding Box (AABB) test taken from computer graphics applications allows for the acceleration of the raytracing component. We present the algorithms used in SPHRAY and verify the code by performing all the test problems detailed in the recent Radiative Transfer Comparison Project of Iliev et. al. The Fortran 90 source code for SPHRAY and example SPH density fields are made available online.

[ascl:1709.001]
SPHYNX: SPH hydrocode for subsonic hydrodynamical instabilities and strong shocks

SPHYNX addresses subsonic hydrodynamical instabilities and strong shocks; it is Newtonian, grounded on the Euler-Lagrange formulation of the smoothed-particle hydrodynamics technique, and density based. SPHYNX uses an integral approach for estimating gradients, a flexible family of interpolators to suppress pairing instability, and incorporates volume elements to provides better partition of the unity.

[ascl:1711.019]
SPIDERMAN: Fast code to simulate secondary transits and phase curves

SPIDERMAN calculates exoplanet phase curves and secondary eclipses with arbitrary surface brightness distributions in two dimensions. The code uses a geometrical algorithm to solve exactly the area of sections of the disc of the planet that are occulted by the star. Approximately 1000 models can be generated per second in typical use, which makes making Markov Chain Monte Carlo analyses practicable. The code is modular and allows comparison of the effect of multiple different brightness distributions for a dataset.

[ascl:1608.020]
SPIDERz: SuPport vector classification for IDEntifying Redshifts

SPIDERz (SuPport vector classification for IDEntifying Redshifts) applies powerful support vector machine (SVM) optimization and statistical learning techniques to custom data sets to obtain accurate photometric redshift (photo-z) estimations. It is written for the IDL environment and can be applied to traditional data sets consisting of photometric band magnitudes, or alternatively to data sets with additional galaxy parameters (such as shape information) to investigate potential correlations between the extra galaxy parameters and redshift.

[ascl:1710.004]
SPIPS: Spectro-Photo-Interferometry of Pulsating Stars

SPIPS (Spectro-Photo-Interferometry of Pulsating Stars) combines radial velocimetry, interferometry, and photometry to estimate physical parameters of pulsating stars, including presence of infrared excess, color excess, Teff, and ratio distance/p-factor. The global model-based parallax-of-pulsation method is implemented in Python. Derived parameters have a high level of confidence; statistical precision is improved (compared to other methods) due to the large number of data taken into account, accuracy is improved by using consistent physical modeling and reliability of the derived parameters is strengthened by redundancy in the data.

[ascl:1512.015]
Spirality: Spiral arm pitch angle measurement

Shields, Douglas W.; Boe, Benjamin; Pfountz, Casey; Davis, Benjamin L.; Hartley, Matthew; Pour Imani, Hamed; Slade, Zac; Kennefick, Daniel; Kennefick, Julia

Spirality measures spiral arm pitch angles by fitting galaxy images to spiral templates of known pitch. Written in MATLAB, the code package also includes GenSpiral, which produces FITS images of synthetic spirals, and SpiralArmCount, which uses a one-dimensional Fast Fourier Transform to count the spiral arms of a galaxy after its pitch is determined.

[ascl:1103.004]
SPLASH: Interactive Visualization Tool for Smoothed Particle Hydrodynamics Simulations

SPLASH (formerly SUPERSPHPLOT) visualizes output from (astrophysical) simulations using the Smoothed Particle Hydrodynamics (SPH) method in one, two and three dimensions. Written in Fortran 90, it uses the PGPLOT graphics subroutine library for plotting. It is based around a command-line menu structure but utilizes the interactive capabilities of PGPLOT to manipulate data interactively in the plotting window. SPLASH is fully interactive; visualizations can be changed rapidly at the touch of a button (e.g. zooming, rotating, shifting cross section positions etc). Data is read directly from the code dump format giving rapid access to results and the visualization is advanced forwards and backwards through timesteps by single keystrokes. SPLASH uses the SPH kernel to render plots of not only density but other physical quantities, giving a smooth representation of the data.

[ascl:1402.008]
SPLAT-VO: Spectral Analysis Tool for the Virtual Observatory

SPLAT-VO is an extension of the SPLAT (Spectral Analysis Tool, ascl:1402.007) graphical tool for displaying, comparing, modifying and analyzing astronomical spectra; it includes facilities that allow it to work as part of the Virtual Observatory (VO). SPLAT-VO comes in two different forms, one for querying and downloading spectra from SSAP servers and one for interoperating with VO tools, such as TOPCAT (ascl:1101.010).

[ascl:1402.007]
SPLAT: Spectral Analysis Tool

SPLAT is a graphical tool for displaying, comparing, modifying and analyzing astronomical spectra stored in NDF, FITS and TEXT files as well as in NDX format. It can read in many spectra at the same time and then display these as line plots. Display windows can show one or several spectra at the same time and can be interactively zoomed and scrolled, centered on specific wavelengths, provide continuous coordinate readout, produce printable hardcopy and be configured in many ways. Analysis facilities include the fitting of a polynomial to selected parts of a spectrum, the fitting of Gaussian, Lorentzian and Voigt profiles to emission and absorption lines and the filtering of spectra using average, median and line-shape window functions as well as wavelet denoising. SPLAT also supports a full range of coordinate systems for spectra, which allows coordinates to be displayed and aligned in many different coordinate systems (wavelength, frequency, energy, velocity) and transformed between these and different standards of rest (topocentric, heliocentric, dynamic and kinematic local standards of rest, etc). SPLAT is distributed as part of the Starlink (ascl:1110.012) software collection.

[ascl:1103.005]
Splotch: Ray Tracer to Visualize SPH Simulations

Splotch is a light and fast, publicly available, ray-tracer software tool which supports the effective visualization of cosmological simulations data. The algorithm it relies on is designed to deal with point-like data, optimizing the ray-tracing calculation by ordering the particles as a function of their 'depth', defined as a function of one of the coordinates or other associated parameters. Realistic three-dimensional impressions are reached through a composition of the final colour in each pixel properly calculating emission and absorption of individual volume elements.

[ascl:1809.006]
spops: Spinning black-hole binary population synthesis

Gerosa, Davide; Berti, Emanuele; O'Shaughnessy, Richard; Belczynski, Krzysztof; Kesden, Michael; Wysocki, Daniel; Gladysz, Wojciech

spops is a database of populations synthesis simulations of spinning black-hole binary systems, together with a python module to query it. Data are obtained with the startrack and precession [ascl:1611.004] numerical codes to consistently evolve binary stars from formation to gravitational-wave detection. spops allows quick exploration of the interplay between stellar physics and black-hole spin dynamics.

[ascl:1411.015]
SPOTROD: Semi-analytic model for transits of spotted stars

SPOTROD is a model for planetary transits of stars with an arbitrary limb darkening law and a number of homogeneous, circular spots on their surface. It facilitates analysis of anomalies due to starspot eclipses, and is a free, open source implementation written in C with a Python API.

[ascl:1506.008]
SPRITE: Sparsity-based super-resolution algorithm

SPRITE (Sparse Recovery of InstrumenTal rEsponse) computes a well-resolved compact source image from several undersampled and noisy observations. The algorithm is based on sparse regularization; adding a sparse penalty in the recovery leads to far better accuracy in terms of ellipticity error, especially at low S/N.

[ascl:1806.013]
SpS: Single-pulse Searcher

The presence of human-made interference mimicking the behavior of celestial radio pulses is a major challenge when searching for radio pulses emitted on millisecond timescales by celestial radio sources such as pulsars and fast radio bursts due to the highly imbalanced samples. Single-pulse Searcher (SpS) reduces the presence of radio interference when processing standard output from radio single-pulse searches to produce diagnostic plots useful for selecting good candidates. The modular software allows modifications for specific search characteristics. LOTAAS Single-pulse Searcher (L-SpS) is an implementation of different features of the software (such as a machine-learning approach) developed for a particular study: the LOFAR Tied-Array All-Sky Survey (LOTAAS).

[ascl:1201.013]
SPS: SPIRE Photometer Simulator

The SPS software simulates the operation of the Spectral and Photometric Imaging Receiver on-board the ESA’s Herschel Space Observatory. It is coded using the Interactive Data Language (IDL), and produces simulated data at the level-0 stage (non-calibrated data in digitised units). The primary uses for the simulator are to:

- optimize and characterize the photometer observing functions
- aid in the development, validation, and characterization of the SPIRE data pipeline
- provide a realistic example of SPIRE data, and thus to facilitate the development of specific analysis tools for specific science cases.

[ascl:1411.025]
SPT Lensing Likelihood: South Pole Telescope CMB lensing likelihood code

The SPT lensing likelihood code, written in Fortran90, performs a Gaussian likelihood based upon the lensing potential power spectrum using a file from CAMB (ascl:1102.026) which contains the normalization required to get the power spectrum that the likelihood call is expecting.

[ascl:1705.005]
SPTCLASS: SPecTral CLASSificator code

SPTCLASS assigns semi-automatic spectral types to a sample of stars. The main code includes three spectral classification schemes: the first one is optimized to classify stars in the mass range of TTS (K5 or later, hereafter LATE-type scheme); the second one is optimized to classify stars in the mass range of IMTTS (F late to K early, hereafter Gtype scheme), and the third one is optimized to classify stars in the mass range of HAeBe (F5 or earlier, hereafter HAeBe scheme). SPTCLASS has an interactive module that allows the user to select the best result from the three schemes and analyze the input spectra.

[ascl:1303.015]
SSE: Single Star Evolution

SSE is a rapid single-star evolution (SSE) code; these analytical formulae cover all phases of evolution from the zero-age main-sequence up to and including remnant phases. It is valid for masses in the range 0.1-100 Msun and metallicity can be varied. The SSE package contains a prescription for mass loss by stellar winds. It also follows the evolution of rotational angular momentum for the star.

[ascl:1807.032]
SSMM: Slotted Symbolic Markov Modeling for classifying variable star signatures

SSMM (Slotted Symbolic Markov Modeling) reduces time-domain stellar variable observations to classify stellar variables. The method can be applied to both folded and unfolded data, and does not require time-warping for waveform alignment. Written in Matlab, the performance of the supervised classification code is quantifiable and consistent, and the rate at which new data is processed is dependent only on the computational processing power available.

[ascl:1901.006]
ssos: Solar system objects detection pipeline

The ssos pipeline detects and identifies known and unknown Solar System Objects (SSOs) in astronomical images. ssos requires at least 3 images with overlapping field-of-views in the sky taken within a reasonable amount of time (*e.g.*, 2 hours, 1 night). SSOs are detected mainly by judging the apparent motion of all sources in the images. The pipeline serves as a wrapper for the SExtractor (ascl:1010.064) and SCAMP (ascl:1010.063) software suites and allows different source extraction strategies to be chosen. All sources in the images are subject to a highly configurable filter pipeline. ssos is a versatile, light-weight, and easy-to-use software for surveys or PI-observation campaigns lacking a dedicated SSO detection pipeline.

[ascl:1105.012]
Stagger: MHD Method for Modeling Star Formation

Stagger is an astrophysical MHD code actively used to model star formation. It is equipped with a multi-frequency radiative transfer module and a comprehensive equation of state module that includes a large number of atomic and molecular species, to be able to compute realistic 3-D models of the near-surface layers of stars. The current version of the code allows a discretization that explicitly conserves mass, momentum, energy, and magnetic flux. The tensor formulation of the viscosity ensures that the viscous force is insensitive to the coordinate system orientation, thereby avoiding artificial grid-alignment.

[ascl:1801.003]
Stan: Statistical inference

Stan facilitates statistical inference at the frontiers of applied statistics and provides both a modeling language for specifying complex statistical models and a library of statistical algorithms for computing inferences with those models. These components are exposed through interfaces in environments such as R, Python, and the command line.

[ascl:1111.010]
Starbase Data Tables: An ASCII Relational Database for Unix

Database management is an increasingly important part of astronomical data analysis. Astronomers need easy and convenient ways of storing, editing, filtering, and retrieving data about data. Commercial databases do not provide good solutions for many of the everyday and informal types of database access astronomers need. The Starbase database system with simple data file formatting rules and command line data operators has been created to answer this need. The system includes a complete set of relational and set operators, fast search/index and sorting operators, and many formatting and I/O operators. Special features are included to enhance the usefulness of the database when manipulating astronomical data. The software runs under UNIX, MSDOS and IRAF.

[ascl:1805.009]
STARBLADE: STar and Artefact Removal with a Bayesian Lightweight Algorithm from Diffuse Emission

STARBLADE (STar and Artefact Removal with a Bayesian Lightweight Algorithm from Diffuse Emission) separates superimposed point-like sources from a diffuse background by imposing physically motivated models as prior knowledge. The algorithm can also be used on noisy and convolved data, though performing a proper reconstruction including a deconvolution prior to the application of the algorithm is advised; the algorithm could also be used within a denoising imaging method. STARBLADE learns the correlation structure of the diffuse emission and takes it into account to determine the occurrence and strength of a superimposed point source.

[ascl:1104.003]
Starburst99: Synthesis Models for Galaxies with Active Star Formation

Leitherer, Claus; Schaerer, Daniel; Goldader, Jeff; Gonzalez-Delgado, Rosa; Robert, Carmelle; Foo Kune, Denis; de Mello, Duilia; Devost, Daniel; Heckman, Timothy M.; Aloisi, Alessandra; Martins, Lucimara; Vazquez, Gerardo

Starburst99 is a comprehensive set of model predictions for spectrophotometric and related properties of galaxies with active star formation. The models are presented in a homogeneous way for five metallicities between Z = 0.040 and 0.001 and three choices of the initial mass function. The age coverage is 10^6 to 10^9 yr. Spectral energy distributions are used to compute colors and other quantities.

[ascl:1010.074]
StarCrash: 3-d Evolution of Self-gravitating Fluid Systems

StarCrash is a parallel fortran code based on Smoothed Particle Hydrodynamics (SPH) techniques to calculate the 3-d evolution of self-gravitating fluid systems. The code in particularly suited to the study of stellar interactions, such as mergers of binary star systems and stellar collisions. The StarCrash code comes with several important features, including:

- Several routines which construct the initial conditions appropriate to a wide variety of physical systems

- An efficient parallel neighbor-finding algorithm for calculating hydrodynamic quantities

- A parallel gravitational field solver based on FFT convolution techniques, which uses the FFTW software libraries

- Relaxation Techniques for single stars and synchronized binaries

- Three different artificial viscosity treatments to calculate the thermodynamic evolution of the matter

- An optional gravitational radiation back-reaction treatment, which calculates the damping force from gravity wave losses to lowest relativistic order in a spatially accurate way

[ascl:0011.001]
StarFinder: A code for stellar field analysis

Diolaiti, Emiliano; Bendinelli, Orazio; Bonaccini, Domenico; Close, Laird M.; Currie, Doug G.; Parmeggiani, Gianluigi

StarFinder is an IDL code for the deep analysis of stellar fields, designed for Adaptive Optics well-sampled images with high and low Strehl ratio. The Point Spread Function is extracted directly from the frame, to take into account the actual structure of the instrumental response and the atmospheric effects. The code is written in IDL language and organized in the form of a self-contained widget-based application, provided with a series of tools for data visualization and analysis. A description of the method and some applications to Adaptive Optics data are presented.

[ascl:1204.008]
StarFISH: For Inferring Star-formation Histories

StarFISH is a suite of programs designed to determine the star formation history (SFH) of a stellar population, given multicolor stellar photometry and a library of theoretical isochrones. It constructs a library of synthetic color-magnitude diagrams from the isochrones, which includes the effects of extinction, photometric errors and completeness, and binarity. A minimization routine is then used to determine the linear combination of synthetic CMDs that best matches the observed photometry. The set of amplitudes modulating each synthetic CMD describes the star formation history of the observed stellar population.

[ascl:1505.007]
Starfish: Robust spectroscopic inference tools

Starfish is a set of tools used for spectroscopic inference. It robustly determines stellar parameters using high resolution spectral models and uses Markov Chain Monte Carlo (MCMC) to explore the full posterior probability distribution of the stellar parameters. Additional potential applications include other types of spectra, such as unresolved stellar clusters or supernovae spectra.

[ascl:1010.076]
Starlab: A Software Environment for Collisional Stellar Dynamics

Traditionally, a simulation of a dense stellar system required choosing an initial model, running an integrator, and analyzing the output. Almost all of the effort went into writing a clever integrator that could handle binaries, triples and encounters between various multiple systems efficiently. Recently, the scope and complexity of these simulations has increased dramatically, for three reasons: 1) the sheer size of the data sets, measured in Terabytes, make traditional 'awking and grepping' of a single output file impractical; 2) the addition of stellar evolution data brings qualitatively new challenges to the data reduction; 3) increased realism of the simulations invites realistic forms of 'SOS': Simulations of Observations of Simulations, to be compared directly with observations. We are now witnessing a shift toward the construction of archives as well as tailored forms of visualization including the use of virtual reality simulators and planetarium domes, and a coupling of both with budding efforts in constructing virtual observatories. This review describes these new trends, presenting Starlab as the first example of a full software environment for realistic large-scale simulations of dense stellar systems.

[ascl:1108.006]
STARLIGHT: Spectral Synthesis Code

The study of stellar populations in galaxies is entering a new era with the availability of large and high quality databases of both observed galactic spectra and state-of-the-art evolutionary synthesis models. The power of spectral synthesis can be investigated as a mean to estimate physical properties of galaxies. Spectral synthesis is nothing more than the decomposition of an observed spectrum in terms of a superposition of a base of simple stellar populations of various ages and metallicities, producing astrophysically interesting output such as the star-formation and chemical enrichment histories of a galaxy, its extinction and velocity dispersion. This is what the STARLIGHT spectral synthesis code does.

[ascl:1411.022]
Starlink Figaro: Starlink version of the Figaro data reduction software package

Shortridge, Keith; Meyerdierks, Horst; Currie, Malcolm J.; Davenhall, Clive; Jenness, Tim; Clayton, Martin

Starlink Figaro is an independently-maintained fork of Figaro (ascl:1203.013) that runs in the Starlink software environment (ascl:1110.012). It is a general-purpose data reduction package targeted mainly at optical/IR spectroscopy. It uses the NDF data format and the ADAM libraries for parameters and messaging.

[ascl:1110.012]
Starlink: Multi-purpose Astronomy Software

Starlink has many applications within it to meet a variety of needs; it includes:

- a general astronomical image viewer;
- data reduction tools, including programs for reducing CCD-like data;
- general-purpose data-analysis and visualisation tools;
- image processing, data visualisation, and manipulating NDF components;
- a flexible and powerful library for handling World Coordinate Systems (partly based on the SLALIB library);
- a library of routines intended to make accurate and reliable positional-astronomy applications easier to write; and
- and a Hierarchical Data System that is portable and flexible for storing and retrieving data.

[ascl:1406.020]
STARMAN: Stellar photometry and image/table handling

STARMAN is a stellar photometry package designed for the reduction of data from imaging systems. Its main components are crowded-field photometry programs, aperture photometry programs, a star finding program, and a CCD reduction program.

Image and table handling are served by a large number of programs which have a general use in photometry and other types of work. The package is a coherent whole, for use in the entire process of stellar photometry from raw images to the final standard-system magnitudes and their plotting as color-magnitude and color-color diagrams. It was distributed as part of the Starlink software collection (ascl:1110.012).

[ascl:1609.002]
StarPy: Quenched star formation history parameters of a galaxy using MCMC

Smethurst, R. J.; Lintott, C. J.; Simmons, B. D.; Schawinski, K.; Marshall, P. J.; Bamford, S.; Fortson, L.; Kaviraj, S.; Masters, K. L.; Melvin, T.; Nichol, R. C.; Skibba, R. A.; Willett, K. W.

StarPy derives the quenching star formation history (SFH) of a single galaxy through the Bayesian Markov Chain Monte Carlo method code *emcee* (ascl:1303.002). The sample function implements the emcee EnsembleSampler function for the galaxy colors input. Burn-in is run and calculated for the length specified before the sampler is reset and then run for the length of steps specified. StarPy provides the ability to use the look-up tables provided or creating your own.

[ascl:1810.005]
STARRY: Analytic computation of occultation light curves

Luger, Rodrigo; Agol, Eric; Foreman-Mackey, Daniel; Fleming, David P.; Lustig-Yaeger, Jacob; Deitrick, Russell

STARRY computes light curves for various applications in astronomy: transits and secondary eclipses of exoplanets, light curves of eclipsing binaries, rotational phase curves of exoplanets, light curves of planet-planet and planet-moon occultations, and more. By modeling celestial body surface maps as sums of spherical harmonics, STARRY does all this analytically and is therefore fast, stable, and differentiable. Coded in C++ but wrapped in Python, STARRY is easy to install and use.

[ascl:1107.008]
STARS: A Stellar Evolution Code

Eggleton, P. P.; Tout, Christopher; Pols, Onno; Izzard, Rob; Eldridge, John; Lesaffre, Pierre; Stancliffe, Richard; Church, Ross; Lau, Herbert

We have developed a detailed stellar evolution code capable of following the simultaneous evolution of both stars in a binary system, together with their orbital properties. To demonstrate the capabilities of the code we investigate potential progenitors for the Type IIb supernova 1993J, which is believed to have been an interacting binary system prior to its primary exploding. We use our detailed binary stellar evolution code to model this system to determine the possible range of primary and secondary masses that could have produced the observed characteristics of this system, with particular reference to the secondary. Using the luminosities and temperatures for both stars (as determined by Maund et al. 2004) and the remaining mass of the hydrogen envelope of the primary at the time of explosion, we find that if mass transfer is 100 per cent efficient the observations can be reproduced by a system consisting of a 15 solar mass primary and a 14 solar mass secondary in an orbit with an initial period of 2100 days. With a mass transfer efficiency of 50 per cent, a more massive system consisting of a 17 solar mass primary and a 16 solar mass secondary in an initial orbit of 2360 days is needed. We also investigate some of the uncertainties in the evolution, including the effects of tidal interaction, convective overshooting and thermohaline mixing.

[ascl:1703.005]
starsense_algorithms: Performance evaluation of various star sensors

Sarpotdar, Mayuresh; Mathew, Joice; Sreejith, A. G.; Nirmal, K.; Ambily, S.; Prakash, Ajin; Safonova, Margarita; Murthy, Jayant

The Matlab starsense_algorithms package evaluates the performance of various star sensors through the implementation of centroiding, geometric voting and QUEST algorithms. The physical parameters of a star sensor are parametrized and by changing these parameters, performance estimators such as sky coverage, memory requirement, and timing requirements can be estimated for the selected star sensor.

[ascl:1805.010]
StarSmasher: Smoothed Particle Hydrodynamics code for smashing stars and planets

Smoothed Particle Hydrodynamics (SPH) is a Lagrangian particle method that approximates a continuous fluid as discrete nodes, each carrying various parameters such as mass, position, velocity, pressure, and temperature. In an SPH simulation the resolution scales with the particle density; StarSmasher is able to handle both equal-mass and equal number-density particle models. StarSmasher solves for hydro forces by calculating the pressure for each particle as a function of the particle's properties - density, internal energy, and internal properties (e.g. temperature and mean molecular weight). The code implements variational equations of motion and libraries to calculate the gravitational forces between particles using direct summation on NVIDIA graphics cards. Using a direct summation instead of a tree-based algorithm for gravity increases the accuracy of the gravity calculations at the cost of speed. The code uses a cubic spline for the smoothing kernel and an artificial viscosity prescription coupled with a Balsara Switch to prevent unphysical interparticle penetration. The code also implements an artificial relaxation force to the equations of motion to add a drag term to the calculated accelerations during relaxation integrations. Initially called StarCrash, StarSmasher was developed originally by Rasio.

[ascl:1704.004]
STATCONT: Statistical continuum level determination method for line-rich sources

STATCONT determines the continuum emission level in line-rich spectral data by inspecting the intensity distribution of a given spectrum by using different statistical approaches. The sigma-clipping algorithm provides the most accurate continuum level determination, together with information on the uncertainty in its determination; this uncertainty is used to correct the final continuum emission level. In general, STATCONT obtains accuracies of < 10 % in the continuum determination, and < 5 % in most cases. The main products of the software are the continuum emission level, together with its uncertainty, and data cubes containing only spectral line emission, i.e. continuum-subtracted data cubes. STATCONT also includes the option to estimate the spectral index or variation of the continuum emission with frequency.

[ascl:1206.006]
statpl: Goodness-of-fit for power-law distributed data

statpl estimates the parameter of power-law distributed data and calculates goodness-of-fit tests for them. Many objects studied in astronomy follow a power-law distribution function (DF), for example the masses of stars or star clusters. Such data is often analyzed by generating a histogram and fitting a straight line to it. The parameters obtained in this way can be severely biased, and the properties of the underlying DF, such as its shape or a possible upper limit, are difficult to extract. statpl is an (effectively) bias-free estimator for the exponent and the upper limit.

[ascl:1108.018]
STECKMAP: STEllar Content and Kinematics via Maximum A Posteriori likelihood

STECKMAP stands for STEllar Content and Kinematics via Maximum A Posteriori likelihood. It is a tool for interpreting galaxy spectra in terms of their stellar populations through the derivation of their star formation history, age-metallicity relation, kinematics and extinction. The observed spectrum is projected onto a temporal sequence of models of single stellar populations, so as to determine a linear combination of these models that best fits the observed spectrum. The weights of the various components of this linear combination indicate the stellar content of the population. This procedure is regularized using various penalizing functions. The principles of the method are detailed in Ocvirk et al. 2006.

[ascl:1108.013]
STELLA: Multi-group Radiation Hydrodynamics Code

STELLA is a one-dimensional multi-group radiation hydrodynamics code. STELLA incorporates implicit hydrodynamics coupled to a multi-group non-equilibrium radiative transfer for modeling SN II-L light curves. The non-equilibrium description of radiation is crucial for this problem since the presupernova envelope may be of low mass and very dilute. STELLA implicitly treats time dependent equations of the angular moments of intensity averaged over a frequency bin. Local thermodynamic equilibrium is assumed to determine the ionization levels of materials.

[ascl:1505.009]
StellaR: Stellar evolution tracks and isochrones tools

stellaR accesses and manipulates publicly available stellar evolutionary tracks and isochrones from the Pisa low-mass database. It retrieves and plots the required calculations from CDS, constructs by interpolation tracks or isochrones of compositions different to the ones available in the database, constructs isochrones for age not included in the database, and extracts relevant evolutionary points from tracks or isochrones.

[ascl:1303.028]
Stellarics: Inverse Compton scattering from stellar heliospheres

Cosmic ray electrons scatter on the photon fields around stars, including the sun, to create gamma rays by the inverse Compton effect. Stellarics computes the spectrum and angular distribution of this emission. The software also includes general-purpose routines for inverse Compton scattering on a given electron spectrum, for example for interstellar or astrophysical source modelling.

[ascl:1901.012]
stellarWakes: Dark matter subhalo searches using stellar kinematic data

stellarWakes uses stellar kinematic data to search for dark matter (DM) subhalos through their gravitational perturbations to the stellar phase-space distribution.

[ascl:1809.014]
stepped_luneburg: Stacked-based ray tracing code to model a stepped Luneburg lens

stepped_luneburg investigates the scattered light properties of a Luneburg lens approximated as a series of concentric shells with discrete refractive indices. The optical Luneburg lens has promising applications for low-cost, continuous all-sky monitoring to obtain transit light curves of bright, nearby stars. This code implements a stack-based algorithm that tracks all reflected and refracted rays generated at each optical interface of the lens as described by Snell's law. The Luneburg lens model parameters, such as number of lens layers, the power-law that describes the refractive indices, the number of incident rays, and the initial direction of the incident wavefront can be altered to optimize lens performance. The stepped_luneburg module can be imported within the Python environment or used with scripting, and it is accompanied by two other modules, enc_int and int_map, that help the user to determine the resolving power of the lens and the strength of scattered light haloes for the purpose of quality assessment.

[ascl:1805.006]
StePS: Stereographically Projected Cosmological Simulations

StePS (Stereographically Projected Cosmological Simulations) compactifies the infinite spatial extent of the Universe into a finite sphere with isotropic boundary conditions to simulate the evolution of the large-scale structure. This eliminates the need for periodic boundary conditions, which are a numerical convenience unsupported by observation and which modifies the law of force on large scales in an unrealistic fashion. StePS uses stereographic projection for space compactification and naive O(N2) force calculation; this arrives at a correlation function of the same quality more quickly than standard (tree or P3M) algorithms with similar spatial and mass resolution. The N2 force calculation is easy to adapt to modern graphics cards, hence StePS can function as a high-speed prediction tool for modern large-scale surveys.

[ascl:1306.009]
STF: Structure Finder

STF is a general structure finder designed to find halos, subhaloes, and tidal debris in N-body simulations. The current version is designed to read in "particle data" (that is SPH N-body data), but a simple modification of the I/O can have it read grid data from Grid based codes.

[submitted]
stginga: Ginga for STScI

stginga customizes Ginga to aid data analysis for the data supported by STScI (e.g., HST or JWST). For instance, it provides plugins and configuration files that understand HST and JWST data products.

[ascl:1810.014]
STiC: Stockholm inversion code

STiC is a MPI-parallel non-LTE inversion code for observed full-Stokes observations. The code processes lines from multiple atoms in non-LTE, including partial redistribution effects of scattered photons in angle and frequency of scattered photons (PRD), and can be used with model atmospheres that have a complex depth stratification without introducing artifacts.

[ascl:1110.006]
STIFF: Converting Scientific FITS Images to TIFF

STIFF is a program that converts scientific FITS1 images to the more popular TIFF2 format for illustration purposes. Most FITS readers and converters do not do a proper job at converting FITS image data to 8 bits. 8-bit images stored in JPEG, PNG or TIFF files have the intensities implicitely stored in a non-linear way. Most current FITS image viewers and converters provide the user an incorrect translation of the FITS image content by simply rescaling linearly input pixel values. A first consequence is that the people working on astronomical images usually have to apply narrow intensity cuts or square-root or logarithmic intensity transformations to actually see something on their deep-sky images. A less obvious consequence is that colors obtained by combining images processed this way are not consistent across such a large range of surface brightnesses. Though with other software the user is generally afforded a choice of nonlinear transformations to apply in order to make the faint stuff stand out more clearly in the images, with the limited selection of choices provides, colors will not be accurately rendered, and some manual tweaking will be necessary. The purpose of STIFF is to produce beautiful pictures in an automatic and consistent way.

[ascl:1105.001]
STILTS: Starlink Tables Infrastructure Library Tool Set

The STIL Tool Set is a set of command-line tools based on STIL, the Starlink Tables Infrastructure Library. It deals with the processing of tabular data; the package has been designed for, but is not restricted to, astronomical tables such as object catalogues. Some of the tools are generic and can work with multiple formats (including FITS, VOTable, CSV, SQL and ASCII), and others are specific to the VOTable format. In some ways, STILTS forms the command-line counterpart of the GUI table analysis tool TOPCAT. The package is robust, fully documented, and designed for efficiency, especially with very large datasets.

Facilities offered include:

- format conversion
- crossmatching
- plotting
- column calculation and rearrangement
- row selections
- data and metadata manipulation and display
- sorting
- statistical calculations
- histogram calculation
- data validation
- VO service access

[ascl:1608.001]
Stingray: Spectral-timing software

Stingray is a spectral-timing software package for astrophysical X-ray (and more) data. The package merges existing efforts for a (spectral-)timing package in Python and is composed of a library of time series methods (including power spectra, cross spectra, covariance spectra, and lags); scripts to load FITS data files from different missions; a simulator of light curves and event lists that includes different kinds of variability and more complicated phenomena based on the impulse response of given physical events (e.g. reverberation); and a GUI to ease the learning curve for new users.

[ascl:1204.009]
STOKES: Modeling Radiative Transfer and Polarization

STOKES was designed to perform three-dimensional radiative transfer simulations for astronomical applications. The code also considers the polarization properties of the radiation. The program is based on the Monte-Carlo method and treats optical and ultraviolet polarization induced by scattering off free electrons or dust grains. Emission and scattering regions can be arranged in various geometries within the model space, the computed continuum and line spectra can be evaluated at different inclinations and azimuthal viewing angles.

[ascl:1708.005]
STools: IDL Tools for Spectroscopic Analysis

STools contains a variety of simple tools for spectroscopy, such as reading an IRAF-formatted (multispec) echelle spectrum in FITS, measuring the wavelength of the center of a line, Gaussian convolution, deriving synthetic photometry from an input spectrum, and extracting and interpolating a MARCS model atmosphere (standard composition).

[ascl:1702.009]
stream-stream: Stellar and dark-matter streams interactions

Stream-stream analyzes the interaction between a stellar stream and a disrupting dark-matter halo. It requires galpy (ascl:1411.008), NEMO (ascl:1010.051), and the usual common scientific Python packages.

[ascl:1702.010]
streamgap-pepper: Effects of peppering streams with many small impacts

streamgap-pepper computes the effect of subhalo fly-bys on cold tidal streams based on the action-angle representation of streams. A line-of-parallel-angle approach is used to calculate the perturbed distribution function of a given stream segment by undoing the effect of all impacts. This approach allows one to compute the perturbed stream density and track in any coordinate system in minutes for realizations of the subhalo distribution down to 10^5 Msun, accounting for the stream's internal dispersion and overlapping impacts. This code uses galpy (ascl:1411.008) and the streampepperdf.py galpy extension, which implements the fast calculation of the perturbed stream structure.

[ascl:1106.021]
StringFast: Fast Code to Compute CMB Power Spectra induced by Cosmic Strings

StringFast implements a method for efficient computation of the C_l spectra induced by a network of strings, which is fast enough to be used in Markov Chain Monte Carlo analyses of future data. This code allows the user to calculate TT, EE, and BB power spectra (scalar [for TT and EE], vector, and tensor modes) for "wiggly" cosmic strings. StringFast uses the output of the public code CMBACT (ascl:1106.023). The properties of the strings are described by four parameters: Gμ—dimensionless string tension; v—rms transverse velocity (as fraction of c); α—"wiggliness"; ξ—comoving correlation length of the string network. It is written as a Fortran 90 module.

[ascl:1206.003]
STSDAS: IRAF Tools for Hubble Space Telescope data reduction

The Space Telescope Science Data Analysis System (STSDAS) is a software package for reducing and analyzing astronomical data. It is layered on top of IRAF and provides general-purpose tools for astronomical data analysis as well as routines specifically designed for HST data. In particular, STSDAS contains all the programs used for the calibration and reduction of HST data in the STScI post-observation processing pipelines.

[submitted]
stsynphot: synphot for HST and JWST

An extension to synphot (ascl:1811.001), stsynphot implements synthetic photometry package for HST and JWST support. The software constructs spectra from various grids of model atmosphere spectra, parameterized spectrum models, and atlases of stellar spectrophotometry. It also simulates observations specific to HST and JWST, computes photometric calibration parameters for any supported instrument mode, and plots instrument-specific sensitivity curves and calibration target spectra.

[ascl:1010.067]
Stuff: Simulating “Perfect” Astronomical Catalogues

Stuff is a program that simulates “perfect” astronomical catalogues. It generate object lists in ASCII which can read by the SkyMaker program to produce realistic astronomical fields. Stuff is part of the EFIGI development project.

[ascl:1401.010]
SunPy: Python for Solar Physicists

SunPy is a community-developed free and open-source software package for solar physics and is an alternative to the SolarSoft data analysis environment. SunPy provides data structures for representing the most common solar data types (images, lightcurves, and spectra) and integration with the Virtual Solar Observatory (VSO) and the Heliophysics Event Knowledgebase (HEK) for data acquisition.

[ascl:1303.030]
Sunrise: Radiation transfer through interstellar dust

Sunrise is a Monte Carlo radiation transfer code for calculating absorption and scattering of light to study the effects of dust in hydrodynamic simulations of interacting galaxies. It uses an adaptive mesh refinement grid to describe arbitrary geometries of emitting and absorbing/scattering media, with spatial dynamical range exceeding 10^{4}; it can efficiently generate images of the emerging radiation at arbitrary points in space and spectral energy distributions of simulated galaxies run with the Gadget, Gasoline, Arepo, Enzo or ART codes. In addition to the monochromatic radiative transfer typically used by Monte Carlo codes, Sunrise can propagate a range of wavelengths simultaneously. This "polychromatic" algorithm gives significant improvements in efficiency and accuracy when spectral features are calculated.

[ascl:1105.007]
Sunspot Models

This IDL code creates a thick magneto-static structure with parameters of a typical sunspot in a solar like photosphere - chromosphere. The variable parameters are field strength on the axis, radius, and Wilson depression (displacement of the atmosphere on the axis with respect to the field-free atmosphere). Output are magnetic field vector, pressure and density distributions with radius and height. The structure has azimuthal symmetry. The codes are relatively self explanatory and the download packages contain README files.

[ascl:1109.007]
SuperBayeS: Supersymmetry Parameters Extraction Routines for Bayesian Statistics

SuperBayeS is a package for fast and efficient sampling of supersymmetric theories. It uses Bayesian techniques to explore multidimensional SUSY parameter spaces and to compare SUSY predictions with observable quantities, including sparticle masses, collider observables, dark matter abundance, direct detection cross sections, indirect detection quantities etc. Scanning can be performed using Markov Chain Monte Carlo (MCMC) technology or even more efficiently by employing a new scanning technique called, MultiNest. which implements the nested sampling algorithm. Using MultiNest, a full 8-dimensional scan of the CMSSM takes about 12 hours on 10 2.4GHz CPUs. There is also an option for old-style fixed-grid scanning. A discussion forum for SuperBayeS is available.

The package combines SoftSusy, DarkSusy, FeynHiggs, Bdecay, MultiNest and MicrOMEGAs. Some of the routines and the plotting tools are based on CosmoMC.

SuperBayeS comes with SuperEGO, a MATLAB graphical user interface tool for interactive plotting of the results. SuperEGO has been developed by Rachid Lemrani and is based on CosmoloGUI by Sarah Bridle.

[ascl:1609.019]
SuperBoL: Module for calculating the bolometric luminosities of supernovae

SuperBoL calculates the bolometric lightcurves of Type II supernovae using observed photometry; it includes three different methods for calculating the bolometric luminosity: quasi-bolometric, direct, and bolometric correction. SuperBoL propagates uncertainties in the input data through the calculations made by the code, allowing for error bars to be included in plots of the lightcurve.

[ascl:1507.002]
SUPERBOX: Particle-multi-mesh code to simulate galaxies

SUPERBOX is a particle-mesh code that uses moving sub-grids to track and resolve high-density peaks in the particle distribution and a nearest grid point force-calculation scheme based on the second derivatives of the potential. The code implements a fast low-storage FFT-algorithm and allows a highly resolved treatment of interactions in clusters of galaxies, such as high-velocity encounters between elliptical galaxies and the tidal disruption of dwarf galaxies, as sub-grids follow the trajectories of individual galaxies. SUPERBOX is efficient in that the computational overhead is kept as slim as possible and is also memory efficient since it uses only one set of grids to treat galaxies in succession.

[ascl:1511.001]
SuperFreq: Numerical determination of fundamental frequencies of an orbit

SuperFreq numerically estimates the fundamental frequencies and orbital actions of pre-computed orbital time series. It is an implementation of a version of the Numerical Analysis of Fundamental Frequencies close to that by Monica Valluri, which itself is an implementation of an algorithm first used by Jacques Laskar.

[ascl:1109.014]
Supernova Flux-averaging Likelihood Code

Flux-averaging justifies the use of the distance-redshift relation for a smooth universe in the analysis of type Ia supernova (SN Ia) data. Flux-averaging of SN Ia data is required to yield cosmological parameter constraints that are free of the bias induced by weak gravitational lensing. SN Ia data are converted into flux. For a given cosmological model, the distance dependence of the data is removed, then the data are binned in redshift, and placed at the average redshift in each redshift bin. The likelihood of the given cosmological model is then computed using "flux statistics''. These Fortran codes compute the likelihood of an arbitrary cosmological model [with given H(z)/H_0] using flux-averaged Type Ia supernova data.

[ascl:1705.017]
supernovae: Photometric classification of supernovae

Supernovae classifies supernovae using their light curves directly as inputs to a deep recurrent neural network, which learns information from the sequence of observations. Observational time and filter fluxes are used as inputs; since the inputs are agnostic, additional data such as host galaxy information can also be included.

[ascl:1612.015]
Superplot: Graphical interface for plotting and analyzing data

Superplot calculates and plots statistical quantities relevant to parameter inference from a "chain" of samples drawn from a parameter space produced by codes such as MultiNest (ascl:1109.006), BAYES-X (ascl:1505.027), and PolyChord (ascl:1502.011). It offers a graphical interface for browsing a chain of many variables quickly and can produce numerous kinds of publication quality plots, including one- and two-dimensional profile likelihood, three-dimensional scatter plots, and confidence intervals and credible regions. Superplot can also save plots in PDF format, create a summary text file, and export a plot as a pickled object for importing and manipulating in a Python interpreter.

[ascl:1403.008]
SURF: Submm User Reduction Facility

SURF reduces data from the SCUBA instrument from the James Clerk Maxwell Telescope. Facilities are provided for reducing all the SCUBA observing modes including jiggle, scan and photometry modes. SURF uses the Starlink environment (ascl:1110.012).

[ascl:1809.007]
surfinBH: Surrogate final black hole properties for mergers of binary black holes

surfinBH predicts the final mass, spin and recoil velocity of the remnant of a binary black hole merger. Trained directly against numerical relativity simulations, these models are extremely accurate, reproducing the results of the simulations at the same level of accuracy as the simulations themselves. Fits such as these play a crucial role in waveform modeling and tests of general relativity with gravitational waves, performed by LIGO.

[ascl:1605.017]
Surprise Calculator: Estimating relative entropy and Surprise between samples

The Surprise is a measure for consistency between posterior distributions and operates in parameter space. It can be used to analyze either the compatibility of separately analyzed posteriors from two datasets, or the posteriors from a Bayesian update. The Surprise Calculator estimates relative entropy and Surprise between two samples, assuming they are Gaussian. The software requires the R package CompQuadForm to estimate the significance of the Surprise, and rpy2 to interface R with Python.

[ascl:1804.016]
surrkick: Black-hole kicks from numerical-relativity surrogate models

surrkick quickly and reliably extract recoils imparted to generic, precessing, black hole binaries. It uses a numerical-relativity surrogate model to obtain the gravitational waveform given a set of binary parameters, and from this waveform directly integrates the gravitational-wave linear momentum flux. This entirely bypasses the need of fitting formulae which are typically used to model black-hole recoils in astrophysical contexts.

[ascl:1208.012]
Swarm-NG: Parallel n-body Integrations

Dindar, Saleh; Ford, Eric B.; Juric, Mario; Young, In Yeo; Gao, Jianwei; Boley, Aaron C.; Nelson, Benjamin; Peters, Jorg

Swarm-NG is a C++ library for the efficient direct integration of many n-body systems using highly-parallel Graphics Processing Units (GPU). Swarm-NG focuses on many few-body systems, e.g., thousands of systems with 3...15 bodies each, as is typical for the study of planetary systems; the code parallelizes the simulation, including both the numerical integration of the equations of motion and the evaluation of forces using NVIDIA's "Compute Unified Device Architecture" (CUDA) on the GPU. Swarm-NG includes optimized implementations of 4th order time-symmetrized Hermite integration and mixed variable symplectic integration as well as several sample codes for other algorithms to illustrate how non-CUDA-savvy users may themselves introduce customized integrators into the Swarm-NG framework. Applications of Swarm-NG include studying the late stages of planet formation, testing the stability of planetary systems and evaluating the goodness-of-fit between many planetary system models and observations of extrasolar planet host stars (e.g., radial velocity, astrometry, transit timing). While Swarm-NG focuses on the parallel integration of many planetary systems,the underlying integrators could be applied to a wide variety of problems that require repeatedly integrating a set of ordinary differential equations many times using different initial conditions and/or parameter values.

[ascl:1010.068]
SWarp: Resampling and Co-adding FITS Images Together

SWarp resamples and co-adds together FITS images using any arbitrary astrometric projection defined in the WCS standard. It operates on pre-reduced images and their weight-maps. Based on the astrometric and photometric calibrations derived at an earlier phase of the pipeline, SWarp re-maps ("warps") the pixels to a perfect projection system, and co-adds them in an optimum way, according to their relative weights. SWarp's astrometric engine is based on a customized version of Calabretta's WCSLib 2.6 and supports all of the projections defined in the 2000 version of the WCS proposal.

[ascl:1303.001]
SWIFT: A solar system integration software package

SWIFT follows the long-term dynamical evolution of a swarm of test particles in the solar system. The code efficiently and accurately handles close approaches between test particles and planets while retaining the powerful features of recently developed mixed variable symplectic integrators. Four integration techniques are included: Wisdom-Holman Mapping; Regularized Mixed Variable Symplectic (RMVS) method; fourth order T+U Symplectic (TU4) method; and Bulirsch-Stoer method. The package is designed so that the calls to each of these look identical so that it is trivial to replace one with another. Complex data manipulations and results can be analyzed with the graphics packace SwiftVis.

[ascl:1805.020]
SWIFT: SPH With Inter-dependent Fine-grained Tasking

SWIFT runs cosmological simulations on peta-scale machines for solving gravity and SPH. It uses the Fast Multipole Method (FMM) to calculate gravitational forces between nearby particles, combining these with long-range forces provided by a mesh that captures both the periodic nature of the calculation and the expansion of the simulated universe. SWIFT currently uses a single fixed but time-variable softening length for all the particles. Many useful external potentials are also available, such as galaxy haloes or stratified boxes that are used in idealised problems. SWIFT implements a standard LCDM cosmology background expansion and solves the equations in a comoving frame; equations of state of dark-energy evolve with scale-factor. The structure of the code allows implementation for modified-gravity solvers or self-interacting dark matter schemes to be implemented. Many hydrodynamics schemes are implemented in SWIFT and the software allows users to add their own.

[ascl:1112.018]
SwiftVis: Data Analysis & Visualization For Planetary Science

SwiftVis is a tool originally developed as part of a rewrite of Swift to be used for analysis and plotting of simulations performed with Swift and Swifter. The extensibility built into the design has allowed us to make SwiftVis a general purpose analysis and plotting package customized to be usable by the planetary science community at large. SwiftVis is written in Java and has been tested on Windows, Linux, and Mac platforms. Its graphical interface allows users to do complex analysis and plotting without having to write custom code.

[ascl:1606.001]
SWOC: Spectral Wavelength Optimization Code

SWOC (Spectral Wavelength Optimization Code) determines the wavelength ranges that provide the optimal amount of information to achieve the required science goals for a spectroscopic study. It computes a figure-of-merit for different spectral configurations using a user-defined list of spectral features, and, utilizing a set of flux-calibrated spectra, determines the spectral regions showing the largest differences among the spectra.

[ascl:1707.007]
swot: Super W Of Theta

SWOT (Super W Of Theta) computes two-point statistics for very large data sets, based on “divide and conquer” algorithms, mainly, but not limited to data storage in binary trees, approximation at large scale, parellelization (open MPI), and bootstrap and jackknife resampling methods “on the fly”. It currently supports projected and 3D galaxy auto and cross correlations, galaxy-galaxy lensing, and weighted histograms.

[ascl:1806.019]
SYGMA: Modeling stellar yields for galactic modeling

SYGMA (Stellar Yields for Galactic Modeling Applications) follows the ejecta of simple stellar populations as a function of time to model the enrichment and feedback from simple stellar populations. It is the basic building block of the galaxy code One-zone Model for the Evolution of GAlaxies (OMEGA, ascl:1806.018) and is part of the NuGrid Python Chemical Evolution Environment (NuPyCEE, ascl:1610.015). Stellar yields of AGB and massive stars are calculated with the same nuclear physics and are provided by the NuGrid collaboration.

[ascl:1308.008]
SYN++: Standalone SN spectrum synthesis

SYN++ is a standalone SN spectrum synthesis program. It is a rewrite of the original SYNOW (ascl:1010.055) code in modern C++. It offers further enhancements, a new structured input control file format, and the atomic data files have been repackaged and are more complete than those of SYNOW.

[ascl:1308.007]
SYNAPPS: Forward-modeling of supernova spectroscopy data sets

SYNAPPS is a spectrum fitter embedding a highly parameterized synthetic SN spectrum calculation within a parallel asynchronous optimizer. This open-source code is aimed primarily at the problem of systematically interpreting large sets of SN spectroscopy data.

[ascl:1302.014]
SYNMAG Photometry: Catalog-level Matched Colors of Extended Sources

Bundy, Kevin; Hogg, David W.; Higgs, Tim D.; Nichol, Robert C.; Yasuda, Naoki; Masters, Karen L.; Lang, Dustin; Wake, David A.

SYNMAG is a tool for producing synthetic aperture magnitudes to enable fast matched photometry at the catalog level without reprocessing imaging data. Aperture magnitudes are the most widely tabulated flux measurements in survey catalogs; obtaining reliable, matched photometry for galaxies imaged by different observatories represents a key challenge in the era of wide-field surveys spanning more than several hundred square degrees. Methods such as flux fitting, profile fitting, and PSF homogenization followed by matched-aperture photometry are all computationally expensive. An alternative solution called "synthetic aperture photometry" exploits galaxy profile fits in one band to efficiently model the observed, point-spread-function-convolved light profile in other bands and predict the flux in arbitrarily sized apertures.

[ascl:1010.055]
SYNOW: A Highly Parameterized Spectrum Synthesis Code for Direct Analysis of SN Spectra

SYNOW is a highly parameterized spectrum synthesis code used primarily for direct (empirical) analysis of SN spectra. The code is based on simple assumptions : spherical symmetry; homologous expansion; a sharp photosphere that emits a blackbody continuous spectrum; and line formation by resonance scattering, treated in the Sobolev approximation. Synow does not do continuum transport, it does not solve rate equations, and it does not calculate ionization ratios. Its main function is to take line multiple scattering into account so that it can be used in an empirical spirit to make line identifications and estimate the velocity at the photosphere (or pseudo-photosphere) and the velocity interval within which each ion is detected. these quantities provide constraints on the composition structure of the ejected matter.

[ascl:1811.001]
synphot: Synthetic photometry using Astropy

Synphot simulates photometric data and spectra, observed or otherwise. It can incorporate the user's filters, spectra, and data, and use of a pre-defined standard star (Vega), bandpass, or extinction law. synphot can also construct complicated composite spectra using different models, simulate observations, and compute photometric properties such as count rate, effective wavelength, and effective stimulus. It can manipulate a spectrum by, for example, applying redshift, or normalize it to a given flux value in a given bandpass. Synphot can also sample a spectrum at given wavelengths, plot a quick-view of a spectrum, and perform repetitive operations such as simulating the observations of multiple type of sources through multiple bandpasses. Synphot understands Astropy (ascl:1304.002) models and units and is an Astropy affiliated package.

[ascl:1109.022]
Synspec: General Spectrum Synthesis Program

Synspec is a user-oriented package written in FORTRAN for modeling stellar atmospheres and for stellar spectroscopic diagnostics. It assumes an existing model atmosphere, calculated previously with Tlusty or taken from the literature (for instance, from the Kurucz grid of models). The opacity sources (continua, atomic and molecular lines) are fully specified by the user. An arbitrary stellar rotation and instrumental profile can be applied to the synthetic spectrum.

[ascl:1212.010]
Synth3: Non-magnetic spectrum synthesis code

Synth3 is a non-magnetic spectrum synthesis code. It works with model atmospheres in Kurucz format and VALD Sf line lists and features element stratification, molecular equilibrium and individual microturbulence for each line. Disk integration can be done with s3di which is included in the archive. Synth3 computes spectra emergent from the stellar atmospheres with a depth-dependent chemical composition if depth-dependent abundance is provided in the input model atmosphere file.

[ascl:1210.018]
Systemic Console: Advanced analysis of exoplanetary data

Systemic Console is a tool for advanced analysis of exoplanetary data. It comprises a graphical tool for fitting radial velocity and transits datasets and a library of routines for non-interactive calculations. Among its features are interactive plotting of RV curves and transits, combined fitting of RV and transit timing (primary and secondary), interactive periodograms and FAP estimation, and bootstrap and MCMC error estimation. The console package includes public radial velocity and transit data.

[ascl:1304.018]
SZpack: Computation of Sunyaev-Zeldovich (SZ) signals

SZpack is a numerical library which allows fast and precise computation of the Sunyaev-Zeldovich (SZ) signal for hot, moving clusters of galaxies. Both explicit numerical integration as well as approximate representation of the SZ signals can be obtained. Variations of the electron temperature and bulk velocity along the line-of-sight can be included. SZpack allows very fast and precise (<~0.001% at frequencies h nu <~ 30kT_g and electron temperature kTe ~ 75 keV) computation and its accuracy practically eliminates uncertainties related to more expensive numerical evaluation of the Boltzmann collision term. It furthermore cleanly separates kinematic corrections from scattering physics, effects that previously have not been clarified.

[ascl:1511.006]
T-Matrix: Codes for Computing Electromagnetic Scattering by Nonspherical and Aggregated Particles

The T-Matrix package includes codes to compute electromagnetic scattering by homogeneous, rotationally symmetric nonspherical particles in fixed and random orientations, randomly oriented two-sphere clusters with touching or separated components, and multi-sphere clusters in fixed and random orientations. All codes are written in Fortran-77. LAPACK-based, extended-precision, Gauss-elimination- and NAG-based, and superposition codes are available, as are double-precision superposition, parallelized double-precision, double-precision Lorenz-Mie codes, and codes for the computation of the coefficients for the generalized Chebyshev shape.

[ascl:1609.001]
T-PHOT: PSF-matched, prior-based, multiwavelength extragalactic deconfusion photometry

Merlin, E.; Fontana, A.; Ferguson, H. C.; Dunlop, J. S.; Elbaz, D.; Bourne, N.; Bruce, V. A.; Buitrago, F.; Castellano, M.; Schreiber, C.; Grazian, A.; McLure, R. J.; Okumura, K.; Shu, X.; Wang, T.; Amorín, R.; Boutsia, K.; Cappelluti, N.; Comastri, A.; Derriere, S.; Faber, S. M.; Santini, P.

T-PHOT extracts accurate photometry from low-resolution images of extragalactic fields, where the blending of sources can be a serious problem for accurate and unbiased measurement of fluxes and colors. It gathers data from a high-resolution image of a region of the sky and uses the source positions and morphologies to obtain priors for the photometric analysis of the lower resolution image of the same field. T-PHOT handles different types of datasets as input priors, including a list of objects that will be used to obtain cutouts from the real high-resolution image, a set of analytical models (as .fits stamps), and a list of unresolved, point-like sources, useful for example for far-infrared wavelength domains. T-PHOT yields accurate estimations of fluxes within the intrinsic uncertainties of the method when systematic errors are taken into account (which can be done using a flagging code given in the output), and handles multiwavelength optical to far-infrared image photometry. T-PHOT was developed as part of the ASTRODEEP project (www.astrodeep.eu).

[ascl:1403.014]
T(dust) as a function of sSFR

This IDL code returns the dust temperature of a galaxy from its redshift, SFR and stellar mass; it can also predict the observed monochromatic fluxes of the galaxy. These monochromatic fluxes correspond to those of a DH SED template with the appropriate dust temperature and the appropriate normalization. Dust temperatures and fluxes predictions are only valid and provided in the redshift, stellar mass, SSFR and wavelength ranges 0 < z < 2.5, Mstar> 10^10 Msun, 10^-11 < SSFR[yr-1]< 10^-7 and 30um < lambda_rest < 2mm.

[ascl:1210.006]
TA-DA: A Tool for Astrophysical Data Analysis

TA-DA is a pre-compiled IDL widget-based application which greatly simplifies and improves the analysis of stellar photometric data in comparison with theoretical models and allows the derivation of stellar parameters from multi-band photometry. It is flexible and can address a number of problems, from the interpolation of stellar models or sets of stellar physical parameters in general to the computation of synthetic photometry in arbitrary filters or units. It also analyzes observed color-magnitude diagrams and allows a Bayesian derivation of stellar parameters (and extinction) based on multi-band data.

[ascl:1303.010]
TAC-maker: Transit Analytical Curve maker

TAC-maker allows for rapid and interactive calculation of synthetic planet transits by numerical computations of the integrals, allowing the use of an arbitrary limb-darkening law of the host star. This advantage together with the practically arbitrary precision of the calculations makes the code a valuable tool for the continuously increasing photometric precision of ground-based and space observations.

[ascl:1512.020]
TACT: The Action Computation Tool

The Action Computation Tool (TACT) tests methods for estimating actions, angles and frequencies of orbits in both axisymmetric and triaxial potentials, including general spherical potentials, analytic potentials (Isochrone and Harmonic oscillator), axisymmetric Stackel fudge, average generating function from orbit (AvGF), and others. It is written in C++; code is provided to compile the routines into a Python library. TM (ascl:1512.014) and LAPACK are required to access some features.

[ascl:1602.013]
TailZ: Redshift distributions estimator of photometric samples of galaxies

TailZ estimates redshift distributions of photometric samples of galaxies selected photometrically given a subsample with measured spectroscopic redshifts. The approach uses a non-parametric Voronoi tessellation density estimator to interpolate the galaxy distribution in the redshift and photometric color space. The Voronoi tessellation estimator performs well at reconstructing the tails of the redshift distribution of individual galaxies and gives unbiased estimates of the first and second moments.

[submitted]
taktent: A Python framework for agent-based simulations of SETI observations

This Python package allows the user to setup and run an agent-based simulation of a SETI survey. The package allows the creation of a population of observing and transmitting civilisations. Each transmitter and observer conducts their activities according to an input strategy. The success of observers and transmitters can then be recorded, and multiple simulations can be run for Monte Carlo Realisation.

This package is therefore a flexible framework in which to simulate and test different SETI strategies, both as an Observer and as a Transmitter. It is primarily designed with radio SETI in mind, but is sufficiently flexible to simulate all forms of electromagnetic SETI, and potentially neutrino and gravitational wave SETI.

[ascl:1202.004]
TALYS: Nuclear Reaction Simulator

TALYS simulates nuclear reactions which involve neutrons, gamma-rays, protons, deuterons, tritons, helions and alpha-particles, in the 1 keV-200MeV energy range. A suite of nuclear reaction models has been implemented into a single code system, enabling one to evaluate basically all nuclear reactions beyond the resonance range. In particular, TALYS estimates the Maxwellian-averaged reaction rates that are of astrophysical relevance. This enables reaction rates to be calculated with increased accuracy and reliability and the approximations of previous codes to be investigated. The TALYS predictions for the thermonuclear rates of relevance to astrophysics are detailed and compared with those derived by widely-used codes for the same nuclear ingredients. TALYS predictions may differ significantly from those of previous codes, in particular for nuclei for which no or little nuclear data is available. The pre-equilibrium process is shown to influence the astrophysics rates of exotic neutron-rich nuclei significantly. The TALYS code provides a tool to estimate all nuclear reaction rates of relevance to astrophysics with improved accuracy and reliability.

[ascl:1503.003]
TAME: Tool for Automatic Measurement of Equivalent-width

TAME measures the equivalent width (EWs) in high-resolution spectra. Written by IDL, TAME provides the EWs of spectral lines by profile fitting in an automatic or interactive mode and is reliable for measuring EWs in a spectrum with a spectral resolution of R ≳ 20000. It offers an interactive mode for more flexible measurement of the EW and a fully automatic mode that can simultaneously measure the EWs for a large set of lines.

[ascl:1306.007]
Tapir: A web interface for transit/eclipse observability

Tapir is a set of tools, written in Perl, that provides a web interface for showing the observability of periodic astronomical events, such as exoplanet transits or eclipsing binaries. The package provides tools for creating finding charts for each target and airmass plots for each event. The code can access target lists that are stored on-line in a Google spreadsheet or in a local text file.

[ascl:1402.018]
TARDIS: Temperature And Radiative Diffusion In Supernovae

TARDIS creates synthetic spectra for supernova ejecta and is sufficiently fast to allow exploration of the complex parameter spaces of models for SN ejecta. TARDIS uses Monte Carlo methods to obtain a self-consistent description of the plasma state and to compute a synthetic spectrum. It is written in Python with a modular design that facilitates the implementation of a range of physical approximations that can be compared to assess both accuracy and computational expediency; this allows users to choose a level of sophistication appropriate for their application.

[ascl:1305.014]
TAU: 1D radiative transfer code for transmission spectroscopy of extrasolar planet atmospheres

TAU is a 1D line-by-line radiative transfer code for modeling transmission spectra of close-in extrasolar planets. The code calculates the optical path through the planetary atmosphere of the radiation from the host star and quantifies the absorption due to the modeled composition in a transmission spectrum of transit depth as a function of wavelength. The code is written in C++ and is parallelized using OpenMP.

[ascl:1807.024]
TBI: Three-Body Integration

Three-Body Integration performs numerical n-body simulations for mapping conditions for close approaches for the relevant parameter space of configurations and mass values of two white dwarfs and a third star. Low tertiary masses of 0.1M⊙ can be studied, and the collision probability can be estimated with good confidence for the case of nearly equal mass white dwarfs.

[ascl:1505.031]
TEA: Thermal Equilibrium Abundances

TEA (Thermal Equilibrium Abundances) calculates gaseous molecular abundances under thermochemical equilibrium conditions. Given a single T,P point or a list of T,P pairs (the thermal profile of an atmosphere) and elemental abundances, TEA calculates mole fractions of the desired molecular species. TEA uses 84 elemental species and thermodynamical data for more then 600 gaseous molecular species, and can adopt any initial elemental abundances.

[ascl:1405.002]
TelFit: Fitting the telluric absorption spectrum

TelFit calculates the best-fit telluric absorption spectrum in high-resolution optical and near-IR spectra. The best-fit model can then be divided out to remove the telluric contamination. Written in Python, TelFit is essentially a wrapper to LBLRTM, the Line-By-Line Radiative Transfer Model, and simplifies the process of generating a telluric model.

[ascl:1509.002]
Tempo: Pulsar timing data analysis

Nice, D; Demorest, P.; Stairs, I.; Manchester, R.; Taylor, J.; Peters, W.; Weisberg, J.; Irwin, A.; Wex, N.; Huang, Y.

Tempo analyzes pulsar timing data. Pulse times of arrival (TOAs), pulsar model parameters, and coded instructions are read from one or more input files. The TOAs are fitted by a pulse timing model incorporating transformation to the solar-system barycenter, pulsar rotation and spin-down and, where necessary, one of several binary models. Program output includes parameter values and uncertainties, residual pulse arrival times, chi-squared statistics, and the covariance matrix of the model. In prediction mode, ephemerides of pulse phase behavior (in the form of polynomial expansions) are calculated from input timing models. Tempo is the basis for the Tempo2 (ascl:1210.015) code.

[ascl:1210.015]
Tempo2: Pulsar Timing Package

Tempo2 is a pulsar timing package developed to be used both for general pulsar timing applications and also for pulsar timing array research in which data-sets from multiple pulsars need to be processed simultaneously. It was initially developed by George Hobbs and Russell Edwards as part of the Parkes Pulsar Timing Array project. Tempo2 is based on the original Tempo (ascl:1509.002) code and can be used (from the command-line) in a similar fashion. It is very versatile and can be extended by plugins.

[ascl:1611.002]
tf_unet: Generic convolutional neural network U-Net implementation in Tensorflow

tf_unet mitigates radio frequency interference (RFI) signals in radio data using a special type of Convolutional Neural Network, the U-Net, that enables the classification of clean signal and RFI signatures in 2D time-ordered data acquired from a radio telescope. The code is not tied to a specific segmentation and can be used, for example, to detect radio frequency interference (RFI) in radio astronomy or galaxies and stars in widefield imaging data. This U-Net implementation can outperform classical RFI mitigation algorithms.

[ascl:1505.019]
TFIT: Mixed-resolution data set photometry package

Laidler, Victoria G.; Papovich, Casey; Grogin, Norman A.; Idzi, Rafal; Dickinson, Mark; Ferguson, Henry C.; Hilbert, Bryan; Clubb, Kelsey; Ravindranath, Swara

TFIT measures galaxy photometry using prior knowledge of sources in a deep, high‐resolution image (HRI) to improve photometric measurements of objects in a corresponding low‐resolution image (LRI) of the same field, usually at a different wavelength. For background‐limited data, this technique produces optimally weighted photometry that maximizes signal‐to‐noise ratio (S/N). For objects not significantly detected in the low‐resolution image, it provides useful and quantitative information for setting upper limits.

This code is no longer updated and has been superseded by T-PHOT (ascl:1609.001).

[ascl:1303.012]
TGCat: Chandra Transmission Grating Catalog and Archive

TGCat is an archive of Chandra transmission grating spectra and a suite of software for processing such data. Users can browse and categorize Chandra gratings observations quickly and easily, generate custom plots of resulting response corrected spectra on-line without the need for special software and download analysis ready products from multiple observations in one convenient operation. Data processing for the catalog is done with a suite of ISIS/S-Lang scripts; the software is available for download. These ISIS scripts wrap and call CIAO tools for reprocessing from "Level 1" (acis_process_events or hrc_process_events) through "Level 2" (binned spectra, via tg_resolve_events and tgextract), compute responses (grating "RMFs" and "ARFs", via mkgrmf and mkgarf), and make summary plots.

[ascl:1602.010]
The Cannon: Data-driven method for determining stellar parameters and abundances from stellar spectra

The Cannon is a data-driven method for determining stellar labels (physical parameters and chemical abundances) from stellar spectra in the context of vast spectroscopic surveys. It fits for the spectral model given training spectra and labels, with the polynomial order for the spectral model decided by the user, infers labels for the test spectra, and provides diagnostic output for monitoring and evaluating the process. It offers SNR-independent continuum normalization, performs well at lower signal-to-noise, and is very accurate.

[ascl:1105.003]
The DTFE public software: The Delaunay Tessellation Field Estimator code

We present the DTFE public software, a code for reconstructing fields from a discrete set of samples/measurements using the maximum of information contained in the point distribution. The code is written in C++ using the CGAL library and is parallelized using OpenMP. The software was designed for the analysis of cosmological data but can be used in other fields where one must interpolate quantities given at a discrete point set. The software comes with a wide suite of options to facilitate the analysis of 2- and 3-dimensional data and of both numerical simulations and galaxy redshift surveys. For comparison purposes, the code also implements the TSC and SPH grid interpolation methods. The code comes with an extensive user guide detailing the program options, examples and the inner workings of the code.

[ascl:1405.003]
The Hammer: An IDL Spectral Typing Suite

The Hammer can classify spectra in a variety of formats with targets spanning the MK spectral sequence. It processes a list of input spectra by automatically estimating each object's spectral type and measuring activity and metallicity tracers in late type stars. Once automatic processing is complete, an interactive interface allows the user to manually tweak the final assigned spectral type through visual comparison with a set of templates.

[ascl:1701.001]
The Joker: A custom Monte Carlo sampler for binary-star and exoplanet radial velocity data

Given sparse or low-quality radial-velocity measurements of a star, there are often many qualitatively different stellar or exoplanet companion orbit models that are consistent with the data. The consequent multimodality of the likelihood function leads to extremely challenging search, optimization, and MCMC posterior sampling over the orbital parameters. The Joker is a custom-built Monte Carlo sampler that can produce a posterior sampling for orbital parameters given sparse or noisy radial-velocity measurements, even when the likelihood function is poorly behaved. The method produces correct samplings in orbital parameters for data that include as few as three epochs. The Joker can therefore be used to produce proper samplings of multimodal pdfs, which are still highly informative and can be used in hierarchical (population) modeling.

[ascl:1407.001]
The Starfish Diagram: Statistical visualization tool

The Starfish Diagram is a statistical visualization tool that simultaneously displays the properties of an individual and its parent sample through a series of histograms. The code is useful for large datasets for which one needs to understand the standing or significance of a single entry.

[ascl:1604.008]
The Tractor: Probabilistic astronomical source detection and measurement

The Tractor optimizes or samples from models of astronomical objects. The approach is generative: given astronomical sources and a description of the image properties, the code produces pixel-space estimates or predictions of what will be observed in the images. This estimate can be used to produce a likelihood for the observed data given the model: assuming the model space actually includes the truth (it doesn’t, in detail), then if we had the optimal model parameters, the predicted image would differ from the actually observed image only by noise. Given a noise model of the instrument and assuming pixelwise independent noise, the log-likelihood is the negative chi-squared difference: (image - model) / noise.

[ascl:1706.008]
the-wizz: Clustering redshift estimation code

the-wizz clusters redshift estimates for any photometric unknown sample in a survey. The software is composed of two main parts: a pair finder and a pdf maker. The pair finder finds spatial pairs and stores the indices of all closer pairs around target reference objects in an output HDF5 data file. Users then query this data file using the indices of their unknown sample to produce an output clustering-z.

[ascl:1308.013]
THELI GUI: Optical, near- & mid-infrared imaging data reduction

THELI is an easy-to-use, end-to-end pipeline for the reduction of any optical, near-IR and mid-IR imaging data. It combines a variety of processing algorithms and third party software into a single, homogeneous tool. Over 90 optical and infrared instruments at observatories world-wide are pre-configured; more can be added by the user. The code's online appendix contains three walk-through examples using public data (optical, near-IR and mid-IR) and additional online documentation is available for training and troubleshooting.

[ascl:1112.003]
THERMINATOR 2: THERMal heavy IoN generATOR 2

THERMINATOR is a Monte Carlo event generator dedicated to studies of the statistical production of particles in relativistic heavy-ion collisions. The increased functionality of the code contains the following features: The input of any shape of the freeze-out hypersurface and the expansion velocity field, including the 3+1 dimensional profiles, in particular those generated externally with various hydrodynamic codes. The hypersufraces may have variable thermal parameters, which allows for studies departing significantly from the mid-rapidity region, where the baryon chemical potential becomes large. We include a library of standard sets of hypersurfaces and velocity profiles describing the RHIC Au+Au data at sqrt(s_(NN)) = 200 GeV for various centralities, as well as those anticipated for the LHC Pb+Pb collisions at sqrt(s_(NN)) = 5.5 TeV. A separate code, FEMTO-THERMINATOR, is provided to carry out the analysis of femtoscopic correlations which are an important source of information concerning the size and expansion of the system. We also include several useful scripts that carry out auxiliary tasks, such as obtaining an estimate of the number of elastic collisions after the freeze-out, counting of particles flowing back into the fireball and violating causality (typically very few), or visualizing various results: the particle p_T-spectra, the elliptic flow coefficients, and the HBT correlation radii. We also investigate the problem of the back-flow of particles into the hydrodynamic region, as well as estimate the elastic rescattering in terms of trajectory crossings. The package is written in C++ and uses the CERN ROOT environment.

[ascl:1711.016]
Thindisk: Protoplanetary disk model

Thindisk computes the line emission from a geometrically thin protoplanetary disk. It creates a datacube in FITS format that can be processed with a data reduction package (such as GILDAS, ascl:1305.010) to produce synthetic images and visibilities. These synthetic data can be compared with observations to determine the properties (e.g. central mass or inclination) of an observed disk. The disk is assumed to be in Keplerian rotation at a radius lower than the centrifugal radius (which can be set to a large value, for a purely Keplerian disk), and in infall with rotation beyond the centrifugal radius.

[ascl:1807.010]
THOR: Global Circulation Model for planetary atmospheres

THOR solves the three-dimensional nonhydrostatic Euler equations. The code implements an icosahedral grid for the poles where converging meridians lead to increasingly smaller time steps; irregularities in the grid are smoothed using spring dynamics. THOR is designed to run on graphics processing units (GPUs) and is part of the open-source Exoclimes Simulation Platform.

[ascl:1212.014]
Thrust: Productivity-Oriented Library for CUDA

Thrust is a parallel algorithms library which resembles the C++ Standard Template Library (STL). Thrust's high-level interface greatly enhances programmer productivity while enabling performance portability between GPUs and multicore CPUs. Interoperability with established technologies (such as CUDA, TBB, and OpenMP) facilitates integration with existing software.

[ascl:1609.021]
TIDEV: Tidal Evolution package

TIDEV (Tidal Evolution package) calculates the evolution of rotation for tidally interacting bodies using Efroimsky-Makarov-Williams (EMW) formalism. The package integrates tidal evolution equations and computes the rotational and dynamical evolution of a planet under tidal and triaxial torques. TIDEV accounts for the perturbative effects due to the presence of the other planets in the system, especially the secular variations of the eccentricity. Bulk parameters include the mass and radius of the planet (and those of the other planets involved in the integration), the size and mass of the host star, the Maxwell time and Andrade's parameter. TIDEV also calculates the time scale that a planet takes to be tidally locked as well as the periods of rotation reached at the end of the spin-orbit evolution.

[ascl:1206.012]
Time Utilities

Time Utilities are software tools that, in principal, allow one to calculate BJD to a precision of 1 μs for any target from anywhere on Earth or from any spacecraft. As the quality and quantity of astrophysical data continue to improve, the precision with which certain astrophysical events can be timed becomes limited not by the data themselves, but by the manner, standard, and uniformity with which time itself is referenced. While some areas of astronomy (most notably pulsar studies) have required absolute time stamps with precisions of considerably better than 1 minute for many decades, recently new areas have crossed into this regime. In particular, in the exoplanet community, we have found that the (typically unspecified) time standards adopted by various groups can differ by as much as a minute. Left uncorrected, this ambiguity may be mistaken for transit timing variations and bias eccentricity measurements. We recommend using BJD_TDB, the Barycentric Julian Date in the Barycentric Dynamical Time standard for any astrophysical event. The BJD_TDB is the most practical absolute time stamp for extraterrestrial phenomena, and is ultimately limited by the properties of the target system. We compile a general summary of factors that must be considered in order to achieve timing precisions ranging from 15 minutes to 1 μs, and provide software for download and online webapps for use.

[ascl:1010.057]
Tiny Tim: Simulated Hubble Space Telescope PSFs

Tiny Tim generates simulated Hubble Space Telescope point spread functions (PSFs). It is written in C and distributed as source code and runs on a wide variety of UNIX and VMS systems. Tiny Tim includes mirror zonal errors, time dependent aberrations (for the pre-repair instruments), field dependent obscuration patterns (for WF/PC-1 and WFPC2), and filter passband effects. It can produce a normally sampled or subsampled PSF. Output is a FITS image file.

[ascl:1111.015]
TIPSY: Code for Display and Analysis of N-body Simulations

The development of TIPSY was motivated by the need to quickly display and analyze the results of N-body simulations. Most data visualization packages are designed for the display of gridded data, and hence are unsuitable for use with particle data. Therefore, a special package was built that could easily perform the following functions:

1.) Display particle positions (as points), and velocities (as line segments) from an arbitrary viewpoint;

2.) Zoom in to a chosen position. Due to their extremely clustered nature, structure of interest in an N-body simulation is often so small that it cannot be seen when looking at the simulation as a whole;

3.) Color particles to display scalar fields. Examples of such fields are potential energy, or for SPH particles, density and temperature;

4.) Selection of a subset of the particles for display and analysis. Regions of interest are generally small subsets of the simulation;

5.) Following selected particles from one timestep to another; and,

6.) Finding cumulative properties of a collection of particles. This usually involves just a sum over the particles.

The basic data structure is an array of particle structures. Since TIPSY was built for use with cosmological N-body simulations, there are actually three separate arrays for each of the types of particle used in such simulations: collisionless particles, SPH particles, and star particles. A single timestep is read into these arrays from a disk file. Display is done by finding the x and y coordinates of the particles in the rotated coordinate system, and storing them in arrays. Screen coordinates are calculated from these arrays according to the current zoom factor. Also, a software Z-buffer is maintained to save time if many particles project to the same screen pixel. There are several types of display. An "all plot" displays all particles colored according to their type. A "radial plot" will color particles according to the projection of the velocity along the line-of-sight. A "gas plot" will color gas according to SPH quantities such as density, temperature, neutral hydrogen fraction, etc. Subsets of particles are maintained using boxes." A box structure contains a bounding box, and an array of pointers to particles within the box. All display and analysis functions are performed on the "active box." By default all particles are loaded into box 0, which becomes the active box. If a new timestep is read from disk, all boxes are destroyed. A selection of particles can be followed between timesteps via a "mark" array. Marked particles are displayed in a different color, and the analysis functions can be told to only operate on the marked particles.

[ascl:1208.008]
TiRiFiC: Tilted Ring Fitting Code

Tilted Ring Fitting Code (TiRiFiC) is a prototype computer program to construct simulated (high-resolution) astronomical spectroscopic 3d-observations (data cubes) of simple kinematical and morphological models of rotating (galactic) disks. It is possible to automatically optimize the parameterizations of constructed model disks to fit spectroscopic (3d-) observations via a χ2 minimization. TiRiFiC is currently implemented as an add-on to the Groningen Image Processing System (GIPSY) software package and attempts to provide a method to automatically fit an extended tilted-ring model directly to a data cube.

[ascl:1108.012]
TITAN: General-purpose Radiation Hydrodynamics Code

TITAN is a general-purpose radiation hydrodynamics code developed at the Laboratory for Computational Astrophysics (NCSA, University of Illinois at Urbana-Champaign). TITAN solves the coupled sets of radiation transfer and fluid dynamics equations on an adaptive mesh in one spatial dimension.

[ascl:1109.021]
TLUSTY: Stellar Atmospheres, Accretion Disks, and Spectroscopic Diagnostics

TLUSTY is a user-oriented package written in FORTRAN77 for modeling stellar atmospheres and accretion disks and wide range of spectroscopic diagnostics. In the program's maximum configuration, the user may start from scratch and calculate a model atmosphere of a chosen degree of complexity, and end with a synthetic spectrum in a wavelength region of interest for an arbitrary stellar rotation and an arbitrary instrumental profile. The user may also model the vertical structure of annuli of an accretion disk.

[ascl:1512.014]
TM: Torus Mapper

TM (Torus Mapper) produces models for orbits in action-angle coordinates in axisymmetric potentials using torus mapping, a non-perturbative technique for creating orbital tori for specified values of the action integrals. It can compute a star's position at any time given an orbital torus and a star’s position at a reference time, and also provides a way to choose initial conditions for N-body simulations of realistic disc

galaxies that start in perfect equilibrium. TM provides some advantages over use of a standard time-stepper to

create orbits.

[ascl:1212.015]
TMAP: Tübingen NLTE Model-Atmosphere Package

The Tübingen NLTE Model-Atmosphere Package (TMAP) is a tool to calculate stellar atmospheres in spherical or plane-parallel geometry in hydrostatic and radiative equilibrium allowing departures from local thermodynamic equilibrium (LTE) for the population of atomic levels. It is based on the Accelerated Lambda Iteration (ALI) method and is able to account for line blanketing by metals. All elements from hydrogen to nickel may be included in the calculation with model atoms which are tailored for the aims of the user.

[ascl:1605.005]
TMBIDL: Single dish radio astronomy data reduction package

The IDL package reduces and analyzes radio astronomy data. It translates SDFITS files into TMBIDL format, and can average and display spectra, remove baselines, and fit Gaussian models.

[ascl:1209.007]
TMCalc: Fast estimation of stellar metallicity [Fe/H]

TMCalc is a C code developed as an extension to ARES. Using the line list given, the code can be used as a precise and fast indicator of the spectroscopic temperature and metallicity for dwarf FKG stars with effective temperatures ranging from 4500 K to 6500 K and with [Fe/H] ranging from -0.8 dex to 0.4 dex.

[ascl:1104.001]
TomograPy: A Fast, Instrument-Independent, Solar Tomography Software

TomograPy is an open-source software freely available on the Python Package Index that can perform fast tomographic inversions that scale linearly with the number of measurements, linearly with the length of the reconstruction cube (and not the number of voxels) and linearly with the number of cores and can use data from different sources and with a variety of physical models. For performance, TomograPy uses a parallelized-projection algorithm. It relies on the World Coordinate System standard to manage various data sources. A variety of inversion algorithms are provided to perform the tomographic-map estimation. A test suite is provided along with the code to ensure software quality. Since it makes use of the Siddon algorithm it is restricted to rectangular parallelepiped voxels but the spherical geometry of the corona can be handled through proper use of priors.

[ascl:1101.010]
TOPCAT: Tool for OPerations on Catalogues And Tables

TOPCAT is an interactive graphical viewer and editor for tabular data. Its aim is to provide most of the facilities that astronomers need for analysis and manipulation of source catalogues and other tables, though it can be used for non-astronomical data as well. It understands a number of different astronomically important formats (including FITS and VOTable) and more formats can be added.

It offers a variety of ways to view and analyse tables, including a browser for the cell data themselves, viewers for information about table and column metadata, and facilities for 1-, 2-, 3- and higher-dimensional visualisation, calculating statistics and joining tables using flexible matching algorithms. Using a powerful and extensible Java-based expression language new columns can be defined and row subsets selected for separate analysis. Table data and metadata can be edited and the resulting modified table can be written out in a wide range of output formats.

It is a stand-alone application which works quite happily with no network connection. However, because it uses Virtual Observatory (VO) standards, it can cooperate smoothly with other tools in the VO world and beyond, such as VODesktop, Aladin and ds9. Between 2006 and 2009 TOPCAT was developed within the AstroGrid project, and is offered as part of a standard suite of applications on the AstroGrid web site, where you can find information on several other VO tools.

The program is written in pure Java and available under the GNU General Public Licence. It has been developed in the UK within the Starlink and AstroGrid projects, and under PPARC and STFC grants. Its underlying table processing facilities are provided by STIL.

[ascl:1404.006]
TORUS: Radiation transport and hydrodynamics code

TORUS is a flexible radiation transfer and radiation-hydrodynamics code. The code has a basic infrastructure that includes the AMR mesh scheme that is used by several physics modules including atomic line transfer in a moving medium, molecular line transfer, photoionization, radiation hydrodynamics and radiative equilibrium. TORUS is useful for a variety of problems, including magnetospheric accretion onto T Tauri stars, spiral nebulae around Wolf-Rayet stars, discs around Herbig AeBe stars, structured winds of O supergiants and Raman-scattered line formation in symbiotic binaries, and dust emission and molecular line formation in star forming clusters. The code is written in Fortran 2003 and is compiled using a standard Gnu makefile. The code is parallelized using both MPI and OMP, and can use these parallel sections either separately or in a hybrid mode.

[ascl:1507.006]
Toyz: Large datasets and astronomical images analysis framework

Toyz is a python web framework that allows scientists to interact with large images and data sets stored on a remote server. A web application is run on the server containing the data and clients are run from web browsers on the user's computer. Toyz displays large FITS images also also renders any image format supported by Pillow (a fork of the Python Imaging Library), contains a GUI to interact with linked plots, and offers a customizable framework that allows students and researchers to create their own work spaces inside a Toyz environment. Astro-Toyz extends the features of the Toyz image viewer, allowing users to view world coordinates and align images based on their WCS.

[ascl:1603.012]
tpipe: Searching radio interferometry data for fast, dispersed transients

Visibilities from radio interferometers have not traditionally been used to study the fast transient sky. Millisecond transients (e.g., fast radio bursts) and periodic sources (e.g., pulsars) have been studied with single-dish radio telescopes and a software stack developed over the past few decades. tpipe is an initial attempt to develop the fast transient algorithms for visibility data. Functions exist for analysis of visibilties, such as reading data, flagging data, applying interferometric gain calibration, and imaging. These functions are given equal footing as time-domain techniques like filters and dedispersion.

[ascl:1305.003]
TPM: Tree-Particle-Mesh code

TPM carries out collisionless (dark matter) cosmological N-body simulations, evolving a system of N particles as they move under their mutual gravitational interaction. It combines aspects of both Tree and Particle-Mesh algorithms. After the global PM forces are calculated, spatially distinct regions above a given density contrast are located; the tree code calculates the gravitational interactions inside these denser objects at higher spatial and temporal resolution. The code is parallel and uses MPI for message passing.

[ascl:1304.011]
TPZ: Trees for Photo-Z

TPZ, a parallel code written in python, produces robust and accurate photometric redshift PDFs by using prediction tree and random forests. The code also produces ancillary information about the sample used, such as prior unbiased errors estimations (giving an estimation of performance) and a ranking of importance of variables as well as a map of performance indicating where extra training data is needed to improve overall performance. It is designed to be easy to use and a tutorial is available.

Would you like to view a random code?