ASCL.net

Astrophysics Source Code Library

Making codes discoverable since 1999

Browsing Codes

Results 501-750 of 1956 (1928 ASCL, 28 submitted)

Order
Title Date
 
Mode
Abstract Compact
Per Page
50100250All
[ascl:1904.014] rate: Reliable Analytic Thermochemical Equilibrium

rate computes thermochemical-equilibrium abundances for a H-C-N-O system with known pressure, temperature, and elemental abundances. The output abundances are H2O, CH4, CO, CO2, NH3, C2H2, C2H4, HCN, and N2, H2, H, and He.

[ascl:1803.015] RAPTOR: Imaging code for relativistic plasmas in strong gravity

RAPTOR produces accurate images, animations, and spectra of relativistic plasmas in strong gravity by numerically integrating the equations of motion of light rays and performing time-dependent radiative transfer calculations along the rays. The code is compatible with any analytical or numerical spacetime, is hardware-agnostic and may be compiled and run on both GPUs and CPUs. RAPTOR is useful for studying accretion models of supermassive black holes, performing time-dependent radiative transfer through general relativistic magneto-hydrodynamical (GRMHD) simulations and investigating the expected observational differences between the so-called fastlight and slow-light paradigms.

[ascl:1011.007] RAMSES: A new N-body and hydrodynamical code

A new N-body and hydrodynamical code, called RAMSES, is presented. It has been designed to study structure formation in the universe with high spatial resolution. The code is based on Adaptive Mesh Refinement (AMR) technique, with a tree based data structure allowing recursive grid refinements on a cell-by-cell basis. The N-body solver is very similar to the one developed for the ART code (Kravtsov et al. 97), with minor differences in the exact implementation. The hydrodynamical solver is based on a second-order Godunov method, a modern shock-capturing scheme known to compute accurately the thermal history of the fluid component. The accuracy of the code is carefully estimated using various test cases, from pure gas dynamical tests to cosmological ones. The specific refinement strategy used in cosmological simulations is described, and potential spurious effects associated to shock waves propagation in the resulting AMR grid are discussed and found to be negligible. Results obtained in a large N-body and hydrodynamical simulation of structure formation in a low density LCDM universe are finally reported, with 256^3 particles and 4.1 10^7 cells in the AMR grid, reaching a formal resolution of 8192^3. A convergence analysis of different quantities, such as dark matter density power spectrum, gas pressure power spectrum and individual haloes temperature profiles, shows that numerical results are converging down to the actual resolution limit of the code, and are well reproduced by recent analytical predictions in the framework of the halo model.

[ascl:1710.013] Ramses-GPU: Second order MUSCL-Handcock finite volume fluid solver

RamsesGPU is a reimplementation of RAMSES (ascl:1011.007) which drops the adaptive mesh refinement (AMR) features to optimize 3D uniform grid algorithms for modern graphics processor units (GPU) to provide an efficient software package for astrophysics applications that do not need AMR features but do require a very large number of integration time steps. RamsesGPU provides an very efficient C++/CUDA/MPI software implementation of a second order MUSCL-Handcock finite volume fluid solver for compressible hydrodynamics as a magnetohydrodynamics solver based on the constraint transport technique. Other useful modules includes static gravity, dissipative terms (viscosity, resistivity), and forcing source term for turbulence studies, and special care was taken to enhance parallel input/output performance by using state-of-the-art libraries such as HDF5 and parallel-netcdf.

[ascl:1411.010] Raga: Monte Carlo simulations of gravitational dynamics of non-spherical stellar systems

Raga (Relaxation in Any Geometry) is a Monte Carlo simulation method for gravitational dynamics of non-spherical stellar systems. It is based on the SMILE software (ascl:1308.001) for orbit analysis. It can simulate stellar systems with a much smaller number of particles N than the number of stars in the actual system, represent an arbitrary non-spherical potential with a basis-set or spline spherical-harmonic expansion with the coefficients of expansion computed from particle trajectories, and compute particle trajectories independently and in parallel using a high-accuracy adaptive-timestep integrator. Raga can also model two-body relaxation by local (position-dependent) velocity diffusion coefficients (as in Spitzer's Monte Carlo formulation) and adjust the magnitude of relaxation to the actual number of stars in the target system, and model the effect of a central massive black hole.

[ascl:1902.008] Radynversion: Solar atmospheric properties during a solar flare

Radynversion infers solar atmospheric properties during a solar flare. The code is based on an Invertible Neural Network (INN) that is trained to learn an approximate bijective mapping between the atmospheric properties of electron density, temperature, and bulk velocity (all as a function of altitude), and the observed Hα and Ca II λ8542 line profiles. As information is lost in the forward process of radiation transfer, this information is injected back into the model during the inverse process by means of a latent space; the training allows this latent space to be filled using an n-dimensional unit Gaussian distribution, where n is the dimensionality of the latent space. The code is based on a model trained by simulations made by RADYN, a 1D non-equilibrium radiation hydrodynamic model with good optically thick radiation treatment that does not consider magnetic effects.

[ascl:1801.012] RadVel: General toolkit for modeling Radial Velocities

RadVel models Keplerian orbits in radial velocity (RV) time series. The code is written in Python with a fast Kepler's equation solver written in C. It provides a framework for fitting RVs using maximum a posteriori optimization and computing robust confidence intervals by sampling the posterior probability density via Markov Chain Monte Carlo (MCMC). RadVel can perform Bayesian model comparison and produces publication quality plots and LaTeX tables.

[ascl:9910.009] RADPACK: A RADical compression analysis PACKage for fitting to the CMB

The RADPACK package, written in IDL, contains both data and software. The data are the constraints on the cosmic microwave background (CMB) angular power spectrum from all published data as of 9/99. A unique aspect of this compilation is that the non-Gaussianity of the uncertainties has been characterized. The most important program in the package, written in the IDL language, is called chisq.pro and calculates $chi^2$, for an input power spectrum, according to the offset log-normal form of Bond, Jaffe and Knox (astro-ph/9808264). chisq.pro also outputs files that are useful for examining the residuals (the difference between the predictions of the model and the data). There is an sm macro for plotting up the residuals, and a histogram of the residuals. The histogram is actually for the 'whitenend' residuals ---a linear combination of the residuals which leaves them uncorrelated and with unit variance. The expectation is that the whitened residuals will be distributed as a Gaussian with unit variance.

[ascl:1811.015] radon: Streak detection using the Fast Radon Transform

radon performs a Fast Radon Transform (FRT) on image data for streak detection. The software finds short streaks and multiple streaks, convolves the images with a given PSF, and tracks the best S/N results and find a automatic threshold. It also calculates the streak parameters in the input image and the streak parameters in the input image. radon has a simulator that can make multiple streaks of different intensities and coordinates, and can simulate random streaks with parameters chosen uniformly in a user-defined range.

[ascl:1108.016] RADMC: A 2-D Continuum Radiative Transfer Tool

RADMC is a 2-D Monte-Carlo code for dust continuum radiative transfer circumstellar disks and envelopes. It is based on the method of Bjorkman & Wood (ApJ 2001, 554, 615), but with several modifications to produce smoother results with fewer photon packages.

[ascl:1202.015] RADMC-3D: A multi-purpose radiative transfer tool

RADMC-3D is a software package for astrophysical radiative transfer calculations in arbitrary 1-D, 2-D or 3-D geometries. It is mainly written for continuum radiative transfer in dusty media, but also includes modules for gas line transfer and gas continuum transfer. RADMC-3D is a new incarnation of the older software package RADMC (ascl:1108.016).

[ascl:1308.012] RADLite: Raytracer for infrared line spectra

RADLite is a raytracer that is optimized for producing infrared line spectra and images from axisymmetric density structures, originally developed to function on top of the dust radiative transfer code RADMC. RADLite can consistently deal with a wide range of velocity gradients, such as those typical for the inner regions of protoplanetary disks. The code is intended as a back-end for chemical and excitation codes, and can rapidly produce spectra of thousands of lines for grids of models for comparison with observations. It includes functionality for simulating telescopic images for optical/IR/midIR/farIR telescopes. It takes advantage of multi-threaded CPUs and includes an escape-probability non-LTE module.

[ascl:1108.014] RADICAL: Multi-purpose 2-D Radiative Transfer Code

RADICAL is a multi-purpose 2-D radiative transfer code for axi-symmetric circumstellar (or circum-black-hole) envelopes /disks / tori etc. It has been extensively tested and found reliable and accurate. The code has recently been supplemented with a Variable Eddington Tensor module which enables it to solve dust continuum radiative transfer problems from very low up to extremely high optical depths with only a few (about 7) iterations at most.

[ascl:1806.017] RadFil: Radial density profile builder for interstellar filaments

RadFil is a radial density profile building and fitting tool for interstellar filaments. The software uses an image array and (in most cases) a boolean mask array that delineates the boundary of the filament to build and fit a radial density profile for the filaments.

[ascl:1010.075] Radex: Fast Non-LTE Analysis of Interstellar Line Spectra

The large quantity and high quality of modern radio and infrared line observations require efficient modeling techniques to infer physical and chemical parameters such as temperature, density, and molecular abundances. Radex calculates the intensities of atomic and molecular lines produced in a uniform medium, based on statistical equilibrium calculations involving collisional and radiative processes and including radiation from background sources. Optical depth effects are treated with an escape probability method. The program makes use of molecular data files maintained in the Leiden Atomic and Molecular Database (LAMDA), which will continue to be improved and expanded. The performance of the program is compared with more approximate and with more sophisticated methods. An Appendix provides diagnostic plots to estimate physical parameters from line intensity ratios of commonly observed molecules. This program should form an important tool in analyzing observations from current and future radio and infrared telescopes.

[ascl:1711.015] rac-2d: Thermo-chemical for modeling water vapor formation in protoplanetary disks

rec-2d models the distribution of water vapor in protoplanetary disks. Given a distribution of gas and dust, rac-2d first solves the dust temperature distribution with a Monte Carlo method and then solves the gas temperature distribution and chemical composition. Although the geometry is symmetric with respect to rotation around the central axis and reflection about the midplane, the photon propagation is done in full three dimensions. After establishing the dust temperature distribution, the disk chemistry is evolved for 1 Myr; the heating and cooling processes are coupled with chemistry, allowing the gas temperature to be evolved in tandem with chemistry based on the heating and cooling rates.

[ascl:1502.013] Rabacus: Analytic Cosmological Radiative Transfer Calculations

Rabacus performs analytic radiative transfer calculations in simple geometries relevant to cosmology and astrophysics; it also contains tools to calculate cosmological quantities such as the power spectrum and mass function. With core routines written in Fortran 90 and then wrapped in Python, the execution speed is thousands of times faster than equivalent routines written in pure Python.

[ascl:1106.005] R3D: Reduction Package for Integral Field Spectroscopy

R3D was developed to reduce fiber-based integral field spectroscopy (IFS) data. The package comprises a set of command-line routines adapted for each of these steps, suitable for creating pipelines. The routines have been tested against simulations, and against real data from various integral field spectrographs (PMAS, PPAK, GMOS, VIMOS and INTEGRAL). Particular attention is paid to the treatment of cross-talk.

R3D unifies the reduction techniques for the different IFS instruments to a single one, in order to allow the general public to reduce different instruments data in an homogeneus, consistent and simple way. Although still in its prototyping phase, it has been proved to be useful to reduce PMAS (both in the Larr and the PPAK modes), VIMOS and INTEGRAL data. The current version has been coded in Perl, using PDL, in order to speed-up the algorithm testing phase. Most of the time critical algorithms have been translated to C[float=][/float], and it is our intention to translate all of them. However, even in this phase R3D is fast enough to produce valuable science frames in reasonable time.

[ascl:1104.009] r-Java: An r-process Code and Graphical User Interface for Heavy-Element Nucleosynthesis

r-Java performs r-process nucleosynthesis calculations. It has a simple graphical user interface and is carries out nuclear statistical equilibrium (NSE) as well as static and dynamic r-process calculations for a wide range of input parameters. r-Java generates an abundance pattern based on a general entropy expression that can be applied to degenerate as well as non-degenerate matter, which allows tracking of the rapid density and temperature evolution of the ejecta during the initial stages of ejecta expansion.

[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:1811.006] QuickSip: Project survey image properties onto the sky into Healpix maps

QuickSip quickly projects Survey Image Properties (e.g. seeing, sky noise, airmass) into Healpix sky maps with flexible weighting schemes. It was initially designed to produce observing condition "systematics" maps for the Dark Energy Survey (DES), but will work with any multi-epoch survey and images with valid WCS. QuickSip can reproduce the Mangle (ascl:1202.005) magnitude limit maps at sub-percent accuracy but doesn't support additional masks (stars, trails, etc), in which case Mangle should be used. Thus, QuickSip can be seen as a simplified Mangle to project image properties into Healpix maps in a fast and more flexible manner.

[ascl:1402.024] QuickReduce: Data reduction pipeline for the WIYN One Degree Imager

QuickReduce quickly reduces data for ODI and is optimized for a first data inspection during acquisition at the the telescope. When installed on the ODI observer's interface, QuickReduce, coded in Python, performs all basic reduction steps as well as more advanced corrections for pupil-ghost removal, fringe correction and masking of persistent pixels and is capable enough for science-quality data reductions. It can also add an accurate astrometric WCS solution based on the 2MASS reference system as well as photometric zeropoint calibration for frames covered by the SDSS foot-print. The pipeline makes use of multiple CPU-cores wherever possible, resulting in an execution time of only a few seconds per frame, thus offering the ODI observer a convenient way to closely monitor data quality.

[ascl:1402.012] QUICKCV: Cosmic variance calculator

QUICKCV is an IDL sample variance/cosmic variance calculator for some geometry for galaxies in given stellar mass bins as a function of mean redshift and redshift bin size.

[ascl:1704.006] Quickclump: Identify clumps within a 3D FITS datacube

Quickclump finds clumps in a 3D FITS datacube. It is a fast, accurate, and automated tool written in Python. Though Quickclump is primarily intended for decomposing observations of interstellar clouds into individual clumps, it can also be used for finding clumps in any 3D rectangular data.

[ascl:1703.011] QtClassify: IFS data emission line candidates classifier

QtClassify is a GUI that helps classify emission lines found in integral field spectroscopic data. Input needed is a datacube as well as a catalog with emission lines and a signal-to-noise cube, such at that created by LSDCat (ascl:1612.002). The main idea is to take each detected line and guess what line it could be (and thus the redshift of the object). You would expect to see other lines that might not have been detected but are visible in the cube if you know where to look, which is why parts of the spectrum are shown where other lines are expected. In addition, monochromatic layers of the datacube are displayed, making it easy to spot additional emission lines.

[ascl:1612.011] QSFit: Quasar Spectral FITting

QSFit performs automatic analysis of Active Galactic Nuclei (AGN) optical spectra. It provides estimates of: AGN continuum luminosities and slopes at several restframe wavelengths; luminosities, widths and velocity offsets of 20 emission lines; luminosities of iron blended lines at optical and UV wavelengths; host galaxy luminosities. The whole fitting process is customizable for specific needs, and can be extended to analyze spectra from other data sources. The ultimate purpose of QSFit is to allow astronomers to run standardized recipes to analyze the AGN data, in a simple, replicable and shareable way.

[ascl:1809.011] qp: Quantile parametrization for probability distribution functions

qp manipulates parametrizations of 1-dimensional probability distribution functions, as suitable for photo-z PDF compression. The code helps determine a parameterization for storing a catalog of photo-z PDFs that balances the available storage resources against the accuracy of the photo-z PDFs and science products reconstructed from the stored parameters.

[ascl:1304.016] Qhull: Quickhull algorithm for computing the convex hull

Qhull computes the convex hull, Delaunay triangulation, Voronoi diagram, halfspace intersection about a point, furthest-site Delaunay triangulation, and furthest-site Voronoi diagram. The source code runs in 2-d, 3-d, 4-d, and higher dimensions. Qhull implements the Quickhull algorithm for computing the convex hull. It handles roundoff errors from floating point arithmetic. It computes volumes, surface areas, and approximations to the convex hull.

[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:1806.006] QE: Quantum opEn-Source Package for Research in Electronic Structure, Simulation, and Optimization

Quantum ESPRESSO (opEn-Source Package for Research in Electronic Structure, Simulation, and Optimization) is an integrated suite of codes for electronic-structure calculations and materials modeling at the nanoscale. It is based on density-functional theory, plane waves, and pseudopotentials. QE performs ground-state calculations such as self-consistent total energies, forces, stresses and Kohn-Sham orbitals, Car-Parrinello and Born-Oppenheimer molecular dynamics, and quantum transport such as ballistic transport, coherent transport from maximally localized Wannier functions, and Kubo-Greenwood electrical conductivity. It can also determine spectroscopic properties and examine time-dependent density functional perturbations and electronic excitations, and has a wide range of other functions.

[ascl:1601.015] QDPHOT: Quick & Dirty PHOTometry

QDPHOT is a fast CCD stellar photometry task which quickly produces CCD stellar photometry from two CCD images of a star field. It was designed to be a data mining tool for finding high-quality stellar observations in the data archives of the National Virtual Observatory. QDPHOT typically takes just a few seconds to analyze two Hubble Space Telescope WFPC2 observations of Local Group star clusters. It is also suitable for real-time data-quality analysis of CCD observations; on-the-fly instrumental color-magnitude diagrams can be produced at the telescope console during the few seconds between CCD readouts.

[ascl:1712.014] QATS: Quasiperiodic Automated Transit Search

QATS detects transiting extrasolar planets in time-series photometry. It relaxes the usual assumption of strictly periodic transits by permitting a variable, but bounded, interval between successive transits.

[submitted] Q3C: A PostgreSQL package for spatial queries and cross-matches of large astronomical catalogs

Q3C is a package designed to enable fast cone, ellipse and polygonal searches and cross-matches between large astronomical catalogs inside a PostgreSQL database. The package supports searches even if objects have proper motions.

[ascl:1806.003] pyZELDA: Python code for Zernike wavefront sensors

pyZELDA analyzes data from Zernike wavefront sensors dedicated to high-contrast imaging applications. This modular software was originally designed to analyze data from the ZELDA wavefront sensor prototype installed in VLT/SPHERE; simple configuration files allow it to be extended to support several other instruments and testbeds. pyZELDA also includes simple simulation tools to measure the theoretical sensitivity of a sensor and to compare it to other sensors.

[ascl:1608.002] pyXSIM: Synthetic X-ray observations generator

pyXSIM simulates X-ray observations from astrophysical sources. X-rays probe the high-energy universe, from hot galaxy clusters to compact objects such as neutron stars and black holes and many interesting sources in between. pyXSIM generates synthetic X-ray observations of these sources from a wide variety of models, whether from grid-based simulation codes such as FLASH (ascl:1010.082), Enzo (ascl:1010.072), and Athena (ascl:1010.014), to particle-based codes such as Gadget (ascl:0003.001) and AREPO, and even from datasets that have been created “by hand”, such as from NumPy arrays. pyXSIM can also manipulate the synthetic observations it produces in various ways and export the simulated X-ray events to other software packages to simulate the end products of specific X-ray observatories. pyXSIM is an implementation of the PHOX (ascl:1112.004) algorithm and was initially the photon_simulator analysis module in yt (ascl:1011.022); it is dependent on yt.

[ascl:1402.034] PyWiFeS: Wide Field Spectrograph data reduction pipeline

PyWiFeS is a Python-based data reduction pipeline for the Wide Field Spectrograph (WiFeS). Its core data processing routines are built on standard scientific Python packages commonly used in astronomical applications. It includes an implementation of a global optical model of the spectrograph which provides wavelengths solutions accurate to ˜0.05 Å (RMS) across the entire detector. Through scripting, PyWiFeS can enable batch processing of large quantities of data.

[ascl:1402.004] PyVO: Python access to the Virtual Observatory

PyVO provides access to remote data and services of the Virtual observatory (VO) using Python. It allows archive searches for data of a particular type or related to a particular topic and query submissions to obtain data to a particular archive to download selected data products. PyVO supports querying the VAO registry; simple data access services (DAL) to access images (SIA), source catalog records (Cone Search), spectra (SSA), and spectral line emission/absorption data (SLAP); and object name resolution (for converting names of objects in the sky into positions). PyVO requires both AstroPy and NumPy.

[ascl:1810.009] PyUltraLight: Pseudo-spectral Python code to compute ultralight dark matter dynamics

PyUltraLight computes non-relativistic ultralight dark matter dynamics in a static spacetime background. It uses pseudo-spectral methods to compute the evolution of a complex scalar field governed by the Schrödinger-Poisson system of coupled differential equations. Computations are performed on a fixed-grid with periodic boundary conditions, allowing for a decomposition of the field in momentum space by way of the discrete Fourier transform. The field is then evolved through a symmetrized split-step Fourier algorithm, in which nonlinear operators are applied in real space, while spatial derivatives are computed in Fourier space. Fourier transforms within PyUltraLight are handled using the pyFFTW pythonic wrapper around FFTW (ascl:1201.015).

[ascl:1710.010] PyTransport: Calculate inflationary correlation functions

PyTransport calculates the 2-point and 3-point function of inflationary perturbations produced during multi-field inflation. The core of PyTransport is C++ code which is automatically edited and compiled into a Python module once an inflationary potential is specified. This module can then be called to solve the background inflationary cosmology as well as the evolution of correlations of inflationary perturbations. PyTransport includes two additional modules written in Python, one to perform the editing and compilation, and one containing a suite of functions for common tasks such as looping over the core module to construct spectra and bispectra.

[ascl:1505.024] PyTransit: Transit light curve modeling

PyTransit implements optimized versions of the Giménez and Mandel & Agol transit models for exoplanet transit light-curves. The two models are implemented natively in Fortran with OpenMP parallelization, and are accessed by an object-oriented python interface. PyTransit facilitates the analysis of photometric time series of exoplanet transits consisting of hundreds of thousands of data points, and of multipassband transit light curves from spectrophotometric observations. It offers efficient model evaluation for multicolour observations and transmission spectroscopy, built-in supersampling to account for extended exposure times, and routines to calculate the projected planet-to-star distance for circular and eccentric orbits, transit durations, and more.

[ascl:1501.010] PythonPhot: Simple DAOPHOT-type photometry in Python

PythonPhot is a simple Python translation of DAOPHOT-type (ascl:1104.011) photometry procedures from the IDL AstroLib (Landsman 1993), including aperture and PSF-fitting algorithms, with a few modest additions to increase functionality and ease of use. These codes allow fast, easy, and reliable photometric measurements and are currently used in the Pan-STARRS supernova pipeline and the HST CLASH/CANDELS supernova analysis.

[ascl:1501.003] python-qucs: Python package for automating QUCS simulations

Characterization of the frequency response of coherent radiometric receivers is a key element in estimating the flux of astrophysical emissions, since the measured signal depends on the convolution of the source spectral emission with the instrument band shape. Python-qucs automates the process of preparing input data, running simulations and exporting results of QUCS (Quasi Universal Circuit Simulator) simulations.

[ascl:1612.001] Python-CPL: Python interface for the ESO Common Pipeline Library

Python-CPL is a framework to configure and execute pipeline recipes written with the Common Pipeline Library (CPL) (ascl:1402.010) with Python2 or Python3. The input, calibration and output data can be specified as FITS files or as astropy.io.fits objects in memory. The package is used to implement the MUSE pipeline in the AstroWISE data management system.

[ascl:1303.023] pysynphot: Synthetic photometry software package

pysynphot is a synthetic photometry software package suitable for either library or interactive use. Intended as a modern-language successor to the IRAF/STSDAS synphot package, it provides improved algorithms that address known shortcomings in synphot, and its object-oriented design is more easily extensible than synphot's task-oriented approach. It runs under PyRAF (ascl:1207.011), and a backwards compatibility mode is provided that recognizes all spectral and throughput tables, obsmodes, and spectral expressions used by synphot, to facilitate the transition for legacy code.

[ascl:1109.001] PySpecKit: Python Spectroscopic Toolkit

PySpecKit is a Python spectroscopic analysis and reduction toolkit meant to be generally applicable to optical, infrared, and radio spectra. It is capable of reading FITS-standard and many non-standard file types including CLASS spectra. It contains procedures for line fitting including gaussian and voigt profile fitters, and baseline-subtraction routines. It is capable of more advanced line fitting using arbitrary model grids. Fitting can be done both in batch mode and interactively. PySpecKit also produces publication-quality plots with TeX axis labels and annotations. It is designed to be extensible, allowing user-written reader, writer, and fitting routines to be "plugged in." It is actively under development and currently in the 'alpha' phase, with plans for a beta release.

[ascl:1411.002] pysovo: A library for implementing alerts triggered by VOEvents

pysovo contains basic tools to work with VOEvents. Though written for specific needs, others interested in VOEvents may find it useful to examine.

[ascl:1503.008] pYSOVAR: Lightcurves analysis

The pYSOVAR code calculates properties for a stack of lightcurves, including simple descriptive statistics (mean, max, min, ...), timing (e.g. Lomb-Scargle periodograms), variability indixes (e.g. Stetson), and color properties (e.g. slope in the color-magnitude diagram). The code is written in python and is closely integrated with astropy tables. Initially, pYSOVAR was written specifically for the analysis of two clusters in the YSOVAR project, using the (not publicly released) YSOVAR database as an input. Additional functionality has been added and the code has become more general; it is now useful for other clusters in the YSOVAR dataset or for other projects that have similar data (lightcurves in one or more bands with a few hundred points for a few thousand objects), though may not work out-of-the-box for different datasets.

[ascl:1704.007] PySM: Python Sky Model

PySM generates full-sky simulations of Galactic foregrounds in intensity and polarization relevant for CMB experiments. The components simulated are thermal dust, synchrotron, AME, free-free, and CMB at a given Nside, with an option to integrate over a top hat bandpass, to add white instrument noise, and to smooth with a given beam. PySM is based on the large-scale Galactic part of Planck Sky Model code and uses some of its inputs.

[ascl:1805.026] PySE: Python Source Extractor for radio astronomical images

PySE finds and measures sources in radio telescope images. It is run with several options, such as the detection threshold (a multiple of the local noise), grid size, and the forced clean beam fit, followed by a list of input image files in standard FITS or CASA format. From these, PySe provides a list of found sources; information such as the calculated background image, source list in different formats (e.g. text, region files importable in DS9), and other data may be saved. PySe can be integrated into a pipeline; it was originally written as part of the LOFAR Transient Detection Pipeline (TraP, ascl:1412.011).

[ascl:1207.010] PySALT: SALT science pipeline

The PySALT user package contains the primary reduction and analysis software tools for the SALT telescope. Currently, these tools include basic data reductions for RSS and SALTICAM in both imaging, spectroscopic, and slot modes. Basic analysis software for slot mode data is also provided. These tools are primarily written in python/PyRAF with some additional IRAF code.

[ascl:1904.026] pyRSD: Accurate predictions for the clustering of galaxies in redshift-space in Python

pyRSD computes the theoretical predictions of the redshift-space power spectrum of galaxies. It also includes functionality for fitting data measurements and finding the optimal model parameters, using both MCMC and nonlinear optimization techniques.

[ascl:1507.018] pyro: Python-based tutorial for computational methods for hydrodynamics

pyro is a simple python-based tutorial on computational methods for hydrodynamics. It includes 2-d solvers for advection, compressible, incompressible, and low Mach number hydrodynamics, diffusion, and multigrid. It is written with ease of understanding in mind. An extensive set of notes that is part of the Open Astrophysics Bookshelf project provides details of the algorithms.

[submitted] pyreaclib

A python interface to the JINA reaclib nuclear reaction database

[ascl:1207.011] PyRAF: Python alternative for IRAF

PyRAF is a command language for running IRAF tasks that is based on the Python scripting language. It gives users the ability to run IRAF tasks in an environment that has all the power and flexibility of Python. PyRAF can be installed along with an existing IRAF installation; users can then choose to run either PyRAF or the IRAF CL.

[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:1807.006] pyqz: Emission line code

pyqz computes the values of log(Q) [the ionization parameter] and 12+log(O/H) [the oxygen abundance, either total or in the gas phase] for a given set of strong emission lines fluxes from HII regions. The log(Q) and 12+log(O/H) values are interpolated from a finite set of diagnostic line ratio grids computed with the MAPPINGS V code (ascl:1807.005). The grids used by pyqz are chosen to be flat, without wraps, to decouple the influence of log(Q) and 12+log(O/H) on the emission line ratios.

[ascl:1809.008] PyQSOFit: Python code to fit the spectrum of quasars

The Python QSO fitting code (PyQSOFit) measures spectral properties of quasars. Based on Shen's IDL version, this code decomposes different components in the quasar spectrum, e.g., host galaxy, power-law continuum, Fe II component, and emission lines. In addition, it can run Monto Carlo iterations using flux randomization to estimate the uncertainties.

[ascl:1706.011] PyPulse: PSRFITS handler

PyPulse handles PSRFITS files and performs subsequent analyses on pulse profiles.

[ascl:1612.005] PyProfit: Wrapper for libprofit

pyprofit is a python wrapper for libprofit (ascl:1612.003).

[ascl:1609.022] PyPHER: Python-based PSF Homogenization kERnels

PyPHER (Python-based PSF Homogenization kERnels) computes an homogenization kernel between two PSFs; the code is well-suited for PSF matching applications in both an astronomical or microscopy context. It can warp (rotation + resampling) the PSF images (if necessary), filter images in Fourier space using a regularized Wiener filter, and produce a homogenization kernel. PyPHER requires the pixel scale information to be present in the FITS files, which can if necessary be added by using the provided ADDPIXSCL method.

[ascl:1802.012] PyOSE: Orbital sampling effect (OSE) simulator

PyOSE is a fully numerical orbital sampling effect (OSE) simulator that can model arbitrary inclinations of the transiting moon orbit. It can be used to search for exomoons in long-term stellar light curves such as those by Kepler and the upcoming PLATO mission.

[ascl:1612.008] PyORBIT: Exoplanet orbital parameters and stellar activity

PyORBIT handles several kinds of datasets, such as radial velocity (RV), activity indexes, and photometry, to simultaneously characterize the orbital parameters of exoplanets and the noise induced by the activity of the host star. RV computation is performed using either non-interacting Kepler orbits or n-body integration. Stellar activity can be modeled either with sinusoids at the rotational period and its harmonics or Gaussian process. In addition, the code can model offsets and systematics in measurements from several instruments. The PyORBIT code is modular; new methods for stellar activity modeling or parameter estimation can easily be incorporated into the code.

[ascl:1501.001] PynPoint: Exoplanet image data analysis

PynPoint uses principal component analysis to detect and estimate the flux of exoplanets in two-dimensional imaging data. It processes many, typically several thousands, of frames to remove the light from the star so as to reveal the companion planet.

The code has been significantly rewritten and expanded; please see ascl:1812.010.

[ascl:1812.010] PynPoint 0.6.0: Pipeline for processing and analysis of high-contrast imaging data

PynPoint processes and analyzes high-contrast imaging data of exoplanets and circumstellar disks. The generic, end-to-end pipeline's modular architecture separates the core functionalities and the pipeline modules. These modules have specific tasks such as background subtraction, frame selection, centering, PSF subtraction with principal component analysis, estimation of detection limits, and photometric and astrometric analysis. All modules store their results in a central database. Management of the available hardware by the backend of the pipeline is in particular an advantage for data sets containing thousands of images, as is common in the mid-infrared wavelength regime. This version of PynPoint is a significant rewrite of the earlier PynPoint package (ascl:1501.001).

[ascl:1304.021] PyNeb: Analysis of emission lines

PyNeb (previously PyNebular) is an update and expansion of the IRAF package NEBULAR; rewritten in Python, it is designed to be more user-friendly and powerful, increasing the speed, easiness of use, and graphic visualization of emission lines analysis. In PyNeb, the atom is represented as an n-level atom. For given density and temperature, PyNeb solves the equilibrium equations and determines the level populations. PyNeb can compute physical conditions from suitable diagnostic line ratios and level populations, critical densities and line emissivities, and can compute and display emissivity grids as a function of Te and Ne. It can also deredden line intensities, read and manage observational data, and plot and compare atomic data from different publications, and compute ionic abundances from line intensities and physical conditions and elemental abundances from ionic abundances and icfs.

[ascl:1305.002] pynbody: N-Body/SPH analysis for python

Pynbody is a lightweight, portable, format-transparent analysis package for astrophysical N-body and smooth particle hydrodynamic simulations supporting PKDGRAV/Gasoline, Gadget, N-Chilada, and RAMSES AMR outputs. Written in python, the core tools are accompanied by a library of publication-level analysis routines.

[ascl:1703.009] PyMVPA: MultiVariate Pattern Analysis in Python

PyMVPA eases statistical learning analyses of large datasets. It offers an extensible framework with a high-level interface to a broad range of algorithms for classification, regression, feature selection, data import and export. It is designed to integrate well with related software packages, such as scikit-learn, shogun, and MDP.

[ascl:1806.028] PyMUSE: VLT/MUSE data analyzer

PyMUSE analyzes VLT/MUSE datacubes. The package is optimized to extract 1-D spectra of arbitrary spatial regions within the cube and also for producing images using photometric filters and customized masks. It is intended to provide the user the tools required for a complete analysis of a MUSE data set.

[ascl:1606.005] PyMultiNest: Python interface for MultiNest

PyMultiNest provides programmatic access to MultiNest (ascl:1109.006) and PyCuba, integration existing Python code (numpy, scipy), and enables writing Prior & LogLikelihood functions in Python. PyMultiNest can plot and visualize MultiNest's progress and allows easy plotting, visualization and summarization of MultiNest results. The plotting can be run on existing MultiNest output, and when not using PyMultiNest for running MultiNest.

[ascl:1310.002] PyMSES: Python modules for RAMSES

PyMSES provides a python solution for getting data out of RAMSES (ascl:1011.007) astrophysical fluid dynamics simulations. It permits transparent manipulation of large simulations and interfaces with common Python libraries and existing code, and can serve as a post-processing toolbox for data analysis. It also does three-dimensional volume rendering with a specific algorithm optimized to work on RAMSES distributed data (Guillet et al. 2011 and Jones et a. 2011).

[ascl:1109.010] PyModelFit: Model-fitting Framework and GUI Tool

PyModelFit provides a pythonic, object-oriented framework that simplifies the task of designing numerical models to fit data. This is a very broad task, and hence the current functionality of PyModelFit focuses on the simpler tasks of 1D curve-fitting, including a GUI interface to simplify interactive work (using Enthought Traits). For more complicated modeling, PyModelFit also provides a wide range of classes and a framework to support more general model/data types (2D to Scalar, 3D to Scalar, 3D to 3D, and so on).

[ascl:1707.005] PyMOC: Multi-Order Coverage map module for Python

PyMOC manipulates Multi-Order Coverage (MOC) maps. It supports reading and writing the three encodings mentioned in the IVOA MOC recommendation: FITS, JSON and ASCII.

[ascl:1808.008] PyMieDap: Python Mie Doubling Adding Program

PyMieDAP (Python Mie Doubling Adding Program) makes light scattering computations with Mie scattering and radiative transfer computations with full orders of scattering and taking into account the polarization of the light scattered. Full planet modeling at any phase angle is possible. With the included subpackage exopy, it is also possible to simulate systems with a star, a planet and a possible moon.

[ascl:1401.003] PyMidas: Interface from Python to Midas

PyMidas is an interface between Python and MIDAS, the major ESO legacy general purpose data processing system. PyMidas allows a user to exploit both the rich legacy of MIDAS software and the power of Python scripting in a unified interactive environment. PyMidas also allows the usage of other Python-based astronomical analysis systems such as PyRAF.

[ascl:1411.011] PyMGC3: Finding stellar streams in the Galactic Halo using a family of Great Circle Cell counts methods

PyMGC3 is a Python toolkit to apply the Modified Great Circle Cell Counts (mGC3) method to search for tidal streams in the Galactic Halo. The code computes pole count maps using the full mGC3/nGC3/GC3 family of methods. The original GC3 method (Johnston et al., 1996) uses positional information to search for 'great-circle-cell structures'; mGC3 makes use of full 6D data and nGC3 uses positional and proper motion data.

[ascl:1902.003] PyMF: Matched filtering techniques for astronomical images

PyMF performs spatial filtering (matched filter, matched multifilter, constrained matched filter and constrained matched mutifilter) image processing that provides optimal reduction of the contamination introduced by sources that can be approximated by templates. These techniques use the flat-sky approximation.

[ascl:1505.025] pyMCZ: Oxygen abundances calculations and uncertainties from strong-line flux measurements

pyMCZ calculates metallicity according to a number of strong line metallicity diagnostics from spectroscopy line measurements and obtain uncertainties from the line flux errors in a Monte Carlo framework. Given line flux measurements and their uncertainties, pyMCZ produces synthetic distributions for the oxygen abundance in up to 13 metallicity scales simultaneously, as well as for E(B-V), and estimates their median values and their 68% confidence regions. The code can output the full MC distributions and their kernel density estimates.

[ascl:1610.016] PyMC3: Python probabilistic programming framework

PyMC3 performs Bayesian statistical modeling and model fitting focused on advanced Markov chain Monte Carlo and variational fitting algorithms. It offers powerful sampling algorithms, such as the No U-Turn Sampler, allowing complex models with thousands of parameters with little specialized knowledge of fitting algorithms, intuitive model specification syntax, and optimization for finding the maximum a posteriori (MAP) point. PyMC3 uses Theano to compute gradients via automatic differentiation as well as compile probabilistic programs on-the-fly to C for increased speed.

[ascl:1506.005] PyMC: Bayesian Stochastic Modelling in Python

PyMC is a python module that implements Bayesian statistical models and fitting algorithms, including Markov chain Monte Carlo. Its flexibility and extensibility make it applicable to a large suite of problems. Along with core sampling functionality, PyMC includes methods for summarizing output, plotting, goodness-of-fit and convergence diagnostics.

[submitted] pyLIMA: An Open Source Package for Microlensing Modeling

pyLIMA is an open source software for microlensing modeling. Based on Python, the goal is to offer to users an efficient and user friendly package to analyze their data. The code is written and tested with professional standards, such as PEP8 or unit testing.

[ascl:1612.018] pylightcurve: Exoplanet lightcurve model

pylightcurve is a model for light-curves of transiting planets. It uses the four coefficients law for the stellar limb darkening and returns the relative flux, F(t), as a function of the limb darkening coefficients, an, the Rp/R* ratio and all the orbital parameters based on the nonlinear limb darkening model (Claret 2000).

[ascl:1811.008] Pylians: Python libraries for the analysis of numerical simulations

Pylians facilitates the analysis of numerical simulations (both N-body and hydro). This set of libraries, written in python, cython and C, compute power spectra, bispectra, and correlation functions, identifies voids, and populates halos with galaxies using an HOD. Pylians can also apply HI+H2 corrections to the output of hydrodynamic simulations, makes 21cm maps, computes DLAs column density distribution functions, and plots density fields.

[ascl:1510.003] PyLDTk: Python toolkit for calculating stellar limb darkening profiles and model-specific coefficients for arbitrary filters

PyLDTk automates the calculation of custom stellar limb darkening (LD) profiles and model-specific limb darkening coefficients (LDC) using the library of PHOENIX-generated specific intensity spectra by Husser et al. (2013). It facilitates exoplanet transit light curve modeling, especially transmission spectroscopy where the modeling is carried out for custom narrow passbands. PyLDTk construct model-specific priors on the limb darkening coefficients prior to the transit light curve modeling. It can also be directly integrated into the log posterior computation of any pre-existing transit modeling code with minimal modifications to constrain the LD model parameter space directly by the LD profile, allowing for the marginalization over the whole parameter space that can explain the profile without the need to approximate this constraint by a prior distribution. This is useful when using a high-order limb darkening model where the coefficients are often correlated, and the priors estimated from the tabulated values usually fail to include these correlations.

[ascl:1708.016] pyLCSIM: X-ray lightcurves simulator

pyLCSIM simulates X-ray lightcurves from coherent signals and power spectrum models. Coherent signals can be specified as a sum of one or more sinusoids, each with its frequency, pulsed fraction and phase shift; or as a series of harmonics of a fundamental frequency (each with its pulsed fraction and phase shift). Power spectra can be simulated from a model of the power spectrum density (PSD) using as a template one or more of the built-in library functions. The user can also define his/her custom models. Models are additive.

[ascl:1506.001] pyKLIP: PSF Subtraction for Exoplanets and Disks

pyKLIP subtracts out the stellar PSF to search for directly-imaged exoplanets and disks using a Python implementation of the Karhunen-Loève Image Projection (KLIP) algorithm. pyKLIP supports ADI, SDI, and ADI+SDI to model the stellar PSF and offers a large array of PSF subtraction parameters to optimize the reduction. pyKLIP relies on a minimal amount of dependencies (numpy, scipy, and astropy) and parallelizes the KLIP algorithm to speed up the reduction. pyKLIP supports GPI and P1640 data and can interface with other data sources with the addition of new modules. It also can inject simulated planets and disks as well as automatically search for point sources in PSF-subtracted data.

[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:1511.005] pyhrs: Spectroscopic data reduction package for SALT

The pyhrs package reduces data from the High Resolution Spectrograph (HRS) on the Southern African Large Telescope (SALT). HRS is a dual-beam, fiber fed echelle spectrectrograph with four modes of operation: low (R~16000), medium (R~34000), high (R~65000), and high stability (R~65000). pyhrs, written in Python, includes all of the steps necessary to reduce HRS low, medium, and high resolution data; this includes basic CCD reductions, order identification, wavelength calibration, and extraction of the spectra.

[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:1611.013] pyGMMis: Mixtures-of-Gaussians density estimation method

pyGMMis is a mixtures-of-Gaussians density estimation method that accounts for arbitrary incompleteness in the process that creates the samples as long as the incompleteness is known over the entire feature space and does not depend on the sample density (missing at random). pyGMMis uses the Expectation-Maximization procedure and generates its best guess of the unobserved samples on the fly. It can also incorporate an uniform "background" distribution as well as independent multivariate normal measurement errors for each of the observed samples, and then recovers an estimate of the error-free distribution from which both observed and unobserved samples are drawn. The code automatically segments the data into localized neighborhoods, and is capable of performing density estimation with millions of samples and thousands of model components on machines with sufficient memory.

[ascl:1402.021] PyGFit: Python Galaxy Fitter

PyGFit measures PSF-matched photometry from images with disparate pixel scales and PSF sizes; its primary purpose is to extract robust spectral energy distributions (SEDs) from crowded images. It fits blended sources in crowded, low resolution images with models generated from a higher resolution image, thus minimizing the impact of crowding and also yielding consistently measured fluxes in different filters which minimizes systematic uncertainty in the final SEDs.

[ascl:1411.001] pyGadgetReader: GADGET snapshot reader for python

pyGadgetReader is a universal GADGET snapshot reader for python that supports type-1, type-2, HDF5, and TIPSY (ascl:1111.015) binary formats. It additionally supports reading binary outputs from FoF_Special, P-StarGroupFinder, Rockstar (ascl:1210.008), and Rockstar-Galaxies.

[ascl:1811.014] pygad: Analyzing Gadget Simulations with Python

pygad provides a framework for dealing with Gadget snapshots. The code reads any of the many different Gadget (ascl:0003.001) formats, allows easy masking snapshots to particles of interest, decorates the data blocks with units, allows to add automatically updating derived blocks, and provides several binning and plotting routines, among other tasks, to provide convenient, intuitive handling of the Gadget data without the need to worry about technical details. pygad provides access to single stellar population (SSP) models, has an interface to Rockstar (ascl:1210.008) output files, provides its own friends-of-friends (FoF) finder, calculates spherical overdensities, and has a sub-module to generate mock absorption lines.

[ascl:1103.012] Pyflation: Second Order Perturbations During Inflation Beyond Slow-roll

Pyflation calculates cosmological perturbations during an inflationary expansion of the universe. The modules in the pyflation Python package can be used to run simulations of different scalar field models of the early universe. The main classes are contained in the cosmomodels module and include simulations of background fields and first order and second order perturbations. The sourceterm package contains modules required for the computation of the term required for the evolution of second order perturbations.

Alongside the Python package, the bin directory contains Python scripts which can run first and second order simulations. A helper script called pyflation-qsubstart.py sets up a full second order run (including background, first order and source calculations) to be used on queueing system which contains the qsub executable (e.g. a Rocks cluster).

[ascl:1207.009] PyFITS: Python FITS Module

PyFITS provides an interface to FITS formatted files in the Python scripting language and PyRAF, the Python-based interface to IRAF. It is useful both for interactive data analysis and for writing analysis scripts in Python using FITS files as either input or output. PyFITS is a development project of the Science Software Branch at the Space Telescope Science Institute.

PyFITS has been deprecated. Please see Astropy.

[ascl:1403.002] pyExtinction: Atmospheric extinction

The Python script/package pyExtinction computes and plots total atmospheric extinction from decomposition into physical components (Rayleigh attenuation, ozone absorption, aerosol extinction). Its default extinction parameters are adapted to mean Mauna Kea summit conditions.

[ascl:1609.025] PYESSENCE: Generalized Coupled Quintessence Linear Perturbation Python Code

PYESSENCE evolves linearly perturbed coupled quintessence models with multiple (cold dark matter) CDM fluid species and multiple DE (dark energy) scalar fields, and can be used to generate quantities such as the growth factor of large scale structure for any coupled quintessence model with an arbitrary number of fields and fluids and arbitrary couplings.

[ascl:1112.014] PyEphem: Astronomical Ephemeris for Python

PyEphem provides scientific-grade astronomical computations for the Python programming language. Given a date and location on the Earth’s surface, it can compute the positions of the Sun and Moon, of the planets and their moons, and of any asteroids, comets, or earth satellites whose orbital elements the user can provide. Additional functions are provided to compute the angular separation between two objects in the sky, to determine the constellation in which an object lies, and to find the times at which an object rises, transits, and sets on a particular day.

The numerical routines that lie behind PyEphem are those from the wonderful XEphem astronomy application, whose author, Elwood Downey, generously gave permission for us to use them as the basis for PyEphem.

[ascl:1401.005] PyDrizzle: Python version of Drizzle

PyDrizzle provides a semi-automated interface for computing the parameters necessary for running Drizzle. PyDrizzle performs the task of determining the parameters necessary for aligning images based on the WCS information in the input image headers, as well as any supplemental alignment information provided in shift files, and combines the images onto the same WCS. Though it does not identify cosmic rays, it has the ability to ignore pixels flagged as bad, such as pixels identified by other programs as affected by cosmic rays.

[submitted] pydftools: Distribution function fitting in Python

pydftools is a pure-python port of the dftools R package (ascl:1805.002), which finds the most likely P parameters of a D-dimensional distribution function (DF) generating N objects, where each object is specified by D observables with measurement uncertainties. For instance, if the objects are galaxies, it can fit a MF (P=1), a mass-size distribution (P=2) or the mass-spin-morphology distribution (P=3). Unlike most common fitting approaches, this method accurately accounts for measurement in uncertainties and complex selection functions. Though this package imitates the dftools package quite closely while being as Pythonic as possible, it has not implemented 2D+ nor non-parametric.

[ascl:1509.010] PyCS : Python Curve Shifting

PyCS is a software toolbox to estimate time delays between multiple images of strongly lensed quasars, from resolved light curves such as obtained by the COSMOGRAIL monitoring program. The pycs package defines a collection of classes and high level functions, that you can script in a flexible way. PyCS makes it easy to compare different point estimators (including your own) without much code integration. The package heavily depends on numpy, scipy, and matplotlib.

[ascl:1810.008] pycraf: Spectrum-management compatibility

The pycraf Python package provides functions and procedures for spectrum-management compatibility studies, such as calculating the interference levels at a radio telescope produced from a radio broadcasting tower. It includes an implementation of ITU-R Recommendation P.452-16 for calculating path attenuation for the distance between an interferer and the victim service. It supports NASA's Shuttle Radar Topography Mission (SRTM) data for height-profile generation, includes a full implementation of ITU-R Rec. P.676-10, which provides two atmospheric models to calculate the attenuation for paths through Earth's atmosphere, and provides various antenna patterns necessary for compatibility studies (e.g., RAS, IMT, fixed-service links). The package can also convert power flux densities, field strengths, transmitted and received powers at certain distances and frequencies into each other.

[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:1311.002] PyCOOL: Cosmological Object-Oriented Lattice code

PyCOOL is a Python + CUDA program that solves the evolution of interacting scalar fields in an expanding universe. PyCOOL uses modern GPUs to solve this evolution and to make the computation much faster. The code includes numerous post-processing functions that provide useful information about the cosmological model, including various spectra and statistics of the fields.

[ascl:1509.007] pycola: N-body COLA method code

pycola is a multithreaded Python/Cython N-body code, implementing the Comoving Lagrangian Acceleration (COLA) method in the temporal and spatial domains, which trades accuracy at small-scales to gain computational speed without sacrificing accuracy at large scales. This is especially useful for cheaply generating large ensembles of accurate mock halo catalogs required to study galaxy clustering and weak lensing. The COLA method achieves its speed by calculating the large-scale dynamics exactly using LPT while letting the N-body code solve for the small scales, without requiring it to capture exactly the internal dynamics of halos.

[ascl:1304.020] pyCloudy: Tools to manage astronomical Cloudy photoionization code

PyCloudy is a Python library that handles input and output files of the Cloudy photoionization code (Gary Ferland). It can also generate 3D nebula from various runs of the 1D Cloudy code. pyCloudy allows you to:

  • define and write input file(s) for Cloudy code. As you can have it in a code, you may generate automatically sets of input files, changing parameters from one to the other.
  • read the Cloudy output files and play with the data: you will be able to plot line emissivity ratio vs. the radius of the nebula, the electron temperature, or any Cloudy output.
  • build pseudo-3D models, a la Cloudy_3D, by running a set of models, changing parameters (e.g. inner radius, density) following angular laws, reading the outputs of the set of models and interpolating the results (Te, ne, line emissivities) in a 3D cube.

[ascl:1805.032] PyCCF: Python Cross Correlation Function for reverberation mapping studies

PyCCF emulates a Fortran program written by B. Peterson for use with reverberation mapping. The code cross correlates two light curves that are unevenly sampled using linear interpolation and measures the peak and centroid of the cross-correlation function. In addition, it is possible to run Monto Carlo iterations using flux randomization and random subset selection (RSS) to produce cross-correlation centroid distributions to estimate the uncertainties in the cross correlation results.

[ascl:1805.030] PyCBC: Gravitational-wave data analysis toolkit

PyCBC analyzes data from gravitational-wave laser interferometer detectors, finds signals, and studies their parameters. It contains algorithms that can detect coalescing compact binaries and measure the astrophysical parameters of detected sources. PyCBC was used in the first direct detection of gravitational waves by LIGO and is used in the ongoing analysis of LIGO and Virgo data.

[ascl:1204.002] pyBLoCXS: Bayesian Low-Count X-ray Spectral analysis

pyBLoCXS is a sophisticated Markov chain Monte Carlo (MCMC) based algorithm designed to carry out Bayesian Low-Count X-ray Spectral (BLoCXS) analysis in the Sherpa environment. The code is a Python extension to Sherpa that explores parameter space at a suspected minimum using a predefined Sherpa model to high-energy X-ray spectral data. pyBLoCXS includes a flexible definition of priors and allows for variations in the calibration information. It can be used to compute posterior predictive p-values for the likelihood ratio test. The pyBLoCXS code has been tested with a number of simple single-component spectral models; it should be used with great care in more complex settings.

[ascl:1502.007] PyBDSF: Python Blob Detection and Source Finder

PyBDSF (Python Blob Detector and Source Finder, formerly PyBDSM) decomposes radio interferometry images into sources and makes their properties available for further use. PyBDSF can decompose an image into a set of Gaussians, shapelets, or wavelets as well as calculate spectral indices and polarization properties of sources and measure the psf variation across an image. PyBDSF uses an interactive environment based on CASA (ascl:1107.013); PyBDSF may also be used in Python scripts.

[ascl:1807.003] PyAutoLens: Strong lens modeling

PyAutoLens models and analyzes galaxy-scale strong gravitational lenses. This automated module suite simultaneously models the lens galaxy's light and mass while reconstructing the extended source galaxy on an adaptive pixel-grid. Source-plane discretization is amorphous, adapting its clustering and regularization to the intrinsic properties of the lensed source. The lens's light is fitted using a superposition of Sersic functions, allowing PyAutoLens to cleanly deblend its light from the source. Bayesian model comparison is used to automatically chose the complexity of the light and mass models. PyAutoLens provides accurate light, mass, and source profiles inferred for data sets representative of both existing Hubble imaging and future Euclid wide-field observations.

[ascl:1707.003] pyaneti: Multi-planet radial velocity and transit fitting

Pyaneti is a multi-planet radial velocity and transit fit software. The code uses Markov chain Monte Carlo (MCMC) methods with a Bayesian approach and a parallelized ensemble sampler algorithm in Fortran which makes the code fast. It creates posteriors, correlations, and ready-to-publish plots automatically, and handles circular and eccentric orbits. It is capable of multi-planet fitting and handles stellar limb darkening, systemic velocities for multiple instruments, and short and long cadence data, and offers additional capabilities.

[ascl:1806.007] PyAMOR: AMmOnia data Reduction

PyAMOR models spectra of low level ammonia transitions (between (J,K)=(1,1) and (5,5)) and derives parameters such as intrinsic linewidth, optical depth, and rotation temperature. For low S/N or low spectral resolution data, the code uses cross-correlation between a model and a regridded spectrum (e.g. 10 times smaller channel width) to find the velocity, then fixes it and runs the minimization process. For high S/N data, PyAMOR runs with the velocity as a free parameter.

[ascl:1905.002] Py4CAtS: PYthon for Computational ATmospheric Spectroscopy

Py4CAtS (PYthon scripts for Computational ATmospheric Spectroscopy) implements the individual steps of an infrared or microwave radiative transfer computation in separate scripts (and corresponding functions) to extract lines of relevant molecules in the spectral range of interest, compute line-by-line cross sections for given pressure(s) and temperature(s), combine cross sections to absorption coefficients and optical depths, and integrate along the line-of-sight to transmission and radiance/intensity. The code is a Python re-implementation of the Fortran code GARLIC (Generic Atmospheric Radiation Line-by-line Code) and uses the Numeric/Scientific Python modules for computationally-intensive highly optimized array-processing. Py4CAtS can be used in the console/terminal, inside the (I)Python interpreter, and in Jupyter notebooks.

[ascl:1712.003] Py-SPHViewer: Cosmological simulations using Smoothed Particle Hydrodynamics

Py-SPHViewer visualizes and explores N-body + Hydrodynamics simulations. The code interpolates the underlying density field (or any other property) traced by a set of particles, using the Smoothed Particle Hydrodynamics (SPH) interpolation scheme, thus producing not only beautiful but also useful scientific images. Py-SPHViewer enables the user to explore simulated volumes using different projections. Py-SPHViewer also provides a natural way to visualize (in a self-consistent fashion) gas dynamical simulations, which use the same technique to compute the interactions between particles.

[ascl:1808.009] py-sdm: Support Distribution Machines

py-sdm (Support Distribution Machines) is a Python implementation of nonparametric nearest-neighbor-based estimators for divergences between distributions for machine learning on sets of data rather than individual data points. It treats points of sets of data as samples from some unknown probability distribution and then statistically estimates the distance between those distributions, such as the KL divergence, the closely related Rényi divergence, L2 distance, or other similar distances.

[ascl:1806.032] pwv_kpno: Modeling atmospheric absorption

pwv_kpno provides models for the atmospheric transmission due to precipitable water vapor (PWV) at user specified sites. Atmospheric transmission in the optical and near-infrared is highly dependent on the PWV column density along the line of sight. The pwv_kpno package uses published SuomiNet data in conjunction with MODTRAN models to determine the modeled, time-dependent atmospheric transmission between 3,000 and 12,000 Å. By default, models are provided for Kitt Peak National Observatory (KPNO). Additional locations can be added by the user for any of the hundreds of SuomiNet locations worldwide.

[ascl:1704.001] pwkit: Astronomical utilities in Python

pwkit is a collection of miscellaneous astronomical utilities in Python, with an emphasis on radio astronomy, reading and writing various data formats, and convenient command-line utilities. Utilities include basic astronomical calculations, data visualization tools such as mapping arbitrary data to color scales and tracing contours, and data input and output utilities such as streaming output from other programs.

[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:1608.010] pvextractor: Position-Velocity Diagram Extractor

Given a path defined in sky coordinates and a spectral cube, pvextractor extracts a slice of the cube along that path and along the spectral axis to produce a position-velocity or position-frequency slice. The path can be defined programmatically in pixel or world coordinates, and can also be drawn interactively using a simple GUI. Pvextractor is the main function, but also includes a few utilities related to header trimming and parsing.

[ascl:1307.019] PURIFY: Tools for radio-interferometric imaging

PURIFY is a collection of routines written in C that implements different tools for radio-interferometric imaging including file handling (for both visibilities and fits files), implementation of the measurement operator and set-up of the different optimization problems used for image deconvolution. The code calls the generic Sparse OPTimization (SOPT) package to solve the imaging optimization problems.

[ascl:1110.014] pureS2HAT: S 2HAT-based Pure E/B Harmonic Transforms

The pS2HAT routines allow efficient, parallel calculation of the so-called 'pure' polarized multipoles. The computed multipole coefficients are equal to the standard pseudo-multipoles calculated for the apodized sky maps of the Stokes parameters Q and U subsequently corrected by so-called counterterms. If the applied apodizations fullfill certain boundary conditions, these multipoles correspond to the pure multipoles. Pure multipoles of one type, i.e., either E or B, are ensured not to contain contributions from the other one, at least to within numerical artifacts. They can be therefore further used in the estimation of the sky power spectra via the pseudo power spectrum technique, which has to however correctly account for the applied apodization on the one hand, and the presence of the counterterms, on the other.

In addition, the package contains the routines permitting calculation of the spin-weighted apodizations, given an input scalar, i.e., spin-0 window. The former are needed to compute the counterterms. It also provides routines for maps and window manipulations. The routines are written in C and based on the S2HAT library, which is used to perform all required spherical harmonic transforms as well as all inter-processor communication. They are therefore parallelized using MPI and follow the distributed-memory computational model. The data distribution patterns, pixelization choices, conventions etc are all as those assumed/allowed by the S2HAT library.

[ascl:1807.022] PUMA: Low-frequency radio catalog cross-matching

PUMA (Positional Update and Matching Algorithm) cross-matches low-frequency radio catalogs using a Bayesian positional probability with spectral matching criteria. The code reliably finds the correct spectral indices of sources and recovers ionospheric offsets. PUMA can be used to facilitate all-sky cross-matches with further constraints applied for other science goals.

[ascl:1606.013] Pulse Portraiture: Pulsar timing

Pulse Portraiture is a wideband pulsar timing code written in python. It uses an extension of the FFTFIT algorithm (Taylor 1992) to simultaneously measure a phase (TOA) and dispersion measure (DM). The code includes a Gaussian-component-based portrait modeling routine. The code uses the python interface to the pulsar data analysis package PSRCHIVE (ascl:1105.014) and also requires the non-linear least-squares minimization package lmfit (ascl:1606.014).

[ascl:1811.020] PulsarHunter: Searching for and confirming pulsars

Pulsarhunter searches for and confirms pulsars; it provides a set of time domain optimization tools for processing timeseries data produced by SIGPROC (ascl:1107.016). The software can natively write candidate lists for JReaper (included in the package), removing the need to manually import candidates into JReaper; JReaper also reads the PulsarHunter candidate file format.

[ascl:1812.017] psrqpy: Python module to query the ATNF Pulsar Catalogue

psrqpy directly queries the Australia Telescope National Facility (ATNF) Pulsar Catalogue by downloading and parsing the full catalog database, which is cached and can be reused. The module assists astronomers who want access to the latest pulsar information via a script rather than through the standard web interface.

[ascl:1501.006] PsrPopPy: Pulsar Population Modelling Programs in Python

PsrPopPy is a Python implementation of the Galactic population and evolution of radio pulsars modelling code PSRPOP.

[ascl:1107.019] PSRPOP: Pulsar Population Modelling Programs

PSRPOP is a package developed to model the Galactic population and evolution of radio pulsars. It is a collection of modules written in Fortran77 for an analysis of a large sample of pulsars detected by the Parkes Multibeam Pulsar Survey. The main programs are: 1.) populate, which creates a model Galaxy of pulsars distributed according according to various assumptions; 2.) survey, which searches the model galaxies generated using populate using realistic models of pulsar surveys; and 3.) visualize, a Tk/PGPLOT script to plot various aspects of model detected pulsars from survey. A sample screenshot from visualize can be found here.

[ascl:1105.014] PSRCHIVE: Development Library for the Analysis of Pulsar Astronomical Data

PSRCHIVE is an Open Source C++ development library for the analysis of pulsar astronomical data. It implements an extensive range of algorithms for use in pulsar timing, polarimetric calibration, single-pulse analyses, RFI mitigation, scintillation studies, etc. These tools are utilized by a powerful suite of user-end programs that come with the library.

[ascl:1710.020] PSPLINE: Princeton Spline and Hermite cubic interpolation routines

PSPLINE is a collection of Spline and Hermite interpolation tools for 1D, 2D, and 3D datasets on rectilinear grids. Spline routines give full control over boundary conditions, including periodic, 1st or 2nd derivative match, or divided difference-based boundary conditions on either end of each grid dimension. Hermite routines take the function value and derivatives at each grid point as input, giving back a representation of the function between grid points. Routines are provided for creating Hermite datasets, with appropriate boundary conditions applied. The 1D spline and Hermite routines are based on standard methods; the 2D and 3D spline or Hermite interpolation functions are constructed from 1D spline or Hermite interpolation functions in a straightforward manner. Spline and Hermite interpolation functions are often much faster to evaluate than other representations using e.g. Fourier series or otherwise involving transcendental functions.

[ascl:1010.011] PSpectRe: A Pseudo-Spectral Code for (P)reheating

PSpectRe, written in C++, uses Fourier-space pseudo-spectral methods to evolve interacting scalar fields in an expanding universe. The code is optimized for the analysis of parametric resonance in the post-inflationary universe and provides an alternative to finite differencing codes. PSpectRe has both second- (Velocity-Verlet) and fourth-order (Runge-Kutta) time integrators. In some circumstances PSpectRe obtains reliable results while using substantially fewer points than a finite differencing code by computing the post-resonance equation of state. PSpectRe is designed to be easily extended to other problems in early-universe cosmology, including the generation of gravitational waves during phase transitions and pre-inflationary bubble collisions.

[ascl:1705.013] PSOAP: Precision Spectroscopic Orbits A-Parametrically

PSOAP (Precision Spectroscopic Orbits A-Parametrically) uses Gaussian processes to infer component spectra of single-lined and double-lined spectroscopic binaries, while simultaneously exploring the posteriors of the orbital parameters and the spectra themselves. PSOAP accounts for the natural λ-covariances in each spectrum, thus providing a natural "de-noising" of the spectra typically offered by Fourier techniques.

[ascl:1208.005] PSM: Planck Sky Model

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:1301.001] PSFEx: Point Spread Function Extractor

PSFEx (“PSF Extractor”) extracts models of the Point Spread Function (PSF) from FITS images processed with SExtractor and measures the quality of images. The generated PSF models can be used for model-fitting photometry or morphological analyses.

[ascl:1306.005] PROS: Multi-mission X-ray analysis software system

PROS is a multi-mission x-ray analysis software system designed to run under IRAF. The PROS software includes spatial, spectral, timing, data I/O and conversion routines, plotting applications, and general algorithms for performing arithmetic operations with imaging data.

[ascl:1904.025] Properimage: Image coaddition and subtraction

Properimage processes astronomical image; it is specially written for coaddition and image subtraction. It performs the statistical proper-coadd of several images using a spatially variant PSF estimation, and also difference image analysis by several strategies developed by others. Most of the code is based on a class called SingleImage, which provides methods and properties for image processing such as PSF determination.

[ascl:1405.006] PROPER: Optical propagation routines

PROPER simulates the propagation of light through an optical system using Fourier transform algorithms (Fresnel, angular spectrum methods). Available in IDL, Python, and Matlab, it includes routines to create complex apertures, aberrated wavefronts, and deformable mirrors. It is especially useful for the simulation of high contrast imaging telescopes (extrasolar planet imagers like TPF).

[ascl:1511.023] PromptNuFlux: Prompt atmospheric neutrino flux calculator

PromptNuFlux computes the prompt atmospheric neutrino flux E3Φ(GeV2/(cm2ssr)), including the total associated theory uncertainty, for a range of energies between E=103 GeV and E=107.5 GeV. Results are available for five different parametrizations of the input cosmic ray flux: BPL, H3P, H3A, H14a, H14b.

[ascl:1805.023] PROM7: 1D modeler of solar filaments or prominences

PROM7 is an update of PROM4 (ascl:1306.004) and computes simple models of solar prominences and filaments using Partial Radiative Distribution (PRD). The models consist of plane-parallel slabs standing vertically above the solar surface. Each model is defined by 5 parameters: temperature, density, geometrical thickness, microturbulent velocity and height above the solar surface. It solves the equations of radiative transfer, statistical equilibrium, ionization and pressure equilibria, and computes electron and hydrogen level population and hydrogen line profiles. Moreover, the code treats calcium atom which is reduced to 3 ionization states (Ca I, Ca II, CA III). Ca II ion has 5 levels which are useful for computing 2 resonance lines (H and K) and infrared triplet (to 8500 A).

[ascl:1306.004] PROM4: 1D isothermal and isobaric modeler for solar prominences

PROM4 computes simple models of solar prominences which consist of plane-parallel slabs standing vertically above the solar surface. Each model is defined by 5 parameters: temperature, density, geometrical thickness, microturbulent velocity and height above the solar surface. PROM4 solves the equations of radiative transfer, statistical equilibrium, ionization and pressure equilibria, and computes electron and hydrogen level populations and hydrogen line profiles. Written in Fortran 90 and with two versions available (one with text in English, one with text in French), the code needs 64-bit arithmetic for real numbers.

PROM7 (ascl:1805.023) is a more recent version of this code.

[ascl:1804.006] ProFound: Source Extraction and Application to Modern Survey Data

ProFound detects sources in noisy images, generates segmentation maps identifying the pixels belonging to each source, and measures statistics like flux, size, and ellipticity. These inputs are key requirements of ProFit (ascl:1612.004), our galaxy profiling package; these two packages used in unison semi-automatically profile large samples of galaxies. The key novel feature introduced in ProFound is that all photometry is executed on dilated segmentation maps that fully contain the identifiable flux, rather than using more traditional circular or ellipse-based photometry. Also, to be less sensitive to pathological segmentation issues, the de-blending is made across saddle points in flux. ProFound offers good initial parameter estimation for ProFit, and also segmentation maps that follow the sometimes complex geometry of resolved sources, whilst capturing nearly all of the flux. A number of bulge-disc decomposition projects are already making use of the ProFound and ProFit pipeline.

[ascl:1204.015] PROFIT: Emission-line PROfile FITting routine

The PROFIT is an IDL routine to do automated fitting of emission-line profiles by Gaussian curves or Gauss-Hermite series optimized for use in Integral Field and Fabry-Perot data cubes. As output PROFIT gives two-dimensional FITS files for the emission-line flux distribution, centroid velocity, velocity dispersion and higher order Gauss-Hermite moments (h3 and h4).

[ascl:1612.004] ProFit: Bayesian galaxy fitting tool

ProFit is a Bayesian galaxy fitting tool that uses the fast C++ image generation library libprofit (ascl:1612.003) and a flexible R interface to a large number of likelihood samplers. It offers a fully featured Bayesian interface to galaxy model fitting (also called profiling), using mostly the same standard inputs as other popular codes (e.g. GALFIT ascl:1104.010), but it is also able to use complex priors and a number of likelihoods.

[ascl:1705.010] PROFILER: 1D galaxy light profile decomposition

Written in Python, PROFILER analyzes the radial surface brightness profiles of galaxies. It accurately models a wide range of galaxies and galaxy components, such as elliptical galaxies, the bulges of spiral and lenticular galaxies, nuclear sources, discs, bars, rings, and spiral arms with a variety of parametric functions routinely employed in the field (Sérsic, core-Sérsic, exponential, Gaussian, Moffat and Ferrers). In addition, Profiler can employ the broken exponential model (relevant for disc truncations or antitruncations) and two special cases of the edge-on disc model: namely along the major axis (in the disc plane) and along the minor axis (perpendicular to the disc plane).

[ascl:1608.011] PROFFIT: Analysis of X-ray surface-brightness profiles

PROFFIT analyzes X-ray surface-brightness profiles for data from any X-ray instrument. It can extract surface-brightness profiles in circular or elliptical annuli, using constant or logarithmic bin size, from the image centroid, the surface-brightness peak, or any user-given center, and provides surface-brightness profiles in any circular or elliptical sectors. It offers background map support to extract background profiles, can excise areas using SAO DS9-compatible (ascl:0003.002) region files to exclude point sources, provides fitting with a number of built-in models, including the popular beta model, double beta, cusp beta, power law, and projected broken power law, uses chi-squared or C statistic, and can fit on the surface-brightness or counts data. It has a command-line interface similar to HEASOFT’s XSPEC (ascl:9910.005) package, provides interactive help with a description of all the commands, and results can be saved in FITS, ROOT or TXT format.

[ascl:1601.020] ProC: Process Coordinator

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:1903.009] PRF: Probabilistic Random Forest

PRF (Probabilistic Random Forest) is a machine learning algorithm for noisy datasets. The PRF is a modification of the long-established Random Forest (RF) algorithm, and takes into account uncertainties in the measurements (i.e., features) as well as in the assigned classes (i.e., labels). To do so, the Probabilistic Random Forest (PRF) algorithm treats the features and labels as probability distribution functions, rather than as deterministic quantities.

[ascl:1107.017] PRESTO: PulsaR Exploration and Search TOolkit

PRESTO is a large suite of pulsar search and analysis software. It was primarily designed to efficiently search for binary millisecond pulsars from long observations of globular clusters (although it has since been used in several surveys with short integrations and to process a lot of X-ray data as well). To date, PRESTO has discovered well over a hundred and fifty pulsars, including approximately 100 recycled pulsars, about 80 of which are in binaries. It is written primarily in ANSI C, with many of the recent routines in Python.

Written with portability, ease-of-use, and memory efficiency in mind, it can currently handle raw data from the following pulsar machines or formats:

  • PSRFITS search-format data (as from GUPPI at the GBT and the Mock Spectrometers at Arecibo)
  • SPIGOT at the GBT
  • Most Wideband Arecibo Pulsar Processor (WAPP) at Arecibo
  • The Parkes and Jodrell Bank 1-bit filterbank formats
  • Berkeley-Caltech Pulsar Machine (BCPM) at the GBT (may it RIP...)
  • 8-bit filterbank format from SIGPROC (other formats will be added if required)
  • A time series composed of single precision (i.e. 4-byte) floating point data
  • Photon arrival times (or events) in ASCII or double-precision binary formats

[ascl:1305.006] Pressure-Entropy SPH: Pressure-entropy smooth-particle hydrodynamics

Pressure-Entropy SPH, a modified version of GADGET-2, uses the Lagrangian “Pressure-Entropy” formulation of the SPH equations. This removes the spurious “surface tension” force substantially improving the treatment of fluid mixing and contact discontinuities. Pressure-Entropy SPH shows good performance in mixing experiments (e.g. Kelvin-Helmholtz & blob tests), with conservation maintained even in strong shock/blastwave tests, where formulations without manifest conservation produce large errors. This improves the treatment of sub-sonic turbulence and lessens the need for large kernel particle numbers.

[ascl:1112.016] PREDICT: Satellite tracking and orbital prediction

PREDICT is an open-source, multi-user satellite tracking and orbital prediction program written under the Linux operating system. PREDICT provides real-time satellite tracking and orbital prediction information to users and client applications through:

  • the system console
  • the command line
  • a network socket
  • the generation of audio speech
Data such as a spacecraft's sub-satellite point, azimuth and elevation headings, Doppler shift, path loss, slant range, orbital altitude, orbital velocity, footprint diameter, orbital phase (mean anomaly), squint angle, eclipse depth, the time and date of the next AOS (or LOS of the current pass), orbit number, and sunlight and visibility information are provided on a real-time basis. PREDICT can also track (or predict the position of) the Sun and Moon. PREDICT has the ability to control AZ/EL antenna rotators to maintain accurate orientation in the direction of communication satellites. As an aid in locating and tracking satellites through optical means, PREDICT can articulate tracking coordinates and visibility information as plain speech.

[ascl:1710.024] pred_loggs: Predicting individual galaxy G/S probability distributions

pred_loggs models the entire PGF probability density field, enabling iterative statistical modeling of upper limits and prediction of full G/S probability distributions for individual galaxies.

[ascl:1611.004] PRECESSION: Python toolbox for dynamics of spinning black-hole binaries

PRECESSION is a comprehensive toolbox for exploring the dynamics of precessing black-hole binaries in the post-Newtonian regime. It allows study of the evolution of the black-hole spins along their precession cycles, performs gravitational-wave-driven binary inspirals using both orbit-averaged and precession-averaged integrations, and predicts the properties of the merger remnant through fitting formulas obtained from numerical-relativity simulations. PRECESSION can add the black-hole spin dynamics to larger-scale numerical studies such as gravitational-wave parameter estimation codes, population synthesis models to predict gravitational-wave event rates, galaxy merger trees and cosmological simulations of structure formation, and provides fast and reliable integration methods to propagate statistical samples of black-hole binaries from/to large separations where they form to/from small separations where they become detectable, thus linking gravitational-wave observations of spinning black-hole binaries to their astrophysical formation history. The code is also useful for computing initial parameters for numerical-relativity simulations targeting specific precessing systems.

[ascl:1210.002] pPXF: Penalized Pixel-Fitting stellar kinematics extraction

pPXF is an IDL (and free GDL or FL) program which extracts the stellar kinematics or stellar population from absorption-line spectra of galaxies using the Penalized Pixel-Fitting method (pPXF) developed by Cappellari & Emsellem (2004, PASP, 116, 138). Additional features implemented in the pPXF routine include:

  • Optimal template: Fitted together with the kinematics to minimize template-mismatch errors. Also useful to extract gas kinematics or derive emission-corrected line-strengths indexes. One can use synthetic templates to study the stellar population of galaxies via "Full Spectral Fitting" instead of using traditional line-strengths.
  • Regularization of templates weights: To reduce the noise in the recovery of the stellar population parameters and attach a physical meaning to the output weights assigned to the templates in term of the star formation history (SFH) or metallicity distribution of an individual galaxy.
  • Iterative sigma clipping: To clean the spectra from residual bad pixels or cosmic rays.
  • Additive/multiplicative polynomials: To correct low frequency continuum variations. Also useful for calibration purposes.

[ascl:1507.009] PPInteractions: Secondary particle spectra from proton-proton interactions

PPInteractions generates the secondary particle energy spectra produced in proton-proton interactions over the entire chosen energy range for any value of the primary proton spectral index by adjusting the low energy part of the spectra (below 0.1TeV) to the high energy end of the spectra (above 0.1TeV). This code is based on the parametrization of Kelner et al (2006), in which the normalization of the low energy part of the spectra is given only for 3 values of the primary proton spectral indices (2, 2.5, 3).

[ascl:1401.009] PPF module for CAMB

The main CAMB code supports smooth dark energy models with constant equation of state and sound speed of one, or a quintessence model based on a potential. This modified code generalizes it to support a time-dependent equation of state w(a) that is allowed to cross the phantom divide, i.e. w=-1 multiple times by implementing a Parameterized Post-Friedmann(PPF) prescription for the dark energy perturbations.

[ascl:1110.017] POWMES: Measuring the Power Spectrum in an N-body Simulation

POWMES is a F90 program to measure very accurately the power spectrum in a N-body simulation, using Taylor expansion of some order on the cosine and sine transforms. It can read GADGET format and requires FFTW2 to be installed.

[ascl:1805.001] powerbox: Arbitrarily structured, arbitrary-dimension boxes and log-normal mocks

powerbox creates density grids (or boxes) with an arbitrary two-point distribution (i.e. power spectrum). The software works in any number of dimensions, creates Gaussian or Log-Normal fields, and measures power spectra of output fields to ensure consistency. The primary motivation for creating the code was the simple creation of log-normal mock galaxy distributions, but the methodology can be used for other applications.

[ascl:1807.021] POWER: Python Open-source Waveform ExtractoR

POWER (Python Open-source Waveform ExtractoR) monitors the status and progress of numerical relativity simulations and post-processes the data products of these simulations to compute the gravitational wave strain at future null infinity.

[ascl:1411.021] POSTMORTEM: Visibility data reduction and map making package

POSTMORTEM is the visibility data reduction and map making package from MRAO (Mullard Radio Astronomy Observatory) and is used with the Ryle and CLFST telescopes at Cambridge. It contains sub-systems for nonitoring telescope performance, displaying and editing the visibility data, performing calibrations, removing flux from interfering bright sources, and map-making. It requires PGPLOT (ascl:1103.002), SLALIB (ascl:1403.025), and NAG numerical routines, all of which are distributed with the STARLINK software collection (ascl:1110.012) or available separately.

[ascl:0202.001] PopRatio: A program to calculate atomic level populations in astrophysical plasmas

PopRatio is a Fortran 90 code to calculate atomic level populations in astrophysical plasmas. The program solves the equations of statistical equilibrium considering all possible bound-bound processes: spontaneous, collisional or radiation induced (the later either directly or by fluorescence). There is no limit on the number of levels or in the number of processes that may be taken into account. The program may find a wide range of applicability in astronomical problems, such as interpreting fine-structure absorption lines or collisionally excited emission lines and also in calculating the cooling rates due to collisional excitation.

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

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:1805.011] PoMiN: A Post-Minkowskian N-Body Solver

PoMiN is a lightweight N-body code based on the Post-Minkowskian N-body Hamiltonian of Ledvinka, Schafer, and Bicak, which includes General Relativistic effects up to first order in Newton's constant G, and all orders in the speed of light c. PoMiN is a single file written in C and uses a fourth-order Runge-Kutta integration scheme. PoMiN has also been written to handle an arbitrary number of particles (both massive and massless) with a computational complexity that scales as O(N^2).

[ascl:1502.011] PolyChord: Nested sampling for cosmology

PolyChord is a Bayesian inference tool for the simultaneous calculation of evidences and sampling of posterior distributions. It is a variation on John Skilling's Nested Sampling, utilizing Slice Sampling to generate new live points. It performs well on moderately high dimensional (~100s D) posterior distributions, and can cope with arbitrary degeneracies and multimodality.

[ascl:1109.005] PolSpice: Spatially Inhomogeneous Correlation Estimator for Temperature and Polarisation

PolSpice (aka Spice) is a tool to statistically analyze Cosmic Microwave Background (CMB) data, as well as any other diffuse data pixelized on the sphere.

This Fortran90 program measures the 2 point auto (or cross-) correlation functions w(θ) and the angular auto- (or cross-) power spectra C(l) from one or (two) sky map(s) of Stokes parameters (intensity I and linear polarisation Q and U). It is based on the fast Spherical Harmonic Transforms allowed by isolatitude pixelisations such as Healpix [for Npix pixels over the whole sky, and a C(l) computed up to l=lmax, PolSpice complexity scales like Npix1/2 lmax2 instead of Npix lmax2]. It corrects for the effects of the masks and can deal with inhomogeneous weights given to the pixels of the map. In the case of polarised data, the mixing of the E and B modes due to the cut sky and pixel weights can be corrected for to provide an unbiased estimate of the "magnetic" (B) component of the polarisation power spectrum. Most of the code is parallelized for shared memory (SMP) architecture using OpenMP.

[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:1405.014] POLPACK: Imaging polarimetry reduction package

POLPACK maps the linear or circular polarization of extended astronomical objects, either in a single waveband, or in multiple wavebands (spectropolarimetry). Data from both single and dual beam polarimeters can be processed. It is part of the Starlink software collection (ascl:1110.012).

[ascl:1406.012] POLMAP: Interactive data analysis package for linear spectropolarimetry

POLMAP provides routines for displaying and analyzing spectropolarimetry data that are not available in the complementary TSP package. Commands are provided to read and write TSP (ascl:1406.011) polarization spectrum format files from within POLMAP. This code is distributed as part of the Starlink software collection (ascl:1110.012).

[ascl:1807.001] POLARIS: POLArized RadIation Simulator

POLARIS (POLArized RadIation Simulator) simulates the intensity and polarization of light emerging from analytical astrophysical models as well as complex magneto-hydrodynamic simulations on various grids. This 3D Monte-Carlo continuum radiative transfer code is written in C++ and is capable of performing dust heating, dust grain alignment, line radiative transfer, and synchrotron simulations to calculate synthetic intensity and polarization maps. The code makes use of a full set of physical quantities (density, temperature, velocity, magnetic field distribution, and dust grain properties as well as different sources of radiation) as input.

[ascl:1505.018] POKER: P Of K EstimatoR

POKER (P Of K EstimatoR) estimates the angular power spectrum of a 2D map or the cross-power spectrum of two 2D maps in the flat sky limit approximation in a realistic data context: steep power spectrum, non periodic boundary conditions, arbitrary pixel resolution, non trivial masks and observation patch geometry.

[ascl:1408.005] POET: Planetary Orbital Evolution due to Tides

POET (Planetary Orbital Evolution due to Tides) calculates the orbital evolution of a system consisting of a single star with a single planet in orbit under the influence of tides. The following effects are The evolutions of the semimajor axis of the orbit due to the tidal dissipation in the star and the angular momentum of the stellar convective envelope by the tidal coupling are taken into account. In addition, the evolution includes the transfer of angular momentum between the stellar convective and radiative zones, effect of the stellar evolution on the tidal dissipation efficiency, and stellar core and envelope spins and loss of stellar convective zone angular momentum to a magnetically launched wind. POET can be used out of the box, and can also be extended and modified.

[ascl:1302.004] pNbody: A python parallelized N-body reduction toolbox

pNbody is a parallelized python module toolbox designed to manipulate and interactively display very large N-body systems. It allows the user to perform complicated manipulations with only very few commands and to load an N-body system and explore it interactively using the python interpreter. pNbody may also be used in python scripts. pNbody contains graphical facilities for creating maps of physical values of the system, such as density, temperature, and velocities maps. Stereo capabilities are also implemented. pNbody is not limited by file format; the user may use a parameter file to redefine how to read a preferred format.

[ascl:1102.015] PMFASTIC: Initial condition generator for PMFAST

PMFASTIC is a parallel initial condition generator, a slab decomposition Fortran 90 parallel cosmological initial condition generator for use with PMFAST. Files required for generating initial dark matter particle distributions and instructions are included, however one would require CMBFAST to create alternative transfer functions.

[ascl:1102.008] PMFAST: Towards Optimal Parallel PM N-body Codes

The parallel PM N-body code PMFAST is cost-effective and memory-efficient. PMFAST is based on a two-level mesh gravity solver where the gravitational forces are separated into long and short range components. The decomposition scheme minimizes communication costs and allows tolerance for slow networks. The code approaches optimality in several dimensions. The force computations are local and exploit highly optimized vendor FFT libraries. It features minimal memory overhead, with the particle positions and velocities being the main cost. The code features support for distributed and shared memory parallelization through the use of MPI and OpenMP, respectively.

The current release version uses two grid levels on a slab decomposition, with periodic boundary conditions for cosmological applications. Open boundary conditions could be added with little computational overhead. Timing information and results from a recent cosmological production run of the code using a 3712^3 mesh with 6.4 x 10^9 particles are available.

[ascl:9909.001] PMCode: Particle-Mesh Code for Cosmological Simulations

Particle-Mesh (PM) codes are still very useful tools for testing predictions of cosmological models in cases when extra high resolution is not very important. We release for public use a cosmological PM N-body code. The code is very fast and simple. We provide a complete package of routines needed to set initial conditions, to run the code, and to analyze the results. The package allows you to simulate models with numerous combinations of parameters: open/flat/closed background, with or without the cosmological constant, different values of the Hubble constant, with or without hot neutrinos, tilted or non-tilted initial spectra, different amount of baryons.

[ascl:1010.045] PLUTO: A Code for Flows in Multiple Spatial Dimensions

PLUTO is a modular Godunov-type code intended mainly for astrophysical applications and high Mach number flows in multiple spatial dimensions. The code embeds different hydrodynamic modules and multiple algorithms to solve the equations describing Newtonian, relativistic, MHD, or relativistic MHD fluids in Cartesian or curvilinear coordinates. PLUTO is entirely written in the C programming language and can run on either single processor machines or large parallel clusters through the MPI library. A simple user-interface based on the Python scripting language is available to setup a physical problem in a quick and self-explanatory way. Computations may be carried on either static or adaptive (structured) grids, the latter functionality being provided through the Chombo adaptive mesh refinement library.

[ascl:1206.007] Plumix: Generating mass segregated star clusters

Plumix is a small package for generating mass segregated star clusters. Its output can be directly used as input initial conditions for NBODY4 or NBODY6 code. Mass segregation stands as one of the most robust features of the dynamical evolution of self-gravitating star clusters. We formulate parametrized models of mass segregated star clusters in virial equilibrium. To this purpose we introduce mean inter-particle potentials for statistically described unsegregated systems and suggest a single-parameter generalization of its form which gives a mass-segregated state. Plumix is a numerical C-code generating the cluster according the algorithm given for construction of appropriate star cluster models. Their stability over several crossing-times is verified by following the evolution by means of direct N-body integration.

[ascl:1106.003] PLplot: Cross-platform Software Package for Scientific Plots

PLplot is a cross-platform software package for creating scientific plots. To help accomplish that task it is organized as a core C library, language bindings for that library, and device drivers which control how the plots are presented in non-interactive and interactive plotting contexts. The PLplot core library can be used to create standard x-y plots, semi-log plots, log-log plots, contour plots, 3D surface plots, mesh plots, bar charts and pie charts. Multiple graphs (of the same or different sizes) may be placed on a single page, and multiple pages are allowed for those device formats that support them. PLplot has core support for Unicode. This means for our many Unicode-aware devices that plots can be labelled using the enormous selection of Unicode mathematical symbols. A large subset of our Unicode-aware devices also support complex text layout (CTL) languages such as Arabic, Hebrew, and Indic and Indic-derived CTL scripts such as Devanagari, Thai, Lao, and Tibetan. PLplot device drivers support a number of different file formats for non-interactive plotting and a number of different platforms that are suitable for interactive plotting. It is easy to add new device drivers to PLplot by writing a small number of device dependent routines.

[ascl:1903.014] PLATON: PLanetary Atmospheric Transmission for Observer Noobs

PLATON (PLanetary Atmospheric Transmission for Observer Noobs) calculates transmission spectra for exoplanets and retrieves atmospheric characteristics based on observed spectra; it is based on ExoTransmit (ascl:1611.005). PLATON supports the most common atmospheric parameters, such as temperature, metallicity, C/O ratio, cloud-top pressure, and scattering slope. It also has less commonly included features, such as a Mie scattering cloud model and unocculted starspot corrections.

[ascl:1506.003] PLATO Simulator: Realistic simulations of expected observations

PLATO Simulator is an end-to-end simulation software tool designed for the performance of realistic simulations of the expected observations of the PLATO mission but easily adaptable to similar types of missions. It models and simulates photometric time-series of CCD images by including models of the CCD and its electronics, the telescope optics, the stellar field, the jitter movements of the spacecraft, and all important natural noise sources.

[ascl:1311.004] PlanetPack: Radial-velocity time-series analysis tool

PlanetPack facilitates and standardizes the advanced analysis of radial velocity (RV) data for the goal of exoplanets detection, characterization, and basic dynamical N-body simulations. PlanetPack is a command-line interpreter that can run either in an interactive mode or in a batch mode of automatic script interpretation.

[ascl:1607.005] Planetary3br: Three massive body resonance calculator

Given two planets P1 and P2 with arbitrary orbits, planetary3br calculates all possible semimajor axes that a third planet P0 can have in order for the system to be in a three body resonance; these are identified by the combination k0*P0 + k1*P1 + k2*P2. P1 and P2 are assumed to be not in an exact two-body resonance. The program also calculates three "strengths" of the resonance, one for each planet, which are only indicators of the dynamical relevance of the resonance on each planet. Sample input data are available along with the Fortran77 source code.

[ascl:1505.032] Planck Level-S: Planck Simulation Package

The Planck simulation package takes a cosmological model specified by the user and calculates a potential CMB sky consistent with this model, including astrophysical foregrounds, and then performs a simulated observation of this sky. This Simulation embraces many instrumental effects such as beam convolution and noise. Alternatively, the package can simulate the observation of a provided sky model, generated by another program such as the Planck Sky Model software. The Planck simulation package does not only provide Planck-like data, it can also be easily adopted to mimic the properties of other existing and upcoming CMB experiments.

[ascl:1609.016] PKDGRAV3: Parallel gravity code

Pkdgrav3 is an 𝒪(N) gravity calculation method; it uses a binary tree algorithm with fifth order fast multipole expansion of the gravitational potential, using cell-cell interactions. Periodic boundaries conditions require very little data movement and allow a high degree of parallelism; the code includes GPU acceleration for all force calculations, leading to a significant speed-up with respect to previous versions (ascl:1305.005). Pkdgrav3 also has a sophisticated time-stepping criterion based on an estimation of the local dynamical time.

[ascl:1305.005] PkdGRAV2: Parallel fast-multipole cosmological code

PkdGRAV2 is a high performance N-body treecode for self-gravitating astrophysical simulations. It is designed to run efficiently in serial and on a wide variety of parallel computers including both shared memory and message passing architectures. It can spatially adapt to large ranges in particle densities, and temporally adapt to large ranges in dynamical timescales. The code uses a non-standard data structure for efficiently calculating the gravitational forces, a variant on the k-D tree, and a novel method for treating periodic boundary conditions.

[ascl:1102.007] PixeLens: A Portable Modeler of Lensed Quasars

We introduce and implement two novel ideas for modeling lensed quasars. The first is to require different lenses to agree about H0. This means that some models for one lens can be ruled out by data on a different lens. We explain using two worked examples. One example models 1115+080 and 1608+656 (time-delay quadruple systems) and 1933+503 (a prospective time-delay system) all together, yielding time-delay predictions for the third lens and a 90% confidence estimate of H0-1=14.6+9.4-1.7 Gyr (H0=67+9-26 km s-1 Mpc-1) assuming ΩM=0.3 and ΩΛ=0.7. The other example models the time-delay doubles 1520+530, 1600+434, 1830-211, and 2149-275, which gives H0-1=14.5+3.3-1.5 Gyr (H0=67+8-13 km s-1 Mpc-1). Our second idea is to write the modeling software as a highly interactive Java applet, which can be used both for coarse-grained results inside a browser and for fine-grained results on a workstation. Several obstacles come up in trying to implement a numerically intensive method thus, but we overcome them.

[ascl:1405.012] PISA: Position Intensity and Shape Analysis

PISA (Position, Intensity and Shape Analysis) routines deal with the location and parameterization of objects on an image frame. The core of this package is the routine PISAFIND which performs image analysis on a 2-dimensional data frame. The program searches the data array for objects that have a minimum number of connected pixels above a given threshold and extracts the image parameters (position, intensity, shape) for each object. The image parameters can be determined using thresholding techniques or an analytical stellar profile can be used to fit the objects. In crowded regions deblending of overlapping sources can be performed. PISA is distributed as part of the Starlink software collection (ascl:1110.012).

[ascl:1611.015] Pippi: Parse and plot MCMC chains

Pippi (parse it, plot it) operates on MCMC chains and related lists of samples from a function or distribution, and can merge, parse, and plot sample ensembles ('chains') either in terms of the likelihood/fitness function directly, or as implied posterior probability densities. Pippi is compatible with ASCII text and hdf5 chains, operates out of core, and can post-process chains on the fly.

[ascl:1007.001] PINTofALE: Package for Interactive Analysis of Line Emission

PINTofALE was originally developed to analyze spectroscopic data from optically-thin coronal plasmas, though much of the software is sufficiently general to be of use in a much wider range of astrophysical data analyses. It is based on a modular set of IDL tools that interact with an atomic database and with observational data. The tools are designed to allow easy identification of spectral features, measure line fluxes, and carry out detailed modeling. The basic philosophy of the package is to provide access to the innards of atomic line databases, and to have flexible tools to interactively compare with the observed data. It is motivated by the large amount of book-keeping, computation and iterative interaction that is required between the researcher and observational and theoretical data in order to derive astrophysical results. The tools link together transparently and automatically the processes of spectral "browsing", feature identification, measurement, and computation and derivation of results. Unlike standard modeling and fitting engines currently in use, PINTofALE opens up the "black box" of atomic data required for UV/X-ray analyses and allows the user full control over the data that are used in any given analysis.

[ascl:1902.007] PINT: High-precision pulsar timing analysis package

PINT (PINT Is Not Tempo3) analyzes high-precision pulsar timing data, enabling interactive data analysis and providing an extensible and flexible development platform for timing applications. PINT utilizes well-debugged public Python packages and modern software development practices (e.g., the NumPy and Astropy libraries, version control and development with git and GitHub, and various types of testing) for increased development efficiency and enhanced stability. PINT has been developed and implemented completely independently from traditional pulsar timing software such as TEMPO (ascl:1509.002) and Tempo2 (ascl:1210.015) and is a robust tool for cross-checking timing analyses and simulating data.

[ascl:1305.007] PINOCCHIO: PINpointing Orbit-Crossing Collapsed HIerarchical Objects

PINOCCHIO generates catalogues of cosmological dark matter halos with known mass, position, velocity and merger history. It is able to reproduce, with very good accuracy, the hierarchical formation of dark matter halos from a realization of an initial (linear) density perturbation field, given on a 3D grid. Its setup is similar to that of a conventional N-body simulation, but it is based on the powerful Lagrangian Perturbation Theory. It runs in just a small fraction of the computing time taken by an equivalent N-body simulation, producing promptly the merging histories of all halos in the catalog.

[ascl:1407.012] PINGSoft2: Integral Field Spectroscopy Software

PINGSoft2 visualizes, manipulates and analyzes integral field spectroscopy (IFS) data based on either 3D cubes or Raw Stacked Spectra (RSS) format. Any IFS data can be adapted to work with PINGSoft2, regardless of the original data format and the size/shape of the spaxel. Written in IDL, PINGSoft2 is optimized for fast visualization rendering; it also includes various routines useful for generic astronomy and spectroscopy tasks.

[ascl:1806.014] pile-up: Monte Carlo simulations of star-disk torques on hot Jupiters

The pile-up gnuplot script generates a Monte Carlo simulation with a selectable number of randomized drawings (1000 by default, ~1min on a modern laptop). For each realization, the script calculates the torque acting on a hot Jupiter around a young, solar-type star as a function of the star-planet distance. The total torque on the planet is composed of the disk torque in the type II migration regime (that is, the planet is assumed to have opened up a gap in the disk) and of the stellar tidal torque. The model has four free parameters, which are drawn from a normal or lognormal distribution: (1) the disk's gas surface density at 1 astronomical unit, (2) the magnitude of tidal dissipation within the star, (3) the disk's alpha viscosity parameter, and (4) and the mean molecular weight of the gas in the disk midplane. For each realization, the total torque is screened for a distance at which it becomes zero. If present, then this distance would represent a tidal migration barrier to the planet. In other words, the planet would stop migrating. This location is added to a histogram on top of the main torque-over-distance panel and the realization is counted as one case that contributes to the overall survival rate of hot Jupiters. Finally, the script generates an output file (PDF by default) and prints the hot Jupiter survival rate for the assumed parameterization of the star-planet-disk system.

[ascl:1408.014] pieflag: CASA task to efficiently flag bad data

pieflag compares bandpass-calibrated data to a clean reference channel and identifies and flags essentially all bad data. pieflag compares visibility amplitudes in each frequency channel to a 'reference' channel that is rfi-free (or manually ensured to be rfi-free). pieflag performs this comparison independently for each correlation on each baseline, but will flag all correlations if threshold conditions are met. To operate effectively, pieflag must be supplied with bandpass-calibrated data. pieflag has two core modes of operation (static and dynamic flagging) with an additional extend mode; the type of data largely determines which mode to choose. Instructions for pre-processing data and selecting the mode of operation are provided in the help file. Once pre-processing and selecting the mode of operation are done, pieflag should work well 'out of the box' with its default parameters.

[ascl:1607.009] PICsar: Particle in cell pulsar magnetosphere simulator

PICsar simulates the magnetosphere of an aligned axisymmetric pulsar and can be used to simulate other arbitrary electromagnetics problems in axisymmetry. Written in Fortran, this special relativistic, electromagnetic, charge conservative particle in cell code features stretchable body-fitted coordinates that follow the surface of a sphere, simplifying the application of boundary conditions in the case of the aligned pulsar; a radiation absorbing outer boundary, which allows a steady state to be set up dynamically and maintained indefinitely from transient initial conditions; and algorithms for injection of charged particles into the simulation domain. PICsar is parallelized using MPI and has been used on research problems with ~1000 CPUs.

[ascl:1306.011] Pico: Parameters for the Impatient Cosmologist

Pico is an algorithm that quickly computes the CMB scalar, tensor and lensed power spectra, the matter transfer function and the WMAP 5 year likelihood. It is intended to accelerate parameter estimation codes; Pico can compute the CMB power spectrum and matter transfer function, as well as any computationally expensive likelihoods, in a few milliseconds. It is extremely fast and accurate over a large volume of parameter space and its accuracy can be improved by using a larger training set. More generally, Pico allows using massively parallel computing resources, including distributed computing projects such as Cosmology@Home, to speed up the slow steps in inherently sequential calculations.

[ascl:1610.001] Piccard: Pulsar timing data analysis package

Piccard is a Bayesian-inference pipeline for Pulsar Timing Array (PTA) data and interacts with Tempo2 (ascl:1210.015) through libstempo. The code is used mainly for single-pulsar analysis and gravitational-wave detection purposes of full Pulsar Timing Array datasets. Modeling of the data can include correlated signals per frequency or modeled spectrum, with uniform, dipolar, quadrupolar, or anisotropic correlations; multiple error bars and EFACs per pulsar; and white and red noise. Timing models can be numerically included, either by using the design matrix (linear timing model), or by calling libstempo for the full non-linear timing model. Many types of samplers are included. For common-mode mitigation, the signals can be reconstructed mitigating arbitrary signals simultaneously.

[ascl:1412.007] PIAO: Python spherIcAl Overdensity code

PIAO is an efficient memory-controlled Python code that uses the standard spherical overdensity (SO) algorithm to identify halos. PIAO employs two additional parameters besides the overdensity Δc. The first is the mesh-box size, which splits the whole simulation box into smaller ones then analyzes them one-by-one, thereby overcoming a possible memory limitation problem that can occur when dealing with high-resolution, large-volume simulations. The second is the smoothed particle hydrodynamics (SPH) neighbors number, which is used for the SPH density calculation.

[ascl:1408.003] PIA: ISOPHOT Interactive Analysis

ISOPHOT is one of the instruments on board the Infrared Space Observatory (ISO). ISOPHOT Interactive Analysis (PIA) is a scientific and calibration interactive data analysis tool for ISOPHOT data reduction. Written in IDL under Xwindows, PIA offers a full context sensitive graphical interface for retrieving, accessing and analyzing ISOPHOT data. It is available in two nearly identical versions; a general observers version omits the calibration sequences.

[ascl:1112.004] PHOX: X-ray Photon Simulator

PHOX is a novel, virtual X-ray observatory designed to obtain synthetic observations from hydro-numerical simulations. The code is a photon simulator and can be apply to simulate galaxy clusters. In fact, X-ray observations of clusters of galaxies continue to provide us with an increasingly detailed picture of their structure and of the underlying physical phenomena governing the gaseous component, which dominates their baryonic content. Therefore, it is fundamental to find the most direct and faithful way to compare such observational data with hydrodynamical simulations of cluster-like objects, which can currently include various complex physical processes. Here, we present and analyse synthetic Suzaku observations of two cluster-size haloes obtained by processing with PHOX the hydrodynamical simulation of the large-scale, filament-like region in which they reside. Taking advantage of the simulated data, we test the results inferred from the X-ray analysis of the mock observations against the underlying, known solution. Remarkably, we are able to recover the theoretical temperature distribution of the two haloes by means of the multi-temperature fitting of the synthetic spectra. Moreover, the shapes of the reconstructed distributions allow us to trace the different thermal structure that distinguishes the dynamical state of the two haloes.

[ascl:1609.011] Photutils: Photometry tools

Photutils provides tools for detecting and performing photometry of astronomical sources. It can estimate the background and background rms in astronomical images, detect sources in astronomical images, estimate morphological parameters of those sources (e.g., centroid and shape parameters), and perform aperture and PSF photometry. Written in Python, it is an affiliated package of Astropy (ascl:1304.002).

[ascl:1408.022] PhotoRApToR: PHOTOmetric Research APplication TO Redshifts

PhotoRApToR (PHOTOmetric Research APplication TO Redshifts) solves regression and classification problems and is specialized for photo-z estimation. PhotoRApToR offers data table manipulation capabilities and 2D and 3D graphics tools for data visualization; it also provides a statistical report for both classification and regression experiments. The code is written in Java; the machine learning model is in C++ to increase the core execution speed.

[ascl:1901.007] Photon: Python tool for data plotting

Photon makes simple 1D plots in python. It uses mainly matplotlib and PyQt5 and has been build to be fully customizable, allowing the user to change the fontstyle, fontsize, fontcolors, linewidth of the axes, thickness, and other parameters, and see the changes directly in the plot. Once a customization is created, it can be saved in a configuration file and reloaded for future use, allowing reuse of the customization for other plots. The main tool is a graphical user interface and it is started using a command line interface.

[ascl:1703.004] PHOTOMETRYPIPELINE: Automated photometry pipeline

PHOTOMETRYPIPELINE (PP) provides calibrated photometry from imaging data obtained with small to medium-sized observatories. PP uses Source Extractor (ascl:1010.064) and SCAMP (ascl:1010.063) to register the image data and perform aperture photometry. Calibration is obtained through matching of field stars with reliable photometric catalogs. PP has been specifically designed for the measurement of asteroid photometry, but can also be used to obtain photometry of fixed sources.

[ascl:1405.013] PHOTOM: Photometry of digitized images

PHOTOM performs photometry of digitized images. It has two basic modes of operation: using an interactive display to specify the positions for the measurements, or obtaining those positions from a file. In both modes of operation PHOTOM performs photometry using either the traditional aperture method or via optimal extraction. When using the traditional aperture extraction method the target aperture can be circular or elliptical and its size and shape can be varied interactively on the display, or by entering values from the keyboard. Both methods allow the background sky level to be either sampled interactively by the manual positioning of an aperture, or automatically from an annulus surrounding the target object. PHOTOM is the photometry backend for the GAIA tool (ascl:1403.024) and is part of the Starlink software collection (ascl:1110.012).

[ascl:1712.013] photodynam: Photodynamical code for fitting the light curves of multiple body systems

Photodynam facilitates so-called "photometric-dynamical" modeling. This model is quite simple and this is reflected in the code base. A N-body code provides coordinates and the photometric code produces light curves based on coordinates.

[ascl:1704.009] Photo-z-SQL: Photometric redshift estimation framework

Photo-z-SQL is a flexible template-based photometric redshift estimation framework that can be seamlessly integrated into a SQL database (or DB) server and executed on demand in SQL. The DB integration eliminates the need to move large photometric datasets outside a database for redshift estimation, and uses the computational capabilities of DB hardware. Photo-z-SQL performs both maximum likelihood and Bayesian estimation and handles inputs of variable photometric filter sets and corresponding broad-band magnitudes.

[ascl:1307.011] PhoSim: Photon Simulator

The Photon Simulator (PhoSim) is a set of fast photon Monte Carlo codes used to calculate the physics of the atmosphere, telescope, and detector by using modern numerical techniques applied to comprehensive physical models. PhoSim generates images by collecting photons into pixels. The code takes the description of what astronomical objects are in the sky at a particular time (the instance catalog) as well as the description of the observing configuration (the operational parameters) and produces a realistic data stream of images that are similar to what a real telescope would produce. PhoSim was developed for large aperture wide field optical telescopes, such as the planned design of LSST. The initial version of the simulator also targeted the LSST telescope and camera design, but the code has since been broadened to include existing telescopes of a related nature. The atmospheric model, in particular, includes physical approximations that are limited to this general context.

[ascl:1010.056] PHOENIX: A General-purpose State-of-the-art Stellar and Planetary Atmosphere Code

PHOENIX is a general-purpose state-of-the-art stellar and planetary atmosphere code. It can calculate atmospheres and spectra of stars all across the HR-diagram including main sequence stars, giants, white dwarfs, stars with winds, TTauri stars, novae, supernovae, brown dwarfs and extrasolar giant planets.

[ascl:1106.002] PHOEBE: PHysics Of Eclipsing BinariEs

PHOEBE (PHysics Of Eclipsing BinariEs) is a modeling package for eclipsing binary stars, built on top of the widely used WD program (Wilson & Devinney 1971). This introductory paper overviews most important scientific extensions (incorporating observational spectra of eclipsing binaries into the solution-seeking process, extracting individual temperatures from observed color indices, main-sequence constraining and proper treatment of the reddening), numerical innovations (suggested improvements to WD's Differential Corrections method, the new Nelder & Mead's downhill Simplex method) and technical aspects (back-end scripter structure, graphical user interface). While PHOEBE retains 100% WD compatibility, its add-ons are a powerful way to enhance WD by encompassing even more physics and solution reliability.

[ascl:1112.006] PhAst: Display and Analysis of FITS Images

PhAst (Photometry-Astrometry) is an IDL astronomical image viewer based on the existing application ATV which displays and analyzes FITS images. It can calibrate raw images, provide astrometric solutions, and do circular aperture photometry. PhAst allows the user to load, process, and blink any number of images. Analysis packages include image calibration, photometry, and astrometry (provided through an interface with SExtractor, SCAMP, and missFITS). PhAst has been designed to generate reports for Minor Planet Center reporting.

[ascl:1611.019] phase_space_cosmo_fisher: Fisher matrix 2D contours

phase_space_cosmo_fisher produces Fisher matrix 2D contours from which the constraints on cosmological parameters can be derived. Given a specified redshift array and cosmological case, 2D marginalized contours of cosmological parameters are generated; the code can also plot the derivatives used in the Fisher matrix. In addition, this package can generate 3D plots of qH^2 and other cosmological quantities as a function of redshift and cosmology.

[ascl:1709.002] PHANTOM: Smoothed particle hydrodynamics and magnetohydrodynamics code

Phantom is a smoothed particle hydrodynamics and magnetohydrodynamics code focused on stellar, galactic, planetary, and high energy astrophysics. It is modular, and handles sink particles, self-gravity, two fluid and one fluid dust, ISM chemistry and cooling, physical viscosity, non-ideal MHD, and more. Its modular structure makes it easy to add new physics to the code.

[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:1103.002] PGPLOT: Device-independent Graphics Package for Simple Scientific Graphs

The PGPLOT Graphics Subroutine Library is a Fortran- or C-callable, device-independent graphics package for making simple scientific graphs. It is intended for making graphical images of publication quality with minimum effort on the part of the user. For most applications, the program can be device-independent, and the output can be directed to the appropriate device at run time.

The PGPLOT library consists of two major parts: a device-independent part and a set of device-dependent "device handler" subroutines for output on various terminals, image displays, dot-matrix printers, laser printers, and pen plotters. Common file formats supported include PostScript and GIF.

PGPLOT itself is written mostly in standard Fortran-77, with a few non-standard, system-dependent subroutines. PGPLOT subroutines can be called directly from a Fortran-77 or Fortran-90 program. A C binding library (cpgplot) and header file (cpgplot.h) are provided that allow PGPLOT to be called from a C or C++ program; the binding library handles conversion between C and Fortran argument-passing conventions.

[ascl:1812.003] PFANT: Stellar spectral synthesis code

PFANT computes a synthetic spectrum assuming local thermodynamic equilibrium from a given stellar model atmosphere and lists of atomic and molecular lines; it provides large wavelength coverage and line lists from ultraviolet through the visible and near-infrared. PFANT has been optimized for speed, offers error reporting, and command-line configuration options.

[ascl:1407.009] Period04: Statistical analysis of large astronomical time series

Period04 statistically analyzes large astronomical time series containing gaps. It calculates formal uncertainties, can extract the individual frequencies from the multiperiodic content of time series, and provides a flexible interface to perform multiple-frequency fits with a combination of least-squares fitting and the discrete Fourier transform algorithm. Period04, written in Java/C++, supports the SAMP communication protocol to provide interoperability with other applications of the Virtual Observatory. It is a reworked and extended version of Period98 (Sperl 1998) and PERIOD/PERDET (Breger 1990).

[ascl:1406.005] PERIOD: Time-series analysis package

PERIOD searches for periodicities in data. It is distributed within the Starlink software collection (ascl:1110.012).

[ascl:1809.005] perfectns: "Perfect" dynamic and standard nested sampling for spherically symmetric likelihoods and priors

perfectns performs dynamic nested sampling and standard nested sampling for spherically symmetric likelihoods and priors, and analyses the samples produced. The spherical symmetry allows the nested sampling algorithm to be followed “perfectly” - i.e. without implementation-specific errors correlations between samples. It is intended for use in research into the statistical properties of nested sampling, and to provide a benchmark for testing the performance of nested sampling software packages used for practical problems - which rely on numerical techniques to produce approximately uncorrelated samples.

[ascl:1811.019] PENTACLE: Large-scale particle simulations code for planet formation

PENTACLE calculates gravitational interactions between particles within a cut-off radius and a Barnes-Hut tree method for gravity from particles beyond. It uses FDPS (ascl:1604.011) to parallelize a Barnes-Hut tree algorithm for a memory-distributed supercomputer. The software can handle 1-10 million particles in a high-resolution N-body simulation on CPU clusters for collisional dynamics, including physical collisions in a planetesimal disc.

[ascl:1010.060] Pencil: Finite-difference Code for Compressible Hydrodynamic Flows

The Pencil code is a high-order finite-difference code for compressible hydrodynamic flows with magnetic fields. It is highly modular and can easily be adapted to different types of problems. The code runs efficiently under MPI on massively parallel shared- or distributed-memory computers, like e.g. large Beowulf clusters. The Pencil code is primarily designed to deal with weakly compressible turbulent flows. To achieve good parallelization, explicit (as opposed to compact) finite differences are used. Typical scientific targets include driven MHD turbulence in a periodic box, convection in a slab with non-periodic upper and lower boundaries, a convective star embedded in a fully nonperiodic box, accretion disc turbulence in the shearing sheet approximation, self-gravity, non-local radiation transfer, dust particle evolution with feedback on the gas, etc. A range of artificial viscosity and diffusion schemes can be invoked to deal with supersonic flows. For direct simulations regular viscosity and diffusion is being used. The code is written in well-commented Fortran90.

[ascl:1507.003] Pelican: Pipeline for Extensible, Lightweight Imaging and CAlibratioN

Pelican is an efficient, lightweight C++ library for quasi-real time data processing. The library provides a framework to separate the acquisition and processing of data, allowing the scalability and flexibility to fit a number of scenarios. Though its origin was in radio astronomy, processing data as it arrives from a telescope, the framework is sufficiently generic to be useful to any application that requires the efficient processing of incoming data streams.

[ascl:1108.007] PÉGASE: Metallicity-consistent Spectral Evolution Model of Galaxies

PÉGASE (Projet d'Étude des GAlaxies par Synthèse Évolutive) is a code to compute the spectral evolution of galaxies. The evolution of the stars, gas and metals is followed for a law of star formation and a stellar initial mass function. The stellar evolutionary tracks extend from the main sequence to the white dwarf stage. The emission of the gas in HII regions is also taken into account. The main improvement in version 2 is the use of evolutionary tracks of different metallicities (from 10-4 to 5×solar). The effect of extinction by dust is also modelled using a radiative transfer code. PÉGASE.2 uses the BaSeL library of stellar spectra and can therefore synthesize low-resolution (R~200) ultraviolet to near-infrared spectra of Hubble sequence galaxies as well as of starbursts.

[ascl:1108.008] PÉGASE-HR: Stellar Population Synthesis at High Resolution Spectra

PÉGASE-HR is a code aimed at computing synthetic evolutive optical spectra of galaxies with a very high resolution (R=10 000, or dlambda=0.55) in the range Lambda=[4000, 6800] Angstroms. PÉGASE-HR is the result of combining the code PÉGASE.2 with the high-resolution stellar library ÉLODIE. This code can also be used at low resolution (R=200) over the range covered by the BaSeL library (from far UV to the near IR), and then produces the same results as PÉGASE.2. In PEGASE-HR, the BaSeL library is replaced by a grid of spectra interpolated from the high-resolution ÉLODIE library of stellar spectra. The ÉLODIE library is a stellar database of 1959 spectra for 1503 stars, observed with the echelle spectrograph ÉLODIE on the 193 cm telescope at the Observatoire de Haute Provence.

[ascl:1304.001] PEC: Period Error Calculator

The PEC (Period Error Calculator) algorithm estimates the period error for eclipsing binaries observed by the Kepler Mission. The algorithm is based on propagation of error theory and assumes that observation of every light curve peak/minimum in a long time-series observation can be unambiguously identified. A simple C implementation of the PEC algorithm is available.

[ascl:1605.008] PDT: Photometric DeTrending Algorithm Using Machine Learning

PDT removes systematic trends in light curves. It finds clusters of light curves that are highly correlated using machine learning, constructs one master trend per cluster and detrends an individual light curve using the constructed master trends by minimizing residuals while constraining coefficients to be positive.

[ascl:1102.022] PDRT: Photo Dissociation Region Toolbox

Ultraviolet photons from O and B stars strongly influence the structure and emission spectra of the interstellar medium. The UV photons energetic enough to ionize hydrogen (hν > 13.6 eV) will create the H II region around the star, but lower energy UV photons escape. These far-UV photons (6 eV < hν < 13.6 eV) are still energetic enough to photodissociate molecules and to ionize low ionization-potential atoms such as carbon, silicon, and sulfur. They thus create a photodissociation region (PDR) just outside the H II region. In aggregate, these PDRs dominates the heating and cooling of the neutral interstellar medium.

As part of the Web Infrared Tool Shed (WITS) we have developed a web tool, called the PDR Toolbox, that allows users to determine the physical parameters of a PDR from a set of spectral line observations. Typical observations of both Galactic and extragalactic PDRs come from ground-based millimeter and submillimeter telescopes such as CARMA or the CSO, or space-based telescopes such as Spitzer, ISO, SOFIA, and Herschel. Given a set of observations of spectral line intensities, PDR Toolbox will compute best-fit FUV incident intensity and cloud density based on our published models of PDR emission.

[ascl:1809.002] PCCDPACK: Polarimetry with CCD

PCCDPACK analyzes polarimetry data. The set of routines is written in CL-IRAF (including compiled Fortran codes) and analyzes dozens of point objects simultaneously on the same CCD image. A subpackage, specpol, is included to analyze spectropolarimetry data.

[ascl:1705.004] PCAT: Probabilistic Cataloger

PCAT (Probabilistic Cataloger) samples from the posterior distribution of a metamodel, i.e., union of models with different dimensionality, to compare the models. This is achieved via transdimensional proposals such as births, deaths, splits and merges in addition to the within-model proposals. This method avoids noisy estimates of the Bayesian evidence that may not reliably distinguish models when sampling from the posterior probability distribution of each model.

The code has been applied in two different subfields of astronomy: high energy photometry, where transdimensional elements are gamma-ray point sources; and strong lensing, where light-deflecting dark matter subhalos take the role of transdimensional elements.

[ascl:1207.012] PCA: Principal Component Analysis for spectra modeling

The mid-infrared spectra of ultraluminous infrared galaxies (ULIRGs) contain a variety of spectral features that can be used as diagnostics to characterize the spectra. However, such diagnostics are biased by our prior prejudices on the origin of the features. Moreover, by using only part of the spectrum they do not utilize the full information content of the spectra. Blind statistical techniques such as principal component analysis (PCA) consider the whole spectrum, find correlated features and separate them out into distinct components.

This code, written in IDL, classifies principal components of IRS spectra to define a new classification scheme using 5D Gaussian mixtures modelling. The five PCs and average spectra for the four classifications to classify objects are made available with the code.

[ascl:1708.007] PBMC: Pre-conditioned Backward Monte Carlo code for radiative transport in planetary atmospheres

PBMC (Pre-Conditioned Backward Monte Carlo) solves the vector Radiative Transport Equation (vRTE) and can be applied to planetary atmospheres irradiated from above. The code builds the solution by simulating the photon trajectories from the detector towards the radiation source, i.e. in the reverse order of the actual photon displacements. In accounting for the polarization in the sampling of photon propagation directions and pre-conditioning the scattering matrix with information from the scattering matrices of prior (in the BMC integration order) photon collisions, PBMC avoids the unstable and biased solutions of classical BMC algorithms for conservative, optically-thick, strongly-polarizing media such as Rayleigh atmospheres.

[ascl:1102.002] PBL: Particle-Based Lensing for Gravitational Lensing Mass Reconstructions of Galaxy Clusters

We present Particle-Based Lensing (PBL), a new technique for gravitational lensing mass reconstructions of galaxy clusters. Traditionally, most methods have employed either a finite inversion or gridding to turn observational lensed galaxy ellipticities into an estimate of the surface mass density of a galaxy cluster. We approach the problem from a different perspective, motivated by the success of multi-scale analysis in smoothed particle hydrodynamics. In PBL, we treat each of the lensed galaxies as a particle and then reconstruct the potential by smoothing over a local kernel with variable smoothing scale. In this way, we can tune a reconstruction to produce constant signal-noise throughout, and maximally exploit regions of high information density.

PBL is designed to include all lensing observables, including multiple image positions and fluxes from strong lensing, as well as weak lensing signals including shear and flexion. In this paper, however, we describe a shear-only reconstruction, and apply the method to several test cases, including simulated lensing clusters, as well as the well-studied ``Bullet Cluster'' (1E0657-56). In the former cases, we show that PBL is better able to identify cusps and substructures than are grid-based reconstructions, and in the latter case, we show that PBL is able to identify substructure in the Bullet Cluster without even exploiting strong lensing measurements.

[ascl:1809.003] PASTA: Python Astronomical Stacking Tool Array

PASTA performs median stacking of astronomical sources. Written in Python, it can filter sources, provide stack statistics, generate Karma annotations, format source lists, and read information from stacked Flexible Image Transport System (FITS) images. PASTA was originally written to examine polarization stack properties and includes a Monte Carlo modeler for obtaining true polarized intensity from the observed polarization of a stack. PASTA is also useful as a generic stacking tool, even if polarization properties are not being examined.

[ascl:1010.073] partiview: Immersive 4D Interactive Visualization of Large-Scale Simulations

In dense clusters a bewildering variety of interactions between stars can be observed, ranging from simple encounters to collisions and other mass-transfer encounters. With faster and special-purpose computers like GRAPE, the amount of data per simulation is now exceeding 1TB. Visualization of such data has now become a complex 4D data-mining problem, combining space and time, and finding interesting events in these large datasets. We have recently starting using the virtual reality simulator, installed in the Hayden Planetarium in the American Museum for Natural History, to tackle some of these problem. partiview is a program that enables you to visualize and animate particle data. partiview runs on relatively simple desktops and laptops, but is mostly compatible with its big brother VirDir.

[ascl:1010.005] Particle module of Piernik MHD code

Piernik is a multi-fluid grid magnetohydrodynamic (MHD) code based on the Relaxing Total Variation Diminishing (RTVD) conservative scheme. The original code has been extended by addition of dust described within the particle approximation. The dust is now described as a system of interacting particles. The particles can interact with gas, which is described as a fluid. The comparison between the test problem results and the results coming from fluid simulations made with Piernik code shows the most important differences between fluid and particle approximations used to describe dynamical evolution of dust under astrophysical conditions.

[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:1502.005] PARSEC: PARametrized Simulation Engine for Cosmic rays

PARSEC (PARametrized Simulation Engine for Cosmic rays) is a simulation engine for fast generation of ultra-high energy cosmic ray data based on parameterizations of common assumptions of UHECR origin and propagation. Implemented are deflections in unstructured turbulent extragalactic fields, energy losses for protons due to photo-pion production and electron-pair production, as well as effects from the expansion of the universe. Additionally, a simple model to estimate propagation effects from iron nuclei is included. Deflections in the Galactic magnetic field are included using a matrix approach with precalculated lenses generated from backtracked cosmic rays. The PARSEC program is based on object oriented programming paradigms enabling users to extend the implemented models and is steerable with a graphical user interface.

[ascl:1601.010] PARAVT: Parallel Voronoi Tessellation

PARAVT offers massive parallel computation of Voronoi tessellations (VT hereafter) in large data sets. The code is focused for astrophysical purposes where VT densities and neighbors are widely used. There are several serial Voronoi tessellation codes, however no open source and parallel implementations are available to handle the large number of particles/galaxies in current N-body simulations and sky surveys. Parallelization is implemented under MPI and VT using Qhull library. Domain decomposition take into account consistent boundary computation between tasks, and support periodic conditions. In addition, the code compute neighbors lists, Voronoi density and Voronoi cell volumes for each particle, and can compute density on a regular grid.

[ascl:1103.014] ParaView: Data Analysis and Visualization Application

ParaView is an open-source, multi-platform data analysis and visualization application. ParaView users can quickly build visualizations to analyze their data using qualitative and quantitative techniques. The data exploration can be done interactively in 3D or programmatically using ParaView's batch processing capabilities.

ParaView was developed to analyze extremely large datasets using distributed memory computing resources. It can be run on supercomputers to analyze datasets of terascale as well as on laptops for smaller data.

[ascl:1010.039] Parameter Estimation from Time-Series Data with Correlated Errors: A Wavelet-Based Method and its Application to Transit Light Curves

We consider the problem of fitting a parametric model to time-series data that are afflicted by correlated noise. The noise is represented by a sum of two stationary Gaussian processes: one that is uncorrelated in time, and another that has a power spectral density varying as $1/f^gamma$. We present an accurate and fast [O(N)] algorithm for parameter estimation based on computing the likelihood in a wavelet basis. The method is illustrated and tested using simulated time-series photometry of exoplanetary transits, with particular attention to estimating the midtransit time. We compare our method to two other methods that have been used in the literature, the time-averaging method and the residual-permutation method. For noise processes that obey our assumptions, the algorithm presented here gives more accurate results for midtransit times and truer estimates of their uncertainties.

[ascl:1106.009] PARAMESH V4.1: Parallel Adaptive Mesh Refinement

PARAMESH is a package of Fortran 90 subroutines designed to provide an application developer with an easy route to extend an existing serial code which uses a logically cartesian structured mesh into a parallel code with adaptive mesh refinement (AMR). Alternatively, in its simplest use, and with minimal effort, it can operate as a domain decomposition tool for users who want to parallelize their serial codes, but who do not wish to use adaptivity.

The package builds a hierarchy of sub-grids to cover the computational domain, with spatial resolution varying to satisfy the demands of the application. These sub-grid blocks form the nodes of a tree data-structure (quad-tree in 2D or oct-tree in 3D). Each grid block has a logically cartesian mesh. The package supports 1, 2 and 3D models. PARAMESH is released under the NASA-wide Open-Source software license.

[ascl:1103.008] Parallel HOP: A Scalable Halo Finder for Massive Cosmological Data Sets

Modern N-body cosmological simulations contain billions ($10^9$) of dark matter particles. These simulations require hundreds to thousands of gigabytes of memory, and employ hundreds to tens of thousands of processing cores on many compute nodes. In order to study the distribution of dark matter in a cosmological simulation, the dark matter halos must be identified using a halo finder, which establishes the halo membership of every particle in the simulation. The resources required for halo finding are similar to the requirements for the simulation itself. In particular, simulations have become too extensive to use commonly-employed halo finders, such that the computational requirements to identify halos must now be spread across multiple nodes and cores. Here we present a scalable-parallel halo finding method called Parallel HOP for large-scale cosmological simulation data. Based on the halo finder HOP, it utilizes MPI and domain decomposition to distribute the halo finding workload across multiple compute nodes, enabling analysis of much larger datasets than is possible with the strictly serial or previous parallel implementations of HOP. We provide a reference implementation of this method as a part of the toolkit yt, an analysis toolkit for Adaptive Mesh Refinement (AMR) data that includes complementary analysis modules. Additionally, we discuss a suite of benchmarks that demonstrate that this method scales well up to several hundred tasks and datasets in excess of $2000^3$ particles. The Parallel HOP method and our implementation can be readily applied to any kind of N-body simulation data and is therefore widely applicable. Parallel HOP is part of yt.

[ascl:1511.009] Pangloss: Reconstructing lensing mass

Pangloss reconstructs all the mass within a light cone through the Universe. Understanding complex mass distributions like this is important for accurate time delay lens cosmography, and also for accurate lens magnification estimation. It aspires to use all available data in an attempt to make the best of all mass maps.

[ascl:1805.021] PampelMuse: Crowded-field 3D spectroscopy

PampelMuse analyzes integral-field spectroscopic observations of crowded stellar fields and provides several subroutines to perform the individual steps of the data analysis. All analysis steps assume that the IFS data has been properly reduced and that all the instrumental artifacts have been removed. PampelMuse is designed to correctly handle IFS data regardless of which instrument was used to observe the data. In addition to the actual data, the software also requires an estimate of the variances for the analysis; optionally, it can use a bad pixel mask. The analysis relies on the presence of a reference catalogue, containing coordinates and magnitudes of the stars in and around the observed field.

[ascl:1406.002] PAMELA: Optimal extraction code for long-slit CCD spectroscopy

PAMELA is an implementation of the optimal extraction algorithm for long-slit CCD spectroscopy and is well suited for time-series spectroscopy. It properly implements the optimal extraction algorithm for curved spectra, including on-the-fly cosmic ray rejection as well as proper calculation and propagation of the errors. The software is distributed as part of the Starlink software collection (ascl:1110.012).

[ascl:1606.002] PAL: Positional Astronomy Library

The PAL library is a partial re-implementation of Pat Wallace's popular SLALIB library written in C using a Gnu GPL license and layered on top of the IAU's SOFA library (or the BSD-licensed ERFA) where appropriate. PAL attempts to stick to the SLA C API where possible.

[ascl:1210.009] PAHFIT: Properties of PAH Emission

PAHFIT is an IDL tool for decomposing Spitzer IRS spectra of PAH emission sources, with a special emphasis on the careful recovery of ambiguous silicate absorption, and weak, blended dust emission features. PAHFIT is primarily designed for use with full 5-35 micron Spitzer low-resolution IRS spectra. PAHFIT is a flexible tool for fitting spectra, and you can add or disable features, compute combined flux bands, change fitting limits, etc., without changing the code.

PAHFIT uses a simple, physically-motivated model, consisting of starlight, thermal dust continuum in a small number of fixed temperature bins, resolved dust features and feature blends, prominent emission lines (which themselves can be blended with dust features), as well as simple fully-mixed or screen dust extinction, dominated by the silicate absorption bands at 9.7 and 18 microns. Most model components are held fixed or are tightly constrained. PAHFIT uses Drude profiles to recover the full strength of dust emission features and blends, including the significant power in the wings of the broad emission profiles. This means the resulting feature strengths are larger (by factors of 2-4) than are recovered by methods which estimate the underlying continuum using line segments or spline curves fit through fiducial wavelength anchors.

[ascl:1708.014] PACSman: IDL Suite for Herschel/PACS spectrometer data

PACSman provides an alternative for several reduction and analysis steps performed in HIPE (ascl:1111.001) on PACS spectroscopic data; it is written in IDL. Among the operations possible with it are transient correction, line fitting, map projection, and map analysis, and unchopped scan, chop/nod, and the decommissioned wavelength switching observation modes are supported.

[ascl:1110.011] Pacerman: Polarisation Angle CorrEcting Rotation Measure ANalysis

Pacerman, written in IDL, is a new method to calculate Faraday rotation measure maps from multi-frequency polarisation angle data. In order to solve the so called n-pi-ambiguity problem which arises from the observationally ambiguity of the polarisation angle which is only determined up to additions of n times pi, where n is an integer, we suggest using a global scheme. Instead of solving the n-pi-ambiguity for each data point independently, our algorithm, which we chose to call Pacerman solves the n-pi-ambiguity for a high signal-to-noise region "democratically" and uses this information to assist computations in adjacent low signal-to-noise areas.

[ascl:1105.002] PACCE: Perl Algorithm to Compute Continuum and Equivalent Widths

PACCE (Perl Algorithm to Compute continuum and Equivalent Widths) computes continuum and equivalent widths. PACCE is able to determine mean continuum and continuum at line center values, which are helpful in stellar population studies, and is also able to compute the uncertainties in the equivalent widths using photon statistics.

[ascl:1205.002] p3d: General data-reduction tool for fiber-fed integral-field spectrographs

p3d is semi-automatic data-reduction tool designed to be used with fiber-fed integral-field spectrographs. p3d is a highly general and freely available tool based on IDL but can be used with full functionality without an IDL license. It is easily extended to include improved algorithms, new visualization tools, and support for additional instruments. It uses a novel algorithm for automatic finding and tracing of spectra on the detector, and includes two methods of optimal spectrum extraction in addition to standard aperture extraction. p3d also provides tools to combine several images, perform wavelength calibration and flat field data.

[ascl:1402.030] P2SAD: Particle Phase Space Average Density

P2SAD computes the Particle Phase Space Average Density (P2SAD) in galactic haloes. The model for the calculation is based on the stable clustering hypothesis in phase space, the spherical collapse model, and tidal disruption of substructures. The multiscale prediction for P2SAD computed by this IDL code can be used to estimate signals sensitive to the small scale structure of dark matter distributions (e.g. dark matter annihilation). The code computes P2SAD averaged over the whole virialized region of a Milky-Way-size halo at redshift zero.

Would you like to view a random code?