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.

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.

SSHT performs fast and exact spin spherical harmonic transforms; functionality is also provided to perform fast and exact adjoint transforms, forward and inverse transforms, and spherical harmonic transforms for a number of alternative sampling schemes. The code can interface with DUCC (ascl:2008.023) and use it as a backend for spherical harmonic transforms and rotations.

sslf is a simple, effective and useful spectral line finder for 1D data. It utilizes the continuous wavelet transform from SciPy, which is a productive way to find even weak spectral lines.

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.

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.

SSSpaNG is a data-driven Gaussian Process model of the spectra of APOGEE red clump stars, whose parameters are inferred using Gibbs sampling. By pooling information between stars to infer their covariance it permits clear identification of the correlations between spectral pixels. Harnessing this correlation structure, a complete spectrum for each red clump star can be inferred, inpainting missing regions and de-noising by a factor of at least 2-3 for low-signal-to-noise stars.

sstrax provides fast simulations of Milky Way stellar stream formation. Using JAX (ascl:2111.002) acceleration to support code compilation, sstrax forward models all aspects of stream formation, including evolution in gravitational potentials, tidal disruption and observational models, in a fully modular way. Although sstrax is a standalone python package, it was also developed to integrate directly with the Albatross (ascl:2306.009) inference pipeline, which performs inference on all relevant aspects of the stream model.

STACKER stacks sources in interferometric data, i.e., averaging emission from different sources. The library allows stacking to be done directly on visibility data as well as in the image domain. The code is in format of a CASA (ascl:1107.013) task and implements uv- and image-stacking algorithms; it also provides several useful tasks for stacking related data processing. It allows introduction and stacking of random sources to estimate bias and noise, and also allows removal of a model of bright sources from the data.

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.

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.

star_shadow automatically analyzes space based light curves of eclipsing binaries and provide a measurement of eccentricity, among other parameters. It measures the timings of eclipses using the time derivatives of the light curves, using a model of orbital harmonics obtained from an initial iterative prewhitening of sinusoids. Since the algorithm extracts the harmonics from the rest of the sinusoidal variability eclipse timings can be measured even in the presence of other (astrophysical) signals, thus determining the orbital eccentricity automatically from the light curve along with information about the other variability present in the light curve. The output includes, but is not limited to, a sinusoid plus linear model of the light curve, the orbital period, the eccentricity, argument of periastron, and inclination.

STAR-MELT extracts and identifies emission lines from FITS files by matching to a compiled reference database of lines. Line profiles are fitted and quantified, allowing for calculations of physical properties across each individual observation. Temporal variations in lines can readily be displayed and quantified. STAR-MELT is also useful for different applications of spectral analysis where emission line identification is required. Standard data formats for spectra are automatically compatible, with user-defined custom formats also available. Any reference database (atomic or molecular) can also be used for line identification.

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.

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.

The python photometry suite StarbugII provides accurate photometry on point-like sources embedded in complex diffuse emissions. The tool has a simple modular interface with a wide range of photometric routines including embedded source detection, aperture and PSF photometry, diffuse background emission estimation, catalog matching and artificial star testing. The core is built around Photutils (ascl:1609.011).

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.

StarburstPy is a python wrapper for Starburst99 (ascl:1104.003). The code contains methods for setting all inputs, running Starburst99, and reading output data into python dictionaries.

StarcNet (STAR Cluster classification NETwork) classifies star clusters from galaxy images taken by the Hubble Space Telescope (HST); it uses a convolutional neural network (CNN) trained to classify five-band galaxy images into four morphological classes. Written in PyTorch, StarcNet runs using mosaics (.fits files with the galaxy photometric information) and catalogs (.tab files with object coordinates), and includes the option to also download the galaxy mosaics from a single .tar.gz file per galaxy (as from the Legacy ExtraGalactic UV Survey).

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

stardate measures precise stellar ages by combining isochrone fitting with gyrochronology (rotation-based ages) to increase the precision of stellar ages on the main sequence. The best possible ages provided by stardate will be for stars with rotation periods, though ages can also be predicted for stars without rotation periods. stardate is an extension to isochrones that incorporates gyrochronology and the code reverts back to isochrones when no rotation period is provided.

The deep learning model Starduster emulates dust radiative transfer simulations, which significantly accelerates the computation of dust attenuation and emission. Starduster contains two specific generative models, which explicitly take into account the features of the dust attenuation curves and dust emission spectra. Both generative models should be trained by a set of characteristic outputs of a radiative transfer simulation. The obtained neural networks can produce realistic galaxy spectral energy distributions that satisfy the energy balance condition of dust attenuation and emission. Applications of Starduster include SED-fitting and SED-modeling from semi-analytic models.

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.

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.

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.

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.

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.

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.

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.

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

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.

starry_process implements an interpretable Gaussian process (GP) for modeling stellar light curves. The code's hyperparameters are physically interpretable, and include the radius of the spots, the mean and variance of the latitude distribution, the spot contrast, and the number of spots, among others. The rotational period of the star, the limb darkening parameters, and the inclination (or marginalize over the inclination if it is not known) can also be specified.

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.

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.

The 3D grid-based Monte Carlo code STaRS (Sejong Radiative Transfer through Raman and Rayleigh Scattering with atomic hydrogen) traces radiative transfer through Raman and Rayleigh scattering. This can be used to investigate line formation of Raman-scattered features in a thick neutral region illuminated by a strong far-UV emission source. Favorable conditions for Raman scattering with atomic hydrogen are easily met in symbiotic stars, young planetary nebulae, and active galactic nuclei.

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.

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.

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.

statmorph calculates non-parametric morphological diagnostics of galaxy images (e.g., Gini-M_{20} and CAS statistics), and fits 2D Sérsic profiles. Given a background-subtracted image and a corresponding segmentation map indicating the source(s) of interest, statmorph calculates the following morphological statistics for each source:
- Gini-M20 statistics;
- Concentration, Asymmetry and Smoothness (CAS) statistics;
- Multimode, Intensity and Deviation (MID) statistics;
- outer asymmetry and shape asymmetry;
- Sérsic index; and,
- several shape and size measurements associated to the above statistics, such as ellipticity, Petrosian radius, and half-light radius, among others.

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.

STDPipe is a set of Python routines for astrometry, photometry and transient detection related tasks, intended for quick and easy implementation of custom pipelines, as well as for interactive data analysis. It is implemented as a library of routines covering most common tasks and operates on standard Python objects, including NumPy arrays for images and Astropy (ascl:1304.002) tables for catalogs and object lists. The pipeline does not re-implement code already implemented in other Python packages; instead, it transparently wraps external codes, such as SExtractor (ascl:1010.064), SCAMP (ascl:1010.063), PSFEx (ascl:1301.001), HOTPANTS (ascl:1504.004), and Astrometry.Net (ascl:1208.001), that do not have their own Python interfaces. STDPipe operates on temporary files, keeping nothing after the run unless something is explicitly requested.

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.

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.

stella creates and trains a neural network to identify stellar flares. Within stella, users can simulate flares as a training set, run a neural network, and feed in their own data to the neural network model. The software returns a probability at each data point as to whether that data point is part of a flare; the code can also characterize the flares identified.

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.

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.

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

StelNet predicts mass and age from absolute luminosity and effective temperature for stars with close to solar metallicity. It uses a Deep Neural Network trained on stellar evolutionary tracks. The underlying model makes no assumption on the evolutionary stage and includes the pre-main sequence phase. A mix of models are trained and bootstrapped to quantify the uncertainty of the model, and data is through all trained models to provide a predictive distribution from which an expectation value and uncertainty level can be estimated.

StePar computes the stellar atmospheric parameters T_eff, log g, [Fe/H], and ξ of FGK-type stars using the Equivalent Width (EW) method. The code implements a grid of MARCS model atmospheres and uses the MOOG radiative transfer code (ascl:1202.009) and TAME (ascl:1503.003). StePar uses a Downhill Simplex minimization algorithm, running it twice for any given star, to compute the stellar atmospheric parameters.

SteParSyn infers stellar atmospheric parameters (Teff, log g, [Fe/H], and Vbroad) of FGKM-type stars using the spectral synthesis method. The code uses the MCMC sampler emcee (ascl:1303.002) in conjunction with an spectral emulator that can interpolate spectra down to a precision < 1%. A grid of synthetic spectra that allow the user to characterize the spectra of FGKM-type stars with parameters in the range of 3500 to 7000 K in Teff, 0.0 to 5.5 dex in log g, and −2.0 to 1.0 dex in [Fe/H] is also provided.

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.

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.

The sterile neutrino production code sterile-dm incorporates new elements to the calculations of the neutrino opacity at temperatures 10 MeV ≤ T ≤ 10 GeV and folds the asymmetry redistribution and opacity calculations into the sterile neutrino production computation, providing updated PSDs for the range of parameters relevant to the X-ray excess. The code requires several data files, which are included. With each run, sterile-dm creates a new output sub-directory that contains a parameter file listing the mass, mixing angle, initial lepton asymmetry and other information, a state file, which includes, among other states, the temperature and FRW coordinate time, and a set of snapshot files, one for each line in the state file.

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.

This code has been updated and renamed to VELOCIraptor-STF (ascl:1911.020).

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.

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.

STIFF converts scientific FITS images to the more popular TIFF 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 implicitly 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.

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

A powerful and extensible expression language is used for specifying data calculations. These facilities can be put together in very flexible and efficient ways. For tasks in which the data can be streamed, the size of table STILTS can process is effectively unlimited. For other tasks, million-row tables usually do not present a problem. STILTS is written in pure Java (J2SE1.5 or later), and can be run from the command line or from Jython, or embedded into java applications. It is released under the GPL.

stimela provides a system-agnostic scripting framework for simulating, processing, and imaging radio interferometric data. The framework executes radio interferometry related tasks such as imaging, calibration, and data synthesis in Docker containers using Python modules. stimela offers a simple interface to packages that perform these tasks rather than doing any data processing, synthesis or analysis itself. stimela only requires Docker and Python. Moreover, because of Docker, a stimela script runs the same way (in the same iso­lated environment) regardless of the host machine’s settings, thus providing a user-friendly and modular scripting environment that gives general users easy access to novel radio interferometry calibration, imaging, and synthesis packages.

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.

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.

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

Stratsi calculates stratified and vertically-shearing streaming instabilities. It solves one- and two-fluid linearized equations, and, for two-fluid models, also provides the parameters and analytic vertical structure and solves for equilibrium horizontal velocity profiles. It offers utilities and various plotting options, including plots to compare one- and two-fluid results, viscous results to inviscid results, and results from two different stokes numbers or two different metallicities. stratsi requires Dedalus (ascl:1603.015) and Eigentools (ascl:2101.017).

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.

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.

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.

stringgen creates emulations of cosmic string maps with statistics similar to those of a single (or small ensemble) of reference simulations. It uses wavelet phase harmonics to calculate a compressed representation of these reference simulations, which may then be used to synthesize new realizations with accurate statistical properties, e.g., 2 and 3 point correlations, skewness, kurtosis, and Minkowski functionals.

StructureFunction determines the X-ray Structure Function of a population of Active Galactic Nuclei (AGN) for which two epoch X-ray observations are available and are separated by rest frame time interval. The calculation of the X-ray structure function is Bayesian. The sampling of the likelihood uses Stan (ascl:1801.003) for statistical modeling and high-performance statistical computation.

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.

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.

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.

SubGen generates Monte-Carlo samples of dark matter subhaloes. It fully describes the joint distribution of subhaloes in final mass, infall mass, and radius; it can be used to predict derived distributions involving combinations of these quantities, including the universal subhalo mass function, the subhalo spatial distribution, the gravitational lensing profile, the dark matter annihilation radiation profile and boost factor. SubGen works only for CDM subhaloes; for an extension of the code to also work with WDM subhaloes, see SubGen2 (ascl:2312.036).

The SubGen2 subhalo population generator works for both CDM and WDM of arbitrary DM particle mass. It can be used to generate a population of subhaloes according to the joint distribution of subhalo bound mass, infall mass and halo-centric distance in a halo of a given mass. SubGen2 is an extension to SubGen (ascl:2312.035), which works only for CDM subhaloes.

SubgridClumping derives the parameters for the global, in-homogeneous and stochastic clumping model and then computes the clumping factor for large low-resolution N-body simulations smoothed on a regular grid. Written for the CUBEP3M simulation, the package contains two main modules. The first derives the three clumping model parameters for a given small high-resolution simulation; the second computes a clumping factor cube (same mesh-size as input) for the three models for the given density field of a large low-resolution simulation.

SUNBIRD trains neural-network-based models for galaxy clustering. It also incorporates pre-trained emulators for different summary statistics, including galaxy two-point correlation function, density-split clustering statistics, and old-galaxy cross-correlation function. These models have been trained on mock galaxy catalogs, and were calibrated to work for specific samples of galaxies. SUNBIRD implements routines with PyTorch to train new neural-network emulators.

SunnyNet learns the mapping the between LTE and NLTE populations of a model atom and predicts the NLTE populations based on LTE populations for an arbitrary 3D atmosphere. To use SunnyNet, one must already have a set of LTE and NLTE populations computed in 3D, to train the network. These must come from another code, as SunnyNet is unable to solve the formal problem. Once SunnyNet is trained, one can feed it LTE populations from a different 3D atmosphere, and obtain predicted NLTE populations. The NLTE populations can then be used to synthesize any spectral line that is included in the model atom. SunnyNet's output is a file with predicted NLTE populations. SunnyNet itself does not calculate synthetic spectra, but a sample script written in the Julia language that quickly computes Hα spectra is included.

SunPy is a community-developed free and open-source software package for solar physics and is an alternative to the SolarSoft (ascl:1208.013) 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.

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⁴; 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 (ascl:0003.001), Gasoline (ascl:1710.019), Arepo (ascl:1909.010), Enzo (ascl:1010.072) 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.

These IDL codes create 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.

The superABC sampling method obtains cosmological constraints from supernova light curves using Approximate Bayesian Computation (ABC) without any likelihood assumptions. It provides an interface to two forward model simulations, SNCosmo (ascl:1611.017) and SNANA (ascl:1010.027), for supernova cosmology.

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 (ascl:1109.006). 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 (ascl:1106.025).

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.

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.

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.

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.

SuperNNova performs photometric classification by leveraging recent advances in deep neural networks. It can train either a recurrent neural network or random forest to classify light-curves using only photometric information. It also allows additional information, such as host-galaxy redshift, to be incorporated to improve performance.

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.

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.

SuperNu simulates time-dependent radiation transport in local thermodynamic equilibrium with matter. It applies the methods of Implicit Monte Carlo (IMC) and Discrete Diffusion Monte Carlo (DDMC) for static or homologously expanding spatial grids. The radiation field affects material temperature but does not affect the motion of the fluid. SuperNu may be applied to simulate radiation transport for supernovae with ejecta velocities that are not affected by radiation momentum. The physical opacity calculation includes elements from Hydrogen up to Cobalt. SuperNu is motivated by the ongoing research into the effect of variation in the structure of progenitor star explosions on observables: the brightness and shape of light curves and the temporal evolution of the spectra. Consequently, the code may be used to post-process data from hydrodynamic simulations. SuperNu does not include any capabilities or methods that allow for non-trivial hydrodynamics.

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.

SuperRad models ultralight boson clouds that arise through black hole superradiance. It uses numerical results in the relativistic regime combined with analytic estimates to describe the dynamics and gravitational wave signals of ultralight scalar or vector clouds. Written in Python, SuperRad includes a set of testing routines that check the internal consistency of the package; these tests mainly serve the purpose of ensuring functionality of the waveform model but can also be utilized to check that SuperRad works as intended.

SuperRAENN performs photometric classification of supernovae in the following categories: Type I superluminos supernovae, Type II, Type IIn, Type Ia and Type Ib/c. Though the code is optimized for use with complete (rather than realtime) light curves from the Pan-STARRS Medium Deep Survey, the classifier can be trained on other data. SuperRAENN can be used on a dataset containing both spectroscopically labelled and unlabelled SNe; all events will be used to train the RAENN, while labelled events will be used to train the random forest.

SUPPNet performs fully automated precise continuum normalization of merged echelle spectra and offers flexible manual fine-tuning, if necessary. The code uses a fully convolutional deep neural network (SUPP Network) trained to predict a pseudo-continuum. The post-processing step uses smoothing splines that give access to regressed knots, which are useful for optional manual corrections. The active learning technique controls possible biases that may arise from training with synthetic spectra and extends the applicability of the method to features absent in this kind of spectra.

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

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.

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.

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.

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.

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.

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.

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.