Results 3001-3100 of 3355 (3271 ASCL, 84 submitted)
SYNOW is a highly parameterized spectrum synthesis code used primarily for direct (empirical) analysis of SN spectra. The code is based on simple assumptions : spherical symmetry; homologous expansion; a sharp photosphere that emits a blackbody continuous spectrum; and line formation by resonance scattering, treated in the Sobolev approximation. Synow does not do continuum transport, it does not solve rate equations, and it does not calculate ionization ratios. Its main function is to take line multiple scattering into account so that it can be used in an empirical spirit to make line identifications and estimate the velocity at the photosphere (or pseudo-photosphere) and the velocity interval within which each ion is detected. these quantities provide constraints on the composition structure of the ejected matter.
Synphot simulates photometric data and spectra, observed or otherwise. It can incorporate the user's filters, spectra, and data, and use of a pre-defined standard star (Vega), bandpass, or extinction law. synphot can also construct complicated composite spectra using different models, simulate observations, and compute photometric properties such as count rate, effective wavelength, and effective stimulus. It can manipulate a spectrum by, for example, applying redshift, or normalize it to a given flux value in a given bandpass. Synphot can also sample a spectrum at given wavelengths, plot a quick-view of a spectrum, and perform repetitive operations such as simulating the observations of multiple type of sources through multiple bandpasses. Synphot understands Astropy (ascl:1304.002) models and units and is an Astropy affiliated package. Support for HST and JWST is available through the extension stsynphot (ascl:2010.003).
Synspec is a user-oriented package written in FORTRAN for modeling stellar atmospheres and for stellar spectroscopic diagnostics. It assumes an existing model atmosphere, calculated previously with Tlusty or taken from the literature (for instance, from the Kurucz grid of models). The opacity sources (continua, atomic and molecular lines) are fully specified by the user. An arbitrary stellar rotation and instrumental profile can be applied to the synthetic spectrum.
Synth3 is a non-magnetic spectrum synthesis code. It works with model atmospheres in Kurucz format and VALD Sf line lists and features element stratification, molecular equilibrium and individual microturbulence for each line. Disk integration can be done with s3di which is included in the archive. Synth3 computes spectra emergent from the stellar atmospheres with a depth-dependent chemical composition if depth-dependent abundance is provided in the input model atmosphere file.
Synthetic LISA simulates the LISA science process at the level of scientific and technical requirements. The code generates synthetic time series of the LISA fundamental noises, as filtered through all the TDI observables, and provides a streamlined module to compute the TDI responses to gravitational waves, according to a full model of TDI, including the motion of the LISA array, and the temporal and directional dependence of the armlengths.
Synthetic Population of Interstellar Objects generates a synthetic population of interstellar objects (orbits and sizes) in arbitrary volume of space around the Sun. The only necessary assumption is that the population of ISOs in the interstellar space (far from any massive body) is homogeneous and isotropic. The assumed distribution of interstellar velocities of ISOs has to be provided as an input. This distribution can be defined analytically, but also in a discrete form. The algorithm, based on the multivariate inverse transform sampling method, is implemented in Python.
Systemic Console is a tool for advanced analysis of exoplanetary data. It comprises a graphical tool for fitting radial velocity and transits datasets and a library of routines for non-interactive calculations. Among its features are interactive plotting of RV curves and transits, combined fitting of RV and transit timing (primary and secondary), interactive periodograms and FAP estimation, and bootstrap and MCMC error estimation. The console package includes public radial velocity and transit data.
SZpack is a numerical library which allows fast and precise computation of the Sunyaev-Zeldovich (SZ) signal for hot, moving clusters of galaxies. Both explicit numerical integration as well as approximate representation of the SZ signals can be obtained. Variations of the electron temperature and bulk velocity along the line-of-sight can be included. SZpack allows very fast and precise (<~0.001% at frequencies h nu <~ 30kT_g and electron temperature kTe ~ 75 keV) computation and its accuracy practically eliminates uncertainties related to more expensive numerical evaluation of the Boltzmann collision term. It furthermore cleanly separates kinematic corrections from scattering physics, effects that previously have not been clarified.
The T-Matrix package includes codes to compute electromagnetic scattering by homogeneous, rotationally symmetric nonspherical particles in fixed and random orientations, randomly oriented two-sphere clusters with touching or separated components, and multi-sphere clusters in fixed and random orientations. All codes are written in Fortran-77. LAPACK-based, extended-precision, Gauss-elimination- and NAG-based, and superposition codes are available, as are double-precision superposition, parallelized double-precision, double-precision Lorenz-Mie codes, and codes for the computation of the coefficients for the generalized Chebyshev shape.
T-PHOT extracts accurate photometry from low-resolution images of extragalactic fields, where the blending of sources can be a serious problem for accurate and unbiased measurement of fluxes and colors. It gathers data from a high-resolution image of a region of the sky and uses the source positions and morphologies to obtain priors for the photometric analysis of the lower resolution image of the same field. T-PHOT handles different types of datasets as input priors, including a list of objects that will be used to obtain cutouts from the real high-resolution image, a set of analytical models (as .fits stamps), and a list of unresolved, point-like sources, useful for example for far-infrared wavelength domains. T-PHOT yields accurate estimations of fluxes within the intrinsic uncertainties of the method when systematic errors are taken into account (which can be done using a flagging code given in the output), and handles multiwavelength optical to far-infrared image photometry. T-PHOT was developed as part of the ASTRODEEP project (www.astrodeep.eu).
T-RECS produces radio sources catalogs with user-defined frequencies, area and depth. It models two main populations of radio galaxies, Active Galactic Nuclei (AGNs) and Star-Forming Galaxies (SFGs), and corresponding sub-populations. T-RECS is not computationally demanding and can be run multiple times, using the same catalog inputs, to project the simulated sky onto different fields.
This IDL code returns the dust temperature of a galaxy from its redshift, SFR and stellar mass; it can also predict the observed monochromatic fluxes of the galaxy. These monochromatic fluxes correspond to those of a DH SED template with the appropriate dust temperature and the appropriate normalization. Dust temperatures and fluxes predictions are only valid and provided in the redshift, stellar mass, SSFR and wavelength ranges 0 < z < 2.5, Mstar> 10^10 Msun, 10^-11 < SSFR[yr-1]< 10^-7 and 30um < lambda_rest < 2mm.
TA-DA is a pre-compiled IDL widget-based application which greatly simplifies and improves the analysis of stellar photometric data in comparison with theoretical models and allows the derivation of stellar parameters from multi-band photometry. It is flexible and can address a number of problems, from the interpolation of stellar models or sets of stellar physical parameters in general to the computation of synthetic photometry in arbitrary filters or units. It also analyzes observed color-magnitude diagrams and allows a Bayesian derivation of stellar parameters (and extinction) based on multi-band data.
TAC-maker allows for rapid and interactive calculation of synthetic planet transits by numerical computations of the integrals, allowing the use of an arbitrary limb-darkening law of the host star. This advantage together with the practically arbitrary precision of the calculations makes the code a valuable tool for the continuously increasing photometric precision of ground-based and space observations.
TACHE (TensoriAl Classification of Hydrodynamic Elements) performs classification of the eigenvalues of either the tidal tensor or the velocity shear tensor at the point of a smoothed particle. This provides local information as to how matter is collapsing or flowing, respectively, in particular what stable manifold is being produced. The code reads in smoothed particle hydrodynamics (SPH) snapshot files in sphNG format and computes neighbor lists for SPH data and either the (symmetric) velocity shear tensor or tidal tensor and their eigenvalues/eigenvectors. It classifies fluid elements by number of "positive" eigenvalues and permits decomposition of snapshots into classified components; it also includes several Python plotting scripts.
The Action Computation Tool (TACT) tests methods for estimating actions, angles and frequencies of orbits in both axisymmetric and triaxial potentials, including general spherical potentials, analytic potentials (Isochrone and Harmonic oscillator), axisymmetric Stackel fudge, average generating function from orbit (AvGF), and others. It is written in C++; code is provided to compile the routines into a Python library. TM (ascl:1512.014) and LAPACK are required to access some features.
TailZ estimates redshift distributions of photometric samples of galaxies selected photometrically given a subsample with measured spectroscopic redshifts. The approach uses a non-parametric Voronoi tessellation density estimator to interpolate the galaxy distribution in the redshift and photometric color space. The Voronoi tessellation estimator performs well at reconstructing the tails of the redshift distribution of individual galaxies and gives unbiased estimates of the first and second moments.
This Python package allows the user to setup and run an agent-based simulation of a SETI survey. The package allows the creation of a population of observing and transmitting civilisations. Each transmitter and observer conducts their activities according to an input strategy. The success of observers and transmitters can then be recorded, and multiple simulations can be run for Monte Carlo Realisation.
This package is therefore a flexible framework in which to simulate and test different SETI strategies, both as an Observer and as a Transmitter. It is primarily designed with radio SETI in mind, but is sufficiently flexible to simulate all forms of electromagnetic SETI, and potentially neutrino and gravitational wave SETI.
TALYS simulates nuclear reactions which involve neutrons, gamma-rays, protons, deuterons, tritons, helions and alpha-particles, in the 1 keV-200MeV energy range. A suite of nuclear reaction models has been implemented into a single code system, enabling one to evaluate basically all nuclear reactions beyond the resonance range. In particular, TALYS estimates the Maxwellian-averaged reaction rates that are of astrophysical relevance. This enables reaction rates to be calculated with increased accuracy and reliability and the approximations of previous codes to be investigated. The TALYS predictions for the thermonuclear rates of relevance to astrophysics are detailed and compared with those derived by widely-used codes for the same nuclear ingredients. TALYS predictions may differ significantly from those of previous codes, in particular for nuclei for which no or little nuclear data is available. The pre-equilibrium process is shown to influence the astrophysics rates of exotic neutron-rich nuclei significantly. The TALYS code provides a tool to estimate all nuclear reaction rates of relevance to astrophysics with improved accuracy and reliability.
TAME measures the equivalent width (EWs) in high-resolution spectra. Written by IDL, TAME provides the EWs of spectral lines by profile fitting in an automatic or interactive mode and is reliable for measuring EWs in a spectrum with a spectral resolution of R ≳ 20000. It offers an interactive mode for more flexible measurement of the EW and a fully automatic mode that can simultaneously measure the EWs for a large set of lines.
Tangos builds databases (along the lines of Eagle or MultiDark) for cosmological and zoom simulations. Its modular system generates and queries databases. It is designed to store and manage results from a user's own analysis code, provides web and python interfaces, and allows users to construct science-focused queries, including across entire merger trees, without requiring knowledge of SQL. Tangos manages the process of populating the database with science data, including auto-parallelizing the analysis. It can be customized to work with multiple python modules such as pynbody (ascl:1305.002) or yt (ascl:1011.022) to process raw simulation data; it defaults to using SQLite, but allows use of other databases as the underlying store through the use of SQLAlchemy.
Tangra performs scientific grade data reduction of GPS time-tagged video observations, including reduction of stellar occultation light curves and astrometry of close flybys of Near Earth Objects. It offers Dark and Flat frame image correction, PSF and aperture photometry, multiple methods for deriving a background as well as extensibility via add-ins. Tangra is actively developed for Windows and the current version of the software supports UCAC2, UCAC3, UCAC4, NOMAD, PPMXL and Gaia DR2 star catalogues for astrometry. The software can perform motion-fitting for fast objects and derive a mini-normal astrometric positions. The supported video file formats are AVI, SER, ADV and AAV. Tangra can be also used with observations recorded as a sequence of FITS files. There are also versions for Linux and OS-X with more limited functionality.
Tapir is a set of tools, written in Perl, that provides a web interface for showing the observability of periodic astronomical events, such as exoplanet transits or eclipsing binaries. The package provides tools for creating finding charts for each target and airmass plots for each event. The code can access target lists that are stored on-line in a Google spreadsheet or in a local text file.
TARDIS creates synthetic spectra for supernova ejecta and is sufficiently fast to allow exploration of the complex parameter spaces of models for SN ejecta. TARDIS uses Monte Carlo methods to obtain a self-consistent description of the plasma state and to compute a synthetic spectrum. It is written in Python with a modular design that facilitates the implementation of a range of physical approximations that can be compared to assess both accuracy and computational expediency; this allows users to choose a level of sophistication appropriate for their application.
TATOO (Tidal-chronology Age TOOl) estimates the age of massive close-in planetary systems, even those subject to tidal spin-up, using the systems' observed properties: the mass of the planet and the star, stellar rotational, and planetary orbital periods. It can also be used as a classical gyrochronological tool and offers first order correction of the impact of tidal interaction on gyrochronology.
TATTER (Two-sAmple TesT EstimatoR) performs two-sample hypothesis test. The two-sample hypothesis test is concerned with whether distributions p(x) and q(x) are different on the basis of finite samples drawn from each of them. This ubiquitous problem appears in a legion of applications, ranging from data mining to data analysis and inference. This implementation can perform the Kolmogorov-Smirnov test (for one-dimensional data only), Kullback-Leibler divergence, and Maximum Mean Discrepancy (MMD) test. The module performs a bootstrap algorithm to estimate the null distribution and compute p-value.
TAU is a 1D line-by-line radiative transfer code for modeling transmission spectra of close-in extrasolar planets. The code calculates the optical path through the planetary atmosphere of the radiation from the host star and quantifies the absorption due to the modeled composition in a transmission spectrum of transit depth as a function of wavelength. The code is written in C++ and is parallelized using OpenMP.
TauREx 3 (Tau Retrieval for Exoplanets) provides a fully Bayesian inverse atmospheric retrieval framework for exoplanetary atmosphere modeling and retrievals. It is fully customizable, allowing the user to mix and match atmospheric parameters and add additional ones. The framework builds forward models, simulates instruments, and performs retrievals, and provides a rich library of classes for building additional programs and using new atmospheric parameters.
TauRunner propagates ultra-high-energy neutrinos, with a focus on tau neutrinos. Although it was developed for extremely high energy (EeV+) applications, it is able to propagate neutrinos from 1 to 10^16 GeV. Oscillations are not taken into account at the lowest energies, but they become negligible above 1 TeV.
TAWAS solves the wave equation for torsional Alfvèn waves in a viscous plasma. The background magnetic field is axisymmetric and force-free with no azimuthal component and the plasma beta is assumed to be negligible. The solution is calculated over a uniform numerical grid with coordinates r and z for the radius and height respectively. TAWAS, written in IDL, requires no input files. The problem parameters at the top of the code can be changed as need. The 'plotting' variable determines which plots are shown by the script; the code contains several options for plotting. Outputs can be saved to a specific location by changing the variables save_dir and run_name listed just below the parameters. The code outputs include solutions for the velocity perturbation, the magnetic field perturbation and the wave energy flux.
Three-Body Integration performs numerical n-body simulations for mapping conditions for close approaches for the relevant parameter space of configurations and mass values of two white dwarfs and a third star. Low tertiary masses of 0.1M⊙ can be studied, and the collision probability can be estimated with good confidence for the case of nearly equal mass white dwarfs.
TCF calculates a periodogram designed to detect exoplanet transits after the light curve has been differenced. It is a matched filter for a periodic double-spike pattern. The difference operator that can be used independently for detrending a light curve; it is also embedded in ARIMA (autoregressive integrated moving average) Box-Jenkins modeling.
TDEmass interprets Tidal Disruption Event (TDE) observations. In TDEs, a supermassive black hole at the center of a galaxy tears apart an ordinary star; the debris is placed on highly eccentric orbits and ultimately produces a very bright flare. Using this TDEmass, one can infer the mass of the black hole (mbh) and the mass of the star (mstar) involved in a TDE.
TEA (Thermal Equilibrium Abundances) calculates gaseous molecular abundances under thermochemical equilibrium conditions. Given a single T,P point or a list of T,P pairs (the thermal profile of an atmosphere) and elemental abundances, TEA calculates mole fractions of the desired molecular species. TEA uses 84 elemental species and thermodynamical data for more then 600 gaseous molecular species, and can adopt any initial elemental abundances.
TelFit calculates the best-fit telluric absorption spectrum in high-resolution optical and near-IR spectra. The best-fit model can then be divided out to remove the telluric contamination. Written in Python, TelFit is essentially a wrapper to LBLRTM (ascl:1405.001), the Line-By-Line Radiative Transfer Model, and simplifies the process of generating a telluric model.
tellrv measures absolute radial velocities for low-resolution NIR spectra. It uses telluric features to provide absolute wavelength calibration, and then cross-correlates with a standard star. Observations of a standard star are included for convenience; the code also requires both the telluric and non-telluric-corrected spectra.
Tempo analyzes pulsar timing data. Pulse times of arrival (TOAs), pulsar model parameters, and coded instructions are read from one or more input files. The TOAs are fitted by a pulse timing model incorporating transformation to the solar-system barycenter, pulsar rotation and spin-down and, where necessary, one of several binary models. Program output includes parameter values and uncertainties, residual pulse arrival times, chi-squared statistics, and the covariance matrix of the model. In prediction mode, ephemerides of pulse phase behavior (in the form of polynomial expansions) are calculated from input timing models. Tempo is the basis for the Tempo2 (ascl:1210.015) code.
Tempo2 is a pulsar timing package developed to be used both for general pulsar timing applications and also for pulsar timing array research in which data-sets from multiple pulsars need to be processed simultaneously. It was initially developed by George Hobbs and Russell Edwards as part of the Parkes Pulsar Timing Array project. Tempo2 is based on the original Tempo (ascl:1509.002) code and can be used (from the command-line) in a similar fashion. It is very versatile and can be extended by plugins.
Tensiometer provides non-Gaussian tension estimators that extend GetDist (ascl:1910.018) capabilities to test the level of agreement or disagreement between different posterior distributions by using kernel density estimates. The code has been used to study the level of internal agreement between different measurements of the clustering of cosmological structures from the Dark Energy Survey and the Planck satellite.
TERRA (Transiting Exoearth Robust Reduction Algorithm) identifies and removes instrumental noise in Kepler photometry. This transit detection code is optimized to detect small planets around photometrically quiet stars. TERRA calculates photometry in the time domain, combs the calibrated photometry for periodic, box-shaped signals, fits promising signals, and rejects signals inconsistent with exoplanet transits.
TES models the evolution of exoplanet systems. This n-body integration package comes in two parts, the C++ TES source code, and the Python-based experiment manager for running experiments and plotting the results. The experiment manager, used as the interface to TES, handles temporary data storage and allows for experiment results to be saved and then loaded later on for plotting. The experiment manager can automatically use multiple threads to run independent experiments in parallel using the mpi4py package. The experiment manager is specifically designed to enable HPC to be performed as easily as possible.
TESS_PRF displays the TESS pixel response function (PRF) at any location on the detector. The package is primarily for estimating how the light from a point source is distributed given its position in a TESS Target Pixel File (TPF) or TESScut postage stamp. By default, it accesses the relevant PRF files on MAST, but can also reference files on a local directory. TESS_PRF assumes the PRF doesn't change considerably within a small TPF. The PRF model can be positioned by passing the relative row and column location within the TPF to the "resample" method. The pixel locations follow WCS convention, that an integer value corresponds to the center of a pixel.
TESS-Localize identifies the location on the target pixel files (TPF) where sources of variability found in the aperture originate. The user needs only to provide a list of frequencies found in the aperture that belong to the same source and the number of principal components needed to be removed from the light curve to ensure it is free of systematic trends.
TESS-Point converts astronomical target coordinates given in right ascension and declination to detector pixel coordinates for the MIT-led NASA Transiting Exoplanet Survey Satellite (TESS) spacecraft. The program can also provide detector pixel coordinates for a star by TESS input catalog identifier number and common astronomical name. Tess-Point outputs the observing sector number, camera number, detector number, and pixel column and row.
TesseRACt computes concentrations of simulated dark matter halos from volume information for particles generated using Voronoi tesselation. This technique is advantageous as it is non-parametric, does not assume spherical symmetry, and allows for the presence of substructure. TesseRACt accepts data in a number of formats, including Gadget-2 (ascl:0003.001), Gasoline (ascl:1710.019), and ASCII, and computes concentrations using particles volumes, traditional fitting to an NFW profile, and non-parametric techniques that assume spherical symmetry.
TESSreduce builds on lightkurve (ascl:1812.013) to reduce TESS data while preserving transient signals. It takes a TPF as input (supplied or constructed with TESScut (https://mast.stsci.edu/tesscut/). The background subtraction accounts for the smooth background and detector straps. In addition to background subtraction, TESSreduce also aligns images, performs difference imaging, detects transient events, and by using PS1 data, can calibrate TESS counts to physical flux or AB magnitudes.
tf_unet mitigates radio frequency interference (RFI) signals in radio data using a special type of Convolutional Neural Network, the U-Net, that enables the classification of clean signal and RFI signatures in 2D time-ordered data acquired from a radio telescope. The code is not tied to a specific segmentation and can be used, for example, to detect radio frequency interference (RFI) in radio astronomy or galaxies and stars in widefield imaging data. This U-Net implementation can outperform classical RFI mitigation algorithms.
TFF derives the Fourier decomposition of period-folded RR Lyrae light curves with gaps. The method can be used for the same purpose on any other types of variables, assuming that the the template database is changed to the proper type of variables.
TFIT measures galaxy photometry using prior knowledge of sources in a deep, high‐resolution image (HRI) to improve photometric measurements of objects in a corresponding low‐resolution image (LRI) of the same field, usually at a different wavelength. For background‐limited data, this technique produces optimally weighted photometry that maximizes signal‐to‐noise ratio (S/N). For objects not significantly detected in the low‐resolution image, it provides useful and quantitative information for setting upper limits.
This code is no longer updated and has been superseded by T-PHOT (ascl:1609.001).
Turbulence Generator generates a time sequence of random Fourier modes via an Ornstein-Uhlenbeck (OU) process, used to drive turbulence in hydrodynamical simulation codes. It can also generate single turbulent realizations. Turbulence driving based on this method is currently supported by implementations in AREPO (ascl:1909.010), FLASH (ascl:1010.082), GADGET (ascl:0003.001), PHANTOM (ascl:1709.002), PLUTO (ascl:1010.045), and Quokka (ascl:2110.009).
TGCat is an archive of Chandra transmission grating spectra and a suite of software for processing such data. Users can browse and categorize Chandra gratings observations quickly and easily, generate custom plots of resulting response corrected spectra on-line without the need for special software and download analysis ready products from multiple observations in one convenient operation. Data processing for the catalog is done with a suite of ISIS/S-Lang scripts; the software is available for download. These ISIS scripts wrap and call CIAO tools for reprocessing from "Level 1" (acis_process_events or hrc_process_events) through "Level 2" (binned spectra, via tg_resolve_events and tgextract), compute responses (grating "RMFs" and "ARFs", via mkgrmf and mkgarf), and make summary plots.
The Tsyganenko models are semi-empirical best-fit representations for the magnetic field, based on a large number of satellite observations (IMP, HEOS, ISEE, POLAR, Geotail, GOES, etc). The models include the contributions from major external magnetospheric sources: ring current, magnetotail current system, magnetopause currents, and large-scale system of field-aligned currents.
THALASSA (Tool for High-Accuracy, Long-term Analyses for SSA) propagates orbits for bodies in the Earth-Moon-Sun system. Written in Fortran, it integrates either Newtonian equations in Cartesian coordinates or regularized equations of motion with the LSODAR (Livermore Solver for Ordinary Differential equations with Automatic Root-finding). THALASSA is a command-line tool; the repository also includes some Python3 scripts to perform batch propagations.
The Cannon is a data-driven method for determining stellar labels (physical parameters and chemical abundances) from stellar spectra in the context of vast spectroscopic surveys. It fits for the spectral model given training spectra and labels, with the polynomial order for the spectral model decided by the user, infers labels for the test spectra, and provides diagnostic output for monitoring and evaluating the process. It offers SNR-independent continuum normalization, performs well at lower signal-to-noise, and is very accurate.
We present the DTFE public software, a code for reconstructing fields from a discrete set of samples/measurements using the maximum of information contained in the point distribution. The code is written in C++ using the CGAL library and is parallelized using OpenMP. The software was designed for the analysis of cosmological data but can be used in other fields where one must interpolate quantities given at a discrete point set. The software comes with a wide suite of options to facilitate the analysis of 2- and 3-dimensional data and of both numerical simulations and galaxy redshift surveys. For comparison purposes, the code also implements the TSC and SPH grid interpolation methods. The code comes with an extensive user guide detailing the program options, examples and the inner workings of the code.
The Exo-Striker analyzes exoplanet orbitals, performs N-body simulations, and models the RV stellar reflex motion caused by dynamically interacting planets in multi-planetary systems. It offers a broad range of tools for detailed analysis of transit and Doppler data, including power spectrum analysis for Doppler and transit data; Keplerian and dynamical modeling of multi-planet systems; MCMC and nested sampling; Gaussian Processes modeling; and a long-term stability check of multi-planet systems. The Exo-Striker can also analyze Mean Motion Resonance (MMR) analysis, create fast fully interactive plots, and export ready-to-use LaTeX tables with best-fit parameters, errors, and statistics. It combines Fortran efficiency and Python flexibility and is cross-platform compatible (MAC OS, Linux, Windows). The tool relies on a number of open-source packages, including RVmod engine, emcee (ascl:1303.002), batman (ascl:1510.002), celerite (ascl:1709.008), and dynesty (ascl:1809.013).
The Hammer can classify spectra in a variety of formats with targets spanning the MK spectral sequence. It processes a list of input spectra by automatically estimating each object's spectral type and measuring activity and metallicity tracers in late type stars. Once automatic processing is complete, an interactive interface allows the user to manually tweak the final assigned spectral type through visual comparison with a set of templates.
Given sparse or low-quality radial-velocity measurements of a star, there are often many qualitatively different stellar or exoplanet companion orbit models that are consistent with the data. The consequent multimodality of the likelihood function leads to extremely challenging search, optimization, and MCMC posterior sampling over the orbital parameters. The Joker is a custom-built Monte Carlo sampler that can produce a posterior sampling for orbital parameters given sparse or noisy radial-velocity measurements, even when the likelihood function is poorly behaved. The method produces correct samplings in orbital parameters for data that include as few as three epochs. The Joker can therefore be used to produce proper samplings of multimodal pdfs, which are still highly informative and can be used in hierarchical (population) modeling.
The Exoplanet Modeling and Analysis Center (EMAC) is a website which serves as a catalog, repository and integration platform for modeling and analysis resources focused on the study of exoplanet characteristics and environments. EMAC hosts user-submitted software ranging in category from planetary interior models to data visualization tools. Other features of EMAC include integrated web tools developed by the EMAC team in collaboration with the tools' original authors and video demonstrations of a growing number of hosted tools. EMAC aims to be a comprehensive repository for researchers to access a variety of exoplanet resources that can assist them in their work, and currently hosts a growing number of code bases, models, and tools. EMAC is a key project of the NASA GSFC Sellers Exoplanet Environments Collaboration (SEEC).
The Sequencer reveals the main sequence in a dataset if one exists. To do so, it reorders objects within a set to produce the most elongated manifold describing their similarities which are measured in a multi-scale manner and using a collection of metrics. To be generic, it combines information from four different metrics: the Euclidean Distance, the Kullback-Leibler Divergence, the Monge-Wasserstein or Earth Mover Distance, and the Energy Distance. It considers different scales of the data by dividing each object in the input data into separate parts (chunks), and estimating pair-wise similarities between the chunks. It then aggregates the information in each of the chunks into a single estimator for each metric+scale.
The Starfish Diagram is a statistical visualization tool that simultaneously displays the properties of an individual and its parent sample through a series of histograms. The code is useful for large datasets for which one needs to understand the standing or significance of a single entry.
The Tractor optimizes or samples from models of astronomical objects. The approach is generative: given astronomical sources and a description of the image properties, the code produces pixel-space estimates or predictions of what will be observed in the images. This estimate can be used to produce a likelihood for the observed data given the model: assuming the model space actually includes the truth (it doesn’t, in detail), then if we had the optimal model parameters, the predicted image would differ from the actually observed image only by noise. Given a noise model of the instrument and assuming pixelwise independent noise, the log-likelihood is the negative chi-squared difference: (image - model) / noise.
the-wizz clusters redshift estimates for any photometric unknown sample in a survey. The software is composed of two main parts: a pair finder and a pdf maker. The pair finder finds spatial pairs and stores the indices of all closer pairs around target reference objects in an output HDF5 data file. Users then query this data file using the indices of their unknown sample to produce an output clustering-z.
THELI is an easy-to-use, end-to-end pipeline for the reduction of any optical, near-IR and mid-IR imaging data. It combines a variety of processing algorithms and third party software into a single, homogeneous tool. Over 90 optical and infrared instruments at observatories world-wide are pre-configured; more can be added by the user. The code's online appendix contains three walk-through examples using public data (optical, near-IR and mid-IR) and additional online documentation is available for training and troubleshooting.
ThERESA retrieves three-dimensional maps of exoplanets. The code constructs 2-dimensional maps for each light given light curve, places those maps vertically in an atmosphere, and runs radiative transfer to calculate emission from the planet over a latitude/longitude grid. ThERESA then integrates over the grid (combined with the visibility function) to generate light curves. These light curves are compared against the input light curves behind MCMC to explore parameter space.
THERMINATOR is a Monte Carlo event generator dedicated to studies of the statistical production of particles in relativistic heavy-ion collisions. The increased functionality of the code contains the following features: The input of any shape of the freeze-out hypersurface and the expansion velocity field, including the 3+1 dimensional profiles, in particular those generated externally with various hydrodynamic codes. The hypersufraces may have variable thermal parameters, which allows for studies departing significantly from the mid-rapidity region, where the baryon chemical potential becomes large. We include a library of standard sets of hypersurfaces and velocity profiles describing the RHIC Au+Au data at sqrt(s_(NN)) = 200 GeV for various centralities, as well as those anticipated for the LHC Pb+Pb collisions at sqrt(s_(NN)) = 5.5 TeV. A separate code, FEMTO-THERMINATOR, is provided to carry out the analysis of femtoscopic correlations which are an important source of information concerning the size and expansion of the system. We also include several useful scripts that carry out auxiliary tasks, such as obtaining an estimate of the number of elastic collisions after the freeze-out, counting of particles flowing back into the fireball and violating causality (typically very few), or visualizing various results: the particle p_T-spectra, the elliptic flow coefficients, and the HBT correlation radii. We also investigate the problem of the back-flow of particles into the hydrodynamic region, as well as estimate the elastic rescattering in terms of trajectory crossings. The package is written in C++ and uses the CERN ROOT environment.
ThermoEngine estimates the thermodynamic properties of minerals, fluids, and melts, and calculates phase equilibriums. The Equilibrate module of ThermoEngine provides Python functions and classes for computing equilibrium phase assemblages with focus on MELTS calculations. The Phases module includes Python functions and classes for computing standard thermodynamic calculations utilizing the Berman, Holland and Powell, or Stixrude-Lithgow-Bertelloni endmember databases, and calculations based on solution properties utilized by MELTS. There are many helper functions available in this module that assist in the calculation of pseudosections, univariant equilibria and the construction of phase diagrams.
Thindisk computes the line emission from a geometrically thin protoplanetary disk. It creates a datacube in FITS format that can be processed with a data reduction package (such as GILDAS, ascl:1305.010) to produce synthetic images and visibilities. These synthetic data can be compared with observations to determine the properties (e.g. central mass or inclination) of an observed disk. The disk is assumed to be in Keplerian rotation at a radius lower than the centrifugal radius (which can be set to a large value, for a purely Keplerian disk), and in infall with rotation beyond the centrifugal radius.
THOR solves the three-dimensional nonhydrostatic Euler equations. The code implements an icosahedral grid for the poles where converging meridians lead to increasingly smaller time steps; irregularities in the grid are smoothed using spring dynamics. THOR is designed to run on graphics processing units (GPUs) and is part of the open-source Exoclimes Simulation Platform.
threepoint models the third-order aperture statistics, the natural components of the shear three-point correlation function and the covariance of third-order aperture statistics. Third-order weak lensing statistics extract cosmological information in the non-Gaussianity of the cosmic large-scale structure, making them a promising tool for cosmological analyses.
Thrust is a parallel algorithms library which resembles the C++ Standard Template Library (STL). Thrust's high-level interface greatly enhances programmer productivity while enabling performance portability between GPUs and multicore CPUs. Interoperability with established technologies (such as CUDA, TBB, and OpenMP) facilitates integration with existing software.
ThumbStack produces stacked maps and profiles, given catalogs of object positions and maps. It is designed for thermal and kinematic Sunyaev-Zel'dovich measurements. Based on Pixell (ascl:2102.003), it outputs 2D stacked maps and radial profiles for different filters (e.g., aperture photometry filters), as well as their covariances, estimated through several methods including bootstrap.
TidalPy performs semi-analytic calculations of tidal dissipation and subsequent orbit-spin evolution for rocky and icy worlds. It can be used as a black box, in which an Object-Oriented Programming (OOP) scheme performs many calculations with very little user input from the user, making it easy to get started with the package, or as a toolbox, as it contains many efficient functions to perform calculations relevant to tides and thermal-orbital coupling, which can be quickly imported and used in a custom scripts. In general, TidelPy's toolbox (functional) scheme provides much higher performance, flexibility, and extensibility than the OOP scheme. It also makes assumptions more visible to the user. The downside is the user may need to be more familiar with the underlying physics.
TiDE (TIdal Disruption Event) computes the light curves or spectrum of tidal disruption events. Written in C++, it can compute the monochromatic light curve without diffusion, including the total luminosity, wind luminosity and disk luminosity, and the monochromatic light curve with diffusion. TiDE can also model the bolometric luminosity and calculate the spectrum at a given time, including the wind luminosity and disk luminosity. This code can be used to explore the possible parameter space and reveal potential biases caused by the model assumptions, and can be extended with new models, allowing one to compare and test different prescriptions and model assumptions under the same circumstances.
TIDEV (Tidal Evolution package) calculates the evolution of rotation for tidally interacting bodies using Efroimsky-Makarov-Williams (EMW) formalism. The package integrates tidal evolution equations and computes the rotational and dynamical evolution of a planet under tidal and triaxial torques. TIDEV accounts for the perturbative effects due to the presence of the other planets in the system, especially the secular variations of the eccentricity. Bulk parameters include the mass and radius of the planet (and those of the other planets involved in the integration), the size and mass of the host star, the Maxwell time and Andrade's parameter. TIDEV also calculates the time scale that a planet takes to be tidally locked as well as the periods of rotation reached at the end of the spin-orbit evolution.
The N-body code TIDYMESS (TIdal DYnamics of Multi-body ExtraSolar Systems) can describe the mass distribution of each body its inertia tensor and directly and self-consistently integrates orbit, spin, and inertia tensors. It manages the deformation of a body follows the tidal Creep model and includes the centrifugal force and tidal force. Written in C++, TIDYMESS is available as a standalone package and also through the AMUSE framework (ascl:1107.007).
Time Utilities are software tools that, in principal, allow one to calculate BJD to a precision of 1 μs for any target from anywhere on Earth or from any spacecraft. As the quality and quantity of astrophysical data continue to improve, the precision with which certain astrophysical events can be timed becomes limited not by the data themselves, but by the manner, standard, and uniformity with which time itself is referenced. While some areas of astronomy (most notably pulsar studies) have required absolute time stamps with precisions of considerably better than 1 minute for many decades, recently new areas have crossed into this regime. In particular, in the exoplanet community, we have found that the (typically unspecified) time standards adopted by various groups can differ by as much as a minute. Left uncorrected, this ambiguity may be mistaken for transit timing variations and bias eccentricity measurements. We recommend using BJD_TDB, the Barycentric Julian Date in the Barycentric Dynamical Time standard for any astrophysical event. The BJD_TDB is the most practical absolute time stamp for extraterrestrial phenomena, and is ultimately limited by the properties of the target system. We compile a general summary of factors that must be considered in order to achieve timing precisions ranging from 15 minutes to 1 μs, and provide software for download and online webapps for use.
Time-domain astronomy sandbox consists in a series of classes to simulate and process time-domain astronomy data products in Python. The code was originally developed to model Fast Radio Burst (FRB) and Radio Frequency Interference (RFI), and evaluate different RFI mitigation methods and their effect on FRB search.
Tiny Tim generates simulated Hubble Space Telescope point spread functions (PSFs). It is written in C and distributed as source code and runs on a wide variety of UNIX and VMS systems. Tiny Tim includes mirror zonal errors, time dependent aberrations (for the pre-repair instruments), field dependent obscuration patterns (for WF/PC-1 and WFPC2), and filter passband effects. It can produce a normally sampled or subsampled PSF. Output is a FITS image file.
The development of TIPSY was motivated by the need to quickly display and analyze the results of N-body simulations. Most data visualization packages are designed for the display of gridded data, and hence are unsuitable for use with particle data. Therefore, a special package was built that could easily perform the following functions:
1.) Display particle positions (as points), and velocities (as line segments) from an arbitrary viewpoint;
2.) Zoom in to a chosen position. Due to their extremely clustered nature, structure of interest in an N-body simulation is often so small that it cannot be seen when looking at the simulation as a whole;
3.) Color particles to display scalar fields. Examples of such fields are potential energy, or for SPH particles, density and temperature;
4.) Selection of a subset of the particles for display and analysis. Regions of interest are generally small subsets of the simulation;
5.) Following selected particles from one timestep to another; and,
6.) Finding cumulative properties of a collection of particles. This usually involves just a sum over the particles.
The basic data structure is an array of particle structures. Since TIPSY was built for use with cosmological N-body simulations, there are actually three separate arrays for each of the types of particle used in such simulations: collisionless particles, SPH particles, and star particles. A single timestep is read into these arrays from a disk file. Display is done by finding the x and y coordinates of the particles in the rotated coordinate system, and storing them in arrays. Screen coordinates are calculated from these arrays according to the current zoom factor. Also, a software Z-buffer is maintained to save time if many particles project to the same screen pixel. There are several types of display. An "all plot" displays all particles colored according to their type. A "radial plot" will color particles according to the projection of the velocity along the line-of-sight. A "gas plot" will color gas according to SPH quantities such as density, temperature, neutral hydrogen fraction, etc. Subsets of particles are maintained using boxes." A box structure contains a bounding box, and an array of pointers to particles within the box. All display and analysis functions are performed on the "active box." By default all particles are loaded into box 0, which becomes the active box. If a new timestep is read from disk, all boxes are destroyed. A selection of particles can be followed between timesteps via a "mark" array. Marked particles are displayed in a different color, and the analysis functions can be told to only operate on the marked particles.
Tilted Ring Fitting Code (TiRiFiC) is a prototype computer program to construct simulated (high-resolution) astronomical spectroscopic 3d-observations (data cubes) of simple kinematical and morphological models of rotating (galactic) disks. It is possible to automatically optimize the parameterizations of constructed model disks to fit spectroscopic (3d-) observations via a χ2 minimization. TiRiFiC is currently implemented as an add-on to the Groningen Image Processing System (GIPSY) software package and attempts to provide a method to automatically fit an extended tilted-ring model directly to a data cube.
TITAN is a general-purpose radiation hydrodynamics code developed at the Laboratory for Computational Astrophysics (NCSA, University of Illinois at Urbana-Champaign). TITAN solves the coupled sets of radiation transfer and fluid dynamics equations on an adaptive mesh in one spatial dimension.
Tidally Locked Coordinates converts global climate model (GCM) output from standard/Earth-like coordinates into a tidally locked coordinate system. The transformations in Tidally Locked Coordinates are useful for plotting and analyzing GCM simulations of slowly rotating tidally locked planets such as Earth-like planets inside the habitable zone of small stars. They can be used to leverage the fact that a slowly rotating planet's climate will start to look approximately symmetric about the axis of insolation.
tlpipe processes the drift scan survey data from the Tianlai experiment; the Tainlai project is a 21cm intensity mapping experiment aimed at detecting dark energy by measuring the baryon acoustic oscillation (BAO) features in the large scale structure power spectrum. tlpipe performs offline data processing tasks such as radio frequency interference (RFI) flagging, array calibration, binning, and map-making, in addition to other tasks. It includes utility functions needed for the data analysis, such as data selection, transformation, visualization and others. tlpipe implements a number of new algorithms are implemented, including the eigenvector decomposition method for array calibration and the Tikhnov regularization for m-mode analysis.
TLS is an optimized transit-fitting algorithm to search for periodic transits of small planets. In contrast to BLS: Box Least Squares (ascl:1607.008), which searches for rectangular signals in stellar light curves, TLS searches for transit-like features with stellar limb-darkening and including the effects of planetary ingress and egress. TLS also analyses the entire, unbinned data of the phase-folded light curve. TLS yields a ~10% higher detection efficiency (and similar false alarm rates) compared to BLS though has a higher computational load. This load is partly compensated for by applying an optimized period sampling and transit duration sampling constrained to the physically plausible range.
TLUSTY is a user-oriented package written in FORTRAN77 for modeling stellar atmospheres and accretion disks and wide range of spectroscopic diagnostics. In the program's maximum configuration, the user may start from scratch and calculate a model atmosphere of a chosen degree of complexity, and end with a synthetic spectrum in a wavelength region of interest for an arbitrary stellar rotation and an arbitrary instrumental profile. The user may also model the vertical structure of annuli of an accretion disk.
TM (Torus Mapper) produces models for orbits in action-angle coordinates in axisymmetric potentials using torus mapping, a non-perturbative technique for creating orbital tori for specified values of the action integrals. It can compute a star's position at any time given an orbital torus and a star’s position at a reference time, and also provides a way to choose initial conditions for N-body simulations of realistic disc galaxies that start in perfect equilibrium. TM provides some advantages over use of a standard time-stepper to create orbits.
The Tübingen NLTE Model-Atmosphere Package (TMAP) is a tool to calculate stellar atmospheres in spherical or plane-parallel geometry in hydrostatic and radiative equilibrium allowing departures from local thermodynamic equilibrium (LTE) for the population of atomic levels. It is based on the Accelerated Lambda Iteration (ALI) method and is able to account for line blanketing by metals. All elements from hydrogen to nickel may be included in the calculation with model atoms which are tailored for the aims of the user.
The IDL package reduces and analyzes radio astronomy data. It translates SDFITS files into TMBIDL format, and can average and display spectra, remove baselines, and fit Gaussian models.
TMCalc is a C code developed as an extension to ARES. Using the line list given, the code can be used as a precise and fast indicator of the spectroscopic temperature and metallicity for dwarf FKG stars with effective temperatures ranging from 4500 K to 6500 K and with [Fe/H] ranging from -0.8 dex to 0.4 dex.
The TOAST software framework simulates and processes timestream data collected by telescopes. The framework can distribute data among many processes and perform operations on the local pieces of the data, and has generic operators for common processing tasks such as filtering, pointing expansion, and map-making. In addition to offering I/O for a limited set of formats, it provides well-defined interfaces for adding custom I/O classes and processing operators. TOAST is written in C++ with a public Python interface, and contains utilities for controlling the runtime environment, logging, timing, streamed random number generation, quaternion operations, FFTs, and special function evaluation.
TOASTER is a pulse times-of-arrival (TOA) tracker. It stores reduced/folded observations, meta data, templates, parfiles, TOAs, and timefiles in an organized manner using an SQL database. TOASTER also provides a full-featured python toolkit for reliably interacting with the data and database, and provides scripts that, for example, list and summarize the TOAs in the data base, and generate TOA files in multiple formats. The framework can also be used to generate TOAs from observations using flexible and reproducible plugins referred to as "manipulators".
The toise framework estimates the sensitivity of natural-medium neutrino detectors such as IceCube-Gen2 to sources of high-energy astrophysical neutrinos. It uses parameterizations of a detector's fiducial area or volume, selection efficiency, energy resolution, angular resolution, and event classification efficiency to convert (surface) neutrino fluxes into mean event rates in bins of observable space. These are then used to estimate statistical quantities of interest, e.g., the median sensitivity to some flux (i.e., 90% upper limit assuming the true flux is zero) or the median discovery potential (i.e., the flux level at which the null hypothesis would be rejected at 5 sigma in 50% of realizations).
The TOM Toolkit combines a flexible, searchable database of all information related to a scientific research project, with an observation and data analysis control system, and communication and data visualization tools. This Toolkit includes a fully operational TOM (Target and Observation Manager) system in addition to a range of optional tools for specific tasks, including interfaces to widely-used observing facilities and data archives and data visualization tools. With TOM Toolkit, project teams can develop and customize a system for their own science goals, without needing specialist expertise in databasing.
TomograPy is an open-source software freely available on the Python Package Index that can perform fast tomographic inversions that scale linearly with the number of measurements, linearly with the length of the reconstruction cube (and not the number of voxels) and linearly with the number of cores and can use data from different sources and with a variety of physical models. For performance, TomograPy uses a parallelized-projection algorithm. It relies on the World Coordinate System standard to manage various data sources. A variety of inversion algorithms are provided to perform the tomographic-map estimation. A test suite is provided along with the code to ensure software quality. Since it makes use of the Siddon algorithm it is restricted to rectangular parallelepiped voxels but the spherical geometry of the corona can be handled through proper use of priors.
Many branches of astronomy interpret observations through approximate, one-dimensional models of stars. Furthermore, many stars are observed to undergo resonant pulsations, and the frequencies at which they do so are similarly interpreted through the predicted pulsations of the one-dimensional models. The study of these resonant pulsations in stars is known as asteroseismology. Since the equations of stellar structure, evolution and pulsation were defined in their modern forms around the mid-20th century, many programs have been written to produce models and predict their pulsations frequencies and correspondingly many custom data formats have been defined, with varying levels of ease-of-use and interoperability. tomso's main purpose is to provide a compact interface for parsing data in these formats and simplify research that uses them.
TOPCAT is an interactive graphical viewer and editor for tabular data. Its aim is to provide most of the facilities that astronomers need for analysis and manipulation of source catalogues and other tables, though it can be used for non-astronomical data as well. It understands a number of different astronomically important formats (including FITS and VOTable) and more formats can be added.
It offers a variety of ways to view and analyse tables, including a browser for the cell data themselves, viewers for information about table and column metadata, and facilities for 1-, 2-, 3- and higher-dimensional visualisation, calculating statistics and joining tables using flexible matching algorithms. Using a powerful and extensible Java-based expression language new columns can be defined and row subsets selected for separate analysis. Table data and metadata can be edited and the resulting modified table can be written out in a wide range of output formats.
It is a stand-alone application which works quite happily with no network connection. However, because it uses Virtual Observatory (VO) standards, it can cooperate smoothly with other tools in the VO world and beyond, such as VODesktop, Aladin and ds9. Between 2006 and 2009 TOPCAT was developed within the AstroGrid project, and is offered as part of a standard suite of applications on the AstroGrid web site, where you can find information on several other VO tools.
The program is written in pure Java and available under the GNU General Public Licence. It has been developed in the UK within the Starlink and AstroGrid projects, and under PPARC and STFC grants. Its underlying table processing facilities are provided by STIL.
topoaccel calculates topological acceleration for several of the S^3 quotient spaces considered 'regular', in that they have a Platonic solid as one of their fundamental domain shapes, and are globally homogeneous. The topoaccel scripts can be run using the free-licensed software package Maxima (https://maxima.sourceforge.io/documentation.html).
Torch simulates coupled gas and N-body dynamics in astrophysical systems such as newly forming star clusters. It combines the FLASH (ascl:1010.082) code for gas dynamics and the ph4 code for direct N-body evolution via the AMUSE framework.
TORUS is a flexible radiation transfer and radiation-hydrodynamics code. The code has a basic infrastructure that includes the AMR mesh scheme that is used by several physics modules including atomic line transfer in a moving medium, molecular line transfer, photoionization, radiation hydrodynamics and radiative equilibrium. TORUS is useful for a variety of problems, including magnetospheric accretion onto T Tauri stars, spiral nebulae around Wolf-Rayet stars, discs around Herbig AeBe stars, structured winds of O supergiants and Raman-scattered line formation in symbiotic binaries, and dust emission and molecular line formation in star forming clusters. The code is written in Fortran 2003 and is compiled using a standard Gnu makefile. The code is parallelized using both MPI and OMP, and can use these parallel sections either separately or in a hybrid mode.
Would you like to view a random code?