Results 1301-1400 of 3361 (3279 ASCL, 82 submitted)
We perform N-body simulations of theories with infinite-volume extra dimensions, such as the Dvali-Gabadadze-Porrati (DGP) model and its higher-dimensional generalizations, where 4D gravity is mediated by massive gravitons. The longitudinal mode of these gravitons mediates an extra scalar force, which we model as a density-dependent modification to the Poisson equation. This enhances gravitational clustering, particularly on scales that have undergone mild nonlinear processing. While the standard non-linear fitting algorithm of Smith et al. overestimates this power enhancement on non-linear scales, we present a modified fitting formula that offers a remarkably good fit to our power spectra. Due to the uncertainty in galaxy bias, our results are consistent with precision power spectrum determinations from galaxy redshift surveys, even for graviton Compton wavelengths as small as 300 Mpc. Our model is sufficiently general that we expect it to capture the phenomenology of a wide class of related higher-dimensional gravity scenarios.
HALOGEN generates approximate synthetic halo catalogs. Written in C, it decomposes the problem of generating cosmological tracer distributions (eg. halos) into four steps: generating an approximate density field, generating the required number of tracers from a CDF over mass, placing the tracers on field particles according to a bias scheme dependent on local density, and assigning velocities to the tracers based on velocities of local particles. It also implements a default set of four models for these steps. HALOGEN uses 2LPTic (ascl:1201.005) and CUTE (ascl:1505.016); the software is flexible and can be adapted to varying cosmologies and simulation specifications.
HaloGen computes all auto and cross spectra and halo model trispectrum in simple configurations. This modular halo model code computes 3d power spectra, and the corresponding projected 2d power spectra in the Limber and flat sky approximations. The observables include matter density, galaxy lensing, CMB lensing, thermal Sunyaev-Zel'dovich, cosmic infrared background, tracers with any dn/dz, b(z) and HOD.
Halogen, written in C, generates multimass spherically symmetric initial conditions for N-body simulations. A large family of radial density profiles is supported. The initial conditions are sampled from the full distribution function.
HaloGraphNet predicts halo masses from simulations using Graph Neural Networks. Given a dark matter halo and its galaxies, this software creates a graph with information about the 3D position, stellar mass and other properties. It then trains a Graph Neural Network to predict the mass of the host halo. Data are taken from the CAMELS hydrodynamic simulations.
halomod calculates cosmological halo model and HOD quantities. It is built on HMF (ascl:1412.006); it retains that code's features and provides extended components for the halo model, including numerous halo bias models, including scale-dependent bias, basic concentration-mass-redshift relations, and several plug-and-play halo-exclusion models. halomod includes built-in HOD parameterizations and halo profiles, support for WDM models, and all basic quantities such as 3D correlations and power spectra, and also several derived quantities such as effective bias and satellite fraction. In addition, it offers a simple routine for populating a halo catalog with galaxies via a HOD. halomod is flexible and modular, making it easily extendable.
Halotools builds and tests models of the galaxy-halo connection and analyzes catalogs of dark matter halos. The core functions of the package include fast generation of synthetic galaxy populations using HODs, abundance matching, and related methods; efficient algorithms for calculating galaxy clustering, lensing, z-space distortions, and other astronomical statistics; a modular, object-oriented framework for designing galaxy evolution models; and end-to-end support for reducing halo catalogs and caching them as hdf5 files.
HAM solves non-relativistic hyperbolic partial differential equations in conservative form using high-resolution shock-capturing techniques. This version of HAM has been configured to solve the magnetohydrodynamic equations of motion in axisymmetry to evolve a shearing box model.
The Hammurabi code is a publicly available C++ code for generating mock polarized observations of Galactic synchrotron emission with telescopes such as LOFAR, SKA, Planck, and WMAP, based on model inputs for the Galactic magnetic field (GMF), the cosmic-ray density distribution, and the thermal electron density. The Hammurabi code allows one to perform simulations of several different data sets simultaneously, providing a more reliable constraint of the magnetized ISM.
hankl implements the FFTLog algorithm in lightweight Python code. The FFTLog algorithm can be thought of as the Fast Fourier Transform (FFT) of a logarithmically spaced periodic sequence (= Hankel Transform). hankl consists of two modules, the General FFTLog module and the Cosmology one. The latter is suited for modern cosmological application and relies heavily on the former to perform the Hankel transforms. The accuracy of the method usually improves as the range of integration is enlarged; FFTlog prefers an interval that spans many orders of magnitude. Resolution is important, as low resolution introduces sharp features which in turn causes ringing.
HAOS-DIPER works with and manipulates data for neutral atoms and atomic ions to understand radiation emitted by some space plasmas, notably the solar atmosphere and stellar atmospheres. HAOS-DIPER works with quantum numbers for atomic levels, enabling it to perform tasks otherwise difficult or very tedious, including a variety of data checks, calculations based upon the atomic numbers, and searching and manipulating data based upon these quantum numbers. HAOS-DIPER handles conditions from LTE to coronal-like conditions, in a manner controlled by one system variable !REGIME, and has some capability for estimating data for which no accurate parameters are available and for accounting for the effects of missing atomic levels.
hardCORE calculates the minimum, maximum, and marginal core radius fractions (CRFmin, CRFmax, CRFmarg) for a solid exoplanet using only its mass and radius. Written in Python, the code is an efficient tool that is extremely fast to execute and perform inversions.
HARM uses a conservative, shock-capturing scheme for evolving the equations of general relativistic magnetohydrodynamics. The fluxes are calculated using the Harten, Lax, & van Leer scheme. A variant of constrained transport, proposed earlier by Tóth, is used to maintain a divergence-free magnetic field. Only the covariant form of the metric in a coordinate basis is required to specify the geometry. On smooth flows HARM converges at second order.
Harmonia combines clustering statistics decomposed in spherical and Cartesian Fourier bases for large-scale galaxy clustering likelihood analysis. Optimal weighting schemes for spherical Fourier analysis can also be readily implemented using the code.
Harmony is a general numerical scheme for evaluating MBS emission and absorption coefficients for both polarized and unpolarized light in a plasma with a general distribution function.
HARMPI is a parallel, 3D version of HARM (ascl:1209.005), which solves hyperbolic partial differential equations in conservative form using high-resolution shock-capturing techniques. The code is parallelized using MPI and is fully operational in 3D. HARMPI, like HARM, is capable of using non-uniform grids and solves the relativistic magnetohydrodynamic equations of motion on a stationary black hole spacetime in Kerr-Schild coordinates to evolve an accretion disk model.
HawkingNet searches for Hawking points in large Cosmic Microwave Background (CMB) data sets. It is based on the deep residual network ResNet18 and consists of eighteen neural layers. Written in Paython, HawkingNet inputs the CMB data, processes the data through its internal network trained for data classification, and outputs the result in a form of a classification score that indicates how confident it is that a Hawking point is contained in the image patch.
HAYASHI (Halo-level AnalYsis of the Absorption Signal in HI) computes the number of absorption features of the 21cm forest using a semianalytic formalism. It includes the enhancement of the signal due to the presence of substructures within minihalos and supports non-standard cosmologies with impact in the large scale structure, such as warm dark matter and primordial black holes. HAYASHI is written in Python3 and uses the cosmological computations package Colossus (ascl:1501.016).
A big challenge in solar and stellar physics in the coming years will be to decipher the magnetism of the solar outer atmosphere (chromosphere and corona) along with its dynamic coupling with the magnetic fields of the underlying photosphere. To this end, it is important to develop rigorous diagnostic tools for the physical interpretation of spectropolarimetric observations in suitably chosen spectral lines. HAZEL is a computer program for the synthesis and inversion of Stokes profiles caused by the joint action of atomic level polarization and the Hanle and Zeeman effects in some spectral lines of diagnostic interest, such as those of the He I 1083.0 nm and 587.6 nm (or D3) multiplets. It is based on the quantum theory of spectral line polarization, which takes into account in a rigorous way all the relevant physical mechanisms and ingredients (optical pumping, atomic level polarization, level crossings and repulsions, Zeeman, Paschen-Back and Hanle effects). The influence of radiative transfer on the emergent spectral line radiation is taken into account through a suitable slab model. The user can either calculate the emergent intensity and polarization for any given magnetic field vector or infer the dynamical and magnetic properties from the observed Stokes profiles via an efficient inversion algorithm based on global optimization methods.
Hazma enables indirect detection of sub-GeV dark matter. It computes gamma-ray and electron/positron spectra from dark matter annihilations, sets limits on sub-GeV dark matter using existing gamma-ray data, and determines the discovery reach of future gamma-ray detectors. The code also derives accurate CMB constraints. Hazma comes with several sub-GeV dark matter models, for which it provides functions to compute dark matter annihilation cross sections and mediator decay widths. A variety of low-level tools are provided to make it straightforward to define new models.
HBT is a Hierarchical Bound-Tracing subhalo finder and merger tree builder, for numerical simulations in cosmology. It tracks haloes from birth and continues to track them after mergers, finding self-bound structures as subhaloes and recording their merger histories as merger trees.
HBT+ is a hybrid subhalo finder and merger tree builder for cosmological simulations. It comes as an MPI edition that can be run on distributed clusters or shared memory machines and is MPI/OpenMP parallelized, and also as an OpenMP edition that can be run on shared memory machines and is only OpenMP parallelized. This version is more memory efficient than the MPI branch on shared memory machines, and is more suitable for analyzing zoomed-in simulations that are difficult to balance on distributed clusters. Both editions support hydro simulations with gas/stars.
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.
HDMSpectra computes the decay spectrum for dark matter with masses above the scale of electroweak symmetry breaking, down to Planck scale and including all relevant electroweak interactions. The code determines the distribution of stable states for photons, neutrinos, positrons, and antiprotons.
The Hierarchical Data System (HDS) is a file-based hierarchical data system designed for the storage of a wide variety of information. It is particularly suited to the storage of large multi-dimensional arrays (with their ancillary data) where efficient access is needed. It is a key component of the Starlink software collection (ascl:1110.012) and is used by the Starlink N-Dimensional Data Format (NDF) library (ascl:1411.023).
HDS organizes data into hierarchies, broadly similar to the directory structure of a hierarchical filing system, but contained within a single HDS container file. The structures stored in these files are self-describing and flexible; HDS supports modification and extension of structures previously created, as well as functions such as deletion, copying, and renaming. All information stored in HDS files is portable between the machines on which HDS is implemented. Thus, there are no format conversion problems when moving between machines. HDS can write files in a private binary format (version 4), or be layered on top of HDF5 (version 5).
HEADSS (HiErArchical Data Splitting and Stitching) facilitates clustering at scale, unlike clustering algorithms that scale poorly with increased data volume or that are intrinsically non-distributed. HEADSS automates data splitting and stitching, allowing repeatable handling, and removal, of edge effects. Implemented in conjunction with scikit's HDBSCAN, the code achieves orders of magnitude reduction in single node memory requirements for both non-distributed and distributed implementations, with the latter offering similar order of magnitude reductions in total run times while recovering analogous accuracy. HEADSS also establishes a hierarchy of features by using a subset of clustering features to split the data.
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.
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.
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.
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.
HEARSAY computes simulations of the causal contacts between emitters in the Galaxy. It implements the Stochastic Constrained Causal Contact Network (SC3Net) model and explores the parameter space of the model for the emergence of communicating nodes through Monte Carlo simulations and analyzes their causal connections. This model for the abundance and duration of civilizations is based on minimal assumptions and three free parameters, with focus on the statistical properties of empirical models instead of an interpretable model with variables to be determined by observation.
HEASOFT combines XANADU, high-level, multi-mission software for X-ray astronomical spectral, timing, and imaging data analysis tasks, and FTOOLS (ascl:9912.002), general and mission-specific software to manipulate FITS files, into one package. It also contains contains the NuSTAR subpackage of tasks, NuSTAR Data Analysis Software (NuSTARDAS). The source code for the software can be downloaded; precompiled executables for the most widely used computer platforms are also available for download. As an additional service, HEAsoft tasks can be directly from a web browser via WebHera.
HEATCVB is a stand-alone Fortran 77 subroutine that estimates the local volumetric coronal heating rate with four required inputs: the radial distance r, the wind speed u, the mass density ρ, and the magnetic field strength |B0|. The primary output is the heating rate Qturb at the location defined by the input parameters. HEATCVB also computes the local turbulent dissipation rate of the waves, γ = Qturb/(2UA).
HeatingRate calculates the nuclear heating rates [erg/s/g] of beta-decay, alpha-decay, and spontaneous fission of r-process nuclei, taking into account for thermalization of gamma-rays and charged decay products in r-process ejecta. It uses the half-lives and injection energy spectra from an evaluated nuclear data library (ENDF/B-VII.1). Each heating rate is computed for given abundances, ejecta mass, velocity, and density profile. HeatingRate also computes the bolometric light curve and the evolution of the effective temperature for given abundances, ejecta mass, velocity, and density profile assuming opacities independent of the wavelength.
HELA performs atmospheric retrieval on exoplanet atmospheres using a Random Forest algorithm. The code has two stages: training (which includes testing), and predicting. It requires a training set that matches the format of the data to be analyzed, with the same number of points and a sample spectrum for each parameter. The number of trees used and the number of jobs are editable. The HELA package includes a training set and data as examples.
HelioPy provides a set of tools to download and read in data, and carry out other common data processing tasks for heliospheric and planetary physics. It handles a wide variety of solar and satellite data and builds upon the SpiceyPy package (ascl:1903.016) to provide an accessible interface for performing orbital calculations. It has also implemented a framework to perform transformations between some common coordinate systems.
HELIOS-K is an opacity calculator for exoplanetary atmospheres. It takes a line list as an input and computes the line shapes of an arbitrary number of spectral lines (~millions to billions). HELIOS-K is capable of computing 100,000 spectral lines in 1 second; it is written in CUDA, is optimized for graphics processing units (GPUs), and can be used with the HELIOS radiative transfer code (ascl:1807.009).
Helios-r2 performs atmospheric retrieval of brown dwarf and exoplanet spectra. It uses a Bayesian statistics approach by employing a nested sampling method to generate posterior distributions and calculate the Bayesian evidence. The nested sampling itself is done by Multinest (ascl:1109.006). The computationally most demanding parts of the model have been written in NVIDIA's CUDA language for an increase in computational speed. Successful applications include retrieval of brown dwarf emission spectra and secondary eclipse measurements of exoplanets.
HELIOS, a radiative transfer code, is constructed for studying exoplanetary atmospheres. The model atmospheres of HELIOS are one-dimensional and plane-parallel, and the equation of radiative transfer is solved in the two-stream approximation with non-isotropic scattering. Though HELIOS can be used alone, the opacity calculator HELIOS-K (ascl:1503.004) can be used with it to provide the molecular opacities.
HENDRICS, a rewrite and update to MaLTPyNT (ascl:1502.021), contains command-line scripts based on Stingray (ascl:1608.001) to perform a quick-look (spectral-)timing analysis of X-ray data, treating the gaps in the data due, e.g., to occultation from the Earth or passages through the SAA, properly. Despite its original main focus on NuSTAR, HENDRICS can perform standard aperiodic timing analysis on X-ray data from, in principle, any other satellite, and its features include power density and cross spectra, time lags, pulsar searches with the Epoch folding and the Z_n^2 statistics, color-color and color-intensity diagrams. The periodograms produced by HENDRICS (such as a power density spectrum or a cospectrum) can be saved in a format compatible with XSPEC (ascl:9910.005) or ISIS (ascl:1302.002).
The hera_opm package provides a convenient and flexible framework for developing data analysis pipelines for operating on a sequence of input files. Though developed for application to the Hydrogen Epoch of Reionization Array (HERA), it is a general package that can be applied to any workflow designed to apply a series of analysis steps to any type of files. It is also portable, operating both on a diversity of computer clusters with batch submission systems and local machines.
HERACLES is a 3D hydrodynamical code used to simulate astrophysical fluid flows. It uses a finite volume method on fixed grids to solve the equations of hydrodynamics, MHD, radiative transfer and gravity. This software is developed at the Service d'Astrophysique, CEA/Saclay as part of the COAST project and is registered under the CeCILL license. HERACLES simulates astrophysical fluid flows using a grid based Eulerian finite volume Godunov method. It is capable of simulating pure hydrodynamical flows, magneto-hydrodynamic flows, radiation hydrodynamic flows (using either flux limited diffusion or the M1 moment method), self-gravitating flows using a Poisson solver or all of the above. HERACLES uses cartesian, spherical and cylindrical grids.
Herculens models imaging data of strong gravitational lenses. The package supports various degrees of model complexity, ranging from standard smooth analytical profiles to pixelated models and machine learning approaches. In particular, it implements multiscale pixelated models regularized with sparsity constraints and wavelet decomposition, for modeling both the source light distribution and the lens potential. The code is fully differentiable - based on JAX (ascl:2111.002) - which enables fast convergence to the solution, access to the parameters covariance matrix, efficient exploration of the parameter space including the sampling of posterior distributions using variational inference or Hamiltonian Monte-Carlo methods.
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.
hfof is a 3-d friends-of-friends (FoF) cluster finder with Python bindings based on a fast spatial hashing algorithm that identifies connected sets of points where the point-wise connections are determined by a fixed spatial distance. This technique sorts particles into fine cells sufficiently compact to guarantee their cohabitants are linked, and uses locality sensitive hashing to search for neighboring (blocks of) cells. Tests on N-body simulations of up to a billion particles exhibit speed increases of factors up to 20x compared with FOF via trees, and is consistently complete in less than the time of a k-d tree construction, giving it an intrinsic advantage over tree-based methods.
hfs_fit performs parameter optimization in the analysis of emission line hyperfine structure (HFS). The code uses a simulated annealing algorithm to optimize the magnetic dipole interaction constants, electric quadrupole interaction constants, Voigt profile widths and the center of gravity wavenumber for a given emission line profile. The fit can be changed visually with sliders for parameters, which is useful when HFS constants are unknown.
HfS fits the hyperfine structure of spectral lines, with multiple velocity components. The HfS_nh3 procedures included in HfS fit simultaneously the hyperfine structure of the NH3 (J,K)= (1,1) and (2,2) inversion transitions, and perform a standard analysis to derive the NH3 column density, rotational temperature Trot, and kinetic temperature Tk. HfS uses a Monte Carlo approach for fitting the line parameters, with special attention to the derivation of the parameter uncertainties. HfS includes procedures that make use of parallel computing for fitting spectra from a data cube.
hh0 is a Bayesian hierarchical model (BHM) that describes the full distance ladder, from nearby geometric-distance anchors through Cepheids to SNe in the Hubble flow. It does not rely on any of the underlying distributions being Gaussian, allowing outliers to be modeled and obviating the need for any arbitrary data cuts.
HHTpywrapper is a python interface to call the Hilbert–Huang Transform (HHT) MATLAB package. HHT is a time-frequency analysis method to adaptively decompose a signal, that could be generated by non-stationary and/or nonlinear processes, into basis components at different timescales, and then Hilbert transform these components into instantaneous phases, frequencies and amplitudes as functions of time. HHT has been successfully applied to analyzing X-ray quasi-periodic oscillations (QPOs) from the active galactic nucleus RE J1034+396 (Hu et al. 2014) and two black hole X-ray binaries, XTE J1550–564 (Su et al. 2015) and GX 339-4 (Su et al. 2017). HHTpywrapper provides examples of reproducing HHT analysis results in Su et al. (2015) and Su et al. (2017). This project is originated from the Astro Hack Week 2015.
hi_class implements Horndeski's theory of gravity in the modern Cosmic Linear Anisotropy Solving System (ascl:1106.020). It can be used to compute any cosmological observable at the level of background or linear perturbations, such as cosmological distances, cosmic microwave background, matter power and number count spectra (including relativistic effects). hi_class can be readily interfaced with Monte Python (ascl:1307.002) to test Gravity and Dark Energy models.
Hi-COLA runs fast approximate N-body simulations of non-linear structure formation in reduced Horndeski gravity (Horndeski theories with luminal gravitational waves). It is generic with respect to the reduced Horndeski class. Given an input Lagrangian, Hi-COLA's front-end dynamically constructs the appropriate field equations and consistently solves for the cosmological background, linear growth, and screened fifth force of that theory. This is passed to the back-end, which runs a hybrid N-body simulation at significantly reduced computational and temporal cost compared to traditional N-body codes. By analyzing the particle snapshots, one can study the formation of structure through statistics such as the matter power spectrum.
HIBAYES implements fully-Bayesian extraction of the sky-averaged (global) 21-cm signal from the Cosmic Dawn and Epoch of Reionization in the presence of foreground emission. User-defined likelihood and prior functions are called by the sampler PyMultiNest (ascl:1606.005) in order to jointly explore the full (signal plus foreground) posterior probability distribution and evaluate the Bayesian evidence for a given model. Implemented models, for simulation and fitting, include gaussians (HI signal) and polynomials (foregrounds). Some simple plotting and analysis tools are supplied. The code can be extended to other models (physical or empirical), to incorporate data from other experiments, or to use alternative Monte-Carlo sampling engines as required.
HIDE (HI Data Emulator) forward-models the process of collecting astronomical radio signals in a single dish radio telescope instrument and outputs pixel-level time-ordered-data. Written in Python, HIDE models the noise and RFI modeling of the data and with its companion code SEEK (ascl:1607.020) provides end-to-end simulation and processing of radio survey data.
hierArc hierarchically infers strong lensing mass density profiles and the cosmological parameters, in particular the Hubble constant. The software supports lenses with imaging data and kinematics, and optionally time delays. The kinematics modeling is performed in conjunction with lenstronomy (ascl:1804.012).
HiFLEx reduces echelle data taken with a single or bifurcated fiber input. It takes a FITS image file (i.e., a CCD image) and runs data reduction steps, extracts out orders from an Echelle spectrograph (regardless of separation and curvature, as long as orders are distinguishable from one-another), applies the wavelength correction, measures the radial velocity, and performs further calibration steps.
HiGal SED Fitter fits modified blackbody SEDs to Herschel data, specifically targeted at Herschel Hi-Gal data.
HiGPUs is an implementation of the numerical integration of the classical, gravitational, N-body problem, based on a 6th order Hermite’s integration scheme with block time steps, with a direct evaluation of the particle-particle forces. The main innovation of this code is its full parallelization, exploiting both OpenMP and MPI in the use of the multicore Central Processing Units as well as either Compute Unified Device Architecture (CUDA) or OpenCL for the hosted Graphic Processing Units. We tested both performance and accuracy of the code using up to 256 GPUs in the supercomputer IBM iDataPlex DX360M3 Linux Infiniband Cluster provided by the italian supercomputing consortium CINECA, for values of N ≤ 8 millions. We were able to follow the evolution of a system of 8 million bodies for few crossing times, task previously unreached by direct summation codes.
HiGPUs is also available as part of the AMUSE project.
HII-CHI-mistry_UV derives oxygen and carbon abundances using the ultraviolet (UV) lines emitted by the gas phase ionized by massive stars. The code first fixes C/O using ratios of appropriate emission lines and, in a second step, calculates O/H and the ionization parameter from carbon lines in the UV. An optical version of this Python code, HII-CHI-mistry (ascl:1807.007), is also available.
HII-CHI-mistry calculates the oxygen abundance for gaseous nebulae ionized by massive stars using optical collisionally excited emission lines. This code takes the extinction-corrected emission line fluxes and, based on a Χ2 minimization on a photoionization models grid, determines chemical-abundances (O/H, N/O) and ionization parameters. An ultraviolet version of this Python code, HII-CHI-mistry-UV (ascl:1807.008), is also available.
HIIexplorer detects and extracts the integrated spectra of HII regions from IFS datacubes. The procedure assumes H ii regions are peaky/isolated structures with a strong ionized gas emission, clearly above the continuum emission and the average ionized gas emission across the galaxy and that H ii regions have a typical physical size of about a hundred or a few hundreds of parsecs, which corresponds to a typical projected size at the distance of the galaxies of a few arcsec for galaxies at z~0.016. All input parameters can be derived from either a visual inspection and/or a statistical analysis of the Hα emission line map. The algorithm produces a segmentation FITS file describing the pixels associated to each H ii region. A newer version of this code, pyHIIexplorer (ascl:2206.010), is available.
HIIPHOT enables accurate photometric characterization of H II regions while permitting genuine adaptivity to irregular source morphology. It makes a first guess at the shapes of all sources through object recognition techniques; it then allows for departure from such idealized "seeds" through an iterative growing procedure and derives photometric corrections for spatially coincident diffuse emission from a low-order surface fit to the background after exclusion of all detected sources.
Hilal-Obs authenticates lunar crescent first visibility reports. The code, written in Python, uses PyEphem (ascl:1112.014) for astrometrics, and takes into account all the factors that affect lunar crescent visibility, including atmospheric extinction, observer physiology, sky and lunar brightness, contrast threshold, and the type of observation.
HilalPy analyzes lunar crescent visibility criteria. Written in Python, the code uses more than 8000 lunar crescent visibility records extracted from literature and websites of lunar crescent observation, descriptive statistics, contradiction rate percentage, and regression analysis in its analysis to predict the visibility of a lunar crescent.
HiLLiPoP is a multifrequency CMB likelihood for Planck data. The likelihood is a spectrum-based Gaussian approximation for cross-correlation spectra from Planck 100, 143 and 217GHz split-frequency maps, with semi-analytic estimates of the Cl covariance matrix based on the data. The cross-spectra are debiased from the effects of the mask and the beam leakage using Xpol (ascl:2301.009) before being compared to the model, which includes CMB and foreground residuals. They cover the multipoles from ℓ=30 to ℓ=2500. HiLLiPoP is interfaced with the Cobaya (ascl:1910.019) MCMC sampler.
The Herschel Space Observatory is the fourth cornerstone mission in the ESA science programme and performs photometry and spectroscopy in the 55 - 672 micron range. The development of the Herschel Data Processing System started in 2002 to support the data analysis for Instrument Level Tests. The Herschel Data Processing System was used for the pre-flight characterisation of the instruments, and during various ground segment test campaigns. Following the successful launch of Herschel 14th of May 2009 the Herschel Data Processing System demonstrated its maturity when the first PACS preview observation of M51 was processed within 30 minutes of reception of the first science data after launch. Also the first HIFI observations on DR21 were successfully reduced to high quality spectra, followed by SPIRE observations on M66 and M74. A fast turn-around cycle between data retrieval and the production of science-ready products was demonstrated during the Herschel Science Demonstration Phase Initial Results Workshop held 7 months after launch, which is a clear proof that the system has reached a good level of maturity.
HIPP (HIgh-Performance Package for scientific computation) provides elegant interfaces for some well-known HPC libraries. Some libraries are wrapped with full-OOP interfaces, and many new extensions based on those raw-interfaces are also provided. This C++ toolkit for HPC can significantly reduce the length of your code, making programming more productive.
HIPSTER (HIgh-k Power Spectrum EstimatoR) computes small-scale power spectra and isotropic bispectra for cosmological simulations and galaxy surveys of arbitrary shape. The code computes the Legendre multipoles of the power spectrum, Pℓ(k), or bispectrum Bℓ(k1,k2), by computing weighted pair counts over the simulation box or survey, truncated at some maximum radius. The code can be run either in 'aperiodic' or 'periodic' mode for galaxy surveys or cosmological simulations respectively. HIPSTER also supports weighted spectra, for example when tracer particles are weighted by their mass in a multi-species simulation. Generalization to anisotropic bispectra is straightforward (and requires no additional computing time) and can be added on request.
HISS stacks HI (emission and absorption) spectra in a consistent and reliable manner to enable statistical analysis of average HI properties. It provides plots of the stacked spectrum and reference spectrum with any fitted function, of the stacked noise response, and of the distribution of the integrated fluxes when calculating the uncertainties. It also produces a table containing the integrated flux calculated from the fitted functions and the stacked spectrum, among other output files.
Hitomi provides a comprehensive set of codes for cosmological analysis of anisotropic galaxy distributions using two- and three-point statistics: two-point correlation function (2PCF), power spectrum, three-point correlation function (3PCF), and bispectrum. The code can measure the Legendre-expanded 2PCF and power spectrum from an observed sample of galaxies, and can measure the 3PCF and bispectrum expanded using the Tripolar spherical harmonic (TripoSH) function. Hitomi is basically a serial code, but can also implement MPI parallelization. Hitomi uses MPI to read multiple different input parameters simultaneously.
HLattice simulates scalar fields and gravity in the early universe. The code allows the user to select between symplectic integrators, descretization schemes, and metrics such as Minkowski or FRW backgrounds and adaptice schemes in an "all-in-one" configuration file.
HLINOP is a collection of codes for computing hydrogen line profiles and opacities in the conditions typical of stellar atmospheres. It includes HLINOP for approximate quick calculation of any line of neutral hydrogen (suitable for model atmosphere calculations), based on the Fortran code of Kurucz and Peterson found in ATLAS9. It also includes HLINPROF, for detailed, accurate calculation of lower Balmer line profiles (suitable for detailed analysis of Balmer lines) and HBOP, to implement the occupation probability formalism of Daeppen, Anderson and Milhalas (1987) and thus account for the merging of bound-bound and bound-free opacity (used often as a wrapper to HLINOP for model atmosphere calculations).
HMcode computes the halo-model matter power spectrum. It is written in Fortran90 and has been designed to quickly (~0.5s for 200 k-values across 16 redshifts on a single core) produce matter spectra for a wide range of cosmological models. In testing it was shown to match spectra produced by the 'Coyote Emulator' to an accuracy of 5 per cent for k less than 10h Mpc^-1. However, it can also produce spectra well outside of the parameter space of the emulator.
HMF calculates the Halo Mass Function (HMF) given any set of cosmological parameters and fitting function and serves as the backend for the web application HMFcalc. Written in Python, it allows for dynamic accurate calculation of the transfer function with CAMB (ascl:1102.026) and efficient and self-consistent parameter updates. HMF offers exploration of the effects of cosmological parameters, redshift and fitting function on the predicted HMF.
HNBody is a new set of software utilities geared to the integration of hierarchical (nearly-Keplerian) N-body systems. Our focus is on symplectic methods, and we have included explicit support for three classes of particles (heavy, light, and massless), second and fourth order methods, post-Newtonian corrections, and the use of a symplectic corrector (among other things). For testing purposes, we also provide support for more general integration schemes (Bulirsch-Stoer & Runge-Kutta). Configuration files employing an intuitive syntax allow for easy problem setup, and many simple simulations can be done without the user compiling any code. Low-level interfaces are also available, enabling extensive customization.
HO-CHUNK calculates radiative equilibrium temperature solution, thermal and PAH/vsg emission, scattering and polarization in protostellar geometries. It is useful for computing spectral energy distributions (SEDs), polarization spectra, and images.
HOCHUNK3D is an updated version of the HOCHUNK radiative equilibrium code (ascl:1711.013); the code has been converted to Fortran 95, which allows a specification of one-dimensional (1D), 2D, or 3D grids at runtime. The code is parallelized so it can be run on multiple processors on one machine, or on multiple machines in a network. It includes 3-D functionality and several other additional geometries and features. The code calculates radiative equilibrium temperature solution, thermal and PAH/vsg emission, scattering and polarization in protostellar geometries. HOCHUNK3D also computes spectral energy distributions (SEDs), polarization spectra, and images.
HoloSim-ML performs beam simulation and analysis of radio holography data from complex optical systems. The code uses machine learning to efficiently determine the position of hundreds of mirror adjusters on multiple mirrors with few micron accuracy.
HOMER (Helper Of My Eternal Retrievals) is a machine-learning-accelerated Bayesian inverse modeling code. Given some data and uncertainties, the code determines the posterior distribution of a model. HOMER uses MC3 (ascl:1610.013) for its MCMC; its forward model is a neural network surrogate model trained by MARGE (ascl:2003.010). The code produces plots of the 1D marginalized posteriors, 2D pairwise posteriors, and parameter history traces, and can also overplot the 1D and 2D posteriors for comparison with another posterior. HOMER computes the Bhattacharyya coefficient to compare the similarity of two 1D marginalized posteriors.
We describe a new method (HOP) for identifying groups of particles in N-body simulations. Having assigned to every particle an estimate of its local density, we associate each particle with the densest of the Nh particles nearest to it. Repeating this process allows us to trace a path, within the particle set itself, from each particle in the direction of increasing density. The path ends when it reaches a particle that is its own densest neighbor; all particles reaching the same such particle are identified as a group. Combined with an adaptive smoothing kernel for finding the densities, this method is spatially adaptive, coordinate-free, and numerically straight-forward. One can proceed to process the output by truncating groups at a particular density contour and combining groups that share a (possibly different) density contour. While the resulting algorithm has several user-chosen parameters, we show that the results are insensitive to most of these, the exception being the outer density cutoff of the groups.
HOPE is a specialized Python just-in-time (JIT) compiler designed for numerical astrophysical applications. HOPE focuses on a subset of the language and is able to translate Python code into C++ while performing numerical optimization on mathematical expressions at runtime. To enable the JIT compilation, the user only needs to add a decorator to the function definition. By using HOPE, the user benefits from being able to write common numerical code in Python while getting the performance of compiled implementation.
HOPS (Haystack Observatory Postprocessing System) analyzes the data generated by DiFX VLBI correlators. It is written in C for Linux computers, and emphasizes quality-control aspects of data processing. It sits between the correlator and an image-processing and/or geodetic-processing package, and performs basic fringe-fitting, data editing, problem diagnosis, and correlator support functions.
HorizonGRound forward models general relativistic effects from the tracer luminosity function. It also compares relativistic corrections with the local primordial non-Gaussianity signature in ultra-large-scale clustering statistics. The package includes several recipes along with the data required to run them.
HOTPANTS (High Order Transform of PSF ANd Template Subtraction) implements the Alard 1999 algorithm for image subtraction. It photometrically aligns one input image with another after they have been astrometrically aligned.
The Hellenic Open University Reconstruction & Simulation (HOURS) software package contains a realistic simulation package of the detector response of very large (km3-scale) underwater neutrino telescopes, including an accurate description of all the relevant physical processes, the production of signal and background as well as several analysis strategies for triggering and pattern recognition, event reconstruction, tracking and energy estimation. HOURS also provides tools for simulating calibration techniques and other studies for estimating the detector sensitivity to several neutrino sources.
Generate simulated radio recombination line observations of HII regions with various internal kinematic structure. Fit single Gaussians to each pixel of the simulated observations and generate images of the fitted Gaussian center and full-width half-maximum (FWHM) linewidth.
HII Region Models fits HII region models to observed radio recombination line and radio continuum data. The algorithm includes the calculations of departure coefficients to correct for non-LTE effects. HII Region Models has been used to model star formation in the nucleus of IC 342.
Hrothgar is a parallel minimizer and Markov Chain Monte Carlo generator. It has been used to solve optimization problems in astrophysics (galaxy cluster mass profiles) as well as in experimental particle physics (hadronic tau decays).
HSIM simulates observations with HARMONI on the Extremely Large Telescope. HSIM takes high spectral and spatial resolution input data cubes, encoding physical descriptions of astrophysical sources, and generates mock observed data cubes. The simulations incorporate detailed models of the sky, telescope, instrument, and detectors to produce realistic mock data. HSIM performs in-depth simulations for several key science cases as part of the design and development of the HARMONI integral field spectrograph, including the ELT AO performance, atmospheric effects and realistic detector statistics.
The Hough Stream Spotter (HSS) is a stream finding code which transforms individual positions of stars to search for linear structure in discrete data sets. The code requires only the two-dimensional plane of galactic longitude and latitude as input.
HSTCosmicrays finds and characterizes cosmic rays found in dark frames (exposures taken with the shutter closed) taken with instruments on the Hubble Space Telescope (HST). Dark exposures are obtained routinely by all the Hubble Space Telescope instruments for calibration. The main processing pipeline runs locally or in the cloud on AWS utilizing the HST Public Dataset.
HTOF parses the intermediate data from Hipparcos and Gaia and fits astrometric solutions to those data. It computes likelihoods and parameter errors in line with the catalog and can reproduce five, seven, and nine (or higher) parameter fits to their astrometry.
HUAYNO implements integrators derived from second order Hamiltonian splitting for N-body dynamics. This integration scheme conserves energy and momentum with little or no systematic drift. The code uses an explicit but approximate formula for the time symmetrization that is compatible with the use of individual time steps, making an iterative scheme unnecessary. HUAYNO is available as part of the AMUSE package (ascl:1107.007).
HumVI creates a composite color image from sets of input FITS files, following the Lupton et al (2004, ascl:1511.013) composition algorithm. Written in Python, it takes three FITS files as input and returns a color composite, color-saturated png image with an arcsinh stretch. HumVI reads the zero points out of the FITS headers and uses them to put all the images on the same flux scale; photometrically calibrated images produce the best results.
We describe the first parallel implementation of an adaptive particle-particle, particle-mesh code with smoothed particle hydrodynamics. Parallelisation of the serial code, "Hydra," is achieved by using CRAFT, a Cray proprietary language which allows rapid implementation of a serial code on a parallel machine by allowing global addressing of distributed memory.
The collisionless variant of the code has already completed several 16.8 million particle cosmological simulations on a 128 processor Cray T3D whilst the full hydrodynamic code has completed several 4.2 million particle combined gas and dark matter runs. The efficiency of the code now allows parameter-space explorations to be performed routinely using $64^3$ particles of each species. A complete run including gas cooling, from high redshift to the present epoch requires approximately 10 hours on 64 processors.
HydraLens generates gravitational lens model files for Lenstool (ascl:1102.004), PixeLens (ascl:1102.007), glafic (ascl:1010.012) and Lensmodel and can also translate lens model files among these four lens model codes. Through a GUI, the user enters a new model by specifying the type of model and is then led through screens to collect the data. Written in MS Visual Basic, the code can also translate an existing model from any of the four supported codes to any of the other three.
HydroCode1D is a 1D finite volume code that can run any problem with 1D or 2D/3D spherical symmetry including external gravity or self-gravity. The program provides, depending on the configuration, output files that contain the midpoint position, density, velocity and pressure for each cell in the grid (in SI units). The program will by default use all available threads (as given by the environment variable OMP_NUM_THREADS). This can be overwritten by giving the desired number of threads as a command line argument to the program.
The R package Hyper-Fit fits hyperplanes (hyper.fit) and creates 2D/3D visualizations (hyper.plot2d / hyper.plot3d) to produce robust 1D linear fits for 2D x vs y type data, and robust 2D plane fits to 3D x vs y vs z type data. This hyperplane fitting works generically for any N-1 hyperplane model being fit to a N dimensional dataset. All fits include intrinsic scatter in the generative model orthogonal to the hyperplane. A web interface for online fitting is also available at http://hyperfit.icrar.org.
Hyperas is a convenience wrapper around hyperopt (ascl:2205.008) for fast prototyping with keras models (ascl:1806.022). Hyperas lets you use the power of hyperopt without having to learn the syntax of it. Instead, just define your keras model as you are used to, but use a simple template notation to define hyper-parameter ranges to tune.
Hyperion is a three-dimensional dust continuum Monte-Carlo radiative transfer code that is designed to be as generic as possible, allowing radiative transfer to be computed through a variety of three-dimensional grids. The main part of the code is problem-independent, and only requires an arbitrary three-dimensional density structure, dust properties, the position and properties of the illuminating sources, and parameters controlling the running and output of the code. Hyperion is parallelized, and is shown to scale well to thousands of processes. Two common benchmark models for protoplanetary disks were computed, and the results are found to be in excellent agreement with those from other codes. Finally, to demonstrate the capabilities of the code, dust temperatures, SEDs, and synthetic multi-wavelength images were computed for a dynamical simulation of a low-mass star formation region.
The Python library Hyperopt performs serial and parallel optimization over awkward search spaces, which may include real-valued, discrete, and conditional dimensions. Three algorithms are implemented in hyperopt: Random Search, Tree of Parzen Estimators (TPE), and Adaptive TPE. Algorithms can be parallelized in two ways, using either Apache Spark or MongoDB. To use Hyperopt, the objective function to minimize and the space over which to search, and the database in which to store all the point evaluations of the search have to be described, and the search algorithm to use has to be specified.
Would you like to view a random code?