Libpsht (or "library for Performing Spherical Harmonic Transforms") is a collection of algorithms for efficient conversion between spatial-domain and spectral-domain representations of data defined on the sphere. The package supports transforms of scalars as well as spin-1 and spin-2 quantities, and can be used for a wide range of pixelisations (including HEALPix, GLESP and ECP). It will take advantage of hardware features like multiple processor cores and floating-point vector operations, if available. Even without this additional acceleration, the employed algorithms are among the most efficient (in terms of CPU time as well as memory consumption) currently being used in the astronomical community.
The library is written in strictly standard-conforming C90, ensuring portability to many different hard- and software platforms, and allowing straightforward integration with codes written in various programming languages like C, C++, Fortran, Python etc.
Libpsht is distributed under the terms of the GNU General Public License (GPL) version 2.
Development on this project has ended; its successor is libsharp (ascl:1402.033).
This code, which requires HEALPix 2.x (ascl:1107.018), allows you to generate power spectrum estimators from WMAP 5-year maps and generate hybrid cross- and auto- power spectrum and covariance from general foreground-cleaned maps. In addition, it allows you to simulate combined maps or combinations of maps for individual detectors and do MPI spherical transforms of arrays of maps, calculate coupling matrices etc. The code includes all of LensPix (ascl:1102.025), the MPI framework used for doing spherical transforms (based on HealPix).
MasQU extracts polarization information in the CMB by reducing contamination from so-called "ambiguous modes" on a masked sky, which contain leakage from the larger E-mode signal and utilizing derivative operators on the real-space Stokes Q and U parameters. In particular, the package can perform finite differences on masked, irregular grids and is applied to a semi-regular spherical pixellization, the HEALPix grid. The formalism reduces to the known finite-difference solutions in the case of a regular grid. On a masked sphere, the software represents a considerable reduction in B-mode noise from limited sky coverage.
Modelling of the weak lensing of the CMB will be crucial to obtain correct cosmological parameter constraints from forthcoming precision CMB anisotropy observations. The lensing affects the power spectrum as well as inducing non-Gaussianities. We discuss the simulation of full sky CMB maps in the weak lensing approximation and describe a fast numerical code. The series expansion in the deflection angle cannot be used to simulate accurate CMB maps, so a pixel remapping must be used. For parameter estimation accounting for the change in the power spectrum but assuming Gaussianity is sufficient to obtain accurate results up to Planck sensitivity using current tools. A fuller analysis may be required to obtain accurate error estimates and for more sensitive observations. We demonstrate a simple full sky simulation and subsequent parameter estimation at Planck-like sensitivity.
HEALPix is an acronym for Hierarchical Equal Area isoLatitude Pixelization of a sphere. As suggested in the name, this pixelization produces a subdivision of a spherical surface in which each pixel covers the same surface area as every other pixel. Another property of the HEALPix grid is that the pixel centers occur on a discrete number of rings of constant latitude, the number of constant-latitude rings is dependent on the resolution of the HEALPix grid.
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.
Many problems in astronomy and astrophysics require a computation of the spherical harmonic transforms. This is in particular the case whenever data to be analyzed are distributed over the sphere or a set of corresponding mock data sets has to be generated. In many of those contexts, rapidly improving resolutions of both the data and simulations puts increasingly bigger emphasis on our ability to calculate the transforms quickly and reliably.
The scalable spherical harmonic transform library S2HAT consists of a set of flexible, massively parallel, and scalable routines for calculating diverse (scalar, spin-weighted, etc) spherical harmonic transforms for a class of isolatitude sky grids or pixelizations. The library routines implement the standard algorithm with the complexity of O(n^3/2), where n is a number of pixels/grid points on the sphere, however, owing to their efficient parallelization and advanced numerical implementation, they achieve very competitive performance and near perfect scalability. S2HAT is written in Fortran 90 with a C interface. This software is a derivative of the spherical harmonic transforms included in the HEALPix package and is based on both serial and MPI routines of its version 2.01, however, since version 2.5 this software is fully autonomous of HEALPix and can be compiled and run without the HEALPix library.
Univiewer is a visualisation program for HEALPix maps. It is written in C++ and uses OpenGL and the wxWidgets library for cross-platform portability. Using it you can:
- Rotate and zoom maps on the sphere in 3D
- Create high-resolution views of square patches of the map
- Change maximum and minimum values of the colourmap interactively
- Calculate the power spectrum of the full-sky map or a patch
- Display any column of a HEALPix map FITS file on the sphere
Since Univiewer uses OpenGL for 3D graphics, its performance is dependent your video card. It has been tested successfully on computers with as little as 8Mb video memory, but it is recommended to have at least 32Mb to get good performance.
In the 3D view, a HEALPix map is projected onto a ECP pixelation to create a texture which is wrapped around the sphere. In calculating the power spectrum, the spherical harmonic transforms are computed using the same ECP pixelation. This inevitably leads to some discrepancies at small scales due to repixelation effects, but they are reasonably small.
High precision cosmology requires analysis of large scale surveys in 3D spherical coordinates, i.e. Fourier-Bessel decomposition. Current methods are insufficient for future data-sets from wide-field cosmology surveys. 3DEX (3D EXpansions) is a public code for fast Fourier-Bessel decomposition of 3D all-sky surveys which takes advantage of HEALPix for the calculation of tangential modes. For surveys with millions of galaxies, computation time is reduced by a factor 4-12 depending on the desired scales and accuracy. The formulation is also suitable for pre-calculations and external storage of the spherical harmonics, which allows for further speed improvements. The 3DEX code can accommodate data with masked regions of missing data. It can be applied not only to cosmological data, but also to 3D data in spherical coordinates in other scientific fields.
Future cosmological surveys will provide 3D large scale structure maps with large sky coverage, for which a 3D Spherical Fourier-Bessel (SFB) analysis is natural. Wavelets are particularly well-suited to the analysis and denoising of cosmological data, but a spherical 3D isotropic wavelet transform does not currently exist to analyse spherical 3D data. We present a new fast Discrete Spherical Fourier-Bessel Transform (DSFBT) based on both a discrete Bessel Transform and the HEALPIX angular pixelisation scheme. We tested the 3D wavelet transform and as a toy-application, applied a denoising algorithm in wavelet space to the Virgo large box cosmological simulations and found we can successfully remove noise without much loss to the large scale structure. The new spherical 3D isotropic wavelet transform, called MRS3D, is ideally suited to analysing and denoising future 3D spherical cosmological surveys; it uses a novel discrete spherical Fourier-Bessel Transform. MRS3D is based on two packages, IDL and Healpix and can be used only if these two packages have been installed.
CMBview is a viewer for FITS files containing HEALPix sky maps. Sky maps are projected onto a 3d sphere which can be rotated and zoomed interactively with the mouse. Features include:
Mangle deals accurately and efficiently with complex angular masks, such as occur typically in galaxy surveys. Mangle performs the following tasks: converts masks between many handy formats (including HEALPix); rapidly finds the polygons containing a given point on the sphere; rapidly decomposes a set of polygons into disjoint parts; expands masks in spherical harmonics; generates random points with weights given by the mask; and implements computations for correlation function analysis. To mangle, a mask is an arbitrary union of arbitrarily weighted angular regions bounded by arbitrary numbers of edges. The restrictions on the mask are only (1) that each edge must be part of some circle on the sphere (but not necessarily a great circle), and (2) that the weight within each subregion of the mask must be constant. Mangle is complementary to and integrated with the HEALPix package (ascl:1107.018); mangle works with vector graphics whereas HEALPix works with pixels.
S2LET provides high performance routines for fast wavelet analysis of signals on the sphere. It uses the SSHT code (ascl:2207.034) built on the MW sampling theorem to perform exact spherical harmonic transforms on the sphere. The resulting wavelet transform implemented in S2LET is theoretically exact, i.e. a band-limited signal can be recovered from its wavelet coefficients exactly and the wavelet coefficients capture all the information. S2LET also supports the HEALPix sampling scheme, in which case the transforms are not theoretically exact but achieve good numerical accuracy. The core routines of S2LET are written in C and have interfaces in Matlab, IDL and Java. Real signals can be written to and read from FITS files and plotted as Mollweide projections.
This IDL library is designed to be used on astronomical images. Its main aim is to stack data to allow a statistical detection of faint signal, using a prior. For instance, you can stack 160um data using the positions of galaxies detected at 24um or 3.6um, or use WMAP sources to stack Planck data. It can estimate error bars using bootstrap, and it can perform photometry (aperture photometry, or PSF fitting, or other that you can plug). The IAS Stacking Library works with gnomonic projections (RA---TAN), and also with HEALPIX projection.
DisPerSE is open source software for the identification of persistent topological features such as peaks, voids, walls and in particular filamentary structures within noisy sampled distributions in 2D, 3D. Using DisPerSE, structure identification can be achieved through the computation of the discrete Morse-Smale complex. The software can deal directly with noisy datasets via the concept of persistence (a measure of the robustness of topological features). Although developed for the study of the properties of filamentary structures in the cosmic web of galaxy distribution over large scales in the Universe, the present version is quite versatile and should be useful for any application where a robust structure identification is required, such as for segmentation or for studying the topology of sampled functions (for example, computing persistent Betti numbers). Currently, it can be applied can work indifferently on many kinds of cell complex (such as structured and unstructured grids, 2D manifolds embedded within a 3D space, discrete point samples using delaunay tesselation, and Healpix tesselations of the sphere). The only constraint is that the distribution must be defined over a manifold, possibly with boundaries.
Aladin Lite is a lightweight version of the Aladin tool, running in the browser and geared towards simple visualization of a sky region. It allows visualization of image surveys (JPEG multi-resolution HEALPix all-sky surveys) and permits superimposing tabular (VOTable) and footprints (STC-S) data. Aladin Lite is powered by HTML5 canvas technology and is easily embeddable on any web page and can also be controlled through a Javacript API.
Libsharp is a collection of algorithms for efficient conversion between maps on the sphere and their spherical harmonic coefficients. It supports a wide range of pixelisations (including HEALPix, GLESP, and ECP). This library is a successor of libpsht (ascl:1010.020); it adds MPI support for distributed memory systems and SHTs of fields with arbitrary spin, and also supports new developments in CPU instruction sets like the Advanced Vector Extensions (AVX) or fused multiply-accumulate (FMA) instructions. libsharp is written in portable C99; it provides an interface accessible to other programming languages such as C++, Fortran, and Python.
PyGDSM (formely PyGSM) is a Python interface for the Global Sky Model (GSM, ascl:1011.010). The GSM is a model of diffuse galactic radio emission, constructed from a variety of all-sky surveys spanning the radio band (e.g. Haslam and WMAP). PyGDSM uses the GSM to generate all-sky maps in Healpix format of diffuse Galactic radio emission from 10 MHz to 94 GHz. The PyGDSM module provides visualization utilities, file output in FITS format, and the ability to generate observed skies for a given location and date. PyGDSM requires Healpy (ascl:2008.022), PyEphem (ascl:1112.014), and AstroPy (ascl:1304.002).
COMB supports the simulation on the sphere of compact objects embedded in a stochastic background process of specified power spectrum. Support is provided to add additional white noise and convolve with beam functions. Functionality to support functions defined on the sphere is provided by the S2 code (ascl:1606.008); HEALPix (ascl:1107.018) and CFITSIO (ascl:1010.001) are also required.
The Python module Cygrid grids (resamples) data to any collection of spherical target coordinates, although its typical application involves FITS maps or data cubes. The module supports the FITS world coordinate system (WCS) standard; its underlying algorithm is based on the convolution of the original samples with a 2D Gaussian kernel. A lookup table scheme allows parallelization of the code and is combined with the HEALPix tessellation of the sphere for fast neighbor searches. Cygrid's runtime scales between O(n) and O(nlog n), with n being the number of input samples.
The s2 package can represent any arbitrary function defined on the sphere. Both real space map and harmonic space spherical harmonic representations are supported. Basic sky representations have been extended to simulate full sky noise distributions and Gaussian cosmic microwave background realisations. Support for the representation and convolution of beams is also provided. The code requires HEALPix (ascl:1107.018) and CFITSIO (ascl:1010.001).
AIPY collects together tools for radio astronomical interferometry. In addition to pure-python phasing, calibration, imaging, and deconvolution code, this package includes interfaces to MIRIAD (ascl:1106.007) and HEALPix (ascl:1107.018), and math/fitting routines from SciPy.
Vizic is a Python visualization library that builds the connection between images and catalogs through an interactive map of the sky region. The software visualizes catalog data over a custom background canvas using the shape, size and orientation of each object in the catalog and displays interactive and customizable objects in the map. Property values such as redshift and magnitude can be used to filter or apply colormaps, and objects can be selected for further analysis through standard Python functions from inside a Jupyter notebook.
Vizic allows custom overlays to be appended dynamically on top of the sky map; included are Voronoi, Delaunay, Minimum Spanning Tree and HEALPix layers, which are helpful for visualizing large-scale structure. Overlays can be generated, added or removed dynamically with one line of code. Catalog data is kept in a non-relational database. The Jupyter Notebook allows the user to create scripts to analyze and plot the data selected/displayed in the interactive map, making Vizic a powerful and flexible interactive analysis tool. Vizic be used for data inspection, clustering analysis, galaxy alignment studies, outlier identification or simply large-scale visualizations.
massmappy recovers convergence mass maps on the celestial sphere from weak lensing cosmic shear observations. It relies on SSHT (ascl:2207.034) and HEALPix (ascl:1107.018) to handle sampled data on the sphere. The spherical Kaiser-Squires estimator is implemented.
correlcalc calculates two-point correlation function (2pCF) of galaxies/quasars using redshift surveys. It can be used for any assumed geometry or Cosmology model. Using BallTree algorithms to reduce the computational effort for large datasets, it is a parallelised code suitable for running on clusters as well as personal computers. It takes redshift (z), Right Ascension (RA) and Declination (DEC) data of galaxies and random catalogs as inputs in form of ascii or fits files. If random catalog is not provided, it generates one of desired size based on the input redshift distribution and mangle polygon file (in .ply format) describing the survey geometry. It also calculates different realisations of (3D) anisotropic 2pCF. Optionally it makes healpix maps of the survey providing visualization.
3D-PDR is a three-dimensional photodissociation region code written in Fortran. It uses the Sundials package (written in C) to solve the set of ordinary differential equations and it is the successor of the one-dimensional PDR code UCL_PDR (ascl:1303.004). Using the HEALpix ray-tracing scheme (ascl:1107.018), 3D-PDR solves a three-dimensional escape probability routine and evaluates the attenuation of the far-ultraviolet radiation in the PDR and the propagation of FIR/submm emission lines out of the PDR. The code is parallelized (OpenMP) and can be applied to 1D and 3D problems.
gdr2_completeness queries Gaia DR2 TAP services and divides the queries into sub-queries chunked into arbitrary healpix bins. Downloaded data are formatted into arrays. Internal completeness is calculated by dividing the total starcount and starcounts with an applied cut (e.g., radial velocity measurement and good parallax). Independent determination of the external GDR2 completeness per healpix (level 6) and G magnitude bin (3 coarse bins: 8-12,12-15,15-18) is inferred from a crossmatch with 2MASS data. The overall completeness of a specific GDR2 sample can be approximated by multiplying the internal with the external completeness map, which is useful when data are compared to models thereof. Jupyter notebooks showcasing both utilities enable the user to easily construct the overall completeness for arbitrary samples of the GDR2 catalogue.
QuickSip quickly projects Survey Image Properties (e.g. seeing, sky noise, airmass) into Healpix sky maps with flexible weighting schemes. It was initially designed to produce observing condition "systematics" maps for the Dark Energy Survey (DES), but will work with any multi-epoch survey and images with valid WCS. QuickSip can reproduce the Mangle (ascl:1202.005) magnitude limit maps at sub-percent accuracy but doesn't support additional masks (stars, trails, etc), in which case Mangle should be used. Thus, QuickSip can be seen as a simplified Mangle to project image properties into Healpix maps in a fast and more flexible manner.
Healvis simulates radio interferometric visibility off of HEALPix shells. It generates a flat-spectrum and a GSM model and computes visibilities, and can simulates visibilities given an Observation Parameter YAML file. Healvis can perform partial frequency simulations in serial to minimize instantaneous memory loads.
intensitypower measures and models the auto- and cross-power spectrum multipoles of galaxy catalogs and radio intensity maps presented in spherical coordinates. It can also convert the multipoles to power spectrum wedges P(k,mu) and 2D power spectra P(k_perp,k_par). The code assumes the galaxy catalog is a set of discrete points and the radio intensity map is a pixelized continuous field which includes angular pixelization using healpix, binning in redshift channels, smoothing by a Gaussian telescope beam, and the addition of a Gaussian noise in each cell. The galaxy catalog and radio intensity map are transferred onto an FFT grid, and power spectrum multipoles are measured including curved-sky effects. Both maps include redshift-space distortions.
DeepSphere implements a generalization of Convolutional Neural Networks (CNNs) to the sphere. It models the discretized sphere as a graph of connected pixels. The resulting convolution is more efficient (especially when data doesn't span the whole sphere) and mostly equivariant to rotation (small distortions are due to the non-existence of a regular sampling of the sphere). The pooling strategy exploits a hierarchical pixelization of the sphere (HEALPix) to analyze the data at multiple scales. The graph neural network model is based on ChebNet and its TensorFlow implementation.
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.
healpy handles pixelated data on the sphere. It is based on the Hierarchical Equal Area isoLatitude Pixelization (HEALPix) scheme and bundles the HEALPix (ascl:1107.018) C++ library. healpy provides utilities to convert between sky coordinates and pixel indices in HEALPix nested and ring schemes and find pixels within a disk, a polygon or a strip in the sky. It can apply coordinate transformations between Galactic, Ecliptic and Equatorial reference frames, apply custom rotations either to vectors or full maps, and read and write HEALPix maps to disk in FITS format. healpy also includes utilities to upgrade and downgrade the resolution of existing HEALPix maps and transform maps to Spherical Harmonics space and back using multi-threaded C++ routines, among other utilities.
rcosmo provides information processing, visualization, manipulation and spatial statistical analysis of Cosmic Microwave Background (CMB) radiation and other spherical data stored in or converted to HEALPix coordinates. The package has more than 100 different functions, and can perform spherical geometry, manipulate CMB and other spherical data, and visualize HEALPix data. rcosmo can also perform statistical analysis of CMB and spherical data, and transforme spherical data in cartesian and geographic coordinates into HEALPix format.
lenspyx creates curved-sky python lensed CMB maps simulations; the software allows those familiar with healpy (ascl:2008.022) to build very easily lensed CMB simulations. Parallelization is done with openmp. The numerical cost is approximately that of an high-res harmonic transform. lenspyx provides two methods to build a simulation; one method computes a deflected spin-0 healpix map from its alm and deflection field alm, and the other computes a deflected spin-weight Healpix map from its gradient and curl modes and deflection field alm. lenspyx can be used in conjunction with the Planck 2018 CMB lensing pipeline plancklens (ascl:2010.009) to reproduce the published map and band-powers.
reproject implements image reprojection (resampling) methods for astronomical images using various techniques via a uniform interface. Reprojection re-grids images from one world coordinate system to another (for example changing the pixel resolution, orientation, coordinate system). reproject works on celestial images by interpolation, as well as by finding the exact overlap between pixels on the celestial sphere. It can also reproject to/from HEALPIX projections by relying on the astropy-healpix package.
HCGrid maps non-uniform radio astronomy data onto a uniformly distributed grid using a convolution-based algorithm on CPU-GPU heterogeneous platforms. The package has three modules; the initialization module initializes parameters needed for the calculation process, such as setting the size of the sampling space and output resolution. The gridding module uses a parallel ordering algorithm to pre-order the sampling points based on HEALPix on the CPU platform and uses an efficient two-level lookup table to speed up the acquisition of sampling points; it then accelerates convolution by using the high parallelism of GPU and through related performance optimization strategies based on CUDA architecture to further improve the gridding performance. The third module processes the results; it visualizes the gridding and exports the final products as FITS files.
cmblensplus reconstructs lensing potential, cosmic bi-refringence, and patchy reionization from cosmic microwave background anisotropies (CMB) in full and flat sky. This Fortran wrapper for Python also includes modules for delensing and bi-spectrum calculations. cmblensplus contains a module of basic routines such as analytic calculation of delensed B-mode spectrum and lensing bispectrum. Two additional main modules are for curved sky and flat sky analyses, and measure lensing, bi-refringence, patchy tau, bias-hardening, bi-spectrum, delensing and analytic reconstruction normalization. The package also contains simple Python utility and demonstration scripts. cmblensplus uses FFTW (ascl:1201.015), HEALPix (ascl:1107.018), LAPACK (ascl:2104.020), CFITSIO (ascl:1010.001), and LensPix (ascl:1102.025).
The HERMES (High-Energy Radiative MESsengers) computational framework for line of sight integration creates sky maps in the HEALPix-compatibile format of various galactic radiative processes, including Faraday rotation, synchrotron and free-free radio emission, gamma-ray emission from pion-decay, bremsstrahlung and inverse-Compton. The code is written in C++ and provides numerous integrators, including dispersion measure, rotation measure, and Gamma-ray emissions from Dark Matter annihilation, among others.
Healpix.jl is a Julia-only port of the C/C++/Fortran/Python HEALPix library (ascl:1107.018), which implements a hierarchical pixelization of the sphere in equal-area pixels. Much like the original library, Healpix.jl supports two enumeration schemes for the pixels (RING and NESTED) and implements an optimized computation of the generalized Fourier transform using spherical harmonics, binding libsharp2 (ascl:1402.033). In addition, Healpix.jl provides four additional features: 1.) it fully supports Windows systems, alongside the usual Linux and MAC OS X machines; 2.) it uses Julia's strong typesystem to prevent several bugs related to mismatches in map ordering (e.g., combining a RING map with a NESTED map); 3.) it uses a versatile memory layout so that map bytes can be stored in shared memory objects or on GPUs; and 4.) it implements an elegant and general way to signal missing values in maps.
DustFilaments paints filaments in the Celestial Sphere to generate a full sky map of the Thermal Dust emission at millimeter frequencies by integrating a population of 3D filaments. The code requires a magnetic field cube, which can be calculated separately or by DustFilaments. With the magnetic field cube as input, the package creates a random filament population with a given seed, and then paints a filament into a healpix map provided as input; the healpix map is updated in place.
BornRaytrace uses neural data compression of weak lensing map summary statistics to simulate weak gravitational lensing effects. It can raytrace through overdensity Healpix maps to return a convergence map, include shear-kappa transformation on the full sphere, and also include intrinsic alignments (NLA model).
MTNeedlet uses needlets to filter spherical (Healpix) maps and detect and analyze the maxima population using a multiple testing approach. It has been developed with the CMB in mind, but it can be applied to other spherical maps. It pivots around three basic steps: 1.) The calculation of several types of needlets and their possible use to filter maps; 2.) The detection of maxima (or minima) on spherical maps, their visualization and basic analysis; and 3.) The multiple testing approach in order to detect anomalies in the maxima population of the maps with respect to the expected behavior for a random Gaussian map. MTNeedlet relies on Healpy (ascl:2008.022) to efficiently deal with spherical maps.
WeakLensingQML implements the Quadratic Maximum Likelihood (QML) estimator and applies it to simulated cosmic shear data and compares the results to a Pseudo-Cl implementation. The package computes and saves relevant data files for later processes, such as the fiduciary cosmic shear power spectrum used in the analysis, the sky mask, and computing an analytic version of the QML's covariance matrix. The core of the package implements a conjugate-gradient approach for the quadratic estimator, and is parallelized for maximum performance. The code relies on the Eigen linear algebra package and the HealPix spherical harmonic transform library. A post-processing script analyzes the results and compares the QML's estimates with those from the Pseudo-Cl estimator; it then produces an array of plots highlighting the results.
ZodiPy simulates the zodiacal emission in intensity that an arbitrary solar system observer is predicted to see given an interplanetary dust model, either in the form of timestreams or full-sky HEALPix maps. Written in Python, the code makes zodiacal emission simulations more accessible by providing a simple interface to existing models.
PolyBin estimates the binned power spectrum, bispectrum, and trispectrum for full-sky HEALPix maps such as the CMB. This can include both spin-0 and spin-2 fields, such as the CMB temperature and polarization, or galaxy positions and galaxy shear. Alternatively, one can use only scalar maps. For each statistic, two estimators are available: the standard (ideal) estimators, which do not take into account the mask, and window-deconvolved estimators. For the second case, a Fisher matrix must be computed; this depends on binning and the mask, but does not need to be recomputed for each new simulation. PolyBin can compute both the parity-even and parity-odd components, accounting for any leakage between the two, for the bispectrum and trispectrum.
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.
mhealpy extends the functionalities of the HEALPix (ascl:1107.018) wrapper healpy (ascl:2008.022) to handle single and multi-resolution maps (a.k.a. multi-order coverage maps or MOC maps). In addition to creating and analyzes MOC maps, it supports arithmetic operations, adaptive grids, resampling of existing multi-resolution maps, and plotting, among other functions, and reads and writes to FITS, which enables sharing spatial information for multiwavelength and multimessenger analyses.
FGCluster runs spectral clustering onto Healpix maps for parametric foreground removal, using a map encoding the feature to cluster as inputs. Pixel similarity is given by the geometrical affinity of each pixel in the sphere. FGCluster can also take an uncertainty map as an input, in which case the adjacency is modified in such a way that the pixel similarity accounts also for the statistical significance given by the pixel values in a map and the uncertainties.
PICASSO (Python Inpainter for Cosmological and AStrophysical SOurces) provides a suite of inpainting methodologies to reconstruct holes on images (128x128 pixels) extracted from a HEALPIX map. Three inpainting techniques are included; these are divided into two main groups: diffusive-based methods (Nearest-Neighbors), and learning-based methods that rely on training DCNNs to fill the missing pixels with the predictions learned from a training data-set (Deep-Prior and Generative Adversarial Networks). PICASSO also provides scripts for projecting from full sky HEALPIX maps to flat thumbnails images, performing inpainting on GPUs and parallel inpainting on multiple processes, and for projecting from flat images to HEALPIX. Pretrained models are also included.