Results 1701-1800 of 2544 (2498 ASCL, 46 submitted)

[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:2101.006]
ptemcee: A parallel-tempered version of emcee

ptemcee, pronounced "tem-cee", is fork of Daniel Foreman-Mackey's emcee (ascl:1303.002) to implement parallel tempering more robustly. As far as possible, it is designed as a drop-in replacement for emcee. It is helpful for characterizing awkward, multi-modal probability distributions.

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

[submitted]
Py-PDM: A Python wrapper of the Phase Dispersion Minimization (PDM)

Phase Dispersion Minimization (PDM) is a periodical signal detection method, and it is originally implemented by Stellingwerf with C (https://www.stellingwerf.com/rfs-bin/index.cgi?action=PageView&id=34). With the help of Cython, Py-PDM is much faster than other Python implementations.

[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:2102.028]
PyAutoFit: Classy probabilistic programming

PyAutoFit supports advanced statistical methods such as massively parallel non-linear search grid-searches, chaining together model-fits and sensitivity mapping. It is a Python-based probabilistic programming language which composes and fits models using a range of Bayesian inference libraries, such as emcee (ascl:1303.002) and dynesty (ascl:1809.013). It performs model composition and customization, outputting results, model-specific visualization and posterior analysis. Built for big-data analysis, results are output as a database which can be loaded after model-fitting is complete.

[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:2104.023]
PyBird: Python code for biased tracers in redshift space

PyBird evaluates the multipoles of the power spectrum of biased tracers in redshift space. In general, PyBird can evaluate the power spectrum of matter or biased tracers in real or redshift space. The code uses FFTLog (ascl:1512.017) to evaluate the one-loop power spectrum and the IR resummation. PyBird is designed for a fast evaluation of the power spectra, and can be easily inserted in a data analysis pipeline. It is a standalone tool whose input is the linear matter power spectrum which can be obtained from any Boltzmann code, such as CAMB (ascl:1102.026) or CLASS (ascl:1106.020). The Pybird output can be used in a likelihood code which can be part of the routine of a standard MCMC sampler. The design is modular and concise, such that parts of the code can be easily adapted to other case uses (e.g., power spectrum at two loops or bispectrum). PyBird can evaluate the power spectrum either given one set of EFT parameters, or independently of the EFT parameters. If the former option is faster, the latter is useful for subsampling or partial marginalization over the EFT parameters, or to Taylor expand around a fiducial cosmology for efficient parameter exploration.

[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:2106.003]
PyDoppler: Wrapper for Doppler tomography software

PyDoppler is a python-based wrapper for the Spruit Doppler tomography software dopmap (ascl:2106.002). PyDoppler is designed to study time-resolved spectroscopic datasets of accreting compact binaries. This code can produce a trail spectra of a dataset and create Doppler tomography maps. It is intended to be a light-weight code for single emission line datasets.

[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:2103.008]
Pyedra: Python implementation for asteroid phase curve fitting

Pyedra performs asteroid phase curve fitting. From a simple table containing the asteroid MPC number, phase angle and reduced magnitude, Pyedra estimates the parameters of the phase function using the least squares method. The user can choose from three different models for the phase curve fit: H-G model, H-G1-G2 model and the Shevchenko model. The output in all cases is a table containing the adjusted parameters and their corresponding errors. This package allows carrying out phase function analysis for a few asteroids as well as to process large volumes of data such as those released by current large surveys.

[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:2102.027]
PyFstat: Continuous gravitational-wave data analysis

PyFstat performs F-statistic-based continuous gravitational wave (CW) searches and other CW data analysis tasks. It is built on top of the LALSuite library (ascl:2012.021), making that library's functionality more accessible through a Python interface; it also provides MCMC-based followup of promising candidates from wide-parameter-space searches.

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

Would you like to view a random code?