ASCL.net

Astrophysics Source Code Library

Making codes discoverable since 1999

Browsing Codes

Results 1501-1600 of 2313 (2278 ASCL, 35 submitted)

Order
Title Date
 
Mode
Abstract Compact
Per Page
50100250All
[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 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

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

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

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

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

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

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

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

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

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

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

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

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.

Would you like to view a random code?