Results 2551-2600 of 3643 (3551 ASCL, 92 submitted)
The pyhrs package reduces data from the High Resolution Spectrograph (HRS) on the Southern African Large Telescope (SALT). HRS is a dual-beam, fiber fed echelle spectrectrograph with four modes of operation: low (R~16000), medium (R~34000), high (R~65000), and high stability (R~65000). pyhrs, written in Python, includes all of the steps necessary to reduce HRS low, medium, and high resolution data; this includes basic CCD reductions, order identification, wavelength calibration, and extraction of the spectra.
pyia provides tools for working with Gaia data. It accesses Gaia data columns as Quantity objects, i.e., with units (e.g., data.parallax will have units ‘milliarcsecond’) , constructs covariance matrices for Gaia data, and generates random samples from the Gaia error distribution per source. pyia can also create SkyCoord objects from Gaia data and execute simple (small) remote queries via the Gaia science archive and automatically fetch the results.
pyICs creates initial condition (IC) files for N-body simulations of the formation of isolated galaxies. It uses the pynbody analysis package (ascl:1305.002) to create the actual IC files. pyICs generates dark matter halos (DM) in dynamical equilibrium which host a rotating gas sphere. The DM particle velocities are drawn from the equilibrium distribution function and the gas sphere has an angular momentum profile. The DM and the gas share the same 3D radial density profile. The code natively supports the αβγ-models: ρ ~ (r/a)-γ[1+(r/a)α](γ-β)/α. If γ <= 3, the profiles are smoothly truncated outside the virial radius. The radial profile can be arbitrary as long as python functions for the profile itself and its first and second derivative with radius are given.
pyilc implements the needlet internal linear combination (NILC) algorithm for CMB component separation in pure Python; it also implements harmonic-space ILC. The code can also perform Cross-ILC, where the covariance matrices are computed only from independent splits of the maps. In addition, pyilc includes an inpainting code, diffusive_inpaint, that diffusively inpaints a masked region with the mean of the unmasked neighboring pixels.
PyIMRPhenomD estimates the population of stellar origin black hole binaries for LISA observations using a Bayesian parameter estimation algorithm. The code reimplements IMRPhenomD (ascl:2307.019) in a pure Python code, compiled with the Numba just-in-time compiler. The module implements the analytic first and second derivatives necessary to compute t(f) and t'(f) rather than computing them numerically. Using the analytic derivatives increases the code complexity but produces faster and more numerically accurate results; the improvement in numerical accuracy is particularly significant for t'(f).
The Python wrapper PyKat extends the optical interferometer modeling software Finesse (ascl:2004.013). It provides an efficient GUI for conducting complex numerical simulations and manipulating and viewing simulation setups, and enables the use of Python's extensive scientific software ecosystem.
PyKE is a python-based PyRAF package that can also be run as a stand-alone program within a unix-based shell without compiling against PyRAF. It is a group of tasks developed for the reduction and analysis of Kepler Simple Aperture Photometry (SAP) data of individual targets with individual characteristics. The main purposes of these tasks are to i) re-extract light curves from manually-chosen pixel apertures and ii) cotrend and/or detrend the data in order to reduce or remove systematic noise structure using methods tunable to user and target-specific requirements. PyKE is an open source project and contributions of new tasks or enhanced functionality of existing tasks by the community are welcome.
pyKLIP subtracts out the stellar PSF to search for directly-imaged exoplanets and disks using a Python implementation of the Karhunen-Loève Image Projection (KLIP) algorithm. pyKLIP supports ADI, SDI, and ADI+SDI to model the stellar PSF and offers a large array of PSF subtraction parameters to optimize the reduction. pyKLIP relies on a minimal amount of dependencies (numpy, scipy, and astropy) and parallelizes the KLIP algorithm to speed up the reduction. pyKLIP supports GPI and P1640 data and can interface with other data sources with the addition of new modules. It also can inject simulated planets and disks as well as automatically search for point sources in PSF-subtracted data.
pyLCSIM simulates X-ray lightcurves from coherent signals and power spectrum models. Coherent signals can be specified as a sum of one or more sinusoids, each with its frequency, pulsed fraction and phase shift; or as a series of harmonics of a fundamental frequency (each with its pulsed fraction and phase shift). Power spectra can be simulated from a model of the power spectrum density (PSD) using as a template one or more of the built-in library functions. The user can also define his/her custom models. Models are additive.
PyLDTk automates the calculation of custom stellar limb darkening (LD) profiles and model-specific limb darkening coefficients (LDC) using the library of PHOENIX-generated specific intensity spectra by Husser et al. (2013). It facilitates exoplanet transit light curve modeling, especially transmission spectroscopy where the modeling is carried out for custom narrow passbands. PyLDTk construct model-specific priors on the limb darkening coefficients prior to the transit light curve modeling. It can also be directly integrated into the log posterior computation of any pre-existing transit modeling code with minimal modifications to constrain the LD model parameter space directly by the LD profile, allowing for the marginalization over the whole parameter space that can explain the profile without the need to approximate this constraint by a prior distribution. This is useful when using a high-order limb darkening model where the coefficients are often correlated, and the priors estimated from the tabulated values usually fail to include these correlations.
Pylians facilitates the analysis of numerical simulations (both N-body and hydro). This set of libraries, written in python, cython and C, compute power spectra, bispectra, and correlation functions, identifies voids, and populates halos with galaxies using an HOD. Pylians can also apply HI+H2 corrections to the output of hydrodynamic simulations, makes 21cm maps, computes DLAs column density distribution functions, and plots density fields. A Python 3 version of this code, Pylians3 (ascl:2403.012) is available.
Pylians3 (Python3 libraries for the analysis of numerical simulations) provides a Python 3 version of Pylians (ascl:1811.008), which analyzes numerical simulations (both N-body and hydrodynamic); parts of the codebase are also written in cython and C. It computes density fields, power spectra, bispectra, and correlation functions, identifies voids, and populates halos with galaxies using an HOD. Pylians3 also applies HI+H2 corrections to the output of hydrodynamic simulations, make 21cm maps, computes DLAs column density distribution functions, and can plot density fields and make movies.
pylightcurve is a model for light-curves of transiting planets. It uses the four coefficients law for the stellar limb darkening and returns the relative flux, F(t), as a function of the limb darkening coefficients, an, the Rp/R* ratio and all the orbital parameters based on the nonlinear limb darkening model (Claret 2000).
pyLIMA (python Lightcurve Identification and Microlensing Analysis) fits microlensing lightcurves and derives the physical quantities of lens systems. The package provides microlensing modeling, and the magnification estimation for high cadence lightcurves has been optimized. pyLIMA is designed to make microlensing modeling and event simulation widely available to the community.
PyMC is a python module that implements Bayesian statistical models and fitting algorithms, including Markov chain Monte Carlo. Its flexibility and extensibility make it applicable to a large suite of problems. Along with core sampling functionality, PyMC includes methods for summarizing output, plotting, goodness-of-fit and convergence diagnostics.
PyMC3 performs Bayesian statistical modeling and model fitting focused on advanced Markov chain Monte Carlo and variational fitting algorithms. It offers powerful sampling algorithms, such as the No U-Turn Sampler, allowing complex models with thousands of parameters with little specialized knowledge of fitting algorithms, intuitive model specification syntax, and optimization for finding the maximum a posteriori (MAP) point. PyMC3 uses Theano to compute gradients via automatic differentiation as well as compile probabilistic programs on-the-fly to C for increased speed.
PyMCCF (Python Modernized Cross Correlation Function), also known as MCCF, cross correlates two light curves that are unevenly sampled using linear interpolation and measures the peak and centroid of the cross-correlation function. Based on PyCCF (ascl:1805.032) and ICCF, it introduces a new parameter, MAX, to reduce the number of interpolated points used to just those which are not farther from the nearest real one than the MAX. This significantly reduces noise from interpolation errors. The estimation of the errors in PyMCCF is exactly the same as in PyCCF.
pymccorrelation calculates correlation coefficients for data, using bootstrapping and/or perturbation to estimate the uncertainties on the correlation coefficient and p-value. The code supports Pearson's r, Spearman's rho, and Kendall's tau. Calculations of Kendall's tau additionally support censored data. This code supercedes and expands the deprecated code pymcspearman (ascl:2309.009).
pymcfost provides an interface to and can be used to visualize results from the 3D radiative transfer code MCFOST (ascl:2207.023). pymcfost can set up continuum and line models, read a single model or library of models, plot basic quantities such as density structures and temperature maps, and plot observables, including SEDs, polarization maps, visibilities, and channels maps (with spatial and spectral convolution). It can also convert units (e.g. W.m-2 to Jy or brightness temperature), and it provides an interface to the ALMA CASA simulator (ascl:1107.013).
pymcspearman is a python implementation of MCSpearman (ascl:1504.008) and calculates Spearman's rank correlation coefficient for data, using bootstrapping and/or perturbation to estimate the uncertainties on the correlation coefficient. This software project has migrated (and expanded) to pymccorrelation (ascl:2309.010).
pyMCZ calculates metallicity according to a number of strong line metallicity diagnostics from spectroscopy line measurements and obtains uncertainties from the line flux errors in a Monte Carlo framework. Given line flux measurements and their uncertainties, pyMCZ produces synthetic distributions for the oxygen abundance in up to 13 metallicity scales simultaneously, as well as for E(B-V), and estimates their median values and their 68% confidence regions. The code can output the full MC distributions and their kernel density estimates.
PyMerger detects binary black hole mergers from the Einstein Telescope based on a Deep Residual Neural Network (ResNet) model; the model was trained on combined data from all three proposed sub-detectors of ET (TSDCD). The model achieved high BBH detection rates. Though not trained on BNS and BHNS mergers, PyMerger successfully detected 11,477 BNS and 323 BHNS mergers in ET-MDC, indicating its potential for broader applicability.
PyMF performs spatial filtering (matched filter, matched multifilter, constrained matched filter and constrained matched mutifilter) image processing that provides optimal reduction of the contamination introduced by sources that can be approximated by templates. These techniques use the flat-sky approximation.
PyMGC3 is a Python toolkit to apply the Modified Great Circle Cell Counts (mGC3) method to search for tidal streams in the Galactic Halo. The code computes pole count maps using the full mGC3/nGC3/GC3 family of methods. The original GC3 method (Johnston et al., 1996) uses positional information to search for 'great-circle-cell structures'; mGC3 makes use of full 6D data and nGC3 uses positional and proper motion data.
PyMidas is an interface between Python and MIDAS, the major ESO legacy general purpose data processing system. PyMidas allows a user to exploit both the rich legacy of MIDAS software and the power of Python scripting in a unified interactive environment. PyMidas also allows the usage of other Python-based astronomical analysis systems such as PyRAF.
PyMieDAP (Python Mie Doubling Adding Program) makes light scattering computations with Mie scattering and radiative transfer computations with full orders of scattering and taking into account the polarization of the light scattered. Full planet modeling at any phase angle is possible. With the included subpackage exopy, it is also possible to simulate systems with a star, a planet and a possible moon.
PyMOC manipulates Multi-Order Coverage (MOC) maps. It supports reading and writing the three encodings mentioned in the IVOA MOC recommendation: FITS, JSON and ASCII.
PyModelFit provides a pythonic, object-oriented framework that simplifies the task of designing numerical models to fit data. This is a very broad task, and hence the current functionality of PyModelFit focuses on the simpler tasks of 1D curve-fitting, including a GUI interface to simplify interactive work (using Enthought Traits). For more complicated modeling, PyModelFit also provides a wide range of classes and a framework to support more general model/data types (2D to Scalar, 3D to Scalar, 3D to 3D, and so on).
PyMORESANE is a Python and pyCUDA-accelerated implementation of the MORESANE deconvolution algorithm, a sparse deconvolution algorithm for radio interferometric imaging. It can restore diffuse astronomical sources which are faint in brightness, complex in morphology and possibly buried in the dirty beam’s side lobes of bright radio sources in the field.
PyMSES provides a python solution for getting data out of RAMSES (ascl:1011.007) astrophysical fluid dynamics simulations. It permits transparent manipulation of large simulations and interfaces with common Python libraries and existing code, and can serve as a post-processing toolbox for data analysis. It also does three-dimensional volume rendering with a specific algorithm optimized to work on RAMSES distributed data (Guillet et al. 2011 and Jones et a. 2011).
PyMsOfa accesses the International Astronomical Union’s SOFA library (ascl:1403.026) from Python. It offers a wrapper package based on a foreign function library for Python (ctypes), a wrapper with the foreign function interface for Python calling C code (cffi), and a package directly written in pure Python codes from SOFA subroutines. PyMsOfa is suitable for the astrometric detection of habitable planets of the Closeby Habitable Exoplanet Survey (CHES) mission and for the frontier themes of black holes and dark matter related to astrometric calculations and other fields.
PyMultiNest provides programmatic access to MultiNest (ascl:1109.006) and PyCuba, integration existing Python code (numpy, scipy), and enables writing Prior & LogLikelihood functions in Python. PyMultiNest can plot and visualize MultiNest's progress and allows easy plotting, visualization and summarization of MultiNest results. The plotting can be run on existing MultiNest output, and when not using PyMultiNest for running MultiNest.
PyMUSE analyzes VLT/MUSE datacubes. The package is optimized to extract 1-D spectra of arbitrary spatial regions within the cube and also for producing images using photometric filters and customized masks. It is intended to provide the user the tools required for a complete analysis of a MUSE data set.
PyMVPA eases statistical learning analyses of large datasets. It offers an extensible framework with a high-level interface to a broad range of algorithms for classification, regression, feature selection, data import and export. It is designed to integrate well with related software packages, such as scikit-learn, shogun, and MDP.
PyNAPLE (PYthon Nac Automated Pair Lunar Evaluator) detects changes and new impact craters on the lunar surface using Lunar Reconnaissance Orbiter Narrow Angle Camera (LRO NAC) images. The code enables large scale analyses of sub-kilometer scale cratering rates and refinement of both scaling laws and the luminous efficiency.
Pynbody is a lightweight, portable, format-transparent analysis package for astrophysical N-body and smooth particle hydrodynamic simulations supporting PKDGRAV/Gasoline, Gadget, N-Chilada, and RAMSES AMR outputs. Written in python, the core tools are accompanied by a library of publication-level analysis routines.
PyNeb (previously PyNebular) is an update and expansion of the IRAF package NEBULAR; rewritten in Python, it is designed to be more user-friendly and powerful, increasing the speed, easiness of use, and graphic visualization of emission lines analysis. In PyNeb, the atom is represented as an n-level atom. For given density and temperature, PyNeb solves the equilibrium equations and determines the level populations. PyNeb can compute physical conditions from suitable diagnostic line ratios and level populations, critical densities and line emissivities, and can compute and display emissivity grids as a function of Te and Ne. It can also deredden line intensities, read and manage observational data, and plot and compare atomic data from different publications, and compute ionic abundances from line intensities and physical conditions and elemental abundances from ionic abundances and icfs.
Pynkowski computes Minkowski Functionals and other higher order statistics of input fields, as well as their expected values for different kinds of fields. This package supports Minkowski functionals, and maxima and minima distributions. Supported input formats include scalar HEALPix maps such as those used by healpy (ascl:2008.022) and polarization HEALPix maps in the SO(3) formalism. Pynkowski also supports various theoretical fields, including Gaussian (e.g., CMB Temperature or the initial density field), Chi squared (e.g., CMB polarization intensity), and spin 2 maps in the SO(3) formalism.
PynPoint processes and analyzes high-contrast imaging data of exoplanets and circumstellar disks. The generic, end-to-end pipeline's modular architecture separates the core functionalities and the pipeline modules. These modules have specific tasks such as background subtraction, frame selection, centering, PSF subtraction with principal component analysis, estimation of detection limits, and photometric and astrometric analysis. All modules store their results in a central database. Management of the available hardware by the backend of the pipeline is in particular an advantage for data sets containing thousands of images, as is common in the mid-infrared wavelength regime. This version of PynPoint is a significant rewrite of the earlier PynPoint package (ascl:1501.001).
PynPoint uses principal component analysis to detect and estimate the flux of exoplanets in two-dimensional imaging data. It processes many, typically several thousands, of frames to remove the light from the star so as to reveal the companion planet.
The code has been significantly rewritten and expanded; please see ascl:1812.010.
pynucastro interfaces to the nuclear reaction rate databases, including the JINA Reaclib nuclear reactions database. This set of Python interfaces enables interactive exploration of rates and collection of rates (networks) in Jupyter notebooks and easy creation of the righthand side routines for reaction network integration (the ODEs) for use in simulation codes.
pyobs enables remote and fully autonomous observation control of astronomical telescopes. It provides an abstraction layer over existing drivers and a means of communication between different devices (called modules in pyobs). The code can also act as a hardware driver for all the devices used at an observatory. In addition, pyobs offers non-hardware-related modules for automating focusing, acquisition, guiding, and other routine tasks.
PyORBIT handles several kinds of datasets, such as radial velocity (RV), activity indexes, and photometry, to simultaneously characterize the orbital parameters of exoplanets and the noise induced by the activity of the host star. RV computation is performed using either non-interacting Kepler orbits or n-body integration. Stellar activity can be modeled either with sinusoids at the rotational period and its harmonics or Gaussian process. In addition, the code can model offsets and systematics in measurements from several instruments. The PyORBIT code is modular; new methods for stellar activity modeling or parameter estimation can easily be incorporated into the code.
PyOSE is a fully numerical orbital sampling effect (OSE) simulator that can model arbitrary inclinations of the transiting moon orbit. It can be used to search for exomoons in long-term stellar light curves such as those by Kepler and the upcoming PLATO mission.
PyPDR calculates the chemistry, thermal balance and molecular excitation of a slab of gas under FUV irradiation in a self-consistent way. The effect of FUV irradiation on the chemistry is that molecules get photodissociated and the gas is heated up to several 1000 K, mostly by the photoelectric effect on small dust grains or UV pumping of H2 followed by collision de-excitation. The gas is cooled by molecular and atomic lines, thus indirectly the chemical composition also affects the thermal structure through the abundance of molecules and atoms. To find a self-consistent solution between heating and cooling, the code iteratively calculates the chemistry, thermal-balance and molecular/atomic excitation.
We present a module built into the PypeIt Python package to reduce high resolution Y, J, H, K, and L band spectra from the W. M. Keck Observatory NIRSPEC spectrograph. This data reduction pipeline is capable of spectral extraction, wavelength calibration, and telluric correction of data taken before and after the 2018 detector upgrade, all in a single package. The procedure for reducing data is thoroughly documented in an expansive tutorial.
PypeIt reduces data from echelle and low-resolution spectrometers; the code can be run in several modes of reduction that demark the level of sophistication (e.g. quick and dirty vs. MonteCarlo) and also the amount of output written to disk. It also generates numerous data products, including 1D and 2D spectra; calibration images, fits, and meta files; and quality assurance figures.
pyPETAL produces cross-correlation functions, discrete correlation functions, and mean time lags from multi-band AGN time-series data, combining multiple different codes (including pyCCF (ascl:1805.032), pyZDCF, PyROA (ascl:2107.012), and JAVELIN (ascl:1010.007)) used for active galactic nuclei (AGN) reverberation mapping (RM) analysis into a unified pipeline. This pipeline also implements outlier rejection using Damped Random Walk Gaussian process fitting, and detrending through the LinMix algorithm. pyPETAL implements a weighting scheme for all lag-producing modules, mitigating aliasing in peaks of time lag distributions between light curves. pyPETAL scales to any combination of internal code modules, supporting a variety of computational workflows.
PyPHER (Python-based PSF Homogenization kERnels) computes an homogenization kernel between two PSFs; the code is well-suited for PSF matching applications in both an astronomical or microscopy context. It can warp (rotation + resampling) the PSF images (if necessary), filter images in Fourier space using a regularized Wiener filter, and produce a homogenization kernel. PyPHER requires the pixel scale information to be present in the FITS files, which can if necessary be added by using the provided ADDPIXSCL method.
PyPion reads in Silo (ascl:2103.025) data files from PION (ascl:2103.024) simulations and plots the data. This library works for 1D, 2D, and 3D data files and for any amount of nested-grid levels. The scripts contained in PyPion save the options entered into the command line when the python script is run, open the silo file and save all of the important header variables, open the directory in the silo (or vtk, or fits) file and save the requested variable data (eg. density, temp, etc.), and set up the plotting function and the figure.
Would you like to view a random code?