ASCL.net

Astrophysics Source Code Library

Making codes discoverable since 1999

Browsing Codes

Results 2601-2700 of 3361 (3279 ASCL, 82 submitted)

Order
Title Date
 
Mode
Abstract Compact
Per Page
50100250All
[ascl:1110.013] S2HAT: Scalable Spherical Harmonic Transform Library

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.

[ascl:1211.001] S2LET: Fast wavelet analysis on the sphere

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.

[ascl:1103.003] S2PLOT: Three-dimensional (3D) Plotting Library

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.

[ascl:2005.009] s3PCF: Compute the 3-point correlation function in the squeezed limit

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.

[ascl:1111.003] Saada: A Generator of Astronomical Database

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.

[ascl:1306.001] SAC: Sheffield Advanced Code

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.

[submitted] Sacc: Save All Correlations and Covariances

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.

[ascl:1601.006] SAGE: Semi-Analytic Galaxy Evolution

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.

[ascl:1203.011] SALT2: Spectral Adaptive Lightcurve Template

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.

[ascl:1407.006] SAMI: Sydney-AAO Multi-object Integral field spectrograph pipeline

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.

[ascl:1504.011] samiDB: A Prototype Data Archive for Big Science Exploration

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.

[ascl:2207.011] samsam: Scaled Adaptive Metropolis SAMpler

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.

[ascl:2307.030] SAMUS: Simulator of Asteroid Malformation Under Stress

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.

[ascl:1605.015] SAND: Automated VLBI imaging and analyzing pipeline

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.

[ascl:0003.002] SAOImage DS9: A utility for displaying astronomical images in the X11 window environment

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.

[ascl:2112.015] SAPHIRES: Stellar Analysis in Python for HIgh REsolution Spectroscopy

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.

[ascl:1210.029] Sapporo: N-body simulation library for GPUs

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.

[ascl:1907.005] SARA-PPD: Preconditioned primal-dual algorithm for radio-interferometric imaging

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.

[ascl:1904.020] SARAH: SUSY and non-SUSY model builder and analyzer

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.

[ascl:1404.004] SAS: Science Analysis System for XMM-Newton observatory

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.

[ascl:2302.013] SASHIMI-C: Semi-Analytical SubHalo Inference ModelIng for Cold Dark Matter

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.

[ascl:2302.010] SASHIMI-W: Semi-Analytical SubHalo Inference ModelIng for Warm Dark Matter

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.

[ascl:1707.002] SASRST: Semi-Analytic Solutions for 1-D Radiative Shock Tubes

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.

[ascl:2103.005] satcand: Orbital stability and tidal migration constraints for KOI exomoon candidates

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.

[ascl:2203.011] SATCHEL: Pipeline to search for long-period exoplanet signals

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.

[ascl:2303.016] SatGen: Semi-analytical satellite galaxy and dark matter halo generator

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.

[ascl:1309.005] SATMC: SED Analysis Through Monte Carlo

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.

[ascl:2306.003] SAVED21cm: Global 21cm signal extraction pipeline

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.

[ascl:1601.012] SavGolFilterCov: Savitzky Golay filter for data with error covariance

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.

[ascl:1904.015] SBGAT: Small Bodies Geophysical Analysis Tool

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.

[ascl:2306.002] sbi: Simulation-based inference toolkit

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.

[ascl:1907.014] sbpy: Small-body planetary astronomy

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.

[ascl:1010.063] SCAMP: Automatic Astrometric and Photometric Calibration

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.

[ascl:2002.006] ScamPy: Sub-halo Clustering and Abundance Matching Python interface

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.

[ascl:1209.012] Scanamorphos: Maps from scan observations made with bolometer arrays

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.

[ascl:1803.003] scarlet: Source separation in multi-band images by Constrained Matrix Factorization

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.

[ascl:2208.003] Scatfit: Scattering fits of time domain radio signals (Fast Radio Bursts or pulsars)

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.

[ascl:1505.008] SCEPtER: Stellar CharactEristics Pisa Estimation gRid

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.

[ascl:2306.060] SCF-FDPS: Disk-halo systems simulator

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.

[ascl:2103.013] schNell: Fast calculation of N_ell for GW anisotropies

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.

[ascl:1907.001] schwimmbad: Parallel processing pools interface

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.

[ascl:2202.007] SciCatalog: Tools for scientific data catalogs

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.

[ascl:1311.001] SciDB: Open Source DMAS for Scientific Research

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.

[ascl:1609.006] SCIMES: Spectral Clustering for Interstellar Molecular Emission Segmentation

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.

[ascl:2011.019] Scintools: Pulsar scintillation data tools

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.

[ascl:2306.013] SCONCE-SCMS: Spherical and conic cosmic web finders with extended SCMS algorithms

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.

[submitted] ScopeSim

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

[submitted] ScopeSim Instrument Reference Database

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.

[submitted] ScopeSim Templates

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

[ascl:2209.005] SCORE: Shape COnstraint REstoration

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.

[ascl:2112.003] SCORPIO: Sky COllector of galaxy Pairs and Image Output

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.

[ascl:1601.003] SCOUSE: Semi-automated multi-COmponent Universal Spectral-line fitting Engine

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.

[ascl:2003.004] scousepy: Semi-automated multi-COmponent Universal Spectral-line fitting Engine

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.

[ascl:2303.011] Scri: Manipulate time-dependent functions of spin-weighted spherical harmonics

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.

[ascl:2204.013] SCRIPT: Semi-numerical Code for ReIonization with PhoTon-conservation

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

[ascl:2202.018] Sculptor: Interactive modeling of astronomical spectra

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.

[ascl:2002.001] SDAR: Slow-Down Algorithmic Regularization code for solving few-body problems

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.

[submitted] SDSS Dual Active Nuclei Galaxy Detection Pipeline

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.

[ascl:2012.015] seaborn: Statistical data visualization

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.

[ascl:1210.012] SearchCal: The JMMC Evolutive Search Calibrator Tool

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.

[ascl:1201.003] SeBa: Stellar and binary evolution

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.

[ascl:1101.001] Second-order Tight-coupling Code

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.

[ascl:1909.003] SecularMultiple: Hierarchical multiple system secular evolution model

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.

[ascl:2008.013] SEDBYS: Spectral Energy Distribution Builder for Young Stars

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.

[ascl:2011.014] SEDkit: Spectral energy distribution construction and analysis tools

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

[ascl:1901.008] SEDobs: Observational spectral energy distribution simulation

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.

[ascl:2012.013] sedop: Optimize discrete versions of common SEDs

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.

[ascl:1905.026] SEDPY: Modules for storing and operating on astronomical source spectral energy distribution

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.

[ascl:1607.020] SEEK: Signal Extraction and Emission Kartographer

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.

[ascl:2303.003] SeeKAT: Localizer for transients detected in tied-array beams

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.

[ascl:1411.007] segueSelect: SDSS/SEGUE selection function modelling

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.

[ascl:2110.019] SELCIE: Screening Equations Linearly Constructed and Iteratively Evaluated

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.

[ascl:2301.006] Self-cal: Optical/IR long-baseline interferometry

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

[ascl:1504.009] Self-lensing binary code with Markov chain

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.

[ascl:2012.003] Sengi: Interactive viewer for spectral outputs from stellar population synthesis models

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.

[ascl:1807.026] SENR: Simple, Efficient Numerical Relativity

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.

[ascl:1811.004] SEP: Source Extraction and Photometry

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.

[ascl:1404.005] SER: Subpixel Event Repositioning Algorithms

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.

[ascl:1102.010] SEREN: A SPH code for star and planet formation simulations

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.

[ascl:1312.001] SERPent: Scripted E-merlin Rfi-mitigation PipelinE for iNTerferometry

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.

[ascl:1304.009] Sérsic: Exact deprojection of Sérsic surface brightness profiles

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.

[ascl:2006.011] SERVAL: SpEctrum Radial Velocity AnaLyser

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.

[ascl:2203.025] SetCoverPy: A heuristic solver for the set cover problem

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.

[ascl:1803.009] SETI-EC: SETI Encryption Code

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.

[ascl:2206.019] SEVN: Stellar EVolution for N-body

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

[ascl:1508.006] SExSeg: SExtractor segmentation

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

[ascl:1010.064] SExtractor: Source Extractor

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

[ascl:2212.010] sf_deconvolve: PSF deconvolution and analysis

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.

[ascl:2001.003] sf3dmodels: Star-forming regions 3D modelling package

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.

[ascl:1304.013] SFH: Star Formation History

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

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

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

[ascl:2302.004] SFQEDtoolkit: Strong-field QED processes modeling for PIC and Monte Carlo codes

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.

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

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

NOTE: SGNAPS functionality has been transitioned to EZ.

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

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

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

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

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

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

[ascl:2107.015] shapelens: Astronomical image analysis and shape estimation framework

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.

[ascl:1307.014] Shapelets: Image Modelling

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

[ascl:2109.022] ShapeMeasurementFisherFormalism: Fisher Formalism for Weak Lensing

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

[ascl:2206.026] ShapePipe: Galaxy shape measurement pipeline

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.

Would you like to view a random code?