ASCL.net

Astrophysics Source Code Library

Making codes discoverable since 1999

Browsing Codes

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

[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:2210.001] PSS: Pulsar Survey Scraper

Pulsar Survey Scraper aggregates pulsar discoveries before they are included in the ATNF pulsar catalog and enables searching and filtering based on position and dispersion measure. This facilitates identifying new pulsar discoveries. Pulsar Survey Scraper can be downloaded or run online using the Pulsar Survey Scraper webform.

[ascl:2111.003] PSwarm: Global optimization solver for bound and linear constrained problems

PSwarm is a global optimization solver for bound and linear constrained problems (for which the derivatives of the objective function are unavailable, inaccurate or expensive). The algorithm combines pattern search and particle swarm. Basically, it applies a directional direct search in the poll step (coordinate search in the pure simple bounds case) and particle swarm in the search step. PSwarm makes no use of derivative information of the objective function. It has been shown to be efficient and robust for smooth and nonsmooth problems, both in serial and in parallel.

[ascl:2110.021] PT-REX: Point-to-point TRend EXtractor

PT-REX (Point-to-point TRend EXtractor) performs ptp analysis on every kind of extended radio source. The code exploits a set of different fitting methods to allow study of the spatial correlation, and is structured in a series of tasks to handle the individual steps of a ptp analysis independently, from defining a grid to sample the radio emission to accurately analyzing the data using several statistical methods. A major feature of PT-REX is the use of an automatic, randomly-generated sampling routine to combine several SMptp analysis into a Monte Carlo ptp (MCptp) analysis. By repeating several cycles of SMptp analysis with randomly-generated grids, PT-REX produces a distribution of values of k that describe its parameter space, thus allowing a reliably estimate of the trend (and its uncertainties).

[ascl:2211.001] PTAfast: PTA correlations from stochastic gravitational wave background

PTAfast calculates the overlap reduction function in Pulsar Timing Array produced by the stochastic gravitational wave background for arbitrary polarizations, propagation velocities, and pulsar distances.

[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:2303.019] pulsar_spectra: Pulsar flux density measurements, spectral models fitting, and catalog

pulsar_spectra provides a pulsar flux density catalog and automated spectral fitting software for finding spectral models. The package can also produce publication-quality plots and allows users to add new spectral measurements to the catalog. The spectral fitting software uses robust statistical methods to determine the best-fitting model for individual pulsar spectra.

[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:2312.012] PulsarX: Pulsar searching

The folding pipeline PulsarX searches for pulsars. The code includes radio frequency interference mitigation, de-dispersion, folding, and parameter optimization, and supports both psrfits and filterbank data formats. The toolset has two implementations of the folding pipelines; one uses a brute-force de-dispersion algorithm, and the other an algorithm that becomes more efficient than the brute-force de-dispersion algorithm as the number of candidates increases. PulsarX is appropriate for large-scale pulsar surveys.

[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:2301.027] Puri-Psi: Radio interferometric imaging

Puri-Psi addresses radio interferometric imaging problems using state-of-the-art optimization algorithms and deep learning. It performs scalable monochromatic, wide-band, and polarized imaging. It also provide joint calibration and imaging, and scalable uncertainty quantification. A scalable framework for wide-field monochromatic intensity imaging is also available, which encompasses a pure optimization algorithm, as well as an AI-based method in the form of a plug-and-play algorithm propelled by Deep Neural Network denoisers.

[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) (ascl:1307.020) 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

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:2405.004] pyADfit: Nested sampling approach to quasi-stellar object (QSO) accretion disc fitting

pyADfit models accretion discs around astrophysical objects. The code provides functions to calculate physical quantities related to accretion disks and perform parameter estimation using observational data. The accretion disc model is the alpha-disc model while the parameter estimation can be performed with Nessai (ascl:2405.002), Raynest (ascl:2405.003), or CPnest (ascl:2205.021).

[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

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:2306.057] pybranch: Calculate experimental branching fractions and transition probabilities from atomic spectra

pybranch calculates experimental branching fractions and transition probabilities from measurements of atomic spectra. Though the program is usually used with spectral line lists from intensity-calibrated spectra from Fourier transform spectrometers, it can in principle be used with any calibrated spectra that meet the input requirements. pybranch takes a set of linelists, computes a weighted average branching fraction (Fki) for each line, combines these branching fractions with the level lifetime to obtain the transition probability, and then prints the calibrated intensities and S/N ratios for all the lines observed from a particular upper level in each spectrum. One line can be chosen to use as a reference to put all of the intensities on the same scale. pybranch can use calculated transition probabilities to calculate a residual from lines that have not been observed.

[ascl:2312.025] pyC2Ray: Python interface to C2Ray with GPU acceleration

pyC2Ray updates C2-Ray (ascl:2312.022), an astrophysical radiative transfer code used to simulate the Epoch of Reionization (EoR). pyC2Ray includes a new raytracing method, ASORA, developed for GPUs, and provides a Python interface for customizable use of the code. The core features of C2-Ray, written in Fortran90, are wrapped using f2py as a Python extension module, while the raytracing library ASORA is implemented in C++ using CUDA. Both are native Python C-extensions and can be directly accessed from any Python script.

[ascl:2107.017] PyCactus: Post-processing tools for Cactus computational toolkit simulation data

PyCactus contains tools for postprocessing data from numerical simulations performed with the Einstein Toolkit, based on the Cactus computational toolkit. The main package is PostCactus, which provides a high-level Python interface to the various data formats in a simulation folder. Further, the package SimRep allows the automatic creation of html reports for a simulation, and the SimVideo package allows the creation of movies visualizing simulation data.

[ascl:2206.021] PyCASSO2: Stellar population and emission line fits in integral field spectra

PyCASSO runs the STARLIGHT code (ascl:1108.006) in integral field spectra (IFS). Cubes from various instruments are supported, including PMAS/PPAK (CALIFA), MaNGA, GMOS and MUSE. Emission lines can be measured using DOBBY, which is included in the package. The package also includes tools for IFS cubes analysis and plotting.

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

[ascl:2112.001] pycelp: Python package for Coronal Emission Line Polarization

pyCELP (aka "pi-KELP") calculates Coronal Emission Line Polarization. It forward synthesizes the polarized emission of ionized atoms formed in the solar corona and calculates the atomic density matrix elements for a single ion under coronal equilibrium conditions and excited by a prescribed radiation field and thermal collisions. pyCELP solves a set of statistical equilibrium equations in the spherical statistical tensor representation for a multi-level atom for the no-coherence case. This approximation is useful in the case of forbidden line emission by visible and infrared lines, such as Fe XIII 1074.7 nm and Si X 3934 nm.

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

[submitted] Pyckles

A super lightweight interface in Python to load spectra from the Pickles 1998 (stellar) and Brown 2014 (galactic) spectral catalogues

[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:2303.007] PyCom: Interstellar communication

PyCom provides function calls for deriving the optimal communication scheme to maximize the data rate between a remote probe and home-base. It includes models for the loss of photons from diffraction, technological limitations, interstellar extinction and atmospheric transmission, and manages major atmospheric, zodiacal, stellar and instrumental noise sources. It also includes scripts for creating figures appearing in the referenced paper.

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

Would you like to view a random code?