Astrophysics Source Code Library

Making codes discoverable since 1999

Browsing Codes

Title Date
Abstract Compact
Per Page
[ascl:1402.032] HALOFIT: Nonlinear distribution of cosmological mass and galaxies

HALOFIT provides an explanatory framework for galaxy bias and clustering and has been incorporated into CMB packages such as CMBFAST (ascl:9909.004) and CAMB (ascl:1102.026). It attains a reasonable level of precision, though the halo model does not match N-body data perfectly. The code is written in Fortran 77. HALOFIT tends to underpredict the power on the smallest scales in standard LCDM universes (although HALOFIT was designed to work for a much wider range of power spectra); its accuracy can be improved by using a supplied correction.

[ascl:2002.014] HaloAnalysis: Read and analyze halo catalogs and merger trees

HaloAnalysis reads and analyzes halo/galaxy catalogs, generated from Rockstar (ascl:1210.008) or AHF (ascl:1102.009), and merger trees generated from Consistent Trees (ascl:1210.011). Written in Python, it offers the following functionalities: reads halo/galaxy/tree catalogs from multiple file formats; assigns baryonic particles and galaxy properties to dark-matter halos; combines and re-generates halo/galaxy/tree files in hdf5 format; analyzes properties of halos/galaxies; and selects halos to generate zoom-in initial conditions. The code includes a tutorial in the form of a Jupyter notebook.

[ascl:1909.005] HADES: Hexadecapolar Analysis for Dust Estimation in Simulations (of CMB B-mode thermal dust emission)

HADES analyzse dust levels in simulated CMB galactic dust maps with realistic experimental noise and lensing configurations. It allows detection of dust via its anisotropy properties in CMB B-modes. It also includes techniques for computing null-tests and a rudimentary technique for dedusting.

[ascl:1402.031] gyrfalcON: N-body code

gyrfalcON (GalaxY simulatoR using falcON) is a full-fledged N-body code using Dehnen’s force algorithm of complexity O(N) (falcON); this algorithm is approximately 10 times faster than an optimally coded tree code. The code features individual adaptive time steps and individual (but fixed) softening lengths. gyrfalcON is included in and requires NEMO to run.

[ascl:1308.010] GYRE: Stellar oscillation code

GYRE is an oscillation code that solves the stellar pulsation equations (both adiabatic and non-adiabatic) using a novel Magnus Multiple Shooting numerical scheme devised to overcome certain weaknesses of the usual relaxation and shooting schemes. The code is accurate (up to 6th order in the number of grid points), robust, and makes efficient use of multiple processor cores and/or nodes.

[ascl:1203.005] Gyoto: General relativitY Orbit Tracer of Observatoire de Paris

GYOTO, a general relativistic ray-tracing code, aims at computing images of astronomical bodies in the vicinity of compact objects, as well as trajectories of massive bodies in relativistic environments. This code is capable of integrating the null and timelike geodesic equations not only in the Kerr metric, but also in any metric computed numerically within the 3+1 formalism of general relativity. Simulated images and spectra have been computed for a variety of astronomical targets, such as a moving star or a toroidal accretion structure. The underlying code is open source and freely available. It is user-friendly, quickly handled and very modular so that extensions are easy to integrate. Custom analytical metrics and astronomical targets can be implemented in C++ plug-in extensions independent from the main code.

[ascl:1912.016] GWpy: Python package for studying data from gravitational-wave detectors

The Python package GWpy analyzes and characterizes gravitational wave data. It provides a user-friendly, intuitive interface to the common time-domain and frequency-domain data produced by the LIGO and Virgo observatories and their analyses. The core Python infrastructure is influenced by, and extends the functionality of, the Astropy (ascl:1304.002) package, and its methodology has been derived from, and augmented by, the LIGO Algorithm Library Suite (LALSuite), a large collection of primarily C99 routines for analysis and manipulation of data from gravitational-wave detectors. These packages use the SWIG program to produce Python wrappings for all C modules, allowing the GWpy package to leverage both the completeness, and the speed, of these libraries.

[ascl:1701.011] GWFrames: Manipulate gravitational waveforms

GWFrames eliminates all rotational behavior, thus simplifying the waveform as much as possible and allowing direct generalizations of methods for analyzing nonprecessing systems. In the process, the angular velocity of a waveform is introduced, which also has important uses, such as supplying a partial solution to an important inverse problem.

[ascl:2002.013] GWecc: Calculator for pulsar timing array signals due to eccentric supermassive binaries

GWecc computes the pulsar timing array (PTA) signals induced by eccentric supermassive binaries. Written in C++, it computes the plus/cross polarizations as well as Earth and pulsar terms of the PTA signal given the binary parameters and the sky locations of the binary and the pulsar. A python wrapper is included through which GWecc can be used to simulate, search for and constrain gravitational wave-emitting eccentric supermassive binaries using packages such as ENTERPRISE (ascl:1912.015) and libstempo (ascl:2002.017).

[ascl:2010.002] GSpec: Gamma-ray Burst Monitor analyzer

GSpec analyzes the Fermi mission's Gamma-ray Burst Monitor (GBM) data via a user-interactive GUI. The software provides a seamless interface to XSPEC (ascl:9910.005). It allows users to create their own Python scripts using the included libraries, and to define additional data reduction techniques, such as background fitting/estimation and data binning, as Python-based plugins. It is part of a larger effort to produce a set of GBM data tools to allow the broader community to analyze all aspects of GBM data, including the continuous data that GBM produces. GSpec is similar to RMfit (ascl:1409.011), a GUI-based spectral analysis code that specializes in the analysis of GBM trigger data, and is intended to eventually replace that IDL package.

[ascl:1610.005] GSGS: In-Focus Phase Retrieval Using Non-Redundant Mask Data

GSGS does phase retrieval on images given an estimate of the pupil phase (from a non-redundant mask or other interferometric approach), the pupil geometry, and the in-focus image. The code uses a modified Gerchberg-Saxton algorithm that iterates between pupil plane and image plane to measure the pupil phase.

[ascl:1806.008] gsf: galactic structure finder

gsf applies Gaussian Mixture Models in the stellar kinematic space of normalized angular momentum and binding energy on NIHAO high resolution galaxies to separate the stars into multiple components. The gsf analysis package assumes that the simulation snapshot has been pre-processed with a halo finder. It is based on pynbody (ascl:1305.002) and the scikit-learnpython package for Machine Learning; after loading, orienting, and transforming a simulation snapshot to physical units, it runs the clustering algorithm and performs the direct N-body gravity force using all the particles in the given halo.

[ascl:1503.009] GSD: Global Section Datafile access library

The GSD library reads data written in the James Clerk Maxwell Telescope GSD format. This format uses the General Single-Dish Data model and was used at the JCMT until 2005. The library provides an API to open GSD files and read their contents. The content of the data files is self-describing and the library can return the type and name of any component. The library is used by SPECX (ascl:1310.008), JCMTDR (ascl:1406.019) and COADD (ascl:1411.020). The SMURF (ascl:1310.007) package can convert GSD heterodyne data files to ACSIS format using this library.

[ascl:1605.013] grtrans: Polarized general relativistic radiative transfer via ray tracing

grtrans calculates ray tracing radiative transfer in the Kerr metric, including the full treatment of polarised radiative transfer and parallel transport along geodesics, for comparing theoretical models of black hole accretion flows and jets with observations. The code is written in Fortran 90 and parallelizes with OpenMP; the full code and several components have Python interfaces. grtrans includes Geokerr (ascl:1011.015) and requires cfitsio (ascl:1010.001) and pyfits (ascl:1207.009).

[ascl:1512.018] growl: Growth factor and growth rate of expanding universes

Growl calculates the linear growth factor Da and its logarithmic derivative dln D/dln a in expanding Friedmann-Robertson-Walker universes with arbitrary matter and vacuum densities. It permits rapid and stable numerical evaluation.

[ascl:1306.002] grmonty: Relativistic radiative transport Monte Carlo code

grmonty is a Monte Carlo radiative transport code intended for calculating spectra of hot, optically thin plasmas in full general relativity. The code models hot accretion flows in the Kerr metric, it incorporates synchrotron emission and absorption and Compton scattering. grmonty can be readily generalized to account for other radiative processes and an arbitrary spacetime.

[ascl:1905.001] Grizli: Grism redshift and line analysis software

Grizli produces quantitative and comprehensive modeling and fitting of slitless spectroscopic observations, which typically involve overlapping spectra of hundreds or thousands of objects in exposures taken with one or more separate grisms and at multiple dispersion position angles. This type of analysis provides complete and uniform characterization of the spectral properties (e.g., continuum shape, redshifts, line fluxes) of all objects in a given exposure taken in the slitless spectroscopic mode.

[ascl:1912.013] GriSPy: Fixed-radius nearest neighbors grid search in Python

GriSPy (Grid Search in Python) uses a regular grid search algorithm for quick fixed-radius nearest-neighbor lookup. It indexes a set of k-dimensional points in a regular grid providing a fast approach for nearest neighbors queries. Optional periodic boundary conditions can be provided for each axis individually. GriSPy implements three types of queries: bubble, shell and the nth-nearest, and offers three different metrics of interest in astronomy: the Euclidean and two distance functions in spherical coordinates of varying precision, haversine and Vincenty. It also provides a custom distance function. GriSPy is particularly useful for large datasets where a brute-force search is not practical.

[ascl:1702.012] GRIM: General Relativistic Implicit Magnetohydrodynamics

GRIM (General Relativistic Implicit Magnetohydrodynamics) evolves a covariant extended magnetohydrodynamics model derived by treating non-ideal effects as a perturbation of ideal magnetohydrodynamics. Non-ideal effects are modeled through heat conduction along magnetic field lines and a difference between the pressure parallel and perpendicular to the field lines. The model relies on an effective collisionality in the disc from wave-particle scattering and velocity-space (mirror and firehose) instabilities. GRIM, which runs on CPUs as well as on GPUs, combines time evolution and primitive variable inversion needed for conservative schemes into a single step using only the residuals of the governing equations as inputs. This enables the code to be physics agnostic as well as flexible regarding time-stepping schemes.

[ascl:1302.007] GRID-core: Gravitational Potential Identification of Cores

GRID-core is a core-finding method using the contours of the local gravitational potential to identify core boundaries. The GRID-core method applied to 2D surface density and 3D volume density are in good agreement for bound cores. We have implemented a version of the GRID-core algorithm in IDL, suitable for core-finding in observed maps. The required input is a two-dimensional FITS file containing a map of the column density in a region of a cloud.

[ascl:1701.009] GrayStarServer: Stellar atmospheric modeling and spectrum synthesis

GrayStarServer is a stellar atmospheric modeling and spectrum synthesis code of pedagogical accuracy that is accessible in any web browser on commonplace computational devices and that runs on a timescale of a few seconds.

[ascl:1701.008] GrayStar: Web-based pedagogical stellar modeling

GrayStar is a web-based pedagogical stellar model. It approximates stellar atmospheric and spectral line modeling in JavaScript with visualization in HTML. It is suitable for a wide range of education and public outreach levels depending on which optional plots and print-outs are turned on. All plots and renderings are pure basic HTML and the plotting module contains original HTML procedures for automatically scaling and graduating x- and y-axes.

[ascl:1403.005] GRay: Massive parallel ODE integrator

GRay is a massive parallel ordinary differential equation integrator that employs the "stream processing paradigm." It is designed to efficiently integrate billions of photons in curved spacetime according to Einstein's general theory of relativity. The code is implemented in CUDA C/C++.

[ascl:1102.003] GRAVLENS: Computational Methods for Gravitational Lensing

Modern applications of strong gravitational lensing require the ability to use precise and varied observational data to constrain complex lens models. Two sets of computational methods for lensing calculations are discussed. The first is a new algorithm for solving the lens equation for general mass distributions. This algorithm makes it possible to apply arbitrarily complicated models to observed lenses. The second is an evaluation of techniques for using observational data including positions, fluxes, and time delays of point-like images, as well as maps of extended images, to constrain models of strong lenses. The techniques presented here are implemented in a flexible and user-friendly software package called gravlens, which is made available to the community.

[ascl:1902.004] GraviDy: Gravitational Dynamics

GraviDy performs N-body 3D visualizations; it is a GPU, direct-summation N-body integrator based on the Hermite scheme and includes relativistic corrections for sources of gravitational radiation. The software is modular, allowing users to readily introduce new physics, and exploits available computational resources. The software can be used in parallel on multiple CPUs and GPUs, with a considerable speed-up benefit. The single-GPU version is between one and two orders of magnitude faster than the single-CPU version.

[ascl:1611.007] GRASP2K: Relativistic Atomic Structure Package

GRASP2K is a revised and greatly expanded version of GRASP (ascl:1609.008) and is adapted for 64-bit computer architecture. It includes new angular libraries, can transform from jj- to LSJ-coupling, and coefficients of fractional parentage have been extended to j=9/2, making calculations feasible for the lanthanides and actinides. GRASP2K identifies each atomic state by the total energy and a label for the configuration state function with the largest expansion coefficient in LSJLSJ intermediate coupling.

[ascl:1609.008] GRASP: General-purpose Relativistic Atomic Structure Package

GRASP (General-purpose Relativistic Atomic Structure Package) calculates atomic structure, including energy levels, radiative rates (A-values) and lifetimes; it is a fully relativistic code based on the jj coupling scheme. This code has been superseded by GRASP2K (ascl:1611.007).

[ascl:1204.006] GRASIL: Spectral evolution of stellar systems with dust

GRASIL (which stands for GRAphite and SILicate) computes the spectral evolution of stellar systems taking into account the effects of dust, which absorbs and scatters optical and UV photons and emits in the IR-submm region. It may be used as well to do “standard” no-dust stellar spectral synthesis. The code is very well calibrated and applied to interpret galaxies at different redshifts. GRASIL can be downloaded or run online using the GALSYNTH WEB interface.

[ascl:2010.005] GRAPUS: GRAvitational instability PopUlation Synthesis

GRAPUS (GRAvitational instability PopUlation Synthesis) executes population synthesis modeling of self-gravitating disc fragmentation and tidal downsizing in protostellar discs. It reads in pre-run 1D viscous disc models of self-gravitating discs and computes where fragmentation will occur and the initial fragment mass. GRAPUS then allows these fragment embryos to evolve under various forces, including quasistatic collapse of the embryo, growth and sedimentation of the dust inside the embryo, and the formation of solid cores. The software also evolves migration due to embryo-disc interactions and tidal disruption of the embryo, and can optionally determine gravitational interactions with neighboring embryos.

[ascl:1812.011] GRAND-HOD: GeneRalized ANd Differentiable Halo Occupation Distribution

GRAND-HOD (GeneRalized ANd Differentiable Halo Occupation Distribution) takes a generalized Halo Occupation Distribution (HOD) prescription as input and outputs the corresponding mock galaxy catalogs in binary files. The code is differentiable and incorporates various generalizations to the standard HOD. It is written for the Abacus simulations, but the main functionalities can be easily adapted for other halo catalogs with the appropriate properties.

[ascl:1908.004] Gramsci: GRAph Made Statistics for Cosmological Information

Gramsci (GRAph Made Statistics for Cosmological Information) computes the general N-point spatial correlation functions of any discrete point set embedded within an Euclidean space of ℝ^n. It uses kd-trees and graph databases to count all possible N-tuples in binned configurations within a given length scale, e.g. all pairs of points or all triplets of points with side lengths. Gramsci can run in serial, OpenMP, MPI and hybrid parallel schemes. It is useful for performing domain decomposition of input catalogs, especially if the catalogs are large or the Rmax value is too large.

[ascl:1011.021] GRALE: A genetic algorithm for the non-parametric inversion of strong lensing systems

We present a non-parametric technique to infer the projected-mass distribution of a gravitational lens system with multiple strong-lensed images. The technique involves a dynamic grid in the lens plane on which the mass distribution of the lens is approximated by a sum of basis functions, one per grid cell. We used the projected mass densities of Plummer spheres as basis functions. A genetic algorithm then determines the mass distribution of the lens by forcing images of a single source, projected back onto the source plane, to coincide as well as possible. Averaging several tens of solutions removes the random fluctuations that are introduced by the reproduction process of genomes in the genetic algorithm and highlights those features common to all solutions. Given the positions of the images and the redshifts of the sources and the lens, we show that the mass of a gravitational lens can be retrieved with an accuracy of a few percent and that, if the sources sufficiently cover the caustics, the mass distribution of the gravitational lens can also be reliably retrieved. A major advantage of the algorithm is that it makes full use of the information contained in the radial images, unlike methods that minimise the residuals of the lens equation, and is thus able to accurately reconstruct also the inner parts of the lens.

[ascl:1106.008] GRAFIC-2: Multiscale Gaussian Random Fields for Cosmological Simulations

This paper describes the generation of initial conditions for numerical simulations in cosmology with multiple levels of resolution, or multiscale simulations. We present the theory of adaptive mesh refinement of Gaussian random fields followed by the implementation and testing of a computer code package performing this refinement called GRAFIC-2.

[ascl:1010.080] GRACOS: Scalable and Load Balanced P3M Cosmological N-body Code

The GRACOS (GRAvitational COSmology) code, a parallel implementation of the particle-particle/particle-mesh (P3M) algorithm for distributed memory clusters, uses a hybrid method for both computation and domain decomposition. Long-range forces are computed using a Fourier transform gravity solver on a regular mesh; the mesh is distributed across parallel processes using a static one-dimensional slab domain decomposition. Short-range forces are computed by direct summation of close pairs; particles are distributed using a dynamic domain decomposition based on a space-filling Hilbert curve. A nearly-optimal method was devised to dynamically repartition the particle distribution so as to maintain load balance even for extremely inhomogeneous mass distributions. Tests using $800^3$ simulations on a 40-processor beowulf cluster showed good load balance and scalability up to 80 processes. There are limits on scalability imposed by communication and extreme clustering which may be removed by extending the algorithm to include adaptive mesh refinement.

[ascl:1612.020] Grackle: Chemistry and radiative cooling library for astrophysical simulations

The chemistry and radiative cooling library Grackle provides options for primordial chemistry and cooling, photo-heating and photo-ionization from UV backgrounds, and support for user-provided arrays of volumetric and specific heating rates for astrophysical simulations and models. The library provides functions to update chemistry species; solve radiative cooling and update internal energy; and calculate cooling time, temperature, pressure, and ratio of specific heats (gamma), and has interfaces for C, C++, Fortran, and Python codes.

[ascl:1010.022] GR1D: Open-Source Code for Spherically-Symmetric Stellar Collapse to Neutron Stars and Black Holes

GR1D is based on the Eulerian formulation of GR hydrodynamics (GRHD) put forth by Romero-Ibanez-Gourgoulhon and employs radial-gauge, polar-slicing coordinates in which the 3+1 equations simplify substantially. GR1D is intended for the simulation of stellar collapse to neutron stars and black holes and will also serve as a testbed for modeling technology to be incorporated in multi-D GR codes. Its GRHD part is coupled to various finite-temperature microphysical equations of state in tabulated form that we make available with GR1D.

[ascl:1906.014] GPUVMEM: Maximum Entropy Method (MEM) GPU algorithm for radio astronomical image synthesis

The maximum entropy method (MEM) is a well known deconvolution technique in radio-interferometry. This method solves a non-linear optimization problem with an entropy regularization term. Other heuristics such as CLEAN are faster but highly user dependent. Nevertheless, MEM has the following advantages: it is unsupervised, it has a statistical basis, it has a better resolution and better image quality under certain conditions. GPUVMEM presents a high performance GPU version of non-gridding MEM.

[ascl:1403.001] GPU-D: Generating cosmological microlensing magnification maps

GPU-D is a GPU-accelerated implementation of the inverse ray-shooting technique used to generate cosmological microlensing magnification maps. These maps approximate the source plane magnification patterns created by an ensemble of stellar-mass compact objects within a foreground macrolens galaxy. Unlike other implementations, GPU-D solves the gravitational lens equation without any approximation. Due to the high computational intensity and high degree of parallelization inherent in the algorithm, it is ideal for brute-force implementation on GPUs. GPU-D uses CUDA for GPU acceleration and require NVIDIA devices to run.

[ascl:2007.001] GProtation: Measuring stellar rotation periods with Gaussian processes

GProtation measures stellar rotation periods with Gaussian processes.

This code is no longer being maintained. Please consider using celerite (ascl:1709.008) or exoplanet (ascl:1910.005) instead.

[ascl:1411.018] GPI Pipeline: Gemini Planet Imager Data Pipeline

The GPI data pipeline allows users to reduce and calibrate raw GPI data into spectral and polarimetric datacubes, and to apply various PSF subtraction methods to those data. Written in IDL and available in a compiled version, the software includes an integrated calibration database to manage reference files and an interactive data viewer customized for high contrast imaging that allows exploration and manipulation of data.

[ascl:1603.004] gPhoton: Time-tagged GALEX photon events analysis tools

Written in Python, gPhoton calibrates and sky-projects the ~1.1 trillion ultraviolet photon events detected by the microchannel plates on the Galaxy Evolution Explorer Spacecraft (GALEX), archives these events in a publicly accessible database at the Mikulski Archive for Space Telescopes (MAST), and provides tools for working with the database to extract scientific results, particularly over short time domains. The software includes a re-implementation of core functionality of the GALEX mission calibration pipeline to produce photon list files from raw spacecraft data as well as a suite of command line tools to generate calibrated light curves, images, and movies from the MAST database.

[ascl:2011.022] GPCAL: Instrumental polarization calibration in VLBI data

GPCAL performs instrumental polarization calibration in very long baseline interferometry (VLBI) data. It enhances the calibration accuracy by enabling users to fit the model to multiple calibrators data simultaneously and to take into account the calibrators linear polarization structures instead of using the conventional similarity assumption. GPCAL is based on AIPS (ascl:9911.003) and uses ParselTongue (ascl:1208.020) to run AIPS tasks.

[ascl:1512.006] GPC: General Polygon Clipper library

The University of Manchester GPC library is a flexible and highly robust polygon set operations library for use with C, C#, Delphi, Java, Perl, Python, Haskell, Lua, VB.Net and other applications. It supports difference, intersection, exclusive-or and union clip operations, and polygons may be comprised of multiple disjoint contours. Contour vertices may be given in any order - clockwise or anticlockwise, and contours may be convex, concave or self-intersecting, and may be nested (i.e. polygons may have holes). Output may take the form of either polygon contours or tristrips, and hole and external contours are differentiated in the result. GPC is free for non-profit and educational use; a Commercial Use License is required for commercial use.

Internet Archive link provided for archival purposes; per its website, GPC is no longer distributed or available as of August 2020.

[ascl:1210.001] GP2PCF: Brute-force computation of 2-point correlation functions

The two-point correlation function is a simple statistic that quantifies the clustering of a given distribution of objects. In studies of the large scale structure of the Universe, it is an important tool containing information about the matter clustering and the evolution of the Universe at different cosmological epochs. A classical application of this statistic is the galaxy-galaxy correlation function to find constraints on the parameter Omega_m or the location of the baryonic acoustic oscillation peak. This calculation, however, is very expensive in terms of computer power and Graphics Processing Units provide one solution for efficient analysis of the increasingly larger galaxy surveys that are currently taking place.

GP2PCF is a public code in CUDA for performing this computation; with a single GPU board it is possible to achieve 120-fold speedups with respect to a standard implementation in C running on a single CPU. With respect to other solutions such as k-trees the improvement is of a factor of a few retaining full precision. The speedup is comparable to running in parallel in a cluster of O(100) cores.

[ascl:2011.008] GOTHIC: Double nuclei galaxy detector

GOTHIC (Graph-bOosTed iterated HIll Climbing) detects whether a given image of a galaxy has characteristic features of a double nuclei galaxy (DNG). Galaxy interactions and mergers play a crucial role in the hierarchical growth of structure in the universe; galaxy mergers can lead to the formation of elliptical galaxies and larger disk galaxies, as well as drive galaxy evolution through star formation and nuclear activity. During mergers, the nuclei of the individual galaxies come closer and finally form a double nuclei galaxy. Although mergers are common, the detection of double-nuclei galaxies (DNGs) is rare and fairly serendipitous. Their properties can help us understand the formation of supermassive black hole (SMBH) binaries, dual active galactic nuclei (DAGN) and the associated feedback effects. GOTHIC provides an automatic and systematic way to survey data for the discovery of double nuclei galaxies.

[ascl:2005.011] gotetra: Cosmic velocity fields tracking through the use of tetrahedra

gotetra uses phase-space tesselation techniques to extract information about cosmological N-body simulations. The key applications of this Go-based code are the measurement of splashback shells around halos and the generation of high resolution images of density fields. The package includes routines to generates 3D and 2D (projected) density fields from a particle snapshot generated by a cosmological N-body simulation, measure density along lines of sight from the center of halos, and compresse the position space data from cosmological N-body simulations. Included are two helper libraries with functions for calculating cosmological quantities and computing a number of useful mathematical functions.

[ascl:1210.003] GOSSIP: SED fitting code

GOSSIP fits the electro-magnetic emission of an object (the SED, Spectral Energy Distribution) against synthetic models to find the simulated one that best reproduces the observed data. It builds-up the observed SED of an object (or a large sample of objects) combining magnitudes in different bands and eventually a spectrum; then it performs a chi-square minimization fitting procedure versus a set of synthetic models. The fitting results are used to estimate a number of physical parameters like the Star Formation History, absolute magnitudes, stellar mass and their Probability Distribution Functions.

[ascl:2011.016] GoFish: Molecular line detections in protoplanetary disks

GoFish exploits the known rotation of a protoplanetary disk to shift all emission to a common line center in order to stack them, increasing the signal-to-noise of the spectrum, detecting weaker lines, or super-sampling the spectrum to better resolve the line profile.

[ascl:1801.009] Gnuastro: GNU Astronomy Utilities

Gnuastro (GNU Astronomy Utilities) manipulates and analyzes astronomical data. It is an official GNU package of a large collection of programs and C/C++ library functions. Command-line programs perform arithmetic operations on images, convert FITS images to common types like JPG or PDF, convolve an image with a given kernel or matching of kernels, perform cosmological calculations, crop parts of large images (possibly in multiple files), manipulate FITS extensions and keywords, and perform statistical operations. In addition, it contains programs to make catalogs from detection maps, add noise, make mock profiles with a variety of radial functions using monte-carlo integration for their centers, match catalogs, and detect objects in an image among many other operations. The command-line programs share the same basic command-line user interface for the comfort of both the users and developers. Gnuastro is written to comply fully with the GNU coding standards and integrates well with all Unix-like operating systems. This enables astronomers to expect a fully familiar experience in the source code, building, installing and command-line user interaction that they have seen in all the other GNU software that they use. Gnuastro's extensive library is included for users who want to build their own unique programs.

[ascl:2001.015] gnm: The MCMC Jagger

gnm is an implementation of the affine-invariant sampler for Markov chain Monte Carlo (MCMC) that uses the Gauss-Newton-Metropolis (GNM) Algorithm. The GNM algorithm is specialized in sampling highly non-linear posterior probability distribution functions of the form exp(-||f(x)||^2/2). The code includes dynamic hyper-parameter optimization to increase performance of the sampling; other features include the Jacobian tester and an error bars creator.

Would you like to view a random code?