Results 1801-1850 of 2328 (2293 ASCL, 35 submitted)

[ascl:1210.019]
QFitsView: FITS file viewer

QFitsView is a FITS file viewer that can display one, two, and three-dimensional FITS files. It has three modes of operation, depending of what kind of data is being displayed. One-dimensional data are shown in an x-y plot. Two-dimensional images are shown in the main window. Three-dimensional data cubes can be displayed in a variety of ways, with the third dimension shown as a x-y plot at the bottom of the image display. QFitsView was written in C++ and uses the Qt widget library, which makes it available for all major platforms: Windows, MAC OS X, and many Unix variants.

[ascl:1210.020]
GASGANO: Data File Organizer

GASGANO is a GUI software tool for managing and viewing data files produced by VLT Control System (VCS) and the Data Flow System (DFS). It is developed and maintained by ESO to help its user community manage and organize astronomical data observed and produced by all VLT compliant telescopes in a systematic way. The software understands FITS, PAF, and ASCII files, and Reduction Blocks, and can group, sort, classify, filter, and search data in addition to allowing the user to browse, view, and manage them.

[ascl:1210.021]
SMART: Spectroscopic Modeling Analysis and Reduction Tool

SMART is an IDL-based software tool, developed by the IRS Instrument Team at Cornell University, that allows users to reduce and analyze Spitzer data from all four modules of the Infrared Spectrograph, including the peak-up arrays. The software is designed to make full use of the ancillary files generated in the Spitzer Science Center pipeline so that it can either remove or flag artifacts and corrupted data and maximize the signal-to-noise ratio in the extraction routines. It can be run in both interactive and batch modes. SMART includes visualization tools for assessing data quality, basic arithmetic operations for either two-dimensional images or one-dimensional spectra, extraction of both point and extended sources, and a suite of spectral analysis tools.

[ascl:1210.022]
HAM2D: 2D Shearing Box Model

HAM solves non-relativistic hyperbolic partial differential equations in conservative form using high-resolution shock-capturing techniques. This version of HAM has been configured to solve the magnetohydrodynamic equations of motion in axisymmetry to evolve a shearing box model.

[ascl:1210.023]
inf_solv: Kerr inflow solver

The efficiency of thin disk accretion onto black holes depends on the inner boundary condition, specifically the torque applied to the disk at the last stable orbit. This is usually assumed to vanish. This code estimates the torque on a magnetized disk using a steady magnetohydrodynamic inflow model originally developed by Takahashi et al. The efficiency e can depart significantly from the classical thin disk value. In some cases e > 1, i.e., energy is extracted from the black hole.

[ascl:1210.024]
ORBADV: ORBital ADVection by interpolation

ORBADV adopts a ZEUS-like scheme to solve magnetohydrodynamic equations of motion in a shearing sheet. The magnetic field is discretized on a staggered mesh, and magnetic field variables represent fluxes through zone faces. The code uses obital advection to ensure fast and accurate integration in a large shearing box.

[ascl:1210.025]
TwoDSSM: Self-gravitating 2D shearing sheet

TwoDSSM solves the equations of self-gravitating hydrodynamics in the shearing sheet, with cooling. TwoDSSM is configured to use a simple, exponential cooling model, although it contains code for a more complicated (and perhaps more realistic) cooling model based on a one-zone vertical model. The complicated cooling model can be switched on using a flag.

[ascl:1210.026]
PVS-GRMHD: Conservative GRMHD Primitive Variable Solvers

Conservative numerical schemes for general relativistic magnetohydrodynamics (GRMHD) require a method for transforming between "conserved'' variables such as momentum and energy density and "primitive" variables such as rest-mass density, internal energy, and components of the four-velocity. The forward transformation (primitive to conserved) has a closed-form solution, but the inverse transformation (conserved to primitive) requires the solution of a set of five nonlinear equations. This code performs the inversion.

[ascl:1210.027]
PyCosmic: Detecting cosmics in CALIFA and other fiber-fed integral-field spectroscopy datasets

The detection of cosmic ray hits (cosmics) in fiber-fed integral-field spectroscopy (IFS) data of single exposures is a challenging task because of the complex signal recorded by IFS instruments. Existing detection algorithms are commonly found to be unreliable in the case of IFS data, and the optimal parameter settings are usually unknown a priori for a given dataset. The Calar Alto legacy integral field area (CALIFA) survey generates hundreds of IFS datasets for which a reliable and robust detection algorithm for cosmics is required as an important part of the fully automatic CALIFA data reduction pipeline. PyCosmic combines the edge-detection algorithm of L.A.Cosmic with a point-spread function convolution scheme. PyCosmic is the only algorithm that achieves an acceptable detection performance for CALIFA data. Only for strongly undersampled IFS data does L.A.Cosmic exceed the performance of PyCosmic by a few percent. Thus, PyCosmic appears to be the most versatile cosmics detection algorithm for IFS data.

[ascl:1210.028]
QYMSYM: A GPU-accelerated hybrid symplectic integrator

QYMSYM is a GPU accelerated 2nd order hybrid symplectic integrator that identifies close approaches between particles and switches from symplectic to Hermite algorithms for particles that require higher resolution integrations. This is a parallel code running with CUDA on a video card that puts the many processors on board to work while taking advantage of fast shared memory.

[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:1210.030]
BOOTTRAN: Error Bars for Keplerian Orbital Parameters

BOOTTRAN calculates error bars for Keplerian orbital parameters for both single- and multiple-planet systems. It takes the best-fit parameters and radial velocity data (BJD, velocity, errors) and calculates the error bars from sampling distribution estimated via bootstrapping. It is recommended to be used together with the RVLIN package, which find best-fit Keplerian orbital parameters. Both RVLIN and BOOTTRAN are compatible with multiple-telescope data. BOOTTRAN also calculates the transit time and secondary eclipse time and their associated error bars. The algorithm is described in the appendix of the associated article.

[ascl:1210.031]
RVLIN: Fitting Keplerian curves to radial velocity data

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

[ascl:1209.001]
Bayesian Blocks: Detecting and characterizing local variability in time series

Bayesian Blocks is a time-domain algorithm for detecting localized structures (bursts), revealing pulse shapes within bursts, and generally characterizing intensity variations. The input is raw time series data, in almost any form. Three data modes are elaborated: (1) time-tagged events, (2) binned counts, and (3) measurements at arbitrary times with normal errors. The output is the most probable segmentation of the observation interval into sub-intervals during which the signal is perceptibly constant, i.e. has no statistically significant variations. The idea is not that the source is deemed to actually have this discontinuous, piecewise constant form, rather that such an approximate and generic model is often useful. Treatment of data gaps, variable exposure, extension to piecewise linear and piecewise exponential representations, multi-variate time series data, analysis of variance, data on the circle, other data modes, and dispersed data are included.

This implementation is exact and replaces the greedy, approximate, and outdated algorithm implemented in BLOCK.

[ascl:1209.002]
JAGS: Just Another Gibbs Sampler

JAGS analyzes Bayesian hierarchical models using Markov Chain Monte Carlo (MCMC) simulation not wholly unlike BUGS. JAGS has three aims:

- to have a cross-platform engine for the BUGS language;
- to be extensible, allowing users to write their own functions, distributions and samplers; and
- to be a platform for experimentation with ideas in Bayesian modeling.

[ascl:1209.003]
LSD: Large Survey Database framework

The Large Survey Database (LSD) is a Python framework and DBMS for distributed storage, cross-matching and querying of large survey catalogs (>10^9 rows, >1 TB). The primary driver behind its development is the analysis of Pan-STARRS PS1 data. It is specifically optimized for fast queries and parallel sweeps of positionally and temporally indexed datasets. It transparently scales to more than >10^2 nodes, and can be made to function in "shared nothing" architectures.

[ascl:1209.004]
CHORIZOS: CHi-square cOde for parameterRized modeling and characterIZation of phOtometry and Spectrophotmetry

CHORIZOS is a multi-purpose Bayesian code developed in IDL to compare photometric data with model spectral energy distributions (SEDs). The user can select the SED family (e.g. Kurucz) and choose the behavior of each parameter (e.g. Teff) to be fixed, constrained to a given range, or unconstrained. The code calculates the likelihood for the full specified parameter ranges, thus allowing for the identification of multiple solutions and the evaluation of the full correlation matrix for the derived parameters of a single solution.

[ascl:1209.005]
HARM: A Numerical Scheme for General Relativistic Magnetohydrodynamics

HARM uses a conservative, shock-capturing scheme for evolving the equations of general relativistic magnetohydrodynamics. The fluxes are calculated using the Harten, Lax, & van Leer scheme. A variant of constrained transport, proposed earlier by Tóth, is used to maintain a divergence-free magnetic field. Only the covariant form of the metric in a coordinate basis is required to specify the geometry. On smooth flows HARM converges at second order.

[ascl:1209.006]
macula: Rotational modulations in the photometry of spotted stars

Photometric rotational modulations due to starspots remain the most common and accessible way to study stellar activity. Modelling rotational modulations allows one to invert the observations into several basic parameters, such as the rotation period, spot coverage, stellar inclination and differential rotation rate. The most widely used analytic model for this inversion comes from Budding (1977) and Dorren (1987), who considered circular, grey starspots for a linearly limb darkened star. That model is extended to be more suitable in the analysis of high precision photometry such as that by Kepler. Macula, a Fortran 90 code, provides several improvements, such as non-linear limb darkening of the star and spot, a single-domain analytic function, partial derivatives for all input parameters, temporal partial derivatives, diluted light compensation, instrumental offset normalisations, differential rotation, starspot evolution and predictions of transit depth variations due to unocculted spots. The inclusion of non-linear limb darkening means macula has a maximum photometric error an order-of-magnitude less than that of Dorren (1987) for Sun-like stars observed in the Kepler-bandpass. The code executes three orders-of-magnitude faster than comparable numerical codes making it well-suited for inference problems.

[ascl:1209.007]
TMCalc: Fast estimation of stellar metallicity [Fe/H]

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.

[ascl:1209.008]
Phantom-GRAPE: SIMD accelerated numerical library for N-body simulations

Phantom-GRAPE is a numerical software library to accelerate collisionless $N$-body simulation with SIMD instruction set on x86 architecture. The Newton's forces and also central forces with an arbitrary shape f(r), which have a finite cutoff radius r_cut (i.e. f(r)=0 at r>r_cut), can be quickly computed.

[ascl:1209.009]
ANNz: Artificial Neural Networks for estimating photometric redshifts

ANNz is a freely available software package for photometric redshift estimation using Artificial Neural Networks. ANNz learns the relation between photometry and redshift from an appropriate training set of galaxies for which the redshift is already known. Where a large and representative training set is available, ANNz is a highly competitive tool when compared with traditional template-fitting methods.

For a newer implementation of this package, please see ANNz2 (ascl:1910.014).

[ascl:1209.010]
MeqTrees: Software package for implementing Measurement Equations

MeqTrees is a software package for implementing Measurement Equations. This makes it uniquely suited for simulation and calibration of radioastronomical data, especially that involving new radiotelescopes and observational regimes. MeqTrees is implemented as a Python-based front-end called the meqbrowser, and an efficient (C++-based) computational back-end called the meqserver. Numerical models are defined on the front-end via a Python-based Tree Definition Language (TDL), then rapidly executed on the back-end. The use of TDL facilitates an extremely short turn-around time for experimentation with new ideas. This is also helped by unprecedented visualization capabilities for all final and intermediate results. A flexible data model and a number of important optimizations in the back-end ensures that the numerical performance is comparable to that of hand-written code.

MeqTrees includes a highly capable FITS viewer and sky model manager called Tigger, which can also work as a standalone tool.

[ascl:1209.011]
DiskFit: Modeling Asymmetries in Disk Galaxies

Kuzio de Naray, Rache; Arsenault, Cameron A.; Spekkens, Kristine; Sellwood, J. A.; McDonald, Michael; Simon, Joshua D.; Teuben, Peter

DiskFit implements procedures for fitting non-axisymmetries in either kinematic or photometric data. DiskFit can analyze H-alpha and CO velocity field data as well as HI kinematics to search for non-circular motions in the disk galaxies. DiskFit can also be used to constrain photometric models of the disc, bar and bulge. It deprecates an earlier version, by a subset of these authors, called velfit.

[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:1209.013]
IRACproc: IRAC Post-BCD Processing

IRACproc is a software suite that facilitates the co-addition of dithered or mapped Spitzer/IRAC data to make them ready for further analysis with application to a wide variety of IRAC observing programs. The software runs within PDL, a numeric extension for Perl available from pdl.perl.org, and as stand alone perl scripts. In acting as a wrapper for the Spitzer Science Center's MOPEX software, IRACproc improves the rejection of cosmic rays and other transients in the co-added data. In addition, IRACproc performs (optional) Point Spread Function (PSF) fitting, subtraction, and masking of saturated stars.

[ascl:1209.014]
FAMIAS: Frequency Analysis and Mode Identification for AsteroSeismology

FAMIAS (Frequency Analysis and Mode Identification for Asteroseismology) is a package of software tools programmed in C++ for the analysis of photometric and spectroscopic time-series data. FAMIAS provides analysis tools that are required for the steps between the data reduction and the seismic modeling. Two main sets of tools are incorporated in FAMIAS. The first set permits to search for periodicities in the data using Fourier and non-linear least-squares fitting techniques. The other set permits to carry out a mode identification for the detected pulsation frequencies to determine their harmonic degree l, and azimuthal order m. FAMIAS is applicable to main-sequence pulsators hotter than the Sun. This includes Gamma Dor, Delta Sct stars, slowly pulsating B (SPB)-stars and Beta Cep stars - basically all stars for which empirical mode identification is required to successfully carry out asteroseismology.

[ascl:1209.015]
Aspects: Probabilistic/positional association of catalogs of sources

Given two catalogs K and K' of n and n' astrophysical sources, respectively, Aspects (Association positionnelle/probabiliste de catalogues de sources) computes, for any objects M_{i} ∈ K and M'_{j} ∈ K', the probability that M'_{j} is a counterpart of M_{i}, i.e. that they are the same source. To determine this probability of association, the code takes into account the coordinates and the positional uncertainties of all the objects. Aspects also computes the probability P(A_{i, 0} | C ∩ C') that M_{i} has no counterpart.

Aspects is written in Fortran 95; the required Fortran 90 Numerical Recipes routines used in version 1.0 have been replaced with free equivalents in version 2.0.

[ascl:1208.001]
Astrometry.net: Astrometric calibration of images

Astrometry.net is a reliable and robust system that takes as input an astronomical image and returns as output the pointing, scale, and orientation of that image (the astrometric calibration or World Coordinate System information). The system requires no first guess, and works with the information in the image pixels alone; that is, the problem is a generalization of the "lost in space" problem in which nothing—not even the image scale—is known. After robust source detection is performed in the input image, asterisms (sets of four or five stars) are geometrically hashed and compared to pre-indexed hashes to generate hypotheses about the astrometric calibration. A hypothesis is only accepted as true if it passes a Bayesian decision theory test against a null hypothesis. With indices built from the USNO-B catalog and designed for uniformity of coverage and redundancy, the success rate is >99.9% for contemporary near-ultraviolet and visual imaging survey data, with no false positives. The failure rate is consistent with the incompleteness of the USNO-B catalog; augmentation with indices built from the Two Micron All Sky Survey catalog brings the completeness to 100% with no false positives. We are using this system to generate consistent and standards-compliant meta-data for digital and digitized imaging from plate repositories, automated observatories, individual scientific investigators, and hobbyists.

[ascl:1208.002]
BINSYN: Simulating Spectra and Light Curves of Binary Systems with or without Accretion Disks

The BINSYN program suite is a collection of programs for analysis of binary star systems with or without an optically thick accretion disk. BINSYN produces synthetic spectra of individual binary star components plus a synthetic spectrum of the system. If the system includes an accretion disk, BINSYN also produces a separate synthetic spectrum of the disk face and rim. A system routine convolves the synthetic spectra with filter profiles of several photometric standards to produce absolute synthetic photometry output. The package generates synthetic light curves and determines an optimized solution for system parameters.

[ascl:1208.003]
APT: Aperture Photometry Tool

Aperture Photometry Tool (APT) is software for astronomers and students interested in manually exploring the photometric qualities of astronomical images. It has a graphical user interface (GUI) which allows the image data associated with aperture photometry calculations for point and extended sources to be visualized and, therefore, more effectively analyzed. Mouse-clicking on a source in the displayed image draws a circular or elliptical aperture and sky annulus around the source and computes the source intensity and its uncertainty, along with several commonly used measures of the local sky background and its variability. The results are displayed and can be optionally saved to an aperture-photometry-table file and plotted on graphs in various ways using functions available in the software. APT is geared toward processing sources in a small number of images and is not suitable for bulk processing a large number of images, unlike other aperture photometry packages (e.g., SExtractor). However, APT does have a convenient source-list tool that enables calculations for a large number of detections in a given image. The source-list tool can be run either in automatic mode to generate an aperture photometry table quickly or in manual mode to permit inspection and adjustment of the calculation for each individual detection. APT displays a variety of useful graphs, including image histogram, and aperture slices, source scatter plot, sky scatter plot, sky histogram, radial profile, curve of growth, and aperture-photometry-table scatter plots and histograms. APT has functions for customizing calculations, including outlier rejection, pixel “picking” and “zapping,” and a selection of source and sky models. The radial-profile-interpolation source model, accessed via the radial-profile-plot panel, allows recovery of source intensity from pixels with missing data and can be especially beneficial in crowded fields.

[ascl:1208.004]
PyKE: Reduction and analysis of Kepler Simple Aperture Photometry data

PyKE is a python-based PyRAF package that can also be run as a stand-alone program within a unix-based shell without compiling against PyRAF. It is a group of tasks developed for the reduction and analysis of Kepler Simple Aperture Photometry (SAP) data of individual targets with individual characteristics. The main purposes of these tasks are to i) re-extract light curves from manually-chosen pixel apertures and ii) cotrend and/or detrend the data in order to reduce or remove systematic noise structure using methods tunable to user and target-specific requirements. PyKE is an open source project and contributions of new tasks or enhanced functionality of existing tasks by the community are welcome.

[ascl:1208.005]
PSM: Planck Sky Model

Ashdown, Mark; Aumont, Jonathan; Baccigalupi, Carlo; Banday, Anthony; Basak, Soumen; Bernard, Jean-Philippe; Betoule, Marc; Bouchet, François; Castex, Guillaume; Clements, Dave; Da Silva, Antonio; De Zotti, Gianfranco; Delabrouille, Jacques; Dickinson, Clive; Dodu, Fabrice; Dolag, Klaus; Elsner, Franz; Fauvet, Lauranne; Faÿ, Gilles; Giardino, Giovanna; Gonzalez-Nuevo, Joaquin; le Jeune, Maude; Leach, Samuel; Lesgourgues, Julien; Liguori, Michele; Macias, Juan; Massardi, Marcella; Matarrese, Sabino; Mazzotta, Pasquale; Melin, Jean-Baptiste; Miville-Deschênes, Marc-Antoine; Montier, Ludovic; Mottet, Sylvain; Paladini, Roberta; Partridge, Bruce; Piffaretti, Rocco; Prézeau, Gary; Prunet, Simon; Ricciardi, Sara; Roman, Matthieu; Schaefer, Bjorn; Toffolatti, Luigi

The Planck Sky Model (PSM) is a global representation of the multi-component sky at frequencies ranging from a few GHz to a few THz. It summarizes in a synthetic way as much of our present knowledge as possible of the GHz sky. PSM is a complete and versatile set of programs and data that can be used for the simulation or the prediction of sky emission in the frequency range of typical CMB experiments, and in particular of the Planck sky mission. It was originally developed as part of the activities of Planck component separation Working Group (or "Working Group 2" - WG2), and of the ADAMIS team at APC.

PSM gives users the opportunity to investigate the model in some depth: look at its parameters, visualize its predictions for all individual components in various formats, simulate sky emission compatible with a given parameter set, and observe the modeled sky with a synthetic instrument. In particular, it makes possible the simulation of sky emission maps as could be plausibly observed by Planck or other CMB experiments that can be used as inputs for the development and testing of data processing and analysis techniques.

[ascl:1208.006]
ccogs: Cosmological Calculations on the GPU

This suite contains two packages for computing cosmological quantities on the GPU: aperture_mass, which calculates the aperture mass map for a given dataset using the filter proposed by Schirmer et al (2007) (an NFW profile with exponential cut-offs at zero and large radii), and angular_correlation, which calculates the 2-pt angular correlation function using data and a flat distribution of randomly generated galaxies. A particular estimator is chosen, but the user has the flexibility to explore other estimators.

[ascl:1208.007]
Big MACS: Accurate photometric calibration

Kelly, P. L.; von der Linden, A.; Applegate, D.; Allen, M.; Allen, S. W.; Burchat, P. R.; Burke, D. L.; Ebeling, H.; Capak, P.; Czoske, O.; Donovan, D.; Mantz, A.; Morris, R. G.

Big MACS is a Python program that estimates an accurate photometric calibration from only an input catalog of stellar magnitudes and filter transmission functions. The user does not have to measure color terms which can be difficult to characterize. Supplied with filter transmission functions, Big MACS synthesizes an expected stellar locus for your data and then simultaneously solves for all unknown zeropoints when fitting to the instrumental locus. The code uses a spectroscopic model for the SDSS stellar locus in color-color space and filter functions to compute expected locus. The stellar locus model is corrected for Milky Way reddening. If SDSS or 2MASS photometry is available for stars in field, Big MACS can yield a highly accurate absolute calibration.

[ascl:1208.008]
TiRiFiC: Tilted Ring Fitting Code

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.

[ascl:1208.009]
BLOBCAT: Software to Catalog Blobs

BLOBCAT is a source extraction software that utilizes the flood fill algorithm to detect and catalog blobs, or islands of pixels representing sources, in 2D astronomical images. The software is designed to process radio-wavelength images of both Stokes I intensity and linear polarization, the latter formed through the quadrature sum of Stokes Q and U intensities or as a by-product of rotation measure synthesis. BLOBCAT corrects for two systematic biases to enable the flood fill algorithm to accurately measure flux densities for Gaussian sources. BLOBCAT exhibits accurate measurement performance in total intensity and, in particular, linear polarization, and is particularly suited to the analysis of large survey data.

[ascl:1208.010]
BASE: Bayesian Astrometric and Spectroscopic Exoplanet Detection and Characterization Tool

BASE is a novel program for the combined or separate Bayesian analysis of astrometric and radial-velocity measurements of potential exoplanet hosts and binary stars. The tool fulfills two major tasks of exoplanet science, namely the detection of exoplanets and the characterization of their orbits. BASE was developed to provide the possibility of an integrated Bayesian analysis of stellar astrometric and Doppler-spectroscopic measurements with respect to their binary or planetary companions’ signals, correctly treating the astrometric measurement uncertainties and allowing to explore the whole parameter space without the need for informative prior constraints. The tool automatically diagnoses convergence of its Markov chain Monte Carlo (MCMC[2]) sampler to the posterior and regularly outputs status information. For orbit characterization, BASE delivers important results such as the probability densities and correlations of model parameters and derived quantities. BASE is a highly configurable command-line tool developed in Fortran 2008 and compiled with GFortran. Options can be used to control the program’s behaviour and supply information such as the stellar mass or prior information. Any option can be supplied in a configuration file and/or on the command line.

[ascl:1208.011]
Fewbody: Numerical toolkit for simulating small-N gravitational dynamics

Fewbody is a numerical toolkit for simulating small-N gravitational dynamics. It is a general N-body dynamics code, although it was written for the purpose of performing scattering experiments, and therefore has several features that make it well-suited for this purpose. Fewbody uses the 8th-order Runge-Kutta Prince-Dormand integration method with 9th-order error estimate and adaptive timestep to advance the N-body system forward in time. It integrates the usual formulation of the N-body equations in configuration space, but allows for the option of global pairwise Kustaanheimo-Stiefel (K-S) regularization (Heggie 1974; Mikkola 1985). The code uses a binary tree algorithm to classify the N-body system into a set of independently bound hierarchies, and performs collisions between stars in the “sticky star” approximation. Fewbody contains a collection of command line utilities that can be used to perform individual scattering and N-body interactions, but is more generally a library of functions that can be used from within other codes.

[ascl:1208.012]
Swarm-NG: Parallel n-body Integrations

Dindar, Saleh; Ford, Eric B.; Juric, Mario; Young, In Yeo; Gao, Jianwei; Boley, Aaron C.; Nelson, Benjamin; Peters, Jorg

Swarm-NG is a C++ library for the efficient direct integration of many n-body systems using highly-parallel Graphics Processing Units (GPU). Swarm-NG focuses on many few-body systems, e.g., thousands of systems with 3...15 bodies each, as is typical for the study of planetary systems; the code parallelizes the simulation, including both the numerical integration of the equations of motion and the evaluation of forces using NVIDIA's "Compute Unified Device Architecture" (CUDA) on the GPU. Swarm-NG includes optimized implementations of 4th order time-symmetrized Hermite integration and mixed variable symplectic integration as well as several sample codes for other algorithms to illustrate how non-CUDA-savvy users may themselves introduce customized integrators into the Swarm-NG framework. Applications of Swarm-NG include studying the late stages of planet formation, testing the stability of planetary systems and evaluating the goodness-of-fit between many planetary system models and observations of extrasolar planet host stars (e.g., radial velocity, astrometry, transit timing). While Swarm-NG focuses on the parallel integration of many planetary systems,the underlying integrators could be applied to a wide variety of problems that require repeatedly integrating a set of ordinary differential equations many times using different initial conditions and/or parameter values.

[ascl:1208.013]
SolarSoft: Programming and data analysis environment for solar physics

SolarSoft is a set of integrated software libraries, data bases, and system utilities which provide a common programming and data analysis environment for Solar Physics. The SolarSoftWare (SSW) system is built from Yohkoh, SOHO, SDAC and Astronomy libraries and draws upon contributions from many members of those projects. It is primarily an IDL based system, although some instrument teams integrate executables written in other languages. The SSW environment provides a consistent look and feel at widely distributed co-investigator institutions to facilitate data exchange and to stimulate coordinated analysis. Commonalities and overlap in solar data and analysis goals are exploited to permit application of fundamental utilities to the data from many different solar instruments. The use of common libraries, utilities, techniques and interfaces minimizes the learning curve for investigators who are analyzing new solar data sets, correlating results from multiple experiments or performing research away from their home institution.

[ascl:1208.014]
MPI-AMRVAC: MPI-Adaptive Mesh Refinement-Versatile Advection Code

van der Holst, Bar; Keppens, Rony; Meliani, Zakaria; Porth, Oliver; van Marle, Allard Jan; Delmont, Peter; Xia, Chun

MPI-AMRVAC is an MPI-parallelized Adaptive Mesh Refinement code, with some heritage (in the solver part) to the Versatile Advection Code or VAC, initiated by Gábor Tóth at the Astronomical Institute at Utrecht in November 1994, with help from Rony Keppens since 1996. Previous incarnations of the Adaptive Mesh Refinement version of VAC were of restricted use only, and have been used for basic research in AMR strategies, or for well-targeted applications. This MPI version uses a full octree block-based approach, and allows for general orthogonal coordinate systems. MPI-AMRVAC aims to advance any system of (primarily hyperbolic) partial differential equations by a number of different numerical schemes. The emphasis is on (near) conservation laws, with shock-dominated problems as a main research target. The actual equations are stored in separate modules, can be added if needed, and they can be selected by a simple configuration of the VACPP preprocessor. The dimensionality of the problem is also set through VACPP. The numerical schemes are able to handle discontinuities and smooth flows as well.

[ascl:1208.015]
Lare3d: Lagrangian-Eulerian remap scheme for MHD

Lare3d is a Lagrangian-remap code for solving the non-linear MHD equations in three spatial dimensions.

[ascl:1208.016]
VARTOOLS: Light Curve Analysis Program

The VARTOOLS program is a command line utility that provides tools for analyzing time series astronomical data. It implements a number of routines for calculating variability/periodicity statistics of light curves, as well as tools for modifying and filtering light curves.

[ascl:1208.017]
APLpy: Astronomical Plotting Library in Python

APLpy (the Astronomical Plotting Library in Python) is a Python module for producing publication-quality plots of astronomical imaging data in FITS format. The module uses Matplotlib, a powerful and interactive plotting package. It is capable of creating output files in several graphical formats, including EPS, PDF, PS, PNG, and SVG. Plots can be made interactively or by using scripts, and can generate co-aligned FITS cubes to make three-color RGB images. It also offers different overlay capabilities, including contour sets, markers with customizable symbols, and coordinate grids, and a range of other useful features.

[ascl:1208.018]
CUBEP3M: High performance P3M N-body code

Harnois-Deraps, Joachim; Pen, Ue-Li; Iliev, Ilian T.; Merz, Hugh; Emberson, J. D.; Desjacques, Vincent

CUBEP^{3}M is a high performance cosmological N-body code which has many utilities and extensions, including a runtime halo finder, a non-Gaussian initial conditions generator, a tuneable accuracy, and a system of unique particle identification. CUBEP^{3}M is fast, has a memory imprint up to three times lower than other widely used N-body codes, and has been run on up to 20,000 cores, achieving close to ideal weak scaling even at this problem size. It is well suited and has already been used for a broad number of science applications that require either large samples of non-linear realizations or very large dark matter N-body simulations, including cosmological reionization, baryonic acoustic oscillations, weak lensing or non-Gaussian statistics.

[ascl:1208.019]
MPFIT: Robust non-linear least squares curve fitting

These IDL routines provide a robust and relatively fast way to perform least-squares curve and surface fitting. The algorithms are translated from MINPACK-1, which is a rugged minimization routine found on Netlib, and distributed with permission. This algorithm is more desirable than CURVEFIT because it is generally more stable and less likely to crash than the brute-force approach taken by CURVEFIT, which is based upon Numerical Recipes.

[ascl:1208.020]
ParselTongue: AIPS Python Interface

ParselTongue is a Python interface to classic AIPS, Obit and possibly other task-based data reduction packages. It serves as the software infrastructure for some of the ALBUS implementation. It allows you to run AIPS tasks, and access AIPS headers and extension tables from Python. There is also support for running Obit tasks and accessing data in FITS files. Full access to the visibilities in AIPS UV data is also available.

[ascl:1208.021]
EzGal: A Flexible Interface for Stellar Population Synthesis Models

EzGal is a flexible Python program which generates observable parameters (magnitudes, colors, and mass-to-light ratios) for arbitrary input stellar population synthesis (SPS) models; it enables simple, direct comparison of different model sets so that the uncertainty introduced by choice of model set can be quantified. EzGal is also capable of generating composite stellar population models (CSPs) for arbitrary input star-formation histories and reddening laws, and can be used to interpolate between metallicities for a given model set.

[ascl:1207.001]
EXOFAST: Fast transit and/or RV fitter for single exoplanet

EXOFAST is a fast, robust suite of routines written in IDL which is designed to fit exoplanetary transits and radial velocity variations simultaneously or separately, and characterize the parameter uncertainties and covariances with a Differential Evolution Markov Chain Monte Carlo method. Our code self-consistently incorporates both data sets to simultaneously derive stellar parameters along with the transit and RV parameters, resulting in consistent, but tighter constraints on an example fit of the discovery data of HAT-P-3b that is well-mixed in under two minutes on a standard desktop computer. EXOFAST has an easy-to-use online interface for several basic features of our transit and radial velocity fitting. A more robust version of EXOFAST, EXOFASTv2 (ascl:1710.003), is also available.

Would you like to view a random code?