Results 151-200 of 2352 (2312 ASCL, 40 submitted)
TVD solves the magnetohydrodynamic (MHD) equations by updating the fluid variables along each direction using the flux-conservative, second-order, total variation diminishing (TVD), upwind scheme of Jin & Xin. The magnetic field is updated separately in two-dimensional advection-constraint steps. The electromotive force (EMF) is computed in the advection step using the TVD scheme, and this same EMF is used immediately in the constraint step in order to preserve ∇˙B=0 without the need to store intermediate fluxes. The code is extended to three dimensions using operator splitting, and Runge-Kutta is used to get second-order accuracy in time. TVD offers high-resolution per grid cell, second-order accuracy in space and time, and enforcement of the ∇˙B=0 constraint to machine precision. Written in Fortran, It has no memory overhead and is fast. It is also available in a fully scalable message-passing parallel MPI implementation.
TurbuStat implements a variety of turbulence-based statistics described in the astronomical literature and defines distance metrics for each statistic to quantitatively compare spectral-line data cubes, as well as column density, integrated intensity, or other moment maps. The software can simulate observations of fractional Brownian Motion fields, including 2-D images and optically thin H I data cubes. TurbuStat also offers multicore fast-Fourier-transform support and provides a segmented linear model for fitting lines with a break point.
Turbospectrum is a 1D LTE spectrum synthesis code which covers 600 molecules, is fast with many lines, and uses the treatment of line broadening described by Barklem & O’Mara (1998).
TurboSETI analyzes filterbank data (frequency vs. time) for narrow band drifting signals; its main purpose is to search for signals of extraterrestrial origin. TurboSETI can search the data for hundreds of drift rates (in Hz/sec) and handles either .fil or .h5 file formats. It has several dependencies, including Blimpy (ascl:1906.002) and Astropy (ascl:1304.002).
turboGL is a fast Mathematica code based on a stochastic approach to cumulative weak lensing. It can easily compute the lensing PDF relative to arbitrary halo mass distributions, selection biases, number of observations, halo profiles and evolutions, making it a useful tool to study how lensing depends on cosmological parameters and impact on observations.
TTVFaster implements analytic formulae for transit time variations (TTVs) that are accurate to first order in the planet–star mass ratios and in the orbital eccentricities; the implementations are available in several languages, including IDL, Julia, Python and C. These formulae compare well with more computationally expensive N-body integrations in the low-eccentricity, low mass-ratio regime when applied to simulated and to actual multi-transiting Kepler planet systems.
TTVFast efficiently calculates transit times for n-planet systems and the corresponding radial velocities. The code uses a symplectic integrator with a Keplerian interpolator for the calculation of transit times (Nesvorny et al. 2013); it is available in both C and Fortran.
TSP is an astronomical data reduction package that handles time series data and polarimetric data from a variety of different instruments, and is distributed as part of the Starlink software collection (ascl:1110.012).
TRUVOT decontaminates Swift UVOT grism spectra for transient objects. The technique makes use of template images in a process similar to image subtraction.
TROVE (Theoretical ROVibrational Energies) performs variational calculations of rovibrational energies for general polyatomic molecules of arbitrary structure in isolated electronic states. The software numerically constructs the kinetic energy operator, which is represented as an expansion in terms of internal coordinates. The code is self-contained, requiring no analytical pre-derivation of the kinetic energy operator. TROVE is also general and can be used with any internal coordinates.
TRISTAN (TRIdimensional STANford) is a fully electromagnetic code with full relativistic particle dynamics. The code simulates large-scale space plasma phenomena such as the formation of systems of galaxies. TRISTAN particles which hit the boundaries are arrested there and redistributed more uniformly by having the boundaries slightly conducting, thus allowing electrons to recombine with ions and provides a realistic way of eliminating escaping particles from the code. Fresh particle fluxes can then be introduced independently across the boundaries. Written in 1993, this code has largely been superceded by TRISTAN-MP (ascl:1908.008).
TRISTAN-MP is a fully relativistic Particle-In-Cell (PIC) code for plasma physics computations and self-consistently solves the full set of Maxwell’s equations, along with the relativistic equations of motion for the charged particles. Fields are discretized on a finite 3D or 2D mesh, the computational grid; the code then uses time-centered and space-centered finite difference schemes to advance the equations in time via the Lorentz force equation, and to calculate spatial derivatives, so that the algorithm is second order accurate in space and time. The charges and currents derived from the particles' velocities and positions are then used as source terms to re-calculate the electromagnetic fields. TRISTAN-MP is based on the original TRISTAN code (ascl:2008.025) by O. Buneman (1993).
TRIPPy (TRailed Image Photometry in Python) uses a pill-shaped aperture, a rectangle described by three parameters (trail length, angle, and radius) to improve photometry of moving sources over that done with circular apertures. It can generate accurate model and trailed point-spread functions from stationary background sources in sidereally tracked images. Appropriate aperture correction provides accurate, unbiased flux measurement. TRIPPy requires numpy, scipy, matplotlib, Astropy (ascl:1304.002), and stsci.numdisplay; emcee (ascl:1303.002) and SExtractor (ascl:1010.064) are optional.
Written in IDL, TRIPP performs CCD time series reduction and analysis. It provides an on-line check of the incoming frames, performs relative aperture photometry and provides a set of time series tools, such as calculation of periodograms including false alarm probability determination, epoc folding, sinus fitting, and light curve simulations.
TRIP is an interactive computer algebra system that is devoted to perturbation series computations, and specially adapted to celestial mechanics. Its development started in 1988, as an upgrade of the special purpose FORTRAN routines elaborated by J. Laskar for the demonstration of the chaotic behavior of the Solar System. TRIP is a mature and efficient tool for handling multivariate generalized power series, and embeds two kernels, a symbolic and a numerical kernel. This numerical kernel communicates with Gnuplot or Grace to plot the graphics and allows one to plot the numerical evaluation of symbolic objects.
Trilogy automatically scales and combines FITS images to produce color or grayscale images using Python scripts. The user assigns images to each color channel (RGB) or a single image to grayscale luminosity. Trilogy determines the intensity scaling automatically and independently in each channel to display faint features without saturating bright features. Each channel's scaling is determined based on a sample of the image (or summed images) and two input parameters. One parameter sets the output luminosity of "the noise," currently determined as 1-sigma above the sigma-clipped mean. The other parameter sets what fraction of the data (if any) in the sample region should be allowed to saturate. Default values for these parameters (0.15% and 0.001%, respectively) work well, but the user is able to adjust them. The scaling is accomplished using the logarithmic function y = a log(kx + 1) clipped between 0 and 1, where a and k are constants determined based on the data and desired scaling parameters as described above.
Trident creates synthetic absorption-line spectra from astrophysical hydrodynamics simulations. It uses the yt package (ascl:1011.022) to read in simulation datasets and extends it to provide realistic synthetic observations appropriate for studies of the interstellar, circumgalactic, and intergalactic media.
triceratops (Tool for Rating Interesting Candidate Exoplanets and Reliability Analysis of Transits Originating from Proximate Stars) validates planet candidates from the Transiting Exoplanet Survey Satellite (TESS). The code calculates the probabilities of a wide range of transit-producing scenarios using the primary transit of the planet candidate and preexisting knowledge of its host and nearby stars. It then uses the known properties of these stars to calculate star-specific priors for each scenario with estimates of stellar multiplicity and planet occurrence rates.
TreeFrog reads in particle IDs information between various structure catalogs and cross matches catalogs, assuming that particle IDs are unique and constant across snapshots. Though it is built as a cross correlator (in that it can match particles across several different catalogs), its principle use is as halo merger tree builder. TreeFrog produces links between objects found at different snapshots (or catalogs) and uses several possible functions to evaluate the merit of a link between one object at a given snapshot (or in a given catalog) to another object in a previous snapshot (or different catalog). It can also produce a full graph. The code utilizes MPI and OpenMP. It is optimzed for reading VELOCIraptor (ascl:1911.020) output but can also read output from other structure finders such as AHF (ascl:1102.009).
TreeCorr efficiently computes two-point correlation functions. It can compute correlations of regular number counts, weak lensing shears, or scalar quantities such as convergence or CMB temperature fluctuations. Two-point correlations may be auto-correlations or cross-correlations, including any combination of shear, kappa, and counts. Two-point functions can be done with correct curved-sky calculation using RA, Dec coordinates, on a Euclidean tangent plane, or in 3D using RA, Dec and a distance. The front end is written in Python, which can be used as a Python module or as a standalone executable using configuration files; the actual computation of the correlation functions is done in C++ using ball trees (similar to kd trees), making the calculation extremely efficient, and when available, OpenMP is used to run in parallel on multi-core machines.
The TraP is a pipeline for detecting and responding to transient and variable sources in a stream of astronomical images. Images are initially processed using a pure-Python source-extraction package, PySE (ascl:1805.026), which is bundled with the TraP. Source positions and fluxes are then loaded into a SQL database for association and variability detection. The database structure allows for estimation of past upper limits on newly detected sources, and for forced fitting of previously detected sources which have since dropped below the blind-extraction threshold. Developed with LOFAR data in mind, the TraP has been used with data from other radio observatories.
TRANSPHERE is a simple dust continuum radiative transfer code for spherically symmetric circumstellar envelopes. It handles absorption and re-emission and computes the dust temperature self-consistently; it does not, however, deal with scattering. TRANSPHERE uses a variable eddington factor method for the radiative transfer. The RADMD code (ascl:1108.016) is more versatile, but for a spherically symmetric problem for which scattering is of much concern, it may be easier to use a simple code such as TRANSPHERE.
Please note that this code has not been updated since 2006.
A self-organizing map (SOM) can be used to identify planetary candidates from Kepler and K2 datasets with accuracies near 90% in distinguishing known Kepler planets from false positives. TransitSOM classifies a Kepler or K2 lightcurve using a self-organizing map (SOM) created and pre-trained using PyMVPA (ascl:1703.009). It includes functions for users to create their own SOMs.
Transit calculates the transmission or emission spectrum of a planetary atmosphere with application to extrasolar-planet transit and eclipse observations, respectively. It computes the spectra by solving the one-dimensional line-by-line radiative-transfer equation for an atmospheric model.
Transit light curves for stellar continua have only one minimum and a "U" shape. By contrast, transit curves for optically thin chromospheric emission lines can have a "W" shape because of stellar limb-brightening. We calculate light curves for an optically thin shell of emission and fit these models to time-resolved observations of Si IV absorption by the planet HD209458b. We find that the best fit Si IV absorption model has R_p,SIV/R_*= 0.34+0.07-0.12, similar to the Roche lobe of the planet. While the large radius is only at the limit of statistical significance, we develop formulae applicable to transits of all optically thin chromospheric emission lines.
Transit Clairvoyance uses Artificial Neural Networks (ANNs) to predict the most likely short period transiters to have additional transiters, which may double the discovery yield of the TESS (Transiting Exoplanet Survey Satellite). Clairvoyance is a simple 2-D interpolant that takes in the number of planets in a system with period less than 13.7 days, as well as the maximum radius amongst them (in Earth radii) and orbital period of the planet with maximum radius (in Earth days) in order to predict the probability of additional transiters in this system with period greater than 13.7 days.
We present an IDL graphical user interface-driven software package designed for the analysis of extrasolar planet transit light curves. The Transit Analysis Package (TAP) software uses Markov Chain Monte Carlo (MCMC) techniques to fit light curves using the analytic model of Mandel and Agol (2002). The package incorporates a wavelet based likelihood function developed by Carter and Winn (2009) which allows the MCMC to assess parameter uncertainties more robustly than classic chi-squared methods by parameterizing uncorrelated "white" and correlated "red" noise. The software is able to simultaneously analyze multiple transits observed in different conditions (instrument, filter, weather, etc). The graphical interface allows for the simple execution and interpretation of Bayesian MCMC analysis tailored to a user's specific data set and has been thoroughly tested on ground-based and Kepler photometry. AutoKep provides a similar GUI for the preparation of Kepler MAST archive data for analysis by TAP or any other analysis software. This paper describes the software release and provides instructions for its use.
The Sloan Digital Sky Survey (SDSS) produces large amounts of data daily. transfer, written in Python, provides the effective automation needed for daily data transfer operations and management and operates essentially free of human intervention. This package has been tested and used successfully for several years.
TRADES (TRAnsits and Dynamics of Exoplanetary Systems) simultaneously fits observed radial velocities and transit times data to determine the orbital parameters of exoplanetary systems from observational data. It uses a dynamical simulator for N-body systems that also fits the available data during the orbital integration and determines the best combination of the orbital parameters using grid search, χ2 minimization, genetic algorithms, particle swarm optimization, and bootstrap analysis.
TPZ, a parallel code written in python, produces robust and accurate photometric redshift PDFs by using prediction tree and random forests. The code also produces ancillary information about the sample used, such as prior unbiased errors estimations (giving an estimation of performance) and a ranking of importance of variables as well as a map of performance indicating where extra training data is needed to improve overall performance. It is designed to be easy to use and a tutorial is available.
TPM carries out collisionless (dark matter) cosmological N-body simulations, evolving a system of N particles as they move under their mutual gravitational interaction. It combines aspects of both Tree and Particle-Mesh algorithms. After the global PM forces are calculated, spatially distinct regions above a given density contrast are located; the tree code calculates the gravitational interactions inside these denser objects at higher spatial and temporal resolution. The code is parallel and uses MPI for message passing.
Visibilities from radio interferometers have not traditionally been used to study the fast transient sky. Millisecond transients (e.g., fast radio bursts) and periodic sources (e.g., pulsars) have been studied with single-dish radio telescopes and a software stack developed over the past few decades. tpipe is an initial attempt to develop the fast transient algorithms for visibility data. Functions exist for analysis of visibilties, such as reading data, flagging data, applying interferometric gain calibration, and imaging. These functions are given equal footing as time-domain techniques like filters and dedispersion.
tpipe has been largely superseded by rtpipe (ascl:1706.002).
TPI computes the gravitational dynamics of particles orbiting a supermassive black hole (SBH). A distinction is made to two types of particles: test particles and field particles. Field particles are assumed to move in quasi-static Keplerian orbits around the SBH that precess due to the enclosed mass (Newtonian 'mass precession') and relativistic effects. Otherwise, field-particle-field-particle interactions are neglected. Test particles are integrated in the time-dependent potential of the field particles and the SBH. Relativistic effects are included in the equations of motion (including the effects of SBH spin), and test-particle-test-particle interactions are neglected.
TP2VIS creates visibilities from a single dish cube; the TP visibilities can be combined with the interferometric visibilities in a joint deconvolution using, for example, CASA's tclean() method. TP2VIS requires CASA 5.4 (ascl:1107.013) or above.
Toyz is a python web framework that allows scientists to interact with large images and data sets stored on a remote server. A web application is run on the server containing the data and clients are run from web browsers on the user's computer. Toyz displays large FITS images also also renders any image format supported by Pillow (a fork of the Python Imaging Library), contains a GUI to interact with linked plots, and offers a customizable framework that allows students and researchers to create their own work spaces inside a Toyz environment. Astro-Toyz extends the features of the Toyz image viewer, allowing users to view world coordinates and align images based on their WCS.
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.
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.
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.
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.
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".
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 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.
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.
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.
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.
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.
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.
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.
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.
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.
Would you like to view a random code?