[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: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: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: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: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: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: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: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: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: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:2001.014]
Peasoup: C++/CUDA GPU pulsar searching library

The NVIDIA GPU-based pipeline code peasoup provides a one-step pulsar search, including searching for pulsars with up to moderate accelerations, with only one command. Its features include dedispersion, dereddening in the Fourier domain, resampling, peak detection, and optional time series folding. peasoup's output is the candidate list.

[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:1108.008]
PÉGASE-HR: Stellar Population Synthesis at High Resolution Spectra

Le Borgne, Damien; Fioc, Michel; Lançon, Ariane; Rocca-Volmerange, Brigitte; Prugniel, Philippe; Soubiran, Caroline

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: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: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: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: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: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: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: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:2007.005]
PeTar: ParticlE Tree & particle-particle & Algorithmic Regularization code for simulating massive star clusters

The N-body code PETAR (ParticlE Tree & particle-particle & Algorithmic Regularization) combines the methods of Barnes-Hut tree, Hermite integrator and slow-down algorithmic regularization (SDAR). It accurately handles an arbitrary fraction of multiple systems (*e.g.* binaries, triples) while keeping a high performance by using the hybrid parallelization methods with MPI, OpenMP, SIMD instructions and GPU. PETAR has very good agreement with NBODY6++GPU results on the long-term evolution of the global structure, binary orbits and escapers and is significantly faster when used on a highly configured GPU desktop computer. PETAR scales well when the number of cores increase on the Cray XC50 supercomputer, allowing a solution to the ten million-body problem which covers the region of ultra compact dwarfs and nuclear star clusters.

[ascl:1910.010]
PEXO: Precise EXOplanetology

Feng, Fabo; Lisogorskyi, Maksym; Jones, Hugh R. A.; Kopeikin, Sergei M.; Butler, R. Paul; Anglada-Escude, Guillem; Boss, Alan P.

PEXO provides a global modeling framework for ns timing, μas astrometry, and μm/s radial velocities. It can account for binary motion and stellar reflex motions induced by planetary companions and also treat various relativistic effects both in the Solar System and in the target system (Roemer, Shapiro, and Einstein delays). PEXO is able to model timing to a precision of 1 ns, astrometry to a precision of 1 μas, and radial velocity to a precision of 1 μm/s.

[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: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: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:1709.002]
PHANTOM: Smoothed particle hydrodynamics and magnetohydrodynamics code

Price, Daniel J.; Wurster, James; Nixon, Chris; Tricco, Terrence S.; Toupin, Stéven; Pettitt, Alex; Chan, Conrad; Laibe, Guillaume; Glover, Simon; Dobbs, Clare; Nealon, Rebecca; Liptai, David; Worpel, Hauke; Bonnerot, Clément; Dipierro, Giovanni; Ragusa, Enrico; Federrath, Christoph; Iaconi, Roberto; Reichardt, Thomas; Forgan, Duncan; Hutchison, Mark; Constantino, Thomas; Ayliffe, Ben; Mentiplay, Daniel; Hirsh, Kieran; Lodato, Giuseppe

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: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:2008.002]
PhaseTracer: Cosmological phases mapping

PhaseTracer maps out cosmological phases, and potential transitions between them, for Standard Model extensions with any number of scalar fields. The code traces the minima of effective potential as the temperature changes, and then calculates the critical temperatures at which the minima are degenerate. PhaseTracer can use potentials provided by other packages and can be used to analyze cosmological phase transitions which played an important role in the early evolution of the Universe.

[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: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: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: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: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: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:1405.013]
PHOTOM: Photometry of digitized images

Eaton, Nicholas; Draper, Peter W.; Allan, Alasdair; Naylor, Tim; Mukai, Koji; Currie, Malcolm J.; McCaughrean, Mark

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: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: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: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:1609.011]
Photutils: Photometry tools

Bradley, Larry; Sipocz, Brigitta; Robitaille, Thomas; Tollerud, Erik; Deil, Christoph; Vinícius, Zè; Barbary, Kyle; Günther, Hans Moritz; Bostroem, Azalee; Droettboom, Michael; Bray, Erik; Bratholm, Lars Andersen; Pickering, T. E.; Craig, Matt; Pascual, Sergio; Greco, Johnny; Donath, Axel; Kerzendorf, Wolfgang; Littlefair, Stuart; Barentsen, Geert; D'Eugenio, Francesco; Weaver, Benjamin Alan

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: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:1408.003]
PIA: ISOPHOT Interactive Analysis

Gabriel, Carlos; Acosta, Jose; Heinrichsen, Ingolf; Skaley, Detlef; Tai, Wai Ming; Morris, Huw; Merluzzi, Paola

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: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:1905.019]
PICASO: Planetary Intensity Code for Atmospheric Scattering Observations

PICASO (Planetary Intensity Code for Atmospheric Scattering Observations), written in Python, computes the reflected light of exoplanets at any phase geometry using direct and diffuse scattering phase functions and Raman scattering spectral features.

[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 (ascl:2002.017). 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: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: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: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: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: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:1910.001]
PINK: Parallelized rotation and flipping INvariant Kohonen maps

Morphological classification is one of the most demanding challenges in astronomy. With the advent of all-sky surveys, an enormous amount of imaging data is publicly available, and are typically analyzed by experts or encouraged amateur volunteers. For upcoming surveys with billions of objects, however, such an approach is not feasible anymore. PINK (Parallelized rotation and flipping INvariant Kohonen maps) is a simple yet effective variant of a rotation-invariant self-organizing map that is suitable for many analysis tasks in astronomy. The code reduces the computational complexity via modern GPUs and applies the resulting framework to galaxy data for morphological analysis.

[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:1902.007]
PINT: High-precision pulsar timing analysis package

Luo, Jing; Ransom, Scott; Demorest, Paul; van Haasteren, Rutger; Ray, Paul; Stovall, Kevin; Bachetti, Matteo; Archibald, Anne; Kerr, Matthew; Colen, Jonathan; Jenet, Fredrick

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: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: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: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:2010.014]
Pix2Prof: Deep learning for textraction of useful sequential information from galaxy imagery

Pix2Prof produces a surface brightness profile from an unprocessed galaxy image from the SDSS in either the g, r, or i bands. It is fast, and given suitable training data, Pix2Prof can be retrained to produce any galaxy profile from any galaxy image.

[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 H_{0}. 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 H_{0}^{-1}=14.6+9.4-1.7 Gyr (H_{0}=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 H_{0}^{-1}=14.5+3.3-1.5 Gyr (H_{0}=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: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: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:1911.001]
PLAN: A Clump-finder for Planetesimal Formation Simulations

PLAN (PLanetesimal ANalyzer) identifies and characterizes planetesimals produced in numerical simulations of the Streaming Instability that includes particle self-gravity with code Athena (ascl:1010.014). PLAN works with the 3D particle output of Athena and finds gravitationally bound clumps robustly and efficiently. PLAN — written in C++ with OpenMP/MPI — is massively parallelized, memory-efficient, and scalable to analyze billions of particles and multiple snapshots simultaneously. The approach of PLAN is based on the dark matter halo finder HOP (ascl:1102.019), but with many customizations for planetesimal formation. PLAN can be easily adapted to analyze other object formation simulations that use Lagrangian particles (e.g., Athena++ simulations). PLAN is also equipped with a toolkit to analyze the grid-based hydro data (VTK dumps of primitive variables) from Athena, which requires the Boost MultiDimensional Array Library.

[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:2010.009]
plancklens: Planck 2018 lensing pipeline

plancklens contains most of Planck 2018 CMB lensing pipeline and makes it possible to reproduce the published map and band-powers. Some numerical parts are written in Fortran, and portions of it (structure and code) have been directly adapted from pre-existing work by Duncan Hanson. The lensed CMB skies is produced by the stand-alone package lenspyx (ascl:2010.010).

[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: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:1911.007]
planetplanet: General photodynamical code for exoplanet light curves

planetplanet models exoplanet transits, secondary eclipses, phase curves, and exomoons, as well as eclipsing binaries, circumbinary planets, and more. The code was originally developed to model planet-planet occultation (PPO) light curves for the TRAPPIST-1 system, but it is generally applicable to any exoplanet system. During a PPO, a planet occults (transits) the disk of another planet in the same planetary system, blocking its thermal (and reflected) light, which can be measured photometrically by a distant observer. planetplanet is coded in C and wrapped in a user-friendly Python interface.

[ascl:1906.019]
PlasmaPy: Core Python package for plasma physics

PlasmaPy Community; Murphy, Nicholas A.; Stańczak, Dominik; Kozlowski, Pawel M.; Langendorf, Samuel J.; Leonard, Andrew J.; Beckers, Jasper P.; Haggerty, Colby C.; Mumford, Stuart J.; Malhotra, Ritiek; Bessi, Ludovico; Carroll, Sean; Choubey, Apoorv; Díaz Pérez, Roberto; Einhorn, Leah; Fan, Thomas; Goudeau, Graham; Guidoni, Silvina; Hillairet, Julien; How, Poh Zi; Huang, Yi-Min; Humphrey, Nabil; Isupova, Maria; Kulshrestha, Siddharth; Kuszaj, Piotr; Munn, Joshua; Parashar, Tulasi; Patel, Neil; Raj, Raajit; Sherpa, Dawa Nurbu; Stansby, David; Tavant, Antoine; Xu, Sixue

PlasmaPy provides core functionality and a common framework for data visualization and analysis for plasma physics. It has modules for basic plasma physics calculations, running desktop-scale simulations to test preliminary ideas such as one-dimensional MHD/PIC or test particles, or comparing data from two different sources, such as simulations and spacecraft.

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

Marcos-Arenal, P.; Zima, W.; De Ridder, J.; Aerts, C.; Huygen, R.; Samadi, R.; Green, J.; Piotto, G.; Salmon, S.; Catala, C.; Rauer, H.

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: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:1907.009]
Plonk: Smoothed particle hydrodynamics data analysis and visualization

Plonk analyzes and visualizes smoothed particle hydrodynamics simulation data, focusing on astrophysical applications. It calculates extra quantities on the particles, calculates and plots radial profiles, accesses subsets of particles, and provides visualization of any quantity defined on the particles via kernel density estimation. Plock's visualization module uses Splash (ascl:1103.004) to produce images using smoothed particle hydrodynamics interpolation. The code is modular and extendible, and can be scripted or used interactively.

[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: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: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: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: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: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 (ascl:1102.008). Files required for generating initial dark matter particle distributions and instructions are included, however one would require CMBFAST to create alternative transfer functions.

[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:2011.025]
PNICER: Extinction estimator

PNICER estimates extinction for individual sources and creates extinction maps using unsupervised machine learning algorithms. Extinction towards single sources is determined by fitting Gaussian Mixture Models along the extinction vector to (extinction-free) control field observations. PNICER also offers access to the well-established NICER technique in a simple unified interface and is capable of building extinction maps including the NICEST correction for cloud substructure.

[ascl:1907.006]
POCS: PANOPTES Observatory Control System

PANOPTES (Panoptic Astronomical Networked Observatories for a Public Transiting Exoplanets Survey) is a citizen science project for low cost, robotic detection of transiting exoplanets. POCS (PANOPTES Observatory Control System) is the main software driver for the PANOPTES telescope system, responsible for high-level control of the unit. POCS defines an Observatory class that automatically controls a commercially available equatorial mount, including image analysis and corresponding mount adjustment to obtain a percent-level photometric precision.

[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: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: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.

[submitted]
polgraw-allsky

Astone, Pia; Bejger, Michał; Bolek, Jan; Ciecieląg, Paweł; Dorosh, Orest; Garus, Aleksander; Królak, Andrzej; Nagy-Egri, Máté Ferenc; Piętka, Maciej; Pisarski, Andrzej; Poghosyan, Gevorg; Sieniawska, Magdalena; Skrzypiec, Rafał

All-sky almost-monochromatic gravitational-wave pipeline (Polgraw group)

[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: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: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: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: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:2007.009]
polyMV: Multipolar coefficients converter

polyMV converts multipolar coefficients (alms in healpix order) into Multipole Vectors (MVs) and also Fréchet Vectors (FVs) given a specific multipole. The code uses MPSolve (ascl:2007.008) and is order of magnitudes faster than other existing public codes at high multipoles.

[ascl:1912.001]
Polyspectrum: Computing polyspectra using an FFT estimator

Polyspectrum computes the polyspectrum from 3D grids using a fast Fourier transformation (FFT) estimator. The code, written in C and MPI-parallelized, support the computation of power- and bispectra; it also supports higher-order polyspectra, but streamlining the input data is required.

[ascl:2012.016]
Pomegranate: Probabilistic model builder

Pomegranate builds probabilistic models in Python that is implemented in Cython for speed. The code merges the easy-to-use API of scikit-learn with the modularity of probabilistic modeling, including general mixture and hidden Markov models and Bayesian networks, to allow users to specify complicated models without the need to be concerned about implementation details. The models are built from the ground up and natively support features such as multi-threaded parallelism and out-of-core processing.

[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:2007.006]
PoPE: Population Profile Estimator

PoPE (Population Profile Estimator) analyzes spatial distribution or internal spatial structure problems of samples of astronomical systems. This population-based Bayesian inference model uses the conditional statistics of spatial profile of multiple observables assuming the individual observations are measured with errors of varying magnitude. Assuming the conditional statistics of the observables can be described with a multivariate normal distribution, the model reduces to the conditional average profile and conditional covariance between all observables. The method consists of two steps: (1) reconstructing the average profile using non-parametric regression with Gaussian Processes and (2) estimating the property profiles covariance given a set of independent variable. PoPE is computationally efficient and capable of inferring average profiles of a population from noisy measurements without stacking and binning nor parameterizing the shape of the average profile.

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

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

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

[ascl: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:1912.008]
PopSyCLE: Population Synthesis for Compact object Lensing Events

PopSyCLE performs compact object population synthesis while taking photometric and astrometric microlensing effects into consideration. It uses Galaxia (ascl:1101.007) to produces a synthetic survey, injects compact objects into the resulting survey, and then produces a list of microlensing events, enabling the discovery of black holes with microlensing. It can be used to examine historical microlensing events from photometric surveys to statistically constrain the abundance of black holes in our galaxy, and to forward model microlensing survey results to constrain, for example, the properties of compact objects, Galactic structure, and the initial-final mass relation.

[ascl:2003.006]
PORTAL: POlarized Radiative Transfer Adapted to Lines

PORTAL (POlarized Radiative Transfer Adapted to Lines), a 3D polarized radiative transfer code, simulates the emergence of polarization in the emission of atomic or molecular (sub-)millimeter lines. Written in Fortran90, PORTAL can be used in standalone mode or can process the output of other 3D radiative transfer codes

[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:2006.018]
Powderday: Dust radiative transfer package

Narayanan, Desika; Turk, Matthew J.; Robitaille, Thomas; Kelly, Ashley J.; Connor McClellan, B.; Sharma, Ray S.; Garg, Prerak; Abruzzo, Matthew; Choi, Ena; Conroy, Charlie; Johnson, Benjamin D.; Kimock, Benjamin; Li, Qi; Lovell, Christopher C.; Lower, Sidney; Privon, George C.; Roberts, Jonathan; Sethuram, Snigdaa; Snyder, Gregory F.; Thompson, Robert; Wise, John H.

The dust radiative transfer software Powderday interfaces with galaxy formation simulations to produce spectral energy distributions and images. The code uses fsps (ascl:1010.043) and its Python bindings python-fsps for stellar SEDs, Hyperion (ascl:1207.004) for dust radiative transfer, and works with a variety of packages, including Arepo (ascl:1909.010), Changa (ascl:1105.005), Gasoline (ascl:1710.019), and Gizmo (ascl:1410.003); threaded throughout is yt (ascl:1011.022).

[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: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: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: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: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:2004.008]
PPMAP: Column density mapping with extra dimensions

PPMAP provides column density mapping with extra dimensions (temperature and dust opacity index); it generate image cubes of differential column density as a function of (x,y) sky position and temperature for diffuse dusty structures. The code incorporates parallel processing using OpenMP for some of the more CPU-intensive steps. It is currently configured for the "Raven" cluster at Cardiff University and runs in a mode in which the computations are split between 16 separate nodes, each of which uses 16 cores with OpenMP.

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

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

The code is available in IDL and in Python versions.

[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:2004.016]
PRECISION: Astronomical infrared observations data reduction

PRECISION reduces astronomical IR imaging data. Written with SPHERE data in mind, it provides a fast and easy reduction of bright sources suitable for science. While it may not extract the absolute maximum amount of science, the objective is to provide a means to get science-ready data with minimal computing time or human interaction.

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

Eckert, Kathleen D.; Kannappan, Sheila J.; Stark, David V.; Moffett, Amanda J.; Norris, Mark A.; Snyder, Elaine M.; Hoversten, Erik A.

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: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

[ascl:1910.002]
PreProFit: Pressure Profile Fitter for galaxy clusters in Python

PreProFit fits the pressure profile of galaxy clusters using Markov chain Monte Carlo (MCMC). The software can analyze data from different sources and offers flexible parametrization for the pressure profile. PreProFit accounts for Abel integral, beam smearing, and transfer function filtering when fitting data and returns χ2, model parameters and uncertainties in addition to marginal and joint probability contours, diagnostic plots, and surface brightness radial profiles. The code can be used for analytic approximations for the beam and transfer functions for feasibility studies.

[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: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: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:2006.002]
PRIISM: Python module for Radio Interferometry Imaging with Sparse Modeling

PRIISM images radio interferometry data using the sparse modeling technique. In addition to generating an image, PRIISM can choose the best image from a range of processing parameters using cross validation. User can obtain statistically optimal images by providing the visibility data with some configuration parameters. The software is implemented as a Python module.

[ascl:2006.010]
PRISim: Precision Radio Interferometer Simulator

PRISim is a modular radio interferometer array simulator, including the radio sky and instrumental effects, and generates a transit dataset in HD5 format.

[ascl:1907.021]
PRISM: Probabilistic Regression Instrument for Simulating Models

PRISM analyzes scientific models using the Bayes linear approach, the emulation technique, and history matching to construct an approximation ('emulator') of any given model. The software facilitates and enhances existing MCMC methods by restricting plausible regions and exploring parameter space efficiently and can be used as a standalone alternative to MCMC for model analysis, providing insight into the behavior of complex scientific models. PRISM stores results in HDF5-files and can be executed in serial or MPI on any number of processes. It accepts any type of model and comparison data and can reduce relevant parameter space by factors over 100,000 using only a few thousand model evaluations.

[ascl:1601.020]
ProC: Process Coordinator

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

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

[ascl: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: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: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: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: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: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: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: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: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: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: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:2002.007]
ProSpect: Spectral generation package

ProSpect generates good quality SEDs that can be used to estimate the broad band photometric properties of galaxies that have known star formation and gas metallicity histories. It allows for complex star formation and metallicity histories to be specified, and can be used in a generative or fitting (Bayesian) mode. ProSpect provides a high level interface to the BC03 (low and high resolution) and EMILES libraries, as well as the Dale 2014 dust emission templates. Its source code is available for download, and it is also available as an interactive web tool.

[ascl:1905.025]
Prospector: Stellar population inference from spectra and SEDs

Prospector conducts principled inference of stellar population properties from photometric and/or spectroscopic data. The code combine photometric and spectroscopic data rigorously using a flexible spectroscopic calibration model and infer high-dimensional stellar population properties using parameteric SFHs (with ensemble MCMC sampling). Prospector also constrains the linear combination of stellar population components that are present in a galaxy (e.g. non-parametric SFHs) using spectra and/or photometry, and fits individual stellar spectra using large interpolated grids.

[ascl:2001.006]
Protostellar Evolution: Stellar evolution simulator

Protostellar Evolution simulates the evolution of stellar stellar radius and luminosity from the bound core stage through to the core hydrogen ignition as a zero-age main-sequence (ZAMS) star and beyond. Written in Fortran 90, the code is implemented as a module of the FLASH astrophysical fluid dynamics code (ascl:1010.082).

[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:1208.005]
PSM: Planck Sky Model

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

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

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

[ascl: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: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: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: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: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: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: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:2007.007]
PSRVoid: Statistical suite for folded pulsar data

PSRVoid performs RFI excision, flux calibration and timing of folded pulsar data. RFI excision is administered via both traditional and multi-layered deep learning neural network algorithms. The software offers full neural network control (over training set creation and manipulation and network parameters). PSRVoid also contains useful data miners for the ATNF, a multitude of plotting tools, as well as many useful pulsar processing macros such as space velocity simulators and Tempo2 (ascl:1210.015) wrappers.

[ascl:1912.017]
PTMCMCSampler: Parallel tempering MCMC sampler package written in Python

PTMCMCSampler performs MCMC sampling using advanced techniques. The code implements a variety of proposal schemes, including adaptive Metropolis, differential evolution, and parallel tempering, which can be used together in the same run.

[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: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: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: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: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: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: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: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: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:2006.012]
pxf_kin_err: Radial velocity and velocity dispersion uncertainties estimator

pxf_kin_err estimates the radial velocity and velocity dispersion uncertainties based solely on the shape of a template spectrum used in the fitting procedure and signal-to-noise information. This method can be used for exposure time calculators, in the design of observational programs and estimates on expected uncertainties for spectral surveys of galaxies and star clusters, and as an accurate substitute for Monte-Carlo simulations when running them for large samples of thousands of spectra is unfeasible.

[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: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: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:1906.010]
PyA: Python astronomy-related packages

Czesla, Stefan; Schröter, Sebastian; Schneider, Christian P.; Huber, Klaus F.; Pfeifer, Fabian; Andreasen, Daniel T.; Zechmeister, Mathias

The PyA (PyAstronomy) suite of astronomy-related packages includes a convenient fitting package that provides support for minimization and MCMC sampling, a set of astrophysical models (*e.g.*, transit light-curve modeling), and algorithms for timing analysis such as the Lomb-Scargle and the Generalized Lomb-Scargle periodograms.

[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: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: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: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:1204.002]
pyBLoCXS: Bayesian Low-Count X-ray Spectral analysis

Siemiginowska, Aneta; Kashyap, Vinay; Refsdal, Brian; van Dyk, David; Connors, Alanna; Park, Taeyoung

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

[submitted]
pycf3 - Cosmicflows-3 Distance-Velocity Calculator client for Python

The project is a simple Python client for Cosmicflows-3 Distance-Velocity Calculator at distances less than 400 Mpc (http://edd.ifa.hawaii.edu/CF3calculator/)

Compute expectation distances or velocities based on smoothed velocity field from the Wiener filter model of https://ui.adsabs.harvard.edu/abs/2019MNRAS.488.5438G/abstract.

[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: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: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: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:2004.007]
PyCosmo: Multi-purpose cosmology calculation tool

Tarsitano, Federica; Schmitt, Uwe; Refregier, Alexandre; Akeret, Joel; Amara, Adam; Gamper, Lukas; Nicola, Andrina

PyCosmo provides accurate predictions for cosmological observables including background quantities, power spectra and Limber and beyond-Limber angular power spectra. The software is designed to be interactive and user-friendly. It is available for download and is also offered on an interactive platform (PyCosmo Hub), which allows users to perform their own computations using Jupyter Notebooks without installing any software.

[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: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.

[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: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.

[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 XEphem astronomy application (ascl:1112.013), whose author, Elwood Downey, generously gave permission for us to use them as the basis for PyEphem.

[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: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:1207.009]
PyFITS: Python FITS Module

Barrett, Paul; Hsu, J. C.; Hanley, Chris; Taylor, James; Droettboom, Michael; Bray, Erik M.; Hack, Warren; Greenfield, Perry; Wyckoff, Eric; Jedrzejewski, Robert; De La Pena, Michele; Hodge, Phil

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

[submitted]
PyFOSC: a pipeline toolbox for BFOSC/YFOSC long-slit spectroscopy data reduction

PyFOSC is a pipeline toolbox for long-slit spectroscopy data reduction written in Python. It can be used for FOSC (Faint Object Spectrograph and Camera) data from Xinglong/Lijiang 2-meter telescopes in China. This pipeline privodes a neat way for data pre-processing, including updating missing header fileds for BFOSC data, reducing fits file extension for YFOSC data, etc. And it makes the data reduction procedure efficient by using previously identified lamp spectra as re-identification references during wavelength calibration, and applying multiprocessing in some modules. PyFOSC also enables customization for any other long-slit spectroscopy data.

[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: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: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: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: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:1907.004]
pyGTC: Parameter covariance plots

pyGTC creates giant triangle confusogram (GTC) plots. Triangle plots display the results of a Monte-Carlo Markov Chain (MCMC) sampling or similar analysis. The recovered parameter constraints are displayed on a grid in which the diagonal shows the one-dimensional posteriors (and, optionally, priors) and the lower-left triangle shows the pairwise projections. Such plots are useful for seeing the parameter covariances along with the priors when fitting a model to data.

[ascl:2007.020]
pygwinc: Gravitational Wave Interferometer Noise Calculator

pygwinc processes and plots noise budgets for ground-based gravitational wave detectors. Its primary feature is a collection of mostly analytic noise calculation functions for various sources of noise affecting detectors, including quantum and seismic noise, mirror coating and substrate thermal noise, suspension fiber thermal noise, and residual gas noise. It is also a generalized noise budgeting tool that allows users to create arbitrary noise budgets for any experiment, not just ground-based GW detectors, using measured or analytically calculated data.

[ascl:2002.011]
PyHammer: Python spectral typing suite

Kesseli, Aurora; West, Andrew; Veyette, Mark; Harrison, Brandon; Feldman, Dan; Morgan, Dylan; Theissen, Chris; Robinson, Connor

PyHammer performs rapid and automatic spectral classification of stars according to the Morgan-Keenan classification system; it is a Python revision of the IDL code The Hammer (ascl:1405.003) and offers additional capabilities. Working in the range of 3,650-10,200 Angstroms, the automatic spectral typing algorithm compares important spectral lines to template spectra and determines the best matching spectral type, ranging from O to L type stars. The code can also determine a star's metallicity ([Fe/H]) and radial velocity shifts. Once the automatic classification algorithm has run, PyHammer provides the user an interface for determining spectral types visually by comparing their spectra to provided templates.

[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:2004.014]
PyKat: Python interface and tools for Finesse

Brown, Daniel D.; Jones, Philip; Rowlinson, Samuel; Freise, Andreas; Leavey, Sean; Green, Anna C.; Toyra, Daniel

The Python wrapper PyKat extends the optical interferometer modeling software Finesse (ascl:2004.013). It provides an efficient GUI for conducting complex numerical simulations and manipulating and viewing simulation setups, and enables the use of Python's extensive scientific software ecosystem.

[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:1506.001]
pyKLIP: PSF Subtraction for Exoplanets and Disks

Wang, Jason J.; Ruffio, Jean-Baptise; De Rosa, Robert J.; Aguilar, Jonathan; Wolff, Schuyler G.; Pueyo, Laurent

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: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: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: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: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, *a _{n}*, the

[ascl:1906.022]
pyLIMA: Microlensing modeling package

pyLIMA (python Lightcurve Identification and Microlensing Analysis) fits microlensing lightcurves and derives the physical quantities of lens systems. The package provides microlensing modeling, and the magnification estimation for high cadence lightcurves has been optimized. pyLIMA is designed to make microlensing modeling and event simulation widely available to the community.

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

[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:1505.025]
pyMCZ: Oxygen abundances calculations and uncertainties from strong-line flux measurements

Bianco, Federica B.; Modjaz, Maryam; Oh, Seung Man; Fierroz, David; Liu, Yuqian; Kewley, Lisa; Graur, Or

pyMCZ calculates metallicity according to a number of strong line metallicity diagnostics from spectroscopy line measurements and obtains 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: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: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: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: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: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: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:1906.009]
PyMORESANE: Python MOdel REconstruction by Synthesis-ANalysis Estimators

PyMORESANE is a Python and pyCUDA-accelerated implementation of the MORESANE deconvolution algorithm, a sparse deconvolution algorithm for radio interferometric imaging. It can restore diffuse astronomical sources which are faint in brightness, complex in morphology and possibly buried in the dirty beam’s side lobes of bright radio sources in the field.

[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: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: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: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: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: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: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: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: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: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:1905.027]
PyPDR: Python Photo Dissociation Regions

PyPDR calculates the chemistry, thermal balance and molecular excitation of a slab of gas under FUV irradiation in a self-consistent way. The effect of FUV irradiation on the chemistry is that molecules get photodissociated and the gas is heated up to several 1000 K, mostly by the photoelectric effect on small dust grains or UV pumping of H2 followed by collision de-excitation. The gas is cooled by molecular and atomic lines, thus indirectly the chemical composition also affects the thermal structure through the abundance of molecules and atoms. To find a self-consistent solution between heating and cooling, the code iteratively calculates the chemistry, thermal-balance and molecular/atomic excitation.

[ascl:1911.004]
PypeIt: Python spectroscopic data reduction pipeline

Prochaska, J. Xavier; Hennawi, Joseph; Cooke, Ryan; Westfall, Kyle; Wang, Feige; Farina, Emanuele Paolo; Hsyu, Tiffany; Wasserman, Asher; Villaume, Alexa; Young, David; Simha, Sunil; Wilde, Matt; Tejos, Nicolas; Isbell, Jacob; Betts, Edward; Holden, Brad

PypeIt reduces data from echelle and low-resolution spectrometers; the code can be run in several modes of reduction that demark the level of sophistication (e.g. quick and dirty vs. MonteCarlo) and also the amount of output written to disk. It also generates numerous data products, including 1D and 2D spectra; calibration images, fits, and meta files; and quality assurance figures.

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

Boucaud, Alexandre; Bocchio, Marco; Abergel, Alain; Orieux, François; Dole, Hervé; Amine Hadj-Youcef, Mohamed

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:1612.005]
PyProfit: Wrapper for libprofit

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

[ascl:1706.011]
PyPulse: PSRFITS handler

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

[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: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:1908.009]
PyRADS: Python RADiation model for planetary atmosphereS

The 1D radiation code PyRADS provides line-by-line spectral resolution. For Earth-like atmospheres, PyRADS currently uses HITRAN 2016 line lists and the MTCKD continuum model. A version for shortwave radiation (scattering) is also available.

[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: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: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.

[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:1207.010]
PySALT: SALT science pipeline

Crawford, S. M.; Still, M.; Schellart, P.; Balona, L.; Buckley, D. A. H.; Gulbis, A. A. S.; Kniazev, A.; Kotze, M.; Loaring, N.; Nordsieck, K. H.; Pickering, T. E.; Potter, S.; Romero Colmenero, E.; Vaisanen, P.; Wiliams, T.; Zietsman, E.

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:2008.005]
PySAP: Python Sparse data Analysis Package

Farrens, S.; Grigis, A.; El Gueddari, L.; Ramzi, Z.; Chaithya G. R.; Starck, S.; Sarthou, B.; Cherkaoui, H.; Ciuciu, P.; Starck, J.-L.

PySAP (Python Sparse data Analysis Package) provides a common API for astronomical and neuroimaging datasets and access to iSAP's (ascl:1303.029) Sparse2D executables with both wrappers and bindings. It also offers a graphical user interface for exploring the provided functions and access to application specific plugins.

[ascl:1908.024]
PYSAT: Python Satellite Data Analysis Toolkit

The Python Satellite Data Analysis Toolkit (pysat) provides a simple and flexible interface for downloading, loading, cleaning, managing, processing, and analyzing space science data. The toolkit supports in situ satellite observations and many different types of ground- and space-based measurements. Its analysis routines are independent of instrument and data source.

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

Spreeuw, Hanno; Swinbank, John; Molenaar, Gijs; Staley, Tim; Rol, Evert; Sanders, John; Scheers, Bart; Kuiack, Mark

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: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:2003.012]
PYSOLATOR: Remove orbital modulation from a binary pulsar and/or its companion

PYSOLATOR removes the orbital modulation from a binary pulsar and/or its companion. In essence, it subtracts the predicted Roemer delay for the given orbit and then resamples the time series so as to make the signal appear as if it were emitted from the barycenter of the binary system, making the search for pulses easier and faster.

[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: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: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:2009.014]
pySpectrum: Power spectrum and bispectrum calculator

pySpectrum calculates the power spectrum and bispectrum for galaxies, halos, and dark matter.

[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: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: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: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: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: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: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:1907.003]
pyuvdata: Pythonic interface to interferometric data sets

pyuvdata defines a pythonic interface to interferometric data sets; it supports the development of and interchange of data between calibration and foreground subtraction pipelines. It can read and write MIRIAD (ascl:1106.007), uvfits, and uvh5 files and reads CASA (ascl:1107.013) measurement sets and FHD (Fast Holographic Deconvolution) visibility save files. Particular focus has been paid to supporting drift and phased array modes.

[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:2004.005]
PyWD2015: Wilson-Devinney code GUI

PyWD2015 provides a modern graphical user interface (GUI) for the 2015 version of the Wilson-Devinney (WD) code (ascl:2004.004). The GUI is written in Python 2.7 and uses the Qt4 interface framework. At its core, PyWD2015 generates lcin and dcin files from user inputs and sends them to WD, then reads and visualizes the output in a user-friendly way. It also includes tools that make the technical aspects of the modeling process significantly easier.

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

Would you like to view a random code?