Results 1201-1250 of 2030 (2002 ASCL, 28 submitted)

[ascl:1601.020]
ProC: Process Coordinator

Hovest, Wolfgang; Knoche, Jörg; Hell, Reinhard; Doerl, Uwe; Riller, Thomas; Matthai, Frank; Ensslin, Torsten; Rachen, Jörg; Robbers, Georg; Adorf, Hans-Martin; Reinecke, Martin; Bartelmann, Matthias

ProC (short for Process Coordinator) is a versatile workflow engine that allows the user to build, run and manage workflows with just a few clicks. It automatically documents every processing step, making every modification to data reproducible. ProC provides a graphical user interface for constructing complex data processing workflows out of a given set of computer programs. The user can, for example, specify that only data products which are affected by a change in the input data are updated selectively, avoiding unnecessary computations. The ProC suite is flexible and satisfies basic needs of data processing centers that have to be able to restructure their data processing along with the development of a project.

[ascl:1601.021]
ISO: Isochrone construction

ISO transforms MESA history files into a uniform basis for interpolation and then constructs new stellar evolution tracks and isochrones from that basis. It is written in Fortran and requires MESA (ascl:1010.083), primarily for interpolation. Though designed to ingest MESA star history files, tracks from other stellar evolution codes can be incorporated by loading the tracks into the data structures used in the codes.

[ascl:1602.001]
Automark: Automatic marking of marked Poisson process in astronomical high-dimensional datasets

Automark models photon counts collected form observation of variable-intensity astronomical sources. It aims to mark the abrupt changes in the corresponding wavelength distribution of the emission automatically. In the underlying methodology, change points are embedded into a marked Poisson process, where photon wavelengths are regarded as marks and both the Poisson intensity parameter and the distribution of the marks are allowed to change.

[ascl:1602.002]
pyraf-dbsp: Reduction pipeline for the Palomar Double Beam Spectrograph

pyraf-dbsp is a PyRAF-based (ascl:1207.011) reduction pipeline for optical spectra taken with the Palomar 200-inch Double Beam Spectrograph. The pipeline provides a simplified interface for basic reduction of single-object spectra with minimal overhead. It is suitable for quicklook classification of transients as well as moderate-precision (few km/s) radial velocity work.

[ascl:1602.003]
ZAP: Zurich Atmosphere Purge

ZAP (Zurich Atmosphere Purge) provides sky subtraction for integral field spectroscopy; its approach is based on principal component analysis (PCA) developed for the Multi Unit Spectrographic Explorer (MUSE) integral field spectrograph. ZAP employs filtering and data segmentation to enhance the inherent capabilities of PCA for sky subtraction. ZAP reduces sky emission residuals while robustly preserving the flux and line shapes of astronomical sources; this method works in a variety of observational situations from sparse fields with a low density of sources to filled fields in which the target source fills the field of view. With the inclusion of both of these situations the method is generally applicable to many different science cases and should also be useful for other instrumentation.

[ascl:1602.004]
DUSTYWAVE: Linear waves in gas and dust

Written in Fortran, DUSTYWAVE computes the exact solution for linear waves in a two-fluid mixture of gas and dust. The solutions are general with respect to both the dust-to-gas ratio and the amplitude of the drag coefficient.

[ascl:1602.005]
LRGS: Linear Regression by Gibbs Sampling

LRGS (Linear Regression by Gibbs Sampling) implements a Gibbs sampler to solve the problem of multivariate linear regression with uncertainties in all measured quantities and intrinsic scatter. LRGS extends an algorithm by Kelly (2007) that used Gibbs sampling for performing linear regression in fairly general cases in two ways: generalizing the procedure for multiple response variables, and modeling the prior distribution of covariates using a Dirichlet process.

[ascl:1602.006]
LIRA: LInear Regression in Astronomy

LIRA (LInear Regression in Astronomy) performs Bayesian linear regression that accounts for heteroscedastic errors in both the independent and the dependent variables, intrinsic scatters (in both variables), time evolution of slopes, normalization and scatters, Malmquist and Eddington bias, and break of linearity. The posterior distribution of the regression parameters is sampled with a Gibbs method exploiting the JAGS (ascl:1209.002) library.

[ascl:1602.007]
FilTER: Filament Trait-Evaluated Reconstruction

FilTER (Filament Trait-Evaluated Reconstruction) post-processes output from DisPerSE (ascl:1302.015

[ascl:1602.008]
NuCraft: Oscillation probabilities for atmospheric neutrinos calculator

NuCraft calculates oscillation probabilities for atmospheric neutrinos, taking into account matter effects and the Earth's atmosphere, and supports an arbitrary number of sterile neutrino flavors with easily configurable continuous Earth models. Continuous modeling of the Earth instead of the often-used approximation of four layers with constant density and consideration of the smearing of baseline lengths due to the variable neutrino production heights in Earth's atmosphere each lead to deviations of 10% or more for conventional neutrinos between 1 and 10 GeV.

[ascl:1602.009]
LensTools: Weak Lensing computing tools

LensTools implements a wide range of routines frequently used in Weak Gravitational Lensing, including tools for image analysis, statistical processing and numerical theory predictions. The package offers many useful features, including complete flexibility and easy customization of input/output formats; efficient measurements of power spectrum, PDF, Minkowski functionals and peak counts of convergence maps; survey masks; artificial noise generation engines; easy to compute parameter statistical inferences; ray tracing simulations; and many others. It requires standard numpy and scipy, and depending on tools used, may require Astropy (ascl:1304.002), emcee (ascl:1303.002), matplotlib, and mpi4py.

[ascl:1602.010]
The Cannon: Data-driven method for determining stellar parameters and abundances from stellar spectra

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.

[ascl:1602.011]
Celestial: Common astronomical conversion routines and functions

The R package Celestial contains common astronomy conversion routines, particularly the HMS and degrees schemes, and a large range of functions for calculating properties of different cosmologies (as used by the cosmocalc website). This includes distances, ages, growth rate/factor and densities (e.g., Omega evolution and critical energy density). It also includes functions for calculating thermal properties of the CMB and Planck's equations and virial properties of halos in different cosmologies, and standard NFW and weak-lensing formulas and low level orbital routines for calculating Roche properties, Vis-Viva and free-fall times.

[ascl:1602.012]
DELightcurveSimulation: Light curve simulation code

DELightcurveSimulation simulates light curves with any given power spectral density and any probability density function, following the algorithm described in Emmanoulopoulos *et al.* (2013). The simulated products have exactly the same variability and statistical properties as the observed light curves. The code is a Python implementation of the Mathematica code provided by Emmanoulopoulos *et al.*

[ascl:1602.013]
TailZ: Redshift distributions estimator of photometric samples of galaxies

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.

[ascl:1602.014]
k2photometry: Read, reduce and detrend K2 photometry

Van Eylen, Vincent; Nowak, Grzegorz; Albrecht, Simon; Palle, Enric; Ribas, Ignasi; Bruntt, Hans; Perger, Manuel; Gandolfi, Davide; Hirano, Teriyuki; Sanchis-Ojeda, Roberto; Kiilerich, Amanda; Arranz, Jorge P.; Badenas, Mariona; Dai, Fei; Deeg, Hans J.; Guenther, Eike W.; Montanes-Rodriguez, Pilar; Narita, Norio; Rogers, Leslie A.; Bejar, Victor J. S.; Shrotriya, Tushar S.; Winn, Joshua N.; Sebastian, Daniel

k2photometry reads, reduces and detrends K2 photometry and searches for transiting planets. MAST database pixel files are used as input; the output includes raw lightcurves, detrended lightcurves and a transit search can be performed as well. Stellar variability is not typically well-preserved but parameters can be tweaked to change that. The BLS algorithm used to detect periodic events is a Python implementation by Ruth Angus and Dan Foreman-Mackey (https://github.com/dfm/python-bls).

[ascl:1602.015]
GANDALF: Graphical Astrophysics code for N-body Dynamics And Lagrangian Fluids

GANDALF, a successor to SEREN (ascl:1102.010), is a hybrid self-gravitating fluid dynamics and collisional N-body code primarily designed for investigating star formation and planet formation problems. GANDALF uses various implementations of Smoothed Particle Hydrodynamics (SPH) to perform hydrodynamical simulations of gas clouds undergoing gravitational collapse to form new stars (or other objects), and can perform simulations of pure N-body dynamics using high accuracy N-body integrators, model the intermediate phase of cluster evolution, and provide visualizations via its python interface as well as interactive simulations. Although based on many of the SEREN routines, GANDALF has been largely re-written from scratch in C++ using more optimal algorithms and data structures.

[ascl:1602.016]
IRSFRINGE: Interactive tool for fringe removal from Spitzer IRS spectra

IRSFRINGE is an IDL-based GUI package that allows observers to interactively remove fringes from IRS spectra. Fringes that originate from the detector subtrates are observed in the IRS Short-High (SH) and Long-High (LH) modules. In the Long-Low (LL) module, another fringe component is seen as a result of the pre-launch change in one of the LL filters. The fringes in the Short-Low (SL) module are not spectrally resolved. the fringes are already largely removed in the pipeline processing when the flat field is applied. However, this correction is not perfect and remaining fringes can be removed with IRSFRINGE from data in each module. IRSFRINGE is available as a stand-alone package and is also part of the Spectroscopic Modeling, Analysis and Reduction Tool (SMART, ascl:1210.021).

[ascl:1602.017]
CHIP: Caltech High-res IRS Pipeline

CHIP (Caltech High-res IRS Pipeline) reduces high signal-to-noise short-high and long-high Spitzer-IRS spectra, especially that taken with dedicated background exposures. Written in IDL, it is independent of other Spitzer reduction tools except IRSFRINGE (ascl:1602.016).

[ascl:1602.018]
POPPY: Physical Optics Propagation in PYthon

Perrin, Marshall; Long, Joseph; Douglas, Ewan; Sivaramakrishnan, Anand; Slocum, Christine; and others

POPPY (Physical Optics Propagation in PYthon) simulates physical optical propagation including diffraction. It implements a flexible framework for modeling Fraunhofer and Fresnel diffraction and point spread function formation, particularly in the context of astronomical telescopes. POPPY provides the optical modeling framework for WebbPSF (ascl:1504.007) and was developed as part of a simulation package for JWST, but is available separately and is broadly applicable to many kinds of imaging simulations.

[ascl:1602.019]
CLOC: Cluster Luminosity Order-Statistic Code

CLOC computes cluster order statistics, *i.e.* the luminosity distribution of the Nth most luminous cluster in a population. It is flexible and requires few assumptions, allowing for parametrized variations in the initial cluster mass function and its upper and lower cutoffs, variations in the cluster age distribution, stellar evolution and dust extinction, as well as observational uncertainties in both the properties of star clusters and their underlying host galaxies. It uses Markov chain Monte Carlo methods to search parameter space to find best-fitting values for the parameters describing cluster formation and disruption, and to obtain rigorous confidence intervals on the inferred values.

[ascl:1602.020]
mbb_emcee: Modified Blackbody MCMC

Mbb_emcee fits modified blackbodies to photometry data using an affine invariant MCMC. It has large number of options which, for example, allow computation of the IR luminosity or dustmass as part of the fit. Carrying out a fit produces a HDF5 output file containing the results, which can either be read directly, or read back into a mbb_results object for analysis. Upper and lower limits can be imposed as well as Gaussian priors on the model parameters. These additions are useful for analyzing poorly constrained data. In addition to standard Python packages scipy, numpy, and cython, mbb_emcee requires emcee (ascl:1303.002), Astropy (ascl:1304.002), h5py, and for unit tests, nose.

[ascl:1602.021]
COLAcode: COmoving Lagrangian Acceleration code

COLAcode is a serial particle mesh-based N-body code illustrating the COLA (COmoving Lagrangian Acceleration) method; it solves for Large Scale Structure (LSS) in a frame that is comoving with observers following trajectories calculated in Lagrangian Perturbation Theory (LPT). It differs from standard N-body code by trading accuracy at small-scales to gain computational speed without sacrificing accuracy at large scales. This is useful for generating large ensembles of accurate mock halo catalogs required to study galaxy clustering and weak lensing; such catalogs are needed to perform detailed error analysis for ongoing and future surveys of LSS.

[ascl:1603.001]
SILSS: SPHERE/IRDIS Long-Slit Spectroscopy pipeline

The ESO's VLT/SPHERE instrument includes a unique long-slit spectroscopy (LSS) mode coupled with Lyot coronagraphy in its infrared dual-band imager and spectrograph (IRDIS) for spectral characterization of young, giant exoplanets detected by direct imaging. The SILSS pipeline is a combination of the official SPHERE pipeline and additional custom IDL routines developed within the SPHERE consortium for the speckle subtraction and spectral extraction of a companion's spectrum; it offers a complete end-to-end pipeline, from raw data (science+calibrations) to a final spectrum of the companion. SILSS works on both the low-resolution (LRS) and medium-resolution (MRS) data, and allows correction for some of the known biases of the instrument. Documentation is included in the header of the main routine of the pipeline.

[ascl:1603.002]
CORBITS: Efficient Geometric Probabilities of Multi-Transiting Exoplanetary Systems

CORBITS (Computed Occurrence of Revolving Bodies for the Investigation of Transiting Systems) computes the probability that any particular group of exoplanets can be observed to transit from a collection of conjectured exoplanets orbiting a star. The efficient, semi-analytical code computes the areas bounded by circular curves on the surface of a sphere by applying elementary differential geometry. CORBITS is faster than previous algorithms, based on comparisons with Monte Carlo simulations, and tests show that it is extremely accurate even for highly eccentric planets.

[submitted]
millennium-tap-query: A Python Tool to Query the Millennium Simulation UWS/TAP client

millennium-tap-query is a simple wrapper for the Python package requests to deal with connections to the Millennium TAP Web Client. With this tool you can perform basic or advanced queries to the Millennium Simulation database and download the data products. millennium-tap-query is similar to the TAP query tool in the German Astrophysical Virtual Observatory (GAVO) VOtables package.

[ascl:1603.003]
VIP: Vortex Image Processing pipeline for high-contrast direct imaging of exoplanets

Gomez Gonzalez, Carlos Alberto; Wertz, Olivier; Christiaens, Valentin; Absil, Olivier; Mawet, Dimitri

VIP (Vortex Image Processing pipeline) provides pre- and post-processing algorithms for high-contrast direct imaging of exoplanets. Written in Python, VIP provides a very flexible framework for data exploration and image processing and supports high-contrast imaging observational techniques, including angular, reference-star and multi-spectral differential imaging. Several post-processing algorithms for PSF subtraction based on principal component analysis are available as well as the LLSG (Local Low-rank plus Sparse plus Gaussian-noise decomposition) algorithm for angular differential imaging. VIP also implements the negative fake companion technique coupled with MCMC sampling for rigorous estimation of the flux and position of potential companions.

[ascl:1603.004]
gPhoton: Time-tagged GALEX photon events analysis tools

Written in Python, gPhoton calibrates and sky-projects the ~1.1 trillion ultraviolet photon events detected by the microchannel plates on the Galaxy Evolution Explorer Spacecraft (GALEX), archives these events in a publicly accessible database at the Mikulski Archive for Space Telescopes (MAST), and provides tools for working with the database to extract scientific results, particularly over short time domains. The software includes a re-implementation of core functionality of the GALEX mission calibration pipeline to produce photon list files from raw spacecraft data as well as a suite of command line tools to generate calibrated light curves, images, and movies from the MAST database.

[ascl:1603.005]
EQUIB: Atomic level populations and line emissivities calculator

Howarth, I. D.; Adams, S.; Clegg, R. E. S.; Ruffle, D. P.; Liu, X.-W.; Pritchet, C. J.; Ercolano, B.

The Fortran program EQUIB solves the statistical equilibrium equation for each ion and yields atomic level populations and line emissivities for given physical conditions, namely electron temperature and electron density, appropriate to the zones in an ionized nebula where the ions are expected to exist.

[ascl:1603.006]
FAST-PT: Convolution integrals in cosmological perturbation theory calculator

FAST-PT calculates 1-loop corrections to the matter power spectrum in cosmology. The code utilizes Fourier methods combined with analytic expressions to reduce the computation time down to scale as N log N, where N is the number of grid point in the input linear power spectrum. FAST-PT is extremely fast, enabling mode-coupling integral computations fast enough to embed in Monte Carlo Markov Chain parameter estimation.

[ascl:1603.007]
SMARTIES: Spheroids Modelled Accurately with a Robust T-matrix Implementation for Electromagnetic Scattering

SMARTIES calculates the optical properties of oblate and prolate spheroidal particles, with comparable capabilities and ease-of-use as Mie theory for spheres. This suite of MATLAB codes provides a fully documented implementation of an improved T-matrix algorithm for the theoretical modelling of electromagnetic scattering by particles of spheroidal shape. Included are scripts that cover a range of scattering problems relevant to nanophotonics and plasmonics, including calculation of far-field scattering and absorption cross-sections for fixed incidence orientation, orientation-averaged cross-sections and scattering matrix, surface-field calculations as well as near-fields, wavelength-dependent near-field and far-field properties, and access to lower-level functions implementing the T-matrix calculations, including the T-matrix elements which may be calculated more accurately than with competing codes.

[ascl:1603.008]
ROBAST: ROOT-based ray-tracing library for cosmic-ray telescopes

ROBAST (ROOT-based simulator for ray tracing) is a non-sequential ray-tracing simulation library developed for wide use in optical simulations of gamma-ray and cosmic-ray telescopes. The library is written in C++ and fully utilizes the geometry library of the ROOT analysis framework, and can build the complex optics geometries typically used in cosmic ray experiments and ground-based gamma-ray telescopes.

[ascl:1603.009]
Asfgrid: Asteroseismic parameters for a star

asfgrid computes asteroseismic parameters for a star with given stellar parameters and vice versa. Written in Python, it determines delta_nu, nu_max or masses via interpolation over a grid.

[ascl:1603.010]
ExoPriors: Accounting for observational bias of transiting exoplanets

ExoPriors calculates a log-likelihood penalty for an input set of transit parameters to account for observational bias (geometric and signal-to-noise ratio detection bias) of transiting exoplanets. Written in Python, the code calculates this log-likelihood penalty in one of seven user-specified cases specified with Boolean input parameters for geometric and/or SNR bias, grazing or non-grazing events, and occultation events.

[ascl:1603.011]
DiskJockey: Protoplanetary disk modeling for dynamical mass derivation

DiskJockey derives dynamical masses for T Tauri stars using the Keplerian motion of their circumstellar disks, applied to radio interferometric data from the Atacama Large Millimeter Array (ALMA) and the Submillimeter Array (SMA). The package relies on RADMC-3D (ascl:1202.015) to perform the radiative transfer of the disk model. DiskJockey is designed to work in a parallel environment where the calculations for each frequency channel can be distributed to independent processors. Due to the computationally expensive nature of the radiative synthesis, fitting sizable datasets (e.g., SMA and ALMA) will require a substantial amount of CPU cores to explore a posterior distribution in a reasonable timeframe.

[ascl:1603.012]
tpipe: Searching radio interferometry data for fast, dispersed transients

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

[ascl:1603.013]
PyGSM: Python interface to the Global Sky Model

PyGSM is a Python interface for the Global Sky Model (GSM, ascl:1011.010). The GSM is a model of diffuse galactic radio emission, constructed from a variety of all-sky surveys spanning the radio band (e.g. Haslam and WMAP). PyGSM uses the GSM to generate all-sky maps in Healpix format of diffuse Galactic radio emission from 10 MHz to 94 GHz. The PyGSM module provides visualization utilities, file output in FITS format, and the ability to generate observed skies for a given location and date. PyGSM requires Healpy, PyEphem (ascl:1112.014), and AstroPy (ascl:1304.002).

[ascl:1603.014]
fibmeasure: Python/Cython module to find the center of back-illuminated optical fibers in metrology images

fibmeasure finds the precise locations of the centers of back-illuminated optical fibers in images. It was developed for astronomical fiber positioning feedback via machine vision cameras and is optimized for high-magnification images where fibers appear as resolvable circles. It was originally written during the design of the WEAVE pick-and-place fiber positioner for the William Herschel Telescope.

[ascl:1603.015]
Dedalus: Flexible framework for spectrally solving differential equations

Dedalus solves differential equations using spectral methods. It implements flexible algorithms to solve initial-value, boundary-value, and eigenvalue problems with broad ranges of custom equations and spectral domains. Its primary features include symbolic equation entry, multidimensional parallelization, implicit-explicit timestepping, and flexible analysis with HDF5. The code is written primarily in Python and features an easy-to-use interface. The numerical algorithm produces highly sparse systems for many equations which are efficiently solved using compiled libraries and MPI.

[ascl:1603.016]
ellc: Light curve model for eclipsing binary stars and transiting exoplanets

ellc analyzes the light curves of detached eclipsing binary stars and transiting exoplanet systems. The model represents stars as triaxial ellipsoids, and the apparent flux from the binary is calculated using Gauss-Legendre integration over the ellipses that are the projection of these ellipsoids on the sky. The code can also calculate the fluxweighted radial velocity of the stars during an eclipse (Rossiter-McLaghlin effect). ellc can model a wide range of eclipsing binary stars and extrasolar planetary systems, and can enable the use of modern Monte Carlo methods for data analysis and model testing.

[ascl:1603.017]
HIIexplorer: Detect and extract integrated spectra of HII regions

HIIexplorer detects and extracts the integrated spectra of HII regions from IFS datacubes. The procedure assumes H ii regions are peaky/isolated structures with a strong ionized gas emission, clearly above the continuum emission and the average ionized gas emission across the galaxy and that H ii regions have a typical physical size of about a hundred or a few hundreds of parsecs, which corresponds to a typical projected size at the distance of the galaxies of a few arcsec for galaxies at z~0.016. All input parameters can be derived from either a visual inspection and/or a statistical analysis of the Hα emission line map. The algorithm produces a segmentation FITS file describing the pixels associated to each H ii region.

[ascl:1603.018]
PolRadTran: Polarized Radiative Transfer Model Distribution

PolRadTran is a plane-parallel polarized radiative transfer model. It is used to compute the radiance exiting a vertically inhomogeneous atmosphere containing randomly-oriented particles. Both solar and thermal sources of radiation are considered. A direct method of incorporating the polarized scattering information is combined with the doubling and adding method to produce a relatively simple formulation.

[ascl:1604.001]
OpenMHD: Godunov-type code for ideal/resistive magnetohydrodynamics (MHD)

OpenMHD is a Godunov-type finite-volume code for ideal/resistive magnetohydrodynamics (MHD). It is written in Fortran 90 and is parallelized by using MPI-2 and OpenMP. The code was originally developed for studying magnetic reconnection problems and has been made publicly available in the hope that others may find it useful.

[ascl:1604.002]
libpolycomp: Compression/decompression library

Libpolycomp compresses and decompresses one-dimensional streams of numbers by means of several algorithms. It is well-suited for time-ordered data acquired by astronomical instruments or simulations. One of the algorithms, called "polynomial compression", combines two widely-used ideas (namely, polynomial approximation and filtering of Fourier series) to achieve substantial compression ratios for datasets characterized by smoothness and lack of noise. Notable examples are the ephemerides of astronomical objects and the pointing information of astronomical telescopes. Other algorithms implemented in this C library are well known and already widely used, e.g., RLE, quantization, deflate (via libz) and Burrows-Wheeler transform (via libbzip2). Libpolycomp can compress the timelines acquired by the Planck/LFI instrument with an overall compression ratio of ~9, while other widely known programs (gzip, bzip2) reach compression ratios less than 1.5.

[ascl:1604.003]
LAMBDAR: Lambda Adaptive Multi-Band Deblending Algorithm in R

LAMBDAR measures galaxy fluxes from an arbitrary FITS image, covering an arbitrary photometric wave-band, when provided all parameters needed to construct galactic apertures at the required locations for multi-band matched aperture galactic photometry. Through sophisticated matched aperture photometry, the package develops robust Spectral Energy Distributions (SEDs) and accurately establishes the physical properties of galactic objects. LAMBDAR was based on a package detailed in Bourne et al. (2012) that determined galactic fluxes in low resolution Herschel images.

[ascl:1604.004]
magicaxis: Pretty scientific plotting with minor-tick and log minor-tick support

The R suite magicaxis makes useful and pretty plots for scientific plotting and includes functions for base plotting, with particular emphasis on pretty axis labelling in a number of circumstances that are often used in scientific plotting. It also includes functions for generating images and contours that reflect the 2D quantile levels of the data designed particularly for output of MCMC posteriors where visualizing the location of the 68% and 95% 2D quantiles for covariant parameters is a necessary part of the post MCMC analysis, can generate low and high error bars, and allows clipping of values, rejection of bad values, and log stretching.

[ascl:1604.005]
Halotools: Galaxy-Halo connection models

Hearin, Andrew; Tollerud, Erik; Robitaille,Thomas; Droettboom, Michael; Zentner, Andrew; Bray, Erik; Craig, Matt; Bradley, Larry; Barbary, Kyle; Deil, Christoph; Tan, Kevin; Becker, Matthew R.; More, Surhud; Günther, Hans Moritz; Sipocz, Brigitta

Halotools builds and tests models of the galaxy-halo connection and analyzes catalogs of dark matter halos. The core functions of the package include fast generation of synthetic galaxy populations using HODs, abundance matching, and related methods; efficient algorithms for calculating galaxy clustering, lensing, z-space distortions, and other astronomical statistics; a modular, object-oriented framework for designing galaxy evolution models; and end-to-end support for reducing halo catalogs and caching them as hdf5 files.

[ascl:1604.006]
2-DUST: Dust radiative transfer code

2-DUST is a general-purpose dust radiative transfer code for an axisymmetric system that reveals the global energetics of dust grains in the shell and the 2-D projected morphologies of the shell that are strongly dependent on the mixed effects of the axisymmetric dust distribution and inclination angle. It can be used to model a variety of axisymmetric astronomical dust systems.

[ascl:1604.007]
DNest3: Diffusive Nested Sampling

DNest3 is a C++ implementation of Diffusive Nested Sampling (ascl:1010.029), a Markov Chain Monte Carlo (MCMC) algorithm for Bayesian Inference and Statistical Mechanics. Relative to older DNest versions, DNest3 has improved performance (in terms of the sampling overhead, likelihood evaluations still dominate in general) and is cleaner code: implementing new models should be easier than it was before. In addition, DNest3 is multi-threaded, so one can run multiple MCMC walkers at the same time, and the results will be combined together.

[ascl:1604.008]
The Tractor: Probabilistic astronomical source detection and measurement

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.

Would you like to view a random code?