Results 2201-2250 of 3450 (3361 ASCL, 89 submitted)

[ascl:1806.014]
pile-up: Monte Carlo simulations of star-disk torques on hot Jupiters

The pile-up gnuplot script generates a Monte Carlo simulation with a selectable number of randomized drawings (1000 by default, ~1min on a modern laptop). For each realization, the script calculates the torque acting on a hot Jupiter around a young, solar-type star as a function of the star-planet distance. The total torque on the planet is composed of the disk torque in the type II migration regime (that is, the planet is assumed to have opened up a gap in the disk) and of the stellar tidal torque. The model has four free parameters, which are drawn from a normal or lognormal distribution: (1) the disk's gas surface density at 1 astronomical unit, (2) the magnitude of tidal dissipation within the star, (3) the disk's alpha viscosity parameter, and (4) and the mean molecular weight of the gas in the disk midplane. For each realization, the total torque is screened for a distance at which it becomes zero. If present, then this distance would represent a tidal migration barrier to the planet. In other words, the planet would stop migrating. This location is added to a histogram on top of the main torque-over-distance panel and the realization is counted as one case that contributes to the overall survival rate of hot Jupiters. Finally, the script generates an output file (PDF by default) and prints the hot Jupiter survival rate for the assumed parameterization of the star-planet-disk system.

[ascl:1407.012]
PINGSoft2: Integral Field Spectroscopy Software

PINGSoft2 visualizes, manipulates and analyzes integral field spectroscopy (IFS) data based on either 3D cubes or Raw Stacked Spectra (RSS) format. Any IFS data can be adapted to work with PINGSoft2, regardless of the original data format and the size/shape of the spaxel. Written in IDL, PINGSoft2 is optimized for fast visualization rendering; it also includes various routines useful for generic astronomy and spectroscopy tasks.

[ascl:2209.008]
PINION: Accelerating radiative transfer simulations for cosmic reionization

PINION (Physics-Informed neural Network for reIONization) predicts the complete 4-D hydrogen fraction evolution from the smoothed gas and mass density fields from pre-computed N-body simulations. Trained on C^{2}-Ray simulation outputs with a physics constraint on the reionization chemistry equation, PINION accurately predicts the entire reionization history between z = 6 and 12 with only five redshift snapshots and a propagation mask as a simplistic approximation of the ionizing photon mean free path. The network's predictions are in good agreement with simulation to redshift z > 7, though the oversimplified propagation mask degrades the network's accuracy for z < 7.

[ascl:1910.001]
PINK: Parallelized rotation and flipping INvariant Kohonen maps

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

[ascl:1305.007]
PINOCCHIO: PINpointing Orbit-Crossing Collapsed HIerarchical Objects

PINOCCHIO generates catalogues of cosmological dark matter halos with known mass, position, velocity and merger history. It is able to reproduce, with very good accuracy, the hierarchical formation of dark matter halos from a realization of an initial (linear) density perturbation field, given on a 3D grid. Its setup is similar to that of a conventional N-body simulation, but it is based on the powerful Lagrangian Perturbation Theory. It runs in just a small fraction of the computing time taken by an equivalent N-body simulation, producing promptly the merging histories of all halos in the catalog.

[ascl:1902.007]
PINT: High-precision pulsar timing analysis package

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

PINT (PINT Is Not Tempo3) analyzes high-precision pulsar timing data, enabling interactive data analysis and providing an extensible and flexible development platform for timing applications. PINT utilizes well-debugged public Python packages and modern software development practices (e.g., the NumPy and Astropy libraries, version control and development with git and GitHub, and various types of testing) for increased development efficiency and enhanced stability. PINT has been developed and implemented completely independently from traditional pulsar timing software such as TEMPO (ascl:1509.002) and Tempo2 (ascl:1210.015) and is a robust tool for cross-checking timing analyses and simulating data.

[ascl:1007.001]
PINTofALE: Package for Interactive Analysis of Line Emission

PINTofALE was originally developed to analyze spectroscopic data from optically-thin coronal plasmas, though much of the software is sufficiently general to be of use in a much wider range of astrophysical data analyses. It is based on a modular set of IDL tools that interact with an atomic database and with observational data. The tools are designed to allow easy identification of spectral features, measure line fluxes, and carry out detailed modeling. The basic philosophy of the package is to provide access to the innards of atomic line databases, and to have flexible tools to interactively compare with the observed data. It is motivated by the large amount of book-keeping, computation and iterative interaction that is required between the researcher and observational and theoretical data in order to derive astrophysical results. The tools link together transparently and automatically the processes of spectral "browsing", feature identification, measurement, and computation and derivation of results. Unlike standard modeling and fitting engines currently in use, PINTofALE opens up the "black box" of atomic data required for UV/X-ray analyses and allows the user full control over the data that are used in any given analysis.

[ascl:2103.024]
PION: Computational fluid-dynamics package for astrophysics

PION (PhotoIonization of Nebulae) is a grid-based fluid dynamics code for hydrodynamics and magnetohydrodynamics, including a ray-tracing module for calculating the attenuation of radiation from point sources of ionizing photons. It also has a module for coupling fluid dynamics and the radiation field to microphysical processes such as heating/cooling and ionization/recombination. PION models the evolution of HII regions, photoionized bubbles that form around hot stars, and has been extended to include stellar wind sources so that both wind bubbles and photoionized bubbles can be simulated at the same time. It is versatile enough to be extended to other applications.

[submitted]
PIPE: Extracting PSF photometry from CHEOPS data

PIPE (PSF Imagette Photometric Extraction) extracts PSF (point-spread function) photometry from data acquired by the space telescope CHEOPS (CHaracterisation of ExOPlanetS). Advantages of PSF photometry over standard aperture photometry include reduced sensitivity to contaminants such as background stars, cosmic ray hits, and hot/bad pixels. For CHEOPS, an additional advantage is that photometry can be extracted from an imagette, a small window around the target that is downlinked at a shorter cadence than the larger-sized subarray used for aperture photometry. These advantages make PIPE particularly well suited for targets brighter or fainter than the nominal G = 7-11 mag range of CHEOPS, i.e. where short-cadence imagettes are available (bright end) or when contamination becomes a problem (faint end). Within the nominal range, PIPE usually offers no advantage over the standard aperture photometry.

[ascl:2306.021]
pipes_vis: Interactive GUI and visualizer tool for SPS spectra

pipes_vis is an interactive graphical user interface for visualizing SPS spectra. Powered by Bagpipes (ascl:2104.017), it provides real-time manipulation of a model galaxy's star formation history, dust, and other relevant properties through sliders and text boxes.

[ascl:1611.015]
Pippi: Parse and plot MCMC chains

Pippi (parse it, plot it) operates on MCMC chains and related lists of samples from a function or distribution, and can merge, parse, and plot sample ensembles ('chains') either in terms of the likelihood/fitness function directly, or as implied posterior probability densities. Pippi is compatible with ASCII text and hdf5 chains, operates out of core, and can post-process chains on the fly.

[ascl:2311.011]
PIPPIN: Polarimetric Differential Imaging (PDI) pipeline for NACO data

PIPPIN (PDI pipeline for NACO data) reduces the polarimetric observations made with the VLT/NACO instrument. It applies the Polarimetric Differential Imaging (PDI) technique to distinguish the polarized, scattered light from the (largely) un-polarized, stellar light. As a result, circumstellar dust can be uncovered. PIPPIN appropriately handles various instrument configurations, including half-wave plate and de-rotator usage, Wollaston beam-splitter, and wiregrid observations. As part of the PDI reduction, PIPPIN performs various levels of corrections for instrumental polarization and crosstalk.

[ascl:2108.019]
PIPS: Period detection and Identification Pipeline Suite

Murakami, Yukei S.; Jennings, Connor; Hoffman, Andrew M.; Sunseri, James; Baer-Way, Raphael; Stahl, Benjamin E.; Savel, Arjun B.; Altunin, Ivan; Girish, Nachiket; Filippenko, Alexei V.

PIPS analyzes the lightcurves of astronomical objects whose brightness changes periodically. Originally developed to determine the periods of RR Lyrae variable stars, the code offers many features designed for variable star analysis and can obtain period values for almost any type of lightcurve with both speed and accuracy. PIPS determines periods through several different methods, analyzes the morphology of lightcurves via Fourier analysis, estimates the statistical significance of the detected signal, and determines stellar properties based on pre-existing stellar models.

[ascl:1405.012]
PISA: Position Intensity and Shape Analysis

PISA (Position, Intensity and Shape Analysis) routines deal with the location and parameterization of objects on an image frame. The core of this package is the routine PISAFIND which performs image analysis on a 2-dimensional data frame. The program searches the data array for objects that have a minimum number of connected pixels above a given threshold and extracts the image parameters (position, intensity, shape) for each object. The image parameters can be determined using thresholding techniques or an analytical stellar profile can be used to fit the objects. In crowded regions deblending of overlapping sources can be performed. PISA is distributed as part of the Starlink software collection (ascl:1110.012).

[ascl:2110.007]
PISCOLA: Python for Intelligent Supernova-COsmology Light-curve Analysis

PISCOLA (Python for Intelligent Supernova-COsmology Light-curve Analysis) fits supernova light curves and corrects them in a few lines of code. It uses Gaussian Processes to estimate rest-frame light curves of transients without needing an underlying light-curve template. The user can add filters, calculates the light-curves parameters, and obtain transmission functions for the observed filters and the Bessell filters. The correction process can be applied with default settings to obtain restframe light curves and light-curve parameters. PISCOLA can plot the SN light curves, filter transmission functions, light-curves fits results, the mangling function for a given phase, and includes several utilities that can, for example, convert fluxes to magnitudes and magnitudes to fluxes, and trim leading and trailing zeros from a 1-D array or sequence.

[ascl:2010.014]
Pix2Prof: Deep learning for textraction of useful sequential information from galaxy imagery

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

[ascl:2207.033]
piXedfit: Analyze spatially resolved SEDs of galaxies

piXedfit provides a self-contained set of tools for analyzing spatially resolved properties of galaxies using imaging data or a combination of imaging data and the integral field spectroscopy (IFS) data. piXedfit has six modules that can handle all tasks in the analysis of the spatially resolved SEDs of galaxies, including images processing, a spatial-matching between reduced broad-band images with an IFS data cube, pixel binning, performing SED fitting, and making visualization plots for the SED fitting results.

[ascl:1102.007]
PixeLens: A Portable Modeler of Lensed Quasars

We introduce and implement two novel ideas for modeling lensed quasars. The first is to require different lenses to agree about H_{0}. This means that some models for one lens can be ruled out by data on a different lens. We explain using two worked examples. One example models 1115+080 and 1608+656 (time-delay quadruple systems) and 1933+503 (a prospective time-delay system) all together, yielding time-delay predictions for the third lens and a 90% confidence estimate of H_{0}^{-1}=14.6+9.4-1.7 Gyr (H_{0}=67+9-26 km s^{-1} Mpc^{-1}) assuming ΩM=0.3 and Ω_{Λ}=0.7. The other example models the time-delay doubles 1520+530, 1600+434, 1830-211, and 2149-275, which gives H_{0}^{-1}=14.5+3.3-1.5 Gyr (H_{0}=67+8-13 km s^{-1} Mpc^{-1}). Our second idea is to write the modeling software as a highly interactive Java applet, which can be used both for coarse-grained results inside a browser and for fine-grained results on a workstation. Several obstacles come up in trying to implement a numerically intensive method thus, but we overcome them.

[ascl:2102.003]
Pixell: Rectangular pixel map manipulation and harmonic analysis library

Pixell loads, manipulates, and analyzes maps stored in rectangular pixelization. It is mainly targeted for use with maps of the sky (e.g., CMB intensity and polarization maps, stacks of 21 cm intensity maps, binned galaxy positions or shear) in cylindrical projection, but its core functionality is more general. It extends numpy's ndarray to an ndmap class that associates a World Coordinate System (WCS) with a numpy array. It includes tools for Fourier transforms (through numpy or pyfft) and spherical harmonic transforms (through libsharp2 (ascl:1402.033)) of such maps and tools for visualization (through the Python Image Library).

[ascl:2210.012]
pixmappy: Python interface to gbdes astrometry solutions

pixmappy provides a Python interface to gbdes pixel map (astrometry) solutions. It reads the YAML format astrometry solutions produced by gbdes (ascl:2210.011) and issues a PixelMap instance, which is a map from one 2d coordinate system ("pixel") to another ("world") 2d system. A PixelMap instance can be used as a function mapping one (or many) coordinate pairs. An inverse method does reverse mapping, and the local jacobian of the map is available also. The type of mapping that can be expressed is very flexible, and PixelMaps can be compounded into chains of tranformations.

[ascl:1305.005]
PkdGRAV2: Parallel fast-multipole cosmological code

PkdGRAV2 is a high performance N-body treecode for self-gravitating astrophysical simulations. It is designed to run efficiently in serial and on a wide variety of parallel computers including both shared memory and message passing architectures. It can spatially adapt to large ranges in particle densities, and temporally adapt to large ranges in dynamical timescales. The code uses a non-standard data structure for efficiently calculating the gravitational forces, a variant on the k-D tree, and a novel method for treating periodic boundary conditions.

[ascl:1609.016]
PKDGRAV3: Parallel gravity code

Pkdgrav3 is an 𝒪(*N*) gravity calculation method; it uses a binary tree algorithm with fifth order fast multipole expansion of the gravitational potential, using cell-cell interactions. Periodic boundaries conditions require very little data movement and allow a high degree of parallelism; the code includes GPU acceleration for all force calculations, leading to a significant speed-up with respect to previous versions (ascl:1305.005). Pkdgrav3 also has a sophisticated time-stepping criterion based on an estimation of the local dynamical time.

[ascl:2307.055]
plan-net: Bayesian neural networks for exoplanetary atmospheric retrieval

Cobb, Adam D.; Himes, Michael D.; Soboczenski, Frank; Zorzan, Simone; O'Beirne, Molly D.; Güneş Baydin, Atılım; Gal, Yarin; Domagal-Goldman, Shawn D.; Arney, Giada N.; Angerhausen, Daniel

plan-net uses machine learning with an ensemble of Bayesian neural networks for atmospheric retrieval; this approach yields greater accuracy and more robust uncertainties than a single model. A new loss function for BNNs learns correlations between the model outputs. Performance is improved by incorporating domain-specific knowledge into the machine learning models and provides additional insight by inferring the covariance of the retrieved atmospheric parameters.

[ascl:1911.001]
PLAN: A Clump-finder for Planetesimal Formation Simulations

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

[ascl:1505.032]
Planck Level-S: Planck Simulation Package

The Planck simulation package takes a cosmological model specified by the user and calculates a potential CMB sky consistent with this model, including astrophysical foregrounds, and then performs a simulated observation of this sky. This Simulation embraces many instrumental effects such as beam convolution and noise. Alternatively, the package can simulate the observation of a provided sky model, generated by another program such as the Planck Sky Model software. The Planck simulation package does not only provide Planck-like data, it can also be easily adopted to mimic the properties of other existing and upcoming CMB experiments.

[ascl:2010.009]
plancklens: Planck 2018 lensing pipeline

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

[ascl:1607.005]
Planetary3br: Three massive body resonance calculator

Given two planets P1 and P2 with arbitrary orbits, planetary3br calculates all possible semimajor axes that a third planet P0 can have in order for the system to be in a three body resonance; these are identified by the combination k0*P0 + k1*P1 + k2*P2. P1 and P2 are assumed to be not in an exact two-body resonance. The program also calculates three "strengths" of the resonance, one for each planet, which are only indicators of the dynamical relevance of the resonance on each planet. Sample input data are available along with the Fortran77 source code.

[ascl:1311.004]
PlanetPack: Radial-velocity time-series analysis tool

PlanetPack facilitates and standardizes the advanced analysis of radial velocity (RV) data for the goal of exoplanets detection, characterization, and basic dynamical N-body simulations. PlanetPack is a command-line interpreter that can run either in an interactive mode or in a batch mode of automatic script interpretation.

[ascl:1911.007]
planetplanet: General photodynamical code for exoplanet light curves

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

[ascl:2309.020]
PlanetSlicer: Orange-slice algorithm for fitting brightness maps to phase curves

PlanetSlicer fits brightness maps to phase curves using the "orange-slice" method and works both for self-luminous objects and those that diffuse reflected light assuming Lambertian reflectance. In both cases, the model supposes that a spherical object can be divided into slices of constant brightness (or albedo) which may be integrated to yield the total flux observed, given the angles of observation. The package contains two key functions: toPhaseCurve and fromPhaseCurve; the former integrates the brightness for each slice to calculate the observed total flux from the object, given the longitude of observation. The latter does the opposite, estimating the brightness of the slices from a set of observed total flux (the phase curve).

[ascl:2107.019]
PlaSim: Planet Simulator

Lunkeit, Frank; Blessing, Simon; Friedrich, Klaus; Jansen, Heiko; Kirk, Edilbert; Luksch, Ute; Sielmann, Frank

PlaSim is a climate model of intermediate complexity for Earth, Mars and other planets. It is written for a university environment, to be used to train the next GCM (general circulation model) developers, to support scientists in understanding climate processes, and to do fundamental research. In addition to an atmospheric GCM of medium complexity, PlaSim includes other compartments of the climate system such as, for example, an ocean with sea ice and a land surface with a biosphere. These other compartments are reduced to linear systems. In other words, PlaSim consists of a GCM with a linear ocean/sea-ice module formulated in terms of a mixed layer energy balance. The soil/biosphere module is introduced analoguously. Thus, working with PlaSim is like testing the performance of an atmospheric or oceanic GCM interacting with various linear processes, which parameterize the variability of the subsystems in terms of their energy (and mass) balances.

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

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

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

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

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

PLATO Simulator is an end-to-end simulation software tool designed for the performance of realistic simulations of the expected observations of the PLATO mission but easily adaptable to similar types of missions. It models and simulates photometric time-series of CCD images by including models of the CCD and its electronics, the telescope optics, the stellar field, the jitter movements of the spacecraft, and all important natural noise sources.

[ascl:1903.014]
PLATON: PLanetary Atmospheric Transmission for Observer Noobs

PLATON (PLanetary Atmospheric Transmission for Observer Noobs) calculates transmission spectra for exoplanets and retrieves atmospheric characteristics based on observed spectra; it is based on ExoTransmit (ascl:1611.005). PLATON supports the most common atmospheric parameters, such as temperature, metallicity, C/O ratio, cloud-top pressure, and scattering slope. It also has less commonly included features, such as a Mie scattering cloud model and unocculted starspot corrections.

[ascl:1907.009]
Plonk: Smoothed particle hydrodynamics data analysis and visualization

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

[ascl:1106.003]
PLplot: Cross-platform Software Package for Scientific Plots

Irwin, Alan W.; Ross, Andrew; Furnish, Geoffrey; Babcock, Hazen; Tomé, António; Markus, Arjen; Roach, Andrew; Carty, Hezekiah M.; Hunt, Doug; Dishaw, James; Bauck, Jerry; LeBrun, Maurice; Rosenberg, Phil; Smekal, Werner

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:2211.008]
pmclib: Population Monte Carlo library

Benabed, Karim; Cappé, Olivier; Cardoso, Jean-François; Fort, Gersende; Kilbinger, Martin; Prunet, Simon; Robert, Christian P.; Wraith, Darren

The Population Monte-Carlo (PMC) sampling code pmclib performs fast end efficient parallel iterative importance sampling to compute integrals over the posterior including the Bayesian evidence.

[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:2107.003]
PMN-body: Particle Mesh N-body code

PMN-body computes the non-linear evolution of the cosmological matter density contrast. It is based on the Particle Mesh (PM) technique. Written in C, the code is parallelized for shared-memory machines using Open Multi-Processing (OpenMP).

[ascl:2205.001]
PMOIRED: Parametric Modeling of Optical Interferometric Data

PMOIRED models astronomical spectro-interferometric data stored in the OIFITS format. Parametric modeling is used to describe the observed scene as blocks such as disks, rings and Gaussians which can be combined and their parameters linked. It includes plotting, least-square fitting and bootstrapping estimation of uncertainties. For spectroscopic instruments (such as GRAVITY), tools are provided to model spectral lines and correct spectra for telluric lines.

[ascl:1010.065]
PN: Higher Post Newtonian Gravity Calculations

Motivated by experimental probes of general relativity, we adopt methods from perturbative (quantum) field theory to compute, up to certain integrals, the effective lagrangian for its n-body problem. Perturbation theory is performed about a background Minkowski spacetime to O[(v/c)^4] beyond Newtonian gravity, where v is the typical speed of these n particles in their center of energy frame. For the specific case of the 2 body problem, the major efforts underway to measure gravitational waves produced by in-spiraling compact astrophysical binaries require their gravitational interactions to be computed beyond the currently known O[(v/c)^7]. We argue that such higher order post-Newtonian calculations must be automated for these field theoretic methods to be applied successfully to achieve this goal. In view of this, we outline an algorithm that would in principle generate the relevant Feynman diagrams to an arbitrary order in v/c and take steps to develop the necessary software. The Feynman diagrams contributing to the n-body effective action at O[(v/c)^6] beyond Newton are derived.

[ascl:2307.009]
pnautilus: Three-phase chemical code

The three-phase pnautilus chemical code finds the abundance of each species by solving rate equations for gas-phase and grain surface chemistries. It performs gas–grain simulations in which both the icy mantle and the surface are considered active, taking into account mantle photodissociation, diffusion, and reactions; the code also considers the competition among reaction, diffusion and evaporation.

[ascl:1302.004]
pNbody: A python parallelized N-body reduction toolbox

pNbody is a parallelized python module toolbox designed to manipulate and interactively display very large N-body systems. It allows the user to perform complicated manipulations with only very few commands and to load an N-body system and explore it interactively using the python interpreter. pNbody may also be used in python scripts. pNbody contains graphical facilities for creating maps of physical values of the system, such as density, temperature, and velocities maps. Stereo capabilities are also implemented. pNbody is not limited by file format; the user may use a parameter file to redefine how to read a preferred format.

[ascl:2011.025]
PNICER: Extinction estimator

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

[ascl:2207.018]
pocoMC: Preconditioned Monte Carlo method for accelerated Bayesian inference

pocoMC performs Bayesian inference, including model comparison, for challenging scientific problems. The code utilizes a normalizing flow to precondition the target distribution by removing any correlations between its parameters. pocoMC then generates posterior samples, used for parameter estimation, with a powerful adaptive Sequential Monte Carlo algorithm manifesting a sampling efficiency that can be orders of magnitude higher than without precondition. Furthermore, pocoMC also provides an unbiased estimate of the model evidence that can be used for the task of Bayesian model comparison. The code is designed to excel in demanding parameter estimation problems that include multimodal and highly non–Gaussian target distributions.

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

Previous1234567891011121314151617181920212223242526272829303132333435363738394041424344**45**464748495051525354555657585960616263646566676869Next

Would you like to view a random code?