rtpipe (real-time pipeline) analyzes radio interferometric data with an emphasis on searching for transient or variable astrophysical sources. The package combines single-dish concepts such as dedispersion and filters with interferometric concepts, including images and the uv-plane. In contrast to time-domain data recorded with large single-dish telescopes, visibilities from interferometers can precisely localize sources anywhere in the entire field of view. rtpipe opens interferometers to the study of fast transient sky, including sources like pulsars, stellar flares, rotating radio transients, and fast radio bursts. Key portions of the search pipeline, such as image generation and dedispersion, have been accelerated. That, in combination with its multi-threaded, multi-node design, makes rtpipe capable of searching millisecond timescale data in real time on small compute clusters.

Radio Transient Simulations uses Monte-Carlo simulations to accurately determine transient rates in radio surveys. The user inputs either a real or simulated observational setup, and the simulations code calculates transient rate as a function of transient duration and peak flux. These simulations allow for simulating a wide variety of scenarios including observations with varying sensitivities and durations, multiple overlapping telescope pointings, and a wide variety of light curve shapes with the user having the ability to easily add more. Though the current scientific focus is on the radio regime, the simulations code can be easily adapted to other wavelength regimes.

Rubble implicitly models the local evolution of dust distributions in size, mass, and surface density by solving the Smoluchowski equation (also known as the coagulation-fragmentation equation) under given disk conditions. The Python package's robustness has been validated by a suite of numerical benchmarks against known analytical and empirical results. Rubble can model prescribed physical processes such as bouncing, modulated mass transfer, regulated dust loss/supply, probabilistic collisional outcomes based on velocity distributions, and more. The package also includes a toolkit for analyzing and visualizing results produced by Rubble.

The centrifugal deformation program RUBIS (Rotation code Using Barotropy conservation over Isopotential Surfaces) takes an input 1D model (with spherical symmetry) and returns its deformed version by applying a conservative rotation profile specified by the user. The code needs only the density as a function of radial distance from the reference model in addition to the surface pressure to be imposed to perform the deformation; preserving the relation between density and pressure when going from the 1D to the 2D structure makes this lightness possible. By solving Poisson's equation in spheroidal rather than spherical coordinates whenever a discontinuity is present, RUBIS can deform both stellar and planetary models, thereby dealing with potential discontinuities in the density profile.

runDM calculates the running of the couplings of Dark Matter (DM) to the Standard Model (SM) in simplified models with vector mediators. By specifying the mass of the mediator and the couplings of the mediator to SM fields at high energy, the code can calculate the couplings at low energy, taking into account the mixing of all dimension-6 operators. runDM can also extract the operator coefficients relevant for direct detection, namely low energy couplings to up, down and strange quarks and to protons and neutrons.

The RV program produces a report listing the components, in a given direction, of the observer's velocity on a given date. This allows an observed radial velocity to be referred to an appropriate standard of rest -- typically either the Sun or an LSR.

As a secondary function, RV computes light time components to the Sun, thus allowing the times of phenomena observed from a terrestrial observatory to be referred to a heliocentric frame of reference. n.b. It will of course, in addition, be necessary to express the observations in the appropriate timescale as well as applying light time corrections. In particular, it is likely that an observed UTC will need to be converted to TDB as well as being corrected to the Sun.)

RV is distributed with the Starlink software collection (ascl:1110.012) and uses SLALIB (ascl:1403.025).

rvfit, developed in IDL 7.0, fits non-precessing keplerian radial velocity (RV) curves for double-line and single-line binary stars or exoplanets. It fits a simple keplerian model to the observed RV and computes the seven parameters (six for a single-line system) from the model. Some parameters can be fixed beforehand if they are known, for instance, if photometric observations are available. The fit is done using an Adaptive Simulated Annealing algorithm optimized for this specific task. Simulated Annealing methods are powerful heuristic algorithms to minimize functions in multiparametric spaces.

The RVLIN package for IDL is a set of routines that quickly fits an arbitrary number of Keplerian curves to radial velocity data. It can handle data from multiple telescopes (i.e. it solves for the offset), constraints on P, e, and time of peri passage, and can incorporate transit timing data. The code handles fixed periods and circular orbits in combination and transit time constraints, including for multiple transiting planets.

RVSAO is a set of programs to obtain redshifts and radial velocities from digital spectra. RVSAO operates in the IRAF (Tody 1986, 1993) environment. The heart of the system is xcsao, which implements the cross-correlation method, and is a direct descendant of the system built by Tonry and Davis (1979). emsao uses intelligent heuristics to search for emission lines in spectra, then fits them to obtain a redshift. sumspec shifts and sums spectra to build templates for cross-correlation. linespec builds synthetic spectra given a list of spectral lines. bcvcorr corrects velocities for the motion of the earth. We discuss in detail the parameters necessary to run xcsao and emsao properly. We discuss the reliability and error associated with xcsao derived redshifts. We develop an internal error estimator, and we show how large, stable surveys can be used to develop more accurate error estimators. We develop a new methodology for building spectral templates for galaxy redshifts. We show how to obtain correlation velocities using emission line templates. Emission line correlations are substantially more efficient than the previous standard technique, automated emission line fitting. We compare the use of RVSAO with new methods, which use Singular Value Decomposition and $chi^2$ fitting techniques.

RVSpecFit determines radial velocities and stellar atmospheric parameters from spectra by direct pixel fitting by interpolated stellar templates. The code doesn't require spectrum normalization and can deal with non-flux calibrated spectra. RVSpecFit is able to fit multiple spectra simultaneously.

Rwcs offers access to all the projection and distortion systems of WCSLIB (ascl:1108.003) in R. This can be used directly for, for example, pixel lookups, or for higher level general distortion and projection.

The s2 package can represent any arbitrary function defined on the sphere. Both real space map and harmonic space spherical harmonic representations are supported. Basic sky representations have been extended to simulate full sky noise distributions and Gaussian cosmic microwave background realisations. Support for the representation and convolution of beams is also provided. The code requires HEALPix (ascl:1107.018) and CFITSIO (ascl:1010.001).

S2FFT computes Fourier transforms on the sphere and rotation group using JAX (ascl:2111.002) or PyTorch. It leverages autodiff to provide differentiable transforms, which are also deployable on hardware accelerators (e.g., GPUs and TPUs). More specifically, S2FFT provides support for spin spherical harmonic and Wigner transforms (for both real and complex signals), with support for adjoint transformations where needed, and comes with different optimisations (precompute or not) that one may select depending on available resources and desired angular resolution L.

Many problems in astronomy and astrophysics require a computation of the spherical harmonic transforms. This is in particular the case whenever data to be analyzed are distributed over the sphere or a set of corresponding mock data sets has to be generated. In many of those contexts, rapidly improving resolutions of both the data and simulations puts increasingly bigger emphasis on our ability to calculate the transforms quickly and reliably.

The scalable spherical harmonic transform library S2HAT consists of a set of flexible, massively parallel, and scalable routines for calculating diverse (scalar, spin-weighted, etc) spherical harmonic transforms for a class of isolatitude sky grids or pixelizations. The library routines implement the standard algorithm with the complexity of O(n^3/2), where n is a number of pixels/grid points on the sphere, however, owing to their efficient parallelization and advanced numerical implementation, they achieve very competitive performance and near perfect scalability. S2HAT is written in Fortran 90 with a C interface. This software is a derivative of the spherical harmonic transforms included in the HEALPix package and is based on both serial and MPI routines of its version 2.01, however, since version 2.5 this software is fully autonomous of HEALPix and can be compiled and run without the HEALPix library.

S2LET provides high performance routines for fast wavelet analysis of signals on the sphere. It uses the SSHT code (ascl:2207.034) built on the MW sampling theorem to perform exact spherical harmonic transforms on the sphere. The resulting wavelet transform implemented in S2LET is theoretically exact, i.e. a band-limited signal can be recovered from its wavelet coefficients exactly and the wavelet coefficients capture all the information. S2LET also supports the HEALPix sampling scheme, in which case the transforms are not theoretically exact but achieve good numerical accuracy. The core routines of S2LET are written in C and have interfaces in Matlab, IDL and Java. Real signals can be written to and read from FITS files and plotted as Mollweide projections.

We present a new, three-dimensional (3D) plotting library with advanced features, and support for standard and enhanced display devices. The library - S2PLOT - is written in C and can be used by C, C++ and FORTRAN programs on GNU/Linux and Apple/OSX systems. S2PLOT draws objects in a 3D (x,y,z) Cartesian space and the user interactively controls how this space is rendered at run time. With a PGPLOT inspired interface, S2PLOT provides astronomers with elegant techniques for displaying and exploring 3D data sets directly from their program code, and the potential to use stereoscopic and dome display devices. The S2PLOT architecture supports dynamic geometry and can be used to plot time-evolving data sets, such as might be produced by simulation codes. In this paper, we introduce S2PLOT to the astronomical community, describe its potential applications, and present some example uses of the library.

s3PCF computes the 3-point correlation function (3PCF) in the squeezed limit given galaxy positions and pair positions. The code is currently written specifically for the Abacus simulations, but the main functionalities can be also easily adapted for other galaxy catalogs with the appropriate properties.

s4cmb (Systematics For Cosmic Microwave Background) studies the impact of instrumental systematic effects on measurements of CMB experiments based on bolometric detector technology. s4cmb provides a unified framework to simulate raw data streams in the time domain (TODs) acquired by CMB experiments scanning the sky, and to inject in these realistic instrumental systematics effect.

Saada transforms a set of heterogeneous FITS files or VOtables of various categories (images, tables, spectra, etc.) in a powerful database deployed on the Web. Databases are located on your host and stay independent of any external server. This job doesn’t require writing code. Saada can mix data of various categories in multiple collections. Data collections can be linked each to others making relevant browsing paths and allowing data-mining oriented queries. Saada supports 4 VO services (Spectra, images, sources and TAP) . Data collections can be published immediately after the deployment of the Web interface.

The Sheffield Advanced Code (SAC) is a fully non-linear MHD code designed for simulations of linear and non-linear wave propagation in gravitationally strongly stratified magnetized plasma. It was developed primarily for the forward modelling of helioseismological processes and for the coupling processes in the solar interior, photosphere, and corona; it is built on the well-known VAC platform that allows robust simulation of the macroscopic processes in gravitationally stratified (non-)magnetized plasmas. The code has no limitations of simulation length in time imposed by complications originating from the upper boundary, nor does it require implementation of special procedures to treat the upper boundaries. SAC inherited its modular structure from VAC, thereby allowing modification to easily add new physics.

SACC (Save All Correlations and Covariances) is a format and reference library for general storage
of summary statistic measurements for the Dark Energy Science Collaboration (DESC) within and from the Large Synoptic Survey Telescope (LSST) project's Dark Energy Science Collaboration.

SAGE (Semi-Analytic Galaxy Evolution) models galaxy formation in a cosmological context. SAGE has been rebuilt to be modular and customizable. The model runs on any dark matter cosmological N-body simulation whose trees are organized in a supported format and contain a minimum set of basic halo properties.

SAGE corrects the time-dependent impact of stellar activity on transmission spectra. It uses a pixelation approach to model the stellar surface with spots and faculae, while accounting for limb-darkening and rotational line-broadening. The code can be used to evaluate stellar contamination for F to M-type hosts, test various spot sizes and locations, and quantify the impact of limb-darkening. SAGE can also retrieve the properties and distribution of active regions on the stellar surface from photometric monitoring, and connect the photometric variability to the stellar contamination of transmission spectra.

SALT (Spectral Adaptive Lightcurve Template) is a package for Type Ia Supernovae light curve fitting. Its main purpose is to provide a distance estimator but it can also be used for photometric redshifts, and spectroscopic + photometric identification. This code is also known by the name snfit.

The SAMI (Sydney-AAO Multi-object Integral field spectrograph) pipeline reduces data from the Sydney-AAO Multi-object Integral field spectrograph (SAMI) for the SAMI Galaxy Survey. The python code organizes SAMI data and, along with the AAO 2dfdr package, carries out all steps in the data reduction, from raw data to fully calibrated datacubes. The principal steps are: data management, use of 2dfdr to produce row-stacked spectra, flux calibration, correction for telluric absorption, removal of atmospheric dispersion, alignment of dithered exposures, and drizzling onto a regular output grid. Variance and covariance information is tracked throughout the pipeline. Some quality control routines are also included.

samiDB is an archive, database, and query engine to serve the spectra, spectral hypercubes, and high-level science products that make up the SAMI Galaxy Survey. Based on the versatile Hierarchical Data Format (HDF5), samiDB does not depend on relational database structures and hence lightens the setup and maintenance load imposed on science teams by metadata tables. The code, written in Python, covers the ingestion, querying, and exporting of data as well as the automatic setup of an HTML schema browser. samiDB serves as a maintenance-light data archive for Big Science and can be adopted and adapted by science teams that lack the means to hire professional archivists to set up the data back end for their projects.

The samsam package provides two samplers, a scaled adaptive metropolis algorithm to robustly obtain samples from a target distribution, and a covariance importance sampling algorithm to efficiently compute the model evidence (or other integrals). It also includes tools to assess the convergence of the sam sampler and a few commonly used prior distributions.

SAMUS (Simulator of Asteroid Malformation Under Stress) simulates the deformation of minor bodies, assuming that they are homogenous incompressible fluid masses. They are initialized as ellipsoids and the Navier-Stokes equations are interatively solved to investigate the deformation of the body over time. The software is modular and allows for user-defined output functions, size, and trajectories. Structured as a single large class, SAMUS can store variables and handle arbitrary function calls, which eases debugging and investigation, especially for lengthy high-fidelity simulation runs.

The Search And Non-Destroy (SAND) is a VLBI data reduction pipeline composed of a set of Python programs based on the AIPS interface provided by ObitTalk. It is designed for the massive data reduction of multi-epoch VLBI monitoring research. It can automatically investigate calibrated visibility data, search all the radio emissions above a given noise floor and do the model fitting either on the CLEANed image or directly on the uv data. It then digests the model-fitting results, intelligently identifies the multi-epoch jet component correspondence, and recognizes the linear or non-linear proper motion patterns. The outputs including CLEANed image catalogue with polarization maps, animation cube, proper motion fitting and core light curves. For uncalibrated data, a user can easily add inline modules to do the calibration and self-calibration in a batch for a specific array.

SAOImage DS9 is an astronomical imaging and data visualization application. DS9 supports FITS images and binary tables, multiple frame buffers, region manipulation, and many scale algorithms and colormaps. It provides for easy communication with external analysis tasks and is highly configurable and extensible via XPA and SAMP. DS9 is a stand-alone application. It requires no installation or support files. Versions of DS9 currently exist for Solaris, Linux, MacOSX, and Windows. All versions and platforms support a consistent set of GUI and functional capabilities. DS9 supports advanced features such as multiple frame buffers, mosaic images, tiling, blinking, geometric markers, colormap manipulation, scaling, arbitrary zoom, rotation, pan, and a variety of coordinate systems. DS9 also supports FTP and HTTP access. The GUI for DS9 is user configurable. GUI elements such as the coordinate display, panner, magnifier, horizontal and vertical graphs, button bar, and colorbar can be configured via menus or the command line. DS9 is a Tk/Tcl application which utilizes the SAOTk widget set. It also incorporates the X Public Access (XPA) mechanism to allow external processes to access and control its data, GUI functions, and algorithms.

The SAPHIRES (Stellar Analysis in Python for HIgh REsolution Spectroscopy) suite contains functions for analyzing high-resolution stellar spectra. Though most of its functionality is aimed at deriving radial velocities (RVs), the suite also includes capabilities to measure projected rotational velocities (vsini) and determine spectroscopic flux ratios in double-lined binary systems (SB2s). These measurements are made primarily by computing spectral-line broadening functions. More traditional techniques such as Fourier cross-correlation, and two-dimensional cross-correlation (TODCOR) are also included.

Sapporo mimics the behavior of GRAPE hardware and uses the GPU to perform high-precision gravitational N-body simulations. It makes use of CUDA and therefore only works on NVIDIA GPUs. N-body codes currently running on GRAPE-6 can switch to Sapporo by a simple relinking of the library. Sapporo's precision is comparable to that of GRAPE-6, even though internally the GPU hardware is limited to single precision arithmetics. This limitation is effectively overcome by emulating double precision for calculating the distance between particles.

SARA-PPD is a proof of concept MATLAB implementation of an acceleration strategy for a recently proposed primal-dual distributed algorithm. The algorithm optimizes resolution by accounting for the correct noise statistics, leverages natural weighting in the definition of the minimization problem for image reconstruction, and optimizes sensitivity by enabling accelerated convergence through a preconditioning strategy incorporating sampling density information. This algorithm offers efficient processing of large-scale data sets that will be acquired by next generation radio-interferometers such as the Square Kilometer Array.

SARAH builds and analyzes SUSY and non-SUSY models. It calculates all vertices, mass matrices, tadpoles equations, one-loop corrections for tadpoles and self-energies, and two-loop RGEs for a given model. SARAH writes model files for a variety of other software packages for dark matter studies, includes many SUSY and non-SUSY models, and makes implementing new models efficient and straightforward. Written in Mathematica, SARAH can also use output from Vevacious (ascl:1904.019) to check for the global minimum for a given model and parameter point.

The Science Analysis System (SAS) is an extensive suite of software tasks developed to process the data collected by the XMM-Newton Observatory. The SAS extracts standard (spectra, light curves) and/or customized science products, and allows reproductions of the reduction pipelines run to get the PPS products from the ODFs files. SAS includes a powerful and extensive suite of FITS file manipulation packages based on the Data Access Layer library.

SASHIMI-C calculates various subhalo properties efficiently using semi-analytical models for cold dark matter (CDM), providing a full catalog of dark matter subhalos in a host halo with arbitrary mass and redshift. Each subhalo is characterized by its mass and density profile both at accretion and at the redshift of interest, accretion redshift, and effective number (or weight) corresponding to that particular subhalo. SASHIMI-C computes the subhalo mass function without making any assumptions such as power-law functional forms; the only assumed power law is that for the primordial power spectrum predicted by inflation. The code is not limited to numerical resolution nor to Poisson shot noise, and its results are well in agreement with those from numerical N-body simulations.

SASHIMI-W calculates various subhalo properties efficiently using semi-analytical models for warm dark matter (WDM); the code is based on the extended Press-Schechter formalism and subhalos' tidal evolution prescription. The calculated constraints are independent of physics of galaxy formation and free from numerical resolution and the Poisson noise, and its results are well in agreement with those from numerical N-body simulations.

SASRST, a small collection of Python scripts, attempts to reproduce the semi-analytical one-dimensional equilibrium and non-equilibrium radiative shock tube solutions of Lowrie & Rauenzahn (2007) and Lowrie & Edwards (2008), respectively. The included code calculates the solution for a given set of input parameters and also plots the results using Matplotlib. This software was written to provide validation for numerical radiative shock tube solutions produced by a radiation hydrodynamics code.

satcand applies theoretical constraints of orbital stability and tidal migration to KOI exomoon candidates. The package can evaluate the tidal migration within a Sun-Earth-Moon system, plot angular velocity over time, and calculate the migration time scale (T1) and the total migration time scale, among other things. In addition to the theoretical constraints, observational constraints can be applied.

SATCHEL (Search Algorithm for Transits in the Citizen science Hunt for Exoplanets in Lightcurves) searches for individual signals of interest in time-series data classified through crowdsourcing. The pipeline was built for the purpose of finding long-period exoplanet transit signals in Kepler photometric time-series data, but may be adapted for searches for any kind of one-dimensional signals in crowdsourced classifications.

SatGen generates satellite-galaxy populations for host halos of desired mass and redshift. It combines halo merger trees, empirical relations for galaxy-halo connection, and analytic prescriptions for tidal effects, dynamical friction, and ram-pressure stripping. It emulates zoom-in cosmological hydrosimulations in certain ways and outperforms simulations regarding statistical power and numerical resolution.

SATMC is a general purpose, MCMC-based SED fitting code written for IDL and Python. Following Bayesian statistics and Monte Carlo Markov Chain algorithms, SATMC derives the best fit parameter values and returns the sampling of parameter space used to construct confidence intervals and parameter-parameter confidence contours. The fitting may cover any range of wavelengths. The code is designed to incorporate any models (and potential priors) of the user's choice. The user guide lists all the relevant details for including observations, models and usage under both IDL and Python.

SAVED21cm extracts the 21cm signal from the simulated mock observation for the Radio Experiment for the Analysis of Cosmic Hydrogen (REACH). Though built for the REACH experiment, this 21cm signal extraction pipeline can in principle can be utilized for any global 21cm experiment. The toolkit is based on a pattern recognition framework using the Singular Value Decomposition (SVD) of the 21cm and foreground training set. SAVED21cm finds the patterns in the training sets and properly models the chromatic distortions with a better basis than the polynomials.

A Savitzky–Golay filter is often applied to data to smooth the data without greatly distorting the signal; however, almost all data inherently comes with noise, and the noise properties can differ from point to point. This python script improves upon the traditional Savitzky-Golay filter by accounting for error covariance in the data. The inputs and arguments are modeled after scipy.signal.savgol_filter.

SBGAT (Small Body Geophysical Analysis Tool) generates simulated data originating from small bodies shape models, combined with advanced shape-modification properties. It uses polyhedral shape models from which can be computed mass properties such as volume, center of mass, and inertia, synthetic observations such as lightcurves and radar, and which can be used within dynamical models, such as spherical harmonics and polyhedron gravity modeling. SBGAT can generate spherical harmonics expansions from constant-density polyhedra (and export them to JSON) and evaluate the spherical harmonics expansions. It can also generate YORP coefficients, multi-threaded Polyhedron Gravity Model gravity and potential evaluations, and synthetic light-curve and radar observations for single/primary asteroids.

SBGAT has two distinct packages: a dynamic library SBGAT Core that contains the data structure and algorithm backbone of SBGAT, and SBGAT Gui, which wraps the former inside a VTK, Qt user interface to facilitate user/data interaction. SBGAT Core can be used without the SBGAT Gui wrapper.

Simulation-based inference is the process of finding parameters of a simulator from observations. The PyTorch package sbi performs simulation-based inference by taking a Bayesian approach to return a full posterior distribution over the parameters, conditional on the observations. This posterior can be amortized (i.e. useful for any observation) or focused (i.e.tailored to a particular observation), with different computational trade-offs. The code offers a simple interface for one-line posterior inference.

sbpy, an Astropy affiliated package, supplements functionality provided by Astropy (ascl:1304.002) with functions and methods that are frequently used for planetary astronomy with a clear focus on asteroids and comets. It offers access tools for various databases for orbital and physical data, spectroscopy analysis tools and models, photometry models for resolved and unresolved observations, ephemerides services, and other tools useful for small-body planetary astronomy.

Astrometric and photometric calibrations have remained the most tiresome step in the reduction of large imaging surveys. SCAMP has been written to address this problem. The program efficiently computes accurate astrometric and photometric solutions for any arbitrary sequence of FITS images in a completely automatic way. SCAMP is released under the GNU General Public License.

ScamPy "paints" an observed population of cosmological objects on top of the DM-halo/subhalo hierarchy obtained from DM-only simulations. The method combines the Halo Occupation Distribution (HOD) method with sub-halo abundance matching (SHAM); the two processes together are dubbed Sub-halo clustering and abundance matching (SCAM). The procedure requires applying the two methods in sequence; by applying the HOD scheme, the host sub-haloes are selected, and the SHAM algorithm associates an observable property of choice to each sub-halo. The provided python interface allows users to load and populate DM halos and sub-halos obtained by FoF and SUBFIND algorithms applied to DM snapshots at any redshift. The software is highly-optimized and flexible.

Scanamorphos is an IDL program to build maps from scan observations made with bolometer arrays. Scanamorphos can post-process scan observations performed with the Herschel photometer arrays. This post-processing mainly consists in subtracting the total low-frequency noise (both its thermal and non-thermal components), masking cosmic ray hit residuals, and projecting the data onto a map. Although it was developed for Herschel, it is also applicable with minimal adjustment to scan observations made with other bolometer arrays provided they entail sufficient redundancy; it was successfully applied to P-Artemis, an instrument operating on the APEX telescope. Scanamorphos does not assume any particular noise model and does not apply any Fourier-space filtering to the data. It is an empirical tool using only the redundancy built in the observations, taking advantage of the fact that each portion of the sky is sampled at multiple times by multiple bolometers. The user is allowed to optionally visualize and control results at each intermediate step, but the processing is fully automated.

SCARLET performs source separation (aka "deblending") on multi-band images. It is geared towards optical astronomy, where scenes are composed of stars and galaxies, but it is straightforward to apply it to other imaging data. Separation is achieved through a constrained matrix factorization, which models each source with a Spectral Energy Distribution (SED) and a non-parametric morphology, or multiple such components per source. The code performs forced photometry (with PSF matching if needed) using an optimal weight function given by the signal-to-noise weighted morphology across bands. The approach works well if the sources in the scene have different colors and can be further strengthened by imposing various additional constraints/priors on each source. Because of its generic utility, this package provides a stand-alone implementation that contains the core components of the source separation algorithm. However, the development of this package is part of the LSST Science Pipeline; the meas_deblender package contains a wrapper to implement the algorithms here for the LSST stack.

Scatfit models observed burst signals of impulsive time domain radio signals ( e.g., Fast Radio Bursts (FRBs) or pulsars pulses), which usually are convolution products of various effects, and fits them to the experimental data. It includes several models for scattering and instrumental effects. The code loads the experimental time domain radio data, cleans them, fits an aggregate scattering model to the data, and robustly estimates the model parameters and their uncertainties. Additionally, scatfit determines the scaling of the scattering time with frequency, i.e. the scattering index, and the scattering-corrected dispersion measure of the burst or pulse.

SCEPtER (Stellar CharactEristics Pisa Estimation gRid) estimates the stellar mass and radius given a set of observable quantities; the results are obtained by adopting a maximum likelihood technique over a grid of pre-computed stellar models. The code is quite flexible since different observables can be used, depending on their availability, as well as different grids of models.

The fast N-body code SCF-FDPS (Self-Consistent Field-Framework for Developing Particle Simulators) simulates disk-halo systems. It combines a self-consistent field (SCF) code, which provides scalability, and a tree code that is parallelized using the Framework for Developing Particle Simulators (FDPS) (ascl:1604.011). SCF-FDPS handles a wide variety of halo profiles and can be used to study extensive dynamical problems of disk-halo systems.

schNell computes basic map-level noise properties for generic networks of gravitational wave interferometers, primarily the noise power spectrum "N_ell", but this lightweight python module that can also be used for, for example, antenna patterns, overlap functions, and inverse variance maps, among other tasks. The code has three main classes; detectors contain information about each individual detector of the network, such as their positions, noise properties, and orientation. NoiseCorrelations describes the noise-level correlation between pairs of detectors, and the MapCalculators class combines a list of Detectors into a network (potentially together with a NoiseCorrelation object) and computes the corresponding map-level noise properties arising from their correlations.

schwimmbad provides a uniform interface to parallel processing pools and enables switching easily between local development (e.g., serial processing or with multiprocessing) and deployment on a cluster or supercomputer (via, e.g., MPI or JobLib). The utilities provided by schwimmbad require that tasks or data be “chunked” and that code can be “mapped” onto the chunked tasks.

SciCatalog handles catalogs of scientific data in a way that is easily extensible, including the ability to create nicely formatted AASTex deluxe tables for use in AAS Publishing manuscripts. It handles catalogs of values, their positive and negative uncertainties, and references for those values with methods for easily adding columns and changing values. The catalog is also backed up every time it is loaded under the assumption that it is about to be modified.

SciDB is a DMAS (Data Management and Analytics Software System) optimized for data management of big data and for big analytics. SciDB is organized around multidimensional array storage, a generalization of relational tables, and is designed to be scalable up to petabytes and beyond. Complex analytics are simplified with SciDB because arrays and vectors are first-class objects with built-in optimized operations. Spatial operators and time-series analysis are easy to express. Interfaces to common scientific tools like R as well as programming languages like C++ and Python are provided.

SCIMES identifies relevant molecular gas structures within dendrograms of emission using the spectral clustering paradigm. It is useful for decomposing objects in complex environments imaged at high resolution.

SCINTOOLS (SCINtillation TOOLS) simulates and analyzes pulsar scintillation data. The code can be used for processing observed dynamic spectra, computing secondary spectra and ACFs, measuring scintillation arcs, simulating dynamic spectra, and modeling pulsar transverse velocities through scintillation arcs or diffractive timescales.

SCONCE-SCMS detects cosmic web structures, primarily cosmic filaments and the associated cosmic nodes, from a collection of discrete observations with the extended subspace constrained mean shift (SCMS) algorithms on the unit (hyper)sphere (in most cases, the 2D (RA,DEC) celestial sphere), and the directional-linear products space (most commonly, the 3D (RA,DEC,redshift) light cone).

The subspace constrained mean shift (SCMS) algorithm is a gradient ascent typed method dealing with the estimation of local principal curves, more widely known as density ridges. The one-dimensional density ridge traces over the curves where observational data are highly concentrated and thus serves as a natural model for cosmic filaments in our Universe. Modeling cosmic filaments as density ridges enables efficient estimation by the kernel density estimator (KDE) and the subsequent SCMS algorithm in a statistically consistent way. While the standard SCMS algorithm can identify the density ridges in any "flat" Euclidean space, it exhibits large bias in estimating the density ridges on the data space with a non-linear curvature. The extended SCMS algorithms used in SCONCE-SCMS are adaptive to the spherical and conic geometries and resolve the estimation bias of the standard SCMS algorithm on a 2D (RA,DEC) celestial sphere or 3D (RA,DEC,redshift) light cone.

An attempt at creating a common pythonic framework for visual and infrared telescope instrument data simulators.

A reference database for astronomical instrument and telescope characteristics for all types of visual and infrared systems. Instrument packages are used in conjunction with the ScopeSim instrument data simulator.

Templates and helper functions for creating on-sky Source description objects for the ScopeSim instrument data simulation engine.

The Shape COnstraint REstoration algorithm (SCORE) is a proximal algorithm based on sparsity and shape constraints to restore images. Its main purpose is to restore images while preserving their shape information. It can, for example, denoise a galaxy image by instanciating SCORE and using its denoise method and then visualize the results, and can deconvolve multiple images with different parameter values.

The Python package SCORPIO retrieves images and associated data of galaxy pairs based on their position, facilitating visual analysis and data collation of multiple archetypal systems. The code ingests information from SDSS, 2MASS and WISE surveys based on the available bands and is designed for studies of galaxy pairs as natural laboratories of multiple astrophysical phenomena for, among other things, tidal force deformation of galaxies, pressure gradient induced star formation regions, and morphological transformation.

The Semi-automated multi-COmponent Universal Spectral-line fitting Engine (SCOUSE) is a spectral line fitting algorithm that fits Gaussian files to spectral line emission. It identifies the spatial area over which to fit the data and generates a grid of spectral averaging areas (SAAs). The spatially averaged spectra are fitted according to user-provided tolerance levels, and the best fit is selected using the Akaike Information Criterion, which weights the chisq of a best-fitting solution according to the number of free-parameters. A more detailed inspection of the spectra can be performed to improve the fit through an iterative process, after which SCOUSE integrates the new solutions into the solution file.

scousepy is a Python implementation of spectral line-fitting IDL code SCOUSE (ascl:1601.003). It fits a large amount of complex astronomical spectral line data in a systematic way.

Scri manipulates time-dependent functions of spin-weighted spherical harmonics. It implements the BMS transformations of the most common gravitational waveforms, including the Newman-Penrose quantity ψ4, the Bondi news function, the shear spin coefficient σ, and the transverse-traceless metric perturbation h, as well as the remaining Newman-Penrose quantities ψ0 through ψ3.

SCRIPT (Semi-numerical Code for ReIonization with PhoTon-conservation) generates the ionization field during the epoch of cosmological reionization using a photon-conserving algorithm. The code depends on density and velocity files obtained using a N-body simulation, which can be generated with a 2LPT code such as MUSIC (ascl:1311.011).

Sculptor manipulates, models and analyzes spectroscopic data; the code facilitates reproducible scientific results and easy to inspect model fits. A built-in graphical user interface around LMFIT (ascl:1606.014) offers interactive control to set up and combine multiple spectral models to fully fit the spectrum of choice. Alternatively, all core functionality can be scripted to facilitate the design of spectral fitting and analysis pipelines.

SDAR (Slow-Down Algorithmic Regularization) simulates the long-term evolution of few-body systems such as binaries and triples. The algorithm used provides a few orders of magnitude faster performance than the classical N-body method. The secular evolution of hierarchical systems, e.g. Kozai-Lidov oscillation, can be well reproduced. The code is written in the C++ language and can be used either as a stand-alone tool or a library to be plugged in other N-body codes. The high precision of the floating point to 62 digits is also supported.

Dual Active Nuclei Galaxies (DAGNs) are rare occurrences in the sky. Until now, most AGNs have been described to be found serendipitously, or by manual observation. In recent years, there has been an increasing interest in such dual AGNs and their astrophysical properties. Their study is important to the understanding of galaxy formation, star formation and these objects are the precursors to Gravitational Wave Sources.

Hence, we have devised a pipeline, that along with systematic data collection, can detect such dual AGN candidates. A novel algorithm 'Graph-Boosted Gradient Ascent' has been devised to detect whether an R-band image of a galaxy is a potential candidate for a DAGN or not. The pipeline can be cloned to a user's machine, and by joining the AstrIRG_DAGN group on SciServer, astronomers can collectively contribute to the mining of DAGNs.

Seaborn provides a high-level interface for drawing attractive statistical graphics. Written in Python, it builds on matplotlib and integrates closely with pandas data structures. Its plotting functions operate on dataframes and arrays containing whole datasets and internally perform the necessary semantic mapping and statistical aggregation to produce informative plots. Its dataset-oriented, declarative API allows the user to focus on what the different elements of the plots mean, rather than on the details of how to draw them.

SearchCal builds an evolutive catalog of stars suitable as calibrators within any given user-defined angular distance and magnitude around a scientific target. SearchCal can select suitable bright calibration stars (V ≤ 10; K ≤ 5.0) for obtaining the ultimate precision of current interferometric instruments like the VLTI and faint calibration stars up to K ~ 15 around the scientific target. Star catalogs available at the CDS are searched via web requests and provide the useful astrometric and photometric informations for selecting calibrators. The missing photometries are computed with an accuracy of about 0.1 mag. The stellar angular diameter is estimated with a precision of about 10% through newly determined surface-brightness versus color-index relations based on the I, J, H and K magnitudes. For each star the squared visibility is computed taking into account the central wavelength and the maximum baseline of the predicted observations.

SeBa is the stellar and binary evolution module, fully integrated into the kira N-body integrator, for Starlab (ascl:1010.076), although it can also be used as a stand-alone module for non-dynamical applications. Due to the interaction between stellar evolution and stellar dynamics, it is difficult to solve for the evolution of both systems in a completely self-consistent way. The trajectories of stars are computed using a block timestep scheme, as described earlier. Stellar and binary evolution is updated at fixed intervals (every 1/64 of a crossing time, typically a few thousand years). Any feedback between the two systems may thus experience a delay of at most one timestep. Internal evolution time steps may differ for each star and binary, and depend on binary period, perturbations due to neighbors, and the evolutionary state of the star. Time steps in this treatment vary from several milliseconds up to (at most) a million years.

Prior to recombination photons, electrons, and atomic nuclei rapidly scattered and behaved, almost, like a single tightly-coupled photon-baryon plasma. In order to solve the cosmological perturbation equations during that time, Cosmic Microwave Background (CMB) codes use the so-called tight-coupling approximation in which the problematic terms (i.e. the source of the stiffness) are expanded in inverse powers of the Thomson Opacity. Most codes only keep the terms linear in the inverse Thomson Opacity. We have developed a second-order tight-coupling code to test the validity of the usual first-order tight-coupling code. It is based on the publicly available code CAMB.

SecularMultiple computes the secular (orbit-averaged) gravitational dynamics of hierarchical multiple systems composed of nested binary orbits (simplex-type systems) with any configuration and any number of bodies. A particle can represent a binary or a body. The structure of the system is determined by linking to other particles with the attributes child1 and child2, and tidal interactions and relativistic corrections are included in an ad hoc fashion. SecularMultiple also includes routines for external perturbations such as flybys and supernovae.

SEDBYS (Spectral Energy Distribution Builder for Young Stars) provides command-line tools and uses existing functions from standard packages such as Astropy (ascl:1304.002) to collate archival photometric and spectroscopic data. It also builds and inspects SEDS, and automatically collates the necessary software references.

SEDkit constructs and analyzes simple spectral energy distributions (SED). This collection of pure Python modules creates individual SEDs or SED catalogs from spectra and/or photometry and calculates fundamental parameters (fbol, Mbol, Lbol, Teff, mass, log(g)).

SEDobs uses state-of-the-art theoretical galaxy SEDs (spectral energy distributions) to create simulated observations of distant galaxies. It used BC03 and M05 theoretical models and allows the user to configure the simulated observation that are needed. For a given simulated galaxy, the user is able to simulate multi-spectral and multi-photometric observations.

sedop is a Monte-Carlo minimization code designed to optimally construct spectral energy distributions (SEDs) for sources of ultraviolet and X-ray radiation employed in numerical simulations of reionization and radiative feedback.

SEDPY performs a variety of tasks for astronomical spectral energy distributions. It can generate synthetic photometry through any filter, provides detailed modeling of extinction curves, and offers basic aperture photometry algorithms. SEDPY can also store and interpolate model SEDs, convolve absolute or apparent fluxes, and calculate rest-frame magnitudes.

SEEK (Signal Extraction and Emission Kartographer) processes time-ordered-data from single dish radio telescopes or from the simulation pipline HIDE (ascl:1607.019), removes artifacts from Radio Frequency Interference (RFI), automatically applies flux calibration, and recovers the astronomical radio signal. With its companion code HIDE (ascl:1607.019), it provides end-to-end simulation and processing of radio survey data.

SeeKAT is a Python implementation of a novel maximum-likelihood estimation approach to localizing transients and pulsars detected in multiple MeerKAT tied-array beams at once to (sub-)arcsecond precision. It reads in list of detections (RA, Dec, S/N) and the beam PSF and computes a covariance matrix of the S/N value ratios, assuming 1-sigma Gaussian errors on each measurement. It models the aggregate beam response by arranging beam PSFs appropriately relative to each other and calculates a likelihood distribution of obtaining the observed S/N in each beam according to the modeled response. In addition, SeeKAT can plot the likelihood function over RA and Dec with 1-sigma uncertainty, overlaid on the beam coordinates and sizes.

The Python package segueSelect automatically models the SDSS/SEGUE selection fraction -- the fraction of stars with good spectra -- as a continuous function of apparent magnitude for each plate. The selection function can be determined for any desired sample cuts in signal-to-noise ratio, u-g, r-i, and E(B-V). The package requires Pyfits (ascl:1207.009) and, for coordinate transformations, galpy (ascl:1411.008). It can calculate the KS probability that the spectropscopic sample was drawn from the underlying photometric sample with the model selection function, plot the cumulative distribution function in r-band apparent magnitude of the spectroscopic sample (red) and the photometric sample+selection-function-model for this plate, and, if galpy is installed, can transform velocities into the Galactic coordinate frame. The code can also determine the selection function for SEGUE K stars.

SELCIE (Screening Equations Linearly Constructed and Iteratively Evaluated) investigates the chameleon model that arises from screening a scalar field introduced in some modified gravity models that is coupled to matter. The code provides tools to construct user defined meshes by utilizing the GMSH mesh generation software. These tools include constructing shapes whose boundaries are defined by some function or by constructing it out of basis shapes such as circles, cones and cylinders. The mesh can also be separated into subdomains, each of which having its own refinement parameters. These meshes can then be converted into a format that is compatible with the finite element software FEniCS. SELCIE uses FEniCS (ascl:2110.018) with a nonlinear solving method (Picard or Newton method) to solve the chameleon equation of motion for some parameters and density distribution. These density distributions are constructed by having the density profile of each subdomain being set by a user defined function, allowing for extremely customizable setups that are easy to implement.

Self-cal produces radio-interferometric images of an astrophysical object. The code is an adaptation of the self-calibration algorithm to optical/infrared long-baseline interferometry, especially to make use of differential phases and differential visibilities. It works together with the Mira image reconstruction software and has been used mainly on VLTI data. Self-cal, written in Yorick, is also available as part of fitsOmatic (ascl:2301.005).

The self-lensing binary code with Markov chain code was used to analyze the self-lensing binary system KOI-3278. It includes the MCMC modeling and the key figures.

Sengi enables online viewing of the spectral outputs of stellar population synthesis (SPS) codes. Typical SPS codes require significant disk space or computing resources to produce spectra for simple stellar populations with arbitrary parameters, making it difficult to present their results in an interactive, web-friendly format. Sengi uses Non-negative Matrix Factorisation (NMF) and bilinear interpolation to estimate output spectra for arbitrary values of stellar age and metallicity; this reduces the disk requirements and computational expense, allowing Sengi to serve the results in a client-based Javascript application.

SENR (Simple, Efficient Numerical Relativity) provides the algorithmic framework that combines the C codes generated by NRPy+ (ascl:1807.025) into a functioning numerical relativity code. It is part of the numerical relativity code package SENR/NRPy+. The package extends previous implementations of the BSSN reference-metric formulation to a much broader class of curvilinear coordinate systems, making it suitable for modeling physical configurations with approximate or exact symmetries, such as modeling black hole dynamics.

SEP (Source Extraction and Photometry) makes the core algorithms of Source Extractor (ascl:1010.064) available as a library of standalone functions and classes. These operate directly on in-memory arrays (no FITS files or configuration files). The code is derived from the Source Extractor code base (written in C) and aims to produce results compatible with Source Extractor whenever possible. SEP consists of a C library with no dependencies outside the standard library and a Python module that wraps the C library in a Pythonic API. The Python wrapper operates on NumPy arrays with NumPy as its only dependency. It is generated using Cython.

From Source Extractor, SEP includes background estimation, image segmentation (including on-the-fly filtering and source deblending), aperture photometry in circular and elliptical apertures, and source measurements such as Kron radius, "windowed" position fitting, and half-light radius. It also adds the following features that are not available in Source Extractor: optimized matched filter for variable noise in source extraction; circular annulus and elliptical annulus aperture photometry functions; local background subtraction in shape consistent with aperture in aperture photometry functions; exact pixel overlap mode in all aperture photometry functions; and masking of elliptical regions on images.

Subpixel Event Repositioning (SER) techniques significantly improve the already unprecedented spatial resolution of Chandra X-ray imaging with the Advanced CCD Imaging Spectrometer (ACIS). Chandra CCD SER techniques are based on the premise that the impact position of events can be refined, based on the distribution of charge among affected CCD pixels. Unlike ACIS SER models that are restricted to corner split (3- and 4-pixel) events and assume that such events take place at the split pixel corners, this IDL code uses two-pixel splits as well, and incorporates more realistic estimates of photon impact positions.

SEREN is an astrophysical Smoothed Particle Hydrodynamics code designed to investigate star and planet formation problems using self-gravitating hydrodynamics simulations of molecular clouds, star-forming cores, and protostellar disks.

SEREN is written in Fortran 95/2003 with a modular philosophy for adding features into the code. Each feature can be easily activated or deactivated by way of setting options in the Makefile before compiling the code. This has the added benefit of allowing unwanted features to be removed at the compilation stage resulting in a smaller and faster executable program. SEREN is written with OpenMP directives to allow parallelization on shared-memory architecture.

SERPent is an automated reduction and RFI-mitigation procedure that uses the SumThreshold methodology. It was originally developed for the LOFAR pipeline. SERPent is written in Parseltongue, enabling interaction with the Astronomical Image Processing Software (AIPS) program. Moreover, SERPent is a simple "out of the box" Python script, which is easy to set up and is free of compilers.

Sérsic is an implementation of the exact deprojection of Sérsic surface brightness profiles described in Baes and Gentile (2011). This code depends on the mpmath python library for an implementation of the Meijer G function required by the Baes and Gentile (hereafter B+G) formulas for rational values of the Sérsic index. Sérsic requires rational Sérsic indices, but any irrational number can be approximated arbitrarily well by some rational number. The code also depends on scipy, but the dependence is mostly for testing. The implementation of the formulas and the formulas themselves have undergone comprehensive testing.

SERVAL calculates radial velocities (RVs) from stellar spectra. The code uses least-squares fitting algorithms to derive the RVs and additional spectral diagnostics. Forward modeling in pixel space is used to properly weight pixel errors, and the stellar templates are reconstructed from the observations themselves to make optimal use of the RV information inherent in the stellar spectra.

SetCoverPy finds an (near-)optimal solution to the set cover problem (SCP) as fast as possible. It employs an iterative heuristic approximation method, combining the greedy and Lagrangian relaxation algorithms. It also includes a few useful tools for a quick chi-squared fitting given two vectors with measurement errors.

The SETI Encryption code, written in Python, creates a message for use in testing the decryptability of a simulated incoming interstellar message. The code uses images in a portable bit map (PBM) format, then writes the corresponding bits into the message, and finally returns both a PBM image and a text (TXT) file of the entire message. The natural constants (c, G, h) and the wavelength of the message are defined in the first few lines of the code, followed by the reading of the input files and their conversion into 757 strings of 359 bits to give one page. Each header of a page, i.e., the little-endian binary code translation of the tempo-spatial yardstick, is calculated and written on-the-fly for each page.

The population synthesis code SEVN (Stellar EVolution for N-body) includes up-to-date stellar evolution (through look-up tables), binary evolution, and different recipes for core-collapse supernovae. SEVN also provides an up-to-date formalism for pair-instability and pulsational pair-instability supernovae, and is designed to interface with direct-summation N-body codes such as STARLAB (ascl:1010.076) and HiGPUs (ascl:1207.002).

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.

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.

sf_deconvolve performs PSF deconvolution using a low-rank approximation and sparsity. It can handle a fixed PSF for the entire field or a stack of PSFs for each galaxy position. The code accepts Numpy binary files or FITS as input, takes the observed (i.e. with PSF effects and noise) stack of galaxy images and a known PSF, and attempts to reconstruct the original images. sf_deconvolve can be run in a terminal or in an active Python session, and includes options for initialization, optimization, low-Rank approximation, sparsity, PSF estimation, and other attributes.

sf3dmodels models star-forming regions; it brings together analytical models in order to compute their physical properties in a 3-dimensional grid. The package can couple different models in a single grid to recreate complex star forming systems such as those being revealed by current instruments. The output data can be read with LIME (ascl:1107.012) or RADMC-3D (ascl:1108.016) to carry out radiative transfer calculations of the modeled region.

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

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.

SFQEDtoolkit implements strong-field QED (SFQED) processes in existing particle-in-cell (PIC) and Monte Carlo codes to determine the dynamics of particles and plasmas in extreme electromagnetic fields, such as those present in the vicinity of compact astrophysical objects. The code uses advanced function approximation techniques to calculate high-energy photon emission and electron-positron pair creation probability rates and energy distributions within the locally-constant-field approximation (LCFA) as well as with more advanced models.

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.

NOTE: SGNAPS functionality has been transitioned to EZ.

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.

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

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.

The shapelens C++ library provides ways to load galaxies and star images from FITS files and catalogs and to analyze their morphology. The main purpose of this library is to make several weak-lensing shape estimators publicly available. All of them are based on the moments of the brightness distribution. The estimators include DEIMOS, for analytic deconvolution in moment space, DEIMOSElliptical, a practical implemention of DEIMOS with an automatically matched elliptical weight function, DEIMOSCircular, which is identical to DEIMOSElliptical but with a circular weight function, and others.

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.

ShapeMeasurementFisherFormalism is used to study Fisher Formalism predictions on galaxy weak lensing for LSST Dark Energy Science Collaboration. It can create predictions with user-defined parameters for one or two galaxies simulated from GalSim (ascl:1402.009).

ShapePipe processes single-exposure images and stacked images. Input images have to be calibrated beforehand for astrometry and photometry. The code can handle different image and file types, such as single-exposure mosaic, single-exposure single-CCD, stacked images, database catalog files, and PSF files, some of which are created by the pipeline during the analysis, among others. The end product of ShapePipe is a final catalog containing information for each galaxy, including its shape parameters and the ellipticity components :math:e_1 and :math:e_2. This catalog also contains shapes of artificially sheared images. This information is used in post-processing to compute calibrated shear estimates via metacalibration.

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.

SHARK solves the hydrodynamic equations for gas and dust mixtures accounting for dust coagulation and fragmentation (among other things). The code is written in Fortran and is capable of handling both 1D and 2D Cartesian geometries; 1D simulations with spherical geometry are also possible. SHARK is versatile and can be used to model various astrophysical environments.

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.

shear-stacking calculates stacked shear profiles and tests based upon them, e.g. consistency for different slices of lensed background galaxies. The basic concept is that the lensing signal in terms of surface mass density (instead of shear) should be entirely determined by the properties of the lens sample and have no dependence on source galaxy properties.

The photometric redshift-aided classification pipeline SHEEP uses ensemble learning to classify astronomical sources into galaxies, quasars and stars. It uses tabular data and also allows the use of sparse data. The approach uses SDSS and WISE photometry, but SHEEP can also be used with other types of tabular data, such as radio fluxes or magnitudes.

SHELLSPEC calculates 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. A related code based on SHELLSPEC, Pyshellspec (ascl:2106.006), solves the inverse problem of finding the stellar and orbital parameters.

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

The end-to-end SHERLOCK (Searching for Hints of Exoplanets fRom Lightcurves Of spaCe-based seeKers) pipeline allows users to explore data from space-based missions to search for planetary candidates. It can recover alerted candidates by the automatic pipelines such as SPOC and the QLP, Kepler objects of interest (KOIs) and TESS objects of interest (TOIs), and can search for candidates that remain unnoticed due to detection thresholds, lack of data exploration, or poor photometric quality. SHERLOCK has six different modules to perform its tasks; these modules can be executed by filling in an initial YAML file with some basic information and using a few lines of code sequentially to pass from one step to the next. Alternatively, the user may provide with the light curve in a csv file, where the time, normalized flux, and flux error are provided in columns in comma-separated format.

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.

SHTOOLS performs (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.

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.

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.

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.

SICON (Stokes Inversion based on COnvolutional Neural networks) provides a three-dimensional cube of thermodynamical and magnetic properties from the interpretation of two-dimensional maps of Stokes profiles by use of a convolutional neural network. In addition to being much faster than parallelized inversion codes, SICON, when trained on synthetic Stokes profiles from two numerical simulations of different structures of the solar atmosphere, also provided a three-dimensional view of the physical properties of the region of interest in geometrical height, and pressure and Wilson depression properties that are decontaminated from the blurring effect of instrumental point spread functions.

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.

The SIDM model combines the isothermal Jeans model and the model of adiabatic halo contraction into a simple semi-analytic procedure for computing the density profile of self-interacting dark-matter (SIDM) haloes with the gravitational influence from the inhabitant galaxies. It agrees well with cosmological SIDM simulations over the entire core-forming stage and up to the onset of gravothermal core-collapse. The fast speed of the method facilitates analyses that would be challenging for numerical simulations.

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.

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

Silo reads and writes a wide variety of scientific data to binary disk files. The files Silo produces and the data within them can be easily shared and exchanged between wholly independently developed applications running on disparate computing platforms. Consequently, Silo facilitates the development of general purpose tools for processing scientific data. One of the more popular tools that process Silo data files is the VisIt visualization tool (ascl:1103.007).

Silo supports gridless (point) meshes, structured meshes, unstructured-zoo and unstructured-arbitrary-polyhedral meshes, block structured AMR meshes, constructive solid geometry (CSG) meshes, piecewise-constant (e.g., zone-centered) and piecewise-linear (e.g. node-centered) variables defined on the node, edge, face or volume elements of meshes as well as the decomposition of meshes into arbitrary subset hierarchies including materials and mixing materials. In addition, Silo supports a wide variety of other useful objects to address various scientific computing application needs. Although the Silo library is a serial library, it has features that enable it to be applied quite effectively and scalable in parallel.

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.

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.

SimAb (Simulating Abundances) simulates planet formation, focusing on the atmosphere accretion of gas giant planets. The package can run the simulation in two different modes. The single simulation mode is run by specifying the initial conditions (the core mass, the initial orbital distance, the planetesimal ratio, and the dust grain fraction), and the mature planet mass and orbital distance. The multi run simulation mode requires specifying the mass and the final orbital distance of the mature planet; the simulation randomly assigns initial orbital distance, initial core mass, initial planetesimal ratio, and initial dust grain fraction. The package also provides Jupyter codes for plotting the results of the simulations.

SIMBI simulates heterogeneous relativistic gas dynamics up to 3d for special relativistic hydrodynamics and up to 2D Newtonian hydrodynamics. It supports user-defined mesh expansion and contraction, density, momentum, and energy density terms outside of grid; the code also supports source terms in the Euler equations and source terms at the boundaries. Boundary conditions, which include periodic, reflecting, outflow, and inflow boundaries, are given as an array of strings. If an inflow boundary condition is set but no inflow boundary source terms are given, SIMBI switches to outflow boundary conditions to prevent crashes. The code can track a single passive scalar, insert an immersed boundary, and is impermeable by default. SIMBI USES the Cython framework to blend together C++, CUDA, HIP, and Python.

SimCADO simulates observations with any NIR/Vis imaging system. Though the package was originally designed to simulate images for the European Extremely Large Telescope (ELT) and MICADO, with the proper input, it is capable of simulating observations from many different telescope and instrument configurations.

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.

SimLine computes the profiles of molecular rotational transitions and atomic fine structure lines in spherically symmetric clouds with arbitrary density, temperature and velocity structure. The code is designed towards a maximum flexibility and very high accuracy based on a completely adaptive discretization of all quantities. The code can treat arbitrary species in spherically symmetric configurations with arbitrary velocity structures and optical depths between about -5 and 5000. Moreover, SimLine includes the treatment of turbulence and clumping effects in a local statistical approximation combined with a radial dependence of the correlation parameters. The code consists of two parts: the self-consistent solution of the balance equations for all level populations and energy densities at all radial points and the computation of the emergent line profiles observed from a telescope with finite beam width and arbitrary offset.

SImMER (Stellar Image Maturation via Efficient Reduction) reduces astronomical imaging data. It performs standard dark-subtraction and flat-fielding operations on data from, for example, the ShARCS camera on the Shane 3-m telescope at Lick Observatory and the PHARO camera on the Hale 5.1-m telescope at Palomar Observatory; its object-oriented design allows the software to be extended to other instruments. SImMER can also perform sky-subtraction, image registration, FWHM measurement, and contrast curve calculation, and can generate tables and plots. For widely separated stars which are of somewhat equal brightness, a “wide binary” mode allows the user to selects which star is the primary around which each image should be centered.

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.

simple_reg_dem reconstructs differential emission measures (DEMs) in the solar corona. It overcomes issues, such as complexity, idiosyncratic output, convergence difficulty, and lack of speed, that exists in other methods. Initially written for extreme ultraviolet (EUV) data, the algorithm is notable for its simplicity, and is robust and extensible to any other wavelengths (e.g., X-rays) where the DEM treatment is valid. It is available in the SolarSoft (ascl:1208.013) package.

Made-to-measure (M2M) is a standard technique for modeling the dynamics of astrophysical systems in which the system is modeled with a set of N particles with weights that are slowly optimized to fit a set of constraints while integrating these particles forward in the gravitational potential. Simple-m2m extends this standard technique to allow parameters of the system other than the particle weights to be fit as well, including nuisance parameters that describe the observer's relation to the dynamical system (e.g., the inclination) or parameters describing an external potential.

SIMPLE (Simple Intensity Map Producer for Line Emission) generates intensity maps that include observational effects such as noise, anisotropic smoothing, sky subtraction, and masking. Written in Python, it is based on a lognormal simulation of galaxies and random assignment of luminosities to these galaxies and generates mock intensity maps that can be used to study survey systematics and calculate covariance matrices of power spectra. The code is modular, allowing its components to be used independently.

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.

simqso generates mock quasar spectra and photometry. Simulated quasar spectra are built from a series of components. Common quasar models are built-in, such as a broken power-law continuum model and Gaussian emission line templates; however, the code allows user-defined features to be included. Mock spectra are generated at arbitrary resolution and can be used to produce broadband photometry representative of a number of surveys.

The R-package SimSpin measures the kinematics of a galaxy simulation as if it had been observed using an IFU. The functions included in the package can produce a kinematic data cube and measure the "observables" from this data cube, specifically the observable spin parameter λr. This package, once installed, is fully documented and tested.

simulateSearch simulates high time-resolution data in radio astronomy. The code is built around producing multiple binary data files that contain information on the radiometer noise and sources that are being simulated. These binary data files subsequently get combined and output PSRFITS
search mode files produced. The PSRFITS files can be processed using standard pulsar software packages such as PRESTO (ascl:1107.017).

simuTrans models transit light curves affected by gravity-darkened stars. The code defines a star on a grid by modeling the brightness of each point as blackbody emission, then sets a series of parameters and uses emcee (ascl:1303.002) to explore the posterior probability distribution for the remaining fitted parameters and determine their best-fit values.

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.

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.

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

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:

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.

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.

SIRENA (Software Ifca for Reconstruction of EveNts for Athena X-IFU) reconstructs the energy of incoming X-ray photons after their detection in the X-IFU TES detector. It is integrated in the SIXTE (ascl:1903.002) end-to-end simulations environment where it currently runs over SIXTE simulated data. This is done by means of a tool called tesreconstruction, which is mainly a wrapper to pass a data file to the SIRENA tasks.

SISPO (Space Imaging Simulator for Proximity Operations) simulates trajectories, light parameters, and camera intrinsic parameters for small solar system body fly-by and terrestrial planet surface missions. The software provides realistic surface rendering and realistic dust- and gas-environment optical models for comets and active asteroids and also simulates common image aberrations such as simple geometric distortions and tangential astigmatism. SISPO uses Blender and its Cycles rendering engine, which provides physically based rendering capabilities and procedural micropolygon displacement texture generation.

SISTER (Starshade Imaging Simulations Toolkit for Exoplanet Reconnaissance) predicts how an exoplanet system would look in an instrument that utilizes an Starshade to block the light from the host star. The tool allows for controlling a set of parameters of the whole instrument for: (1) the Starshade design, (2) the exoplanetary system, (3) the telescope and (4) the camera. SISTER includes plotting software, and can also store simulations on disk for plotting with other software.

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.

SIXTE simulates X-Ray telescope observation; the software performs instrument performance analyses and produces simulated event files for mission and analysis studies. SIXTE strives to find a compromise between exactness of the simulation and speed. Using calibration files such as the PSF, RMF and ARF makes efficient simulations possible at comparably high speed, even though they include nonlinear effects such as pileup. Setups for some current and future missions, such as XMM-Newton and Athena, are included in the package; others can be added by the user with relatively little effort through specifying the main instrument characteristics in a flexible, human-readable XML-based format. Properties of X-ray sources to be simulated are described in a detector-independent format, i.e., the same input can be used for simulating observations with all available instruments, and the same input can also be used for simulations with the SIMX simulator. The input files are easily generated from standard data such as XSPEC (ascl:9910.005) spectral models or FITS images with tools provided with the SIXTE distribution. The input data scale well from single point sources up to very complicated setups.

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.

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.

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.

SkyCalc-iPy (SkyCalc for interactive Python) accesses atmospheric emission and transmission data generated by ESO’s SkyCalc tool interactively with Python. This package is based on the command line tool by ESO for accessing spectra on the ESO SkyCalc server.

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

All of the required packages are always included in the tarfile.

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.

The Skye framework develops and prototypes new EOS physics; it is not tied to a specific set of physics choices and can be extended for new effects by writing new terms in the free energy. It takes into account the effects of positrons, relativity, electron degeneracy, and non-linear mixing effects and more, and determines the point of Coulomb crystallization in a self-consistent manner. It is available in the MESA (ascl:1010.083) EOS module and as a standalone package.

Skye detects a statistically significant excess clustering of transit times, indicating that there are likely systematics at specific times that cause many false positive detections, for the Kepler DR25 planet candidate catalog. The technique could be used for any survey looking to statistically cull false alarms.

Skyfield computes positions for the stars, planets, and satellites in orbit around the Earth. Its results should agree with the positions generated by the United States Naval Observatory and their Astronomical Almanac to within 0.0005 arcseconds (which equals half a “mas” or milliarcsecond). It computes geocentric coordinates or topocentric coordinates specific to your location on the Earth’s surface. Skyfield accepts AstroPy (ascl:1304.002) time objects as input and can return results in native AstroPy units but is not dependend on AstroPy nor its compiled libraries.

Skylens++ implements a Layer-based raytracing framework particularly well-suited for realistic simulations of weak and strong gravitational lensing. Source galaxies can be drawn from analytic models or deep space-based imaging. Lens planes can be populated with arbitrary deflectors, typically either from N-body simulations or analytic lens models. Both sources and lenses can be placed at freely configurable positions into the light cone, in effect allowing for multiple source and lens planes.

SkyLine generates mock line-intensity maps (both in 3D and 2D) in a lightcone from a halo catalog, accounting for the evolution of clustering and astrophysical properties, and observational effects such as spectral and angular resolutions, line-interlopers, and galactic foregrounds. Using a given astrophysical model for the luminosity of each line, the code paints the signal for each emitter and generates the map, adding coherently all contributions of interest. In addition, SkyLine can generate maps with the distribution of Luminous Red Galaxies and Emitting Line Galaxies.

SkyMaker simulates astronomical images. It accepts object lists in ASCII generated by the Stuff program (ascl:1010.067) to produce realistic astronomical fields. SkyMaker is part of the EFIGI development project.

Skymapper maps astronomical survey data from the celestial sphere onto 2D using a collection of matplotlib instructions. It facilitates interactive work as well as the creation of publication-quality plots with a python-based workflow many astronomers are accustomed to. The primary motivation is a truthful representation of samples and fields from the curved sky in planar figures, which becomes relevant when sizable portions of the sky are observed.

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.

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.

Skyoffset makes wide-field mosaics of FITS images. Principal features of Skyoffset are the ability to produce a mosaic with a continuous background level by solving for sky offsets that minimize the intensity differences between overlapping images, and its handling of hierarchies, making it ideal for optimizing backgrounds in large mosaics made with array cameras (such as CFHT’s MegaCam and WIRCam). Skyoffset uses MongoDB in conjunction with Mo’Astro (ascl:2104.012) to store metadata about each mosaic and SWarp (ascl:1010.068) to handle image combination and propagate uncertainty maps. Skyoffset can be integrated into Python pipelines and offers a convenient API and metadata storage in MongoDB. It was developed originally for the Andromeda Optical and Infrared Disk Survey (ANDROIDS).

SkyPy simulates the astrophysical sky. It provides functions that sample realizations of sources and their associated properties from probability distributions. Simulation pipelines are constructed from these models, while task scheduling and data dependencies are handled internally. The package's modular design, containing a library of physical and empirical models across a range of observables and a command line script to run end-to-end simulations, allows users to interface with external software.

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.

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.

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

Many fields in science and engineering measure data that inherently live on non-Euclidean geometries, such as the sphere. Techniques developed in the Euclidean setting must be extended to other geometries. Due to recent interest in geometric deep learning, analogues of Euclidean techniques must also handle general manifolds or graphs. Often, data are only observed over partial regions of manifolds, and thus standard whole-manifold techniques may not yield accurate predictions. In this thesis, a new wavelet basis is designed for datasets like these.

Although many definitions of spherical convolutions exist, none fully emulate the Euclidean definition. A novel spherical convolution is developed, designed to tackle the shortcomings of existing methods. The so-called sifting convolution exploits the sifting property of the Dirac delta and follows by the inner product of a function with the translated version of another. This translation operator is analogous to the Euclidean translation in harmonic space and exhibits some useful properties. In particular, the sifting convolution supports directional kernels; has an output that remains on the sphere; and is efficient to compute. The convolution is entirely generic and thus may be used with any set of basis functions. An application of the sifting convolution with a topographic map of the Earth demonstrates that it supports directional kernels to perform anisotropic filtering.

Slepian wavelets are built upon the eigenfunctions of the Slepian concentration problem of the manifold - a set of bandlimited functions which are maximally concentrated within a given region. Wavelets are constructed through a tiling of the Slepian harmonic line by leveraging the existing scale-discretised framework. A straightforward denoising formalism demonstrates a boost in signal-to-noise for both a spherical and general manifold example. Whilst these wavelets were inspired by spherical datasets, like in cosmology, the wavelet construction may be utilised for manifold or graph data.

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.

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.

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.

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.

SLIT (Sparse Lens Inversion Technique) provides a method for inversion of lensed images in the frame of strong gravitational lensing. The code requires the input image along with lens mass profile and a PSF. The user then has to chose a maximum number of iterations after which the algorithm will stop if not converged and a image size ratio to the input image to set the resolution of the reconstructed source. Results are displayed in pyplot windows.

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.

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.

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.

SMART (Spectral energy distributions Markov chain Analysis with Radiative Transfer models) implements a Bayesian Markov chain Monte Carlo (MCMC) method to fit the ultraviolet to millimeter spectral energy distributions (SEDs) of galaxies exclusively with radiative transfer models. The models constitute four types of pre-computed libraries, which describe the starburst, active galactic nucleus (AGN) torus, host galaxy and polar dust components.

Smart provides pre-processing for LP-VIcode (ascl:1501.007). It computes the accelerations and variational equations given a generic user-defined potential function, eliminating the need to calculate manually the accelerations and variational equations.

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.

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.

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.

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² log n) and efficiently derives the necessary conditional covariance matrices.

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.

SMILI uses sparse sampling techniques and other regularization methods for interferometric imaging. The python-interfaced library is mainly designed for very long baseline interferometry, and has been under the active development primarily for the Event Horizon Telescope (EHT).

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.

Smooth calculates several mean quantities for all particles in an N-Body simulation output file. The program produces a file for each type of output specified on the command line. This output file is in ASCII format with one smoothed quantity for each particle. The program uses a symmetric SPH (Smoothed Particle Hydrodynamics) smoothing kernel to find the mean quantities.

smops interpolates input sub-band model FITS images, such as those produced by WSClean (ascl:1408.023), into more finely channelized sub-band model FITS images, thus generating model images at a higher frequency resolution. It is a Python-based command line tool. For example, given input model FITS images initially created from sub-dividing a given bandwidth into four, smops can subdivide that bandwidth further, resulting in more finely channelized model images, to a specified frequency resolution. This smooths out the stepwise behavior of models across frequency, which can improve the results of self-calibration with such models.

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.

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.

SNAPDRAGONS (Stellar Numbers And Parameters Determined Routinely And Generated Observing N-body Systems) is a simplified version of the population synthesis code Galaxia (ascl:1101.007), using a different process to generate the stellar catalog. It splits each N-body particle from the galaxy simulation into an appropriate number of stellar particles to create a mock catalog of observable stars from the N-body model. SNAPDRAGON uses the same isochrones and extinction map as Galaxia.

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.

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

SNEWPY uses simulated supernovae data to generate a time series of neutrino spectral fluences at Earth or the total time-integrated spectral fluence. The code can also process generated data through SNOwGLoBES (ascl:2109.019) and collate its output into the observable channels of each detector. Data from core-collapse, thermonuclear, and pair-instability supernovae simulations are included in the package.

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.

snmachine reads in photometric supernova light curves, extracts useful features from them, and subsequently performs supervised machine learning to classify supernovae based on their light curves. This python library is also flexible enough to easily extend to general transient classification.

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.

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.

Snowball models atmospheric loss in order to constrain an atmosphere's cumulative impact of historic X-ray and extreme ultraviolet radiation-driven mass loss. The escape model interpolates the BaSTI luminosity evolution grid to the observed mass and luminosity of the host star.

SNOwGLoBES (SuperNova Observatories with GLoBES) computes interaction rates and distributions of observed quantities for supernova burst neutrinos in common detector materials. The code provides a very simple and fast code and data package for tests of observability of physics signatures in current and future detectors, and for evaluation of relative sensitivities of different detector configurations. The event estimates are made using available cross-sections and parameterized detector responses. Water, argon, scintillator and lead-based configurations are included. The package makes use of GLoBES (ascl:2109.018). SNOwGLoBES is not intended to replace full detector simulations; however output should be useful for many types of studies, and simulation results can be incorporated.

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.

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.

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.

so_noise_models is the N(ell) noise curve projection code for the Simons Observatory. The code, written in pure Python, consists of several independent sub-modules, representing each version of the noise code. The usage of the models can vary substantially from version to version. The package also includes demo code that that demonstrates usage of the noise models, such as by producing noise curve plots, effective noise power spectra for SO LAT component-separated CMB T, E, B, and Compton-y maps, and lensing noise curves from SO LAT component-separated CMB T, E, B maps.

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.

SOAP-GPU is a revision of SOAP 2 (ascl:1504.021), which simulates spectral time series with the effect of active regions (spot, faculae or both). In addition to the traditional outputs of SOAP 2.0 (the cross-correlation function and extracted parameters: radial velocity, bisector span, full width at half maximum), SOAP-GPU generates the integrated spectra at each phase for given input spectra and spectral resolution. Additional capabilities include fast spectral simulation of stellar activity due to GPU acceleration, simulation of more complicated active region structures with superposition between active regions, and more realistic line bisectors, based on solar observations, that varies as function of mu angle for both quiet and active regions. In addition, SOAP-GPU accepts any input high resolution observed spectra. The PHOENIX synthetic spectral library are already implemented at the code level which allows users to simulate stellar activity for stars other than the Sun. Furthermore, SOAP-GPU simulates realistic spectral time series with either spot number/SDO image as additional inputs. The code is written in C and provides python scripts for input pre-processing and output post-processing.

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.

SoFiA 2 is a fully automated spectral-line source finding pipeline originally intended for the detection of galaxies in large HI data cubes. It is a reimplementation of parts of the original SoFiA pipeline (ascl:1412.001) in the C programming language and uses OpenMP for multithreading, making it substantially faster and more memory-efficient than its predecessor. At its core, SoFiA 2 uses the Smooth + Clip algorithm for source finding which operates by spatially and spectrally smoothing the data on multiple scales and applying a user-defined flux threshold relative to the noise level in each iteration. A wide range of useful preconditioning and post-processing filters is available, including noise normalization, flagging of artifacts and reliability filtering. In addition to global data products and source catalogs in different formats, SoFiA 2 can also generate cutout images and spectra for each individual detection.

SoFiA is a flexible source finding pipeline designed to detect and parameterize sources in 3D spectral-line data cubes. SoFiA combines several powerful source finding and parameterization algorithms, including wavelet denoising, spatial and spectral smoothing, source mask optimization, 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.

A reimplementation of this pipeline using OpenMPI, SoFiA 2 (ascl:2109.005), is available.

SoFiAX is a web-based platform to merge and interact with the results of parallel execution of SoFiA HI source finding software [ascl:1412.001] and other steps of processing ASKAP Wallaby HI survey data.

Solar-MACH (Solar MAgnetic Connection HAUS) derives and visualizes the spatial configuration and solar magnetic connection of different observers (i.e., spacecraft or planets) in the heliosphere at different times. It provides publication-ready figures for analyzing Solar Energetic Particle events (SEPs) or solar transients such as Coronal Mass Ejections (CMEs). Solar-MACH is available as a Python package; a Streamlit-enabled tool that runs in a browser is also available (solar-mach.github.io)

SolarAxionFlux quantifies systematic differences and statistical uncertainties in the calculation of the solar axion flux from axion-photon and axion-electron interactions. Determining the limitations of these calculations can be used to identify potential improvements and help determine axion model parameters more accurately.

SolarKAT mitigates solar interference in MeerKAT data and recovers the visibilities rather than discarding them; this solar imaging pipeline takes 1GC calibrated data in Measurement Set format as input. Written in Python, the pipeline employs solar tracking, subtraction, and peeling techniques to enhance data quality by significantly reducing solar radio interference. This is achieved while preserving the flux measurements in the main field. SolarKAT is versatile and can be applied to general radio astronomy observations and solar radio astronomy; additionally, generated solar images can be used for weather forecasting. SolarKAT is deployed in Stimela (ascl:2305.007). It is based on existing radio astronomy software, including CASA (ascl:1107.013), breizorro (ascl:2305.009), WSclean (ascl:1408.023), Quartical (ascl:2305.006), and Astropy (ascl:1304.002).

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.

SolAster provides querying, analysis, and calculation methods to independently derive 'sun-as-a-star' RV variations using SDO/HMI data for any time span since SDO has begun observing. Scaling factors are provided in order to calculate RVs comparable to magnitudes measured by ground-based spectrographs (HARPS-N and NEID). In addition, there are routines to calculate magnetic observables to compare with RV variations and determine what is driving Solar activity.

SolTrack computes the position of the Sun, the rise and set times and azimuths, and transit times and altitudes. It includes corrections for aberration and parallax, and has a simple routine to correct for atmospheric refraction, taking into account local atmospheric conditions. SolTrack is derived from the Fortran library libTheSky (ascl:2209.018). The package can be used to track the Sun on a low-specs machine, such as a microcontroller or PLC, and can be used for (highly) concentrated (photovoltaic) solar power or accurate solar-energy modeling.

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.

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.

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.

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.

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.

SORA optimally analyzes stellar occultation data. The library includes processes starting on the prediction of such events to the resulting size, shape and position of the Solar System object and can be used to build pipelines to analyze stellar occultation data. A stellar occultation is defined by the occulting body (Body), the occulted star (Star), and the time of the occultation. On the other hand, each observational station (Observer) will be associated with their light curve (LightCurve). SORA has tasks that allow the user to determine the immersion and emersion times and project them to the tangent sky plane, using the information within the Observer, Body and Star Objects. That projection will lead to chords that will be used to obtain the object’s apparent size, shape and position at the moment of the occultation. Automatic processes optimize the reduction of typical events. However, users have full control over the parameters and methods and can make changes in every step of the process.

Spin-Orbit Tomography (SOT) is a retrieval technique of a two-dimensional map of an Exo-Earth from time-series data of integrated reflection light. The software provides code for the Bayesian version of the static SOT and dynamic mapping (time-varying mapping) with full Bayesian modeling, and tutorials for L2 and Bayesian SOT are available in jupyter notebooks.

SourceXtractor++ extracts a catalog of sources from astronomical images; it is the successor to SExtractor (ascl:1010.064). SourceXtractor++ has been completely rewritten in C++ and improves over its predecessor in many ways. It provides support for multiple “measurement” images, has an optimized multi-object, multi-frame model-fitting engine, and can define complex priors and dependencies for model parameters. It also offers efficient image data caching and multi-threaded processing, and has a modular design with support for third-party plug-ins.

SOXS creates simulated X-ray observations of astrophysical sources. The package provides a comprehensive set of tools to design source models and convolve them with simulated models of X-ray observatories. In particular, SOXS is the primary simulation tool for simulations of Lynx and Line Emission Mapper observations. SOXS provides facilities for creating spectral models, simple spatial models for sources, astrophysical background and foreground models, as well as a Python implementation of the SIMPUT file format.

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.

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 https://www.nrel.gov/midc/solpos/spa.html.

SpaceHub uses unique algorithms for fast precise and accurate computations for few-body problems ranging from interacting black holes to planetary dynamics. This few-body gravity integration toolkit can treat black hole dynamics with extreme mass ratios, extreme eccentricities and very close encounters. SpaceHub offers a regularized Radau integrator with round off error control down to 64 bits floating point machine precision and can handle extremely eccentric orbits and close approaches in long-term integrations.

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.

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.

spalipy performs detection-based astronomical image registration in Python. A source image is transformed to the pixel-coordinate system of a template image using their respective detections as tie-points by finding matching quads of detections. spalipy also includes an optional additional warping of the initial affine transformation via splines to achieve accurate registration in the case of non-homogeneous coordinate transforms. This is particularly useful in the case of optically distorted or wide field-of-view images.

SPAM searches for imprints of Hu-Sawicki f(R) gravity on the rotation curves of the SPARC (Spitzer Photometry and Accurate Rotation Curves) sample using the MCMC sampler emcee (ascl:1303.002). The code provides attributes for inspecting the MCMC chains and translating names of parameters to indices. The SPAM package also contains plotting scripts.

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.

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

SPAMMS (Spectroscopic PAtch Model for Massive Stars), designed with geometrically deformed systems in mind, combines the eclipsing binary modelling code PHOEBE 2 (ascl:1106.002) and the NLTE radiative transfer code FASTWIND to produce synthetic spectra for systems at given phases, orientations and geometries. SPAMMS reproduces the morphology of observed spectral line profiles for overcontact systems and the Rossiter-Mclaughlin and Struve-Sahade effects.

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.

SpArcFiRe takes as input an image of a galaxy in FITS, JPG, or PNG format, identifies spiral arms, and extracts structural information about the spiral arms. Pixels in each arm segment are listed, enabling image analysis on each segment. The automated method also performs a least-squares fit of a logarithmic spiral arc to the pixels in that segment, giving per-arc parameters, such as the pitch angle, arm segment length, and location, and outputs images showing the steps SpArcFire took to detect arm segments.