Warpfield (Winds And Radiation Pressure: Feedback Induced Expansion, colLapse and Dissolution) calculates shell dynamics and shell structure simultaneously for isolated massive clouds (≥105 M☉). This semi-analytic 1D feedback model scans a large range of physical parameters (gas density, star formation efficiency, and metallicity) to estimate escape fractions of ionizing radiation fesc, I, the minimum star formation efficiency ∊min required to drive an outflow, and recollapse time-scales for clouds that are not destroyed by feedback.
PyAutoLens models and analyzes galaxy-scale strong gravitational lenses. This automated module suite simultaneously models the lens galaxy's light and mass while reconstructing the extended source galaxy on an adaptive pixel-grid. Source-plane discretization is amorphous, adapting its clustering and regularization to the intrinsic properties of the lensed source. The lens's light is fitted using a superposition of Sersic functions, allowing PyAutoLens to cleanly deblend its light from the source. Bayesian model comparison is used to automatically chose the complexity of the light and mass models. PyAutoLens provides accurate light, mass, and source profiles inferred for data sets representative of both existing Hubble imaging and future Euclid wide-field observations.
ARKCoS (Accelerated radial kernel convolution on the sphere) efficiently convolves pixelated maps on the sphere with radially symmetric kernels with compact support. It performs the convolution along isolatitude rings in Fourier space and integrates in longitudinal direction in pixel space. The computational costs scale linearly with the kernel support, making the method most beneficial for convolution with compact kernels. Typical applications include CMB beam smoothing, symmetric wavelet analyses, and point-source filtering operations. The software is written in C++/CUDA and provides two independent code paths to do the necessary computation either on conventional hardware (CPUs), or on graphics processing units (GPUs).
MAPPINGS V is a update of the MAPPINGS code (ascl:1306.008) and provides new cooling function computations for optically thin plasmas based on the greatly expanded atomic data of the CHIANTI 8 database. The number of cooling and recombination lines has been expanded from ~2000 to over 80,000, and temperature-dependent spline-based collisional data have been adopted for the majority of transitions. The expanded atomic data set provides improved modeling of both thermally ionized and photoionized plasmas; the code is now capable of predicting detailed X-ray spectra of nonequilibrium plasmas over the full nonrelativistic temperature range, increasing its utility in cosmological simulations, in modeling cooling flows, and in generating accurate models for the X-ray emission from shocks in supernova remnants.
pyqz computes the values of log(Q) [the ionization parameter] and 12+log(O/H) [the oxygen abundance, either total or in the gas phase] for a given set of strong emission lines fluxes from HII regions. The log(Q) and 12+log(O/H) values are interpolated from a finite set of diagnostic line ratio grids computed with the MAPPINGS V code (ascl:1807.005). The grids used by pyqz are chosen to be flat, without wraps, to decouple the influence of log(Q) and 12+log(O/H) on the emission line ratios.
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.
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.
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.
THOR solves the three-dimensional nonhydrostatic Euler equations. The code implements an icosahedral grid for the poles where converging meridians lead to increasingly smaller time steps; irregularities in the grid are smoothed using spring dynamics. THOR is designed to run on graphics processing units (GPUs) and is part of the open-source Exoclimes Simulation Platform.
nfield uses a stochastic formalism to compute the IR correlation functions of quantum fields during cosmic inflation in n-field dimensions. This is a necessary 1-loop resummation of the correlation functions to render them finite. The code supports the implementation of n-numbers of coupled test fields (energetically sub-dominant) as well as non-test fields.
AngPow computes the auto (z1 = z2) and cross (z1 ≠ z2) angular power spectra between redshift bins (i.e. Cℓ(z1,z2)). The developed algorithm is based on developments on the Chebyshev polynomial basis and on the Clenshaw-Curtis quadrature method. AngPow is flexible and can handle any user-defined power spectra, transfer functions, bias functions, and redshift selection windows. The code is fast enough to be embedded inside programs exploring large cosmological parameter spaces through the Cℓ(z1,z2) comparison with data.
CLASSgal computes large scale structure observables; it includes all relativistic corrections and computes both the power spectrum Cl(z1,z2) and the corresponding correlation function ξ(θ, z1, z2) of the matter density and the galaxy number fluctuations in linear perturbation theory. These quantities contain the full information encoded in the large scale matter distribution at the level of linear perturbation theory for Gaussian initial perturbations. CLASSgal is a modified version of CLASS (ascl:1106.020).
SPEGID (Single-Pulse Event Group IDentification) identifies astrophysical pulse candidates as trial single-pulse event groups (SPEGs) by first applying Density Based Spatial Clustering of Applications with Noise (DBSCAN) on trial single-pulse events and then merging the clusters that fall within the expected DM (Dispersion Measure) and time span of astrophysical pulses. SPEGID also calculates the peak score for each SPEG in the S/N versus DM space to identify the expected peak-like shape in the signal-to-noise (S/N) ratio versus DM curve of astrophysical pulses. Additionally, SPEGID groups SPEGs that appear at a consistent DM and therefore are likely emitted from the same source. After running SPEGID, periocity.py can be used to find (or verify) the underlying periodicity among a group of SPEGs (i.e., astrophysical pulse candidates).
CAESAR extracts and parameterizes both compact and extended sources from astronomical radio interferometric maps. The processing pipeline is a series of stages that can run on multiple cores and processors. After local background and rms map computation, compact sources are extracted with flood-fill and blob finder algorithms, processed (selection + deblending), and fitted using a 2D gaussian mixture model. Extended source search is based on a pre-filtering stage, allowing image denoising, compact source removal and enhancement of diffuse emission, followed by a final segmentation. Different algorithms are available for image filtering and segmentation. The outputs delivered to the user include source fitted and shape parameters, regions and contours. Written in C++, CAESAR is designed to handle the large-scale surveys planned with the Square Kilometer Array (SKA) and its precursors.
The Markwardt IDL Library contains routines for curve fitting and function minimization, including MPFIT (ascl:1208.019), statistical tests, and non-linear optimization (TNMIN); graphics programs including plotting three-dimensional data as a cube and fixed- or variable-width histograms; adaptive numerical integration (Quadpack), Chebyshev approximation and interpolation, and other mathematical tools; many ephemeris and timing routines; and array and set operations, such as computing the fast product of a large array, efficiently inserting or deleting elements in an array, and performing set operations on numbers and strings; and many other useful and varied routines.
ZBARYCORR determines the barycentric redshift (zB) for a given star. It calculates the positions and velocities of solar system objects, applies the rotation, precession, nutation, and polar motion of the Earth, applies the stellar motion using the Markwardt library (ascl:1807.016), Shapiro delay, and light-travel term, and finally calculates the quantity zB—the barycentric correction independent of the measured redshift. A Python wrapper, BARYCORR (ascl:1807.018), is available.
BARYCORR is a Python interface for ZBARYCORR (ascl:1807.017); it requires the measured redshift and returns the corrected barycentric velocity and time correction.
The Lomb-Scargle periodogram is a common tool in the frequency analysis of unequally spaced data equivalent to least-squares fitting of sine waves. GLS is a solution for the generalization to a full sine wave fit, including an offset and weights (χ2 fitting). Compared to the Lomb-Scargle periodogram, GLS is superior as it provides more accurate frequencies, is less susceptible to aliasing, and gives a much better determination of the spectral intensity.
wdmerger simulates binary white dwarf mergers (and related events) in CASTRO (ascl:1105.010) and provides useful information on the viability of mergers of white dwarfs as a progenitor for Type Ia supernovae.
POWER (Python Open-source Waveform ExtractoR) monitors the status and progress of numerical relativity simulations and post-processes the data products of these simulations to compute the gravitational wave strain at future null infinity.
PUMA (Positional Update and Matching Algorithm) cross-matches low-frequency radio catalogs using a Bayesian positional probability with spectral matching criteria. The code reliably finds the correct spectral indices of sources and recovers ionospheric offsets. PUMA can be used to facilitate all-sky cross-matches with further constraints applied for other science goals.
The Monte Carlo code DAMOCLES models the effects of dust, composed of any combination of species and grain size distributions, on optical and NIR emission lines emitted from the expanding ejecta of a late-time (> 1 yr) supernova. The emissivity and dust distributions follow smooth radial power-law distributions; any arbitrary distribution can be specified by providing the appropriate grid. DAMOCLES treats a variety of clumping structures as specified by a clumped dust mass fraction, volume filling factor, clump size and clump power-law distribution, and the emissivity distribution may also initially be clumped. The code has a large number of variable parameters ranging from 5 dimensions in the simplest models to > 20 in the most complex cases.
Three-Body Integration performs numerical n-body simulations for mapping conditions for close approaches for the relevant parameter space of configurations and mass values of two white dwarfs and a third star. Low tertiary masses of 0.1M⊙ can be studied, and the collision probability can be estimated with good confidence for the case of nearly equal mass white dwarfs.
NRPy+ (Python-based Code generation for Numerical Relativity and Beyond) generates highly-optimized C code from complex tensorial expressions input in Einstein-like notation. NRPy+ uses SymPy as its computer algebra system backend. It is part of the NRPy+/SENR numerical relativity code package for solving Einstein's equations of general relativity to model compact objects at about 1/100 the cost in memory of more traditional, AMR-based numerical relativity codes, thus allowing desktop computers to be used for gravitational wave astrophysics.
SENR (Simple, Efficient Numerical Relativity) provides the algorithmic framework that combines the C codes generated by NRPy+ (ascl:1807.025) into a functioning numerical relativity code. It is part of the numerical relativity code package SENR/NRPy+. The package extends previous implementations of the BSSN reference-metric formulation to a much broader class of curvilinear coordinate systems, making it suitable for modeling physical configurations with approximate or exact symmetries, such as modeling black hole dynamics.
kplr provides a lightweight Pythonic interface to the catalog of planet candidates (Kepler Objects of Interest [KOIs]) in the NASA Exoplanet Archive and the data stored in the Barbara A. Mikulski Archive for Space Telescopes (MAST). kplr automatically supports loading Kepler data using pyfits (ascl:1207.009) and supports two types of data: light curves and target pixel files.
The routines in ktransit create and fit a transiting planet model. The underlying model is a Fortran implementation of the Mandel & Agol (2002) limb darkened transit model. The code calculates a full orbital model and eccentricity can be allowed to vary; radial velocity data can also be calculated via the model and included in the fit.
EVEREST (EPIC Variability Extraction and Removal for Exoplanet Science Targets) removes instrumental noise from light curves with pixel level decorrelation and Gaussian processes. The code, written in Python, generates the EVEREST catalog and offers tools for accessing and interacting with the de-trended light curves. EVEREST exploits correlations across the pixels on the CCD to remove systematics introduced by the spacecraft’s pointing error. For K2, it yields light curves with precision comparable to that of the original Kepler mission. Interaction with the EVEREST catalog catalog is available via the command line and through the Python interface. Though written for K2, EVEREST can be applied to additional surveys, such as the TESS mission, to correct for instrumental systematics and enable the detection of low signal-to-noise transiting exoplanets.
ASP (Ames Stereo Pipeline) provides fully automated geodesy and stereogrammetry tools for processing stereo imagery captured from satellites (around Earth and other planets), robotic rovers, aerial cameras, and historical imagery, with and without accurate camera pose information. It produces cartographic products, including digital elevation models (DEMs), ortho-projected imagery, 3D models, and bundle-adjusted networks of cameras. ASP's data products are suitable for science analysis, mission planning, and public outreach.
xGDS (Exploration Ground Data Systems) synthesizes real world data (from sensors, robots, ROVs, mobile devices, etc) and human observations into rich, digital maps and displays for analysis, decision making, and collaboration. xGDS processes and maps data (including video) in real-time during operations and uses it to support live role-based geolocated note taking. Notes can be used to search for and display important data. The software enables real-time analysis of data, permitting one to make inferences and plan new data collection operations while still in the field.
SSMM (Slotted Symbolic Markov Modeling) reduces time-domain stellar variable observations to classify stellar variables. The method can be applied to both folded and unfolded data, and does not require time-warping for waveform alignment. Written in Matlab, the performance of the supervised classification code is quantifiable and consistent, and the rate at which new data is processed is dependent only on the computational processing power available.
LSC (LINEAR Supervised Classification) trains a number of classifiers, including random forest and K-nearest neighbor, to classify variable stars and compares the results to determine which classifier is most successful. Written in R, the package includes anomaly detection code for testing the application of the selected classifier to new data, thus enabling the creation of highly reliable data sets of classified variable stars.
The Matlab Tool generates a 3D model (WRL, texturized in height false color map) of a defined region of the Mars surface. It defines the region of interest of the Mars surface (by Lat Long), a resolution of the MOLA DTMs to be considered (with a minimum px onground of 468 m), a scale factor to be multiplied to the height of the surface to improve features visibility for bumping or shadowing effect.
barycorrpy (BCPy) is a Python implementation of Wright and Eastman's 2014 code (ascl:1807.017) that calculates precise barycentric corrections well below the 1 cm/s level. This level of precision is required in the search for 1 Earth mass planets in the Habitable Zones of Sun-like stars by the Radial Velocity (RV) method, where the maximum semi-amplitude is about 9 cm/s. BCPy was developed for the pipeline for the next generation Doppler Spectrometers - Habitable-zone Planet Finder (HPF) and NEID. An automated leap second management routine improves upon the one available in Astropy. It checks for and downloads a new leap second file before converting from the UT time scale to TDB. The code also includes a converter for JDUTC to BJDTDB.
rsigma calculates the resonant disturbing function, R(sigma), for a massless particle in an arbitrary orbit perturbed by a planet in circular orbit. This function defines the strength of the resonance (its semi-amplitude) and the location of the stable equilibrium points (the minima). It depends on the variable sigma called critical angle and on the particle's orbital elements a, e, i and the argument of the perihelion. R(sigma) is numerically calculated and the code is valid for arbitrary eccentricities and inclinations, including retrograde orbits.
Corral generates astronomical pipelines. Data processing pipelines represent an important slice of the astronomical software library that include chains of processes that transform raw data into valuable information via data reduction and analysis. Written in Python, Corral features a Model-View-Controller design pattern on top of an SQL Relational Database capable of handling custom data models, processing stages, and communication alerts. It also provides automatic quality and structural metrics based on unit testing. The Model-View-Controller provides concept separation between the user logic and the data models, delivering at the same time multi-processing and distributed computing capabilities.
Aperture masking interferometric data analysis involves measuring phases and amplitudes of fringes formed by interference between holes in the pupil mask. These fringe observables can be measured by computing an analytic model of the point spread function and fitting the relevant set of spatial frequencies directly in the image plane, without recourse to numerical Fourier transforms. The ImPlaneIA pipeline converts aperture masking images to fringe observables by fitting fringes in the image plane, calibrates data from a target of interest with one or more point source calibrators, and contains some basic model-fitting routines. The pipeline can accept different mask geometries, instruments, and observing modes.
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.
FIPS is a cross-platform FITS viewer with a responsive user interface. Unlike other FITS viewers, FIPS uses GPU hardware via OpenGL to provide functionality such as zooming, panning and level adjustments. OpenGL 2.1 and later is supported. FIPS supports all 2D image formats except floating point formats on OpenGL 2.1. FITS image extension has basic limited support.
The vectorized physical domain structure function (SF) algorithm calculates the velocity anisotropy within two-dimensional molecular line emission observations. The vectorized approach is significantly faster than brute force iterative algorithms and is very efficient for even relatively large images. Furthermore, unlike frequency domain algorithms which require the input data to be fully integrable, this algorithm, implemented in Python, has no such requirements, making it a robust tool for observations with irregularities such as asymmetric boundaries and missing data.
PyMieDAP (Python Mie Doubling Adding Program) makes light scattering computations with Mie scattering and radiative transfer computations with full orders of scattering and taking into account the polarization of the light scattered. Full planet modeling at any phase angle is possible. With the included subpackage exopy, it is also possible to simulate systems with a star, a planet and a possible moon.
py-sdm (Support Distribution Machines) is a Python implementation of nonparametric nearest-neighbor-based estimators for divergences between distributions for machine learning on sets of data rather than individual data points. It treats points of sets of data as samples from some unknown probability distribution and then statistically estimates the distance between those distributions, such as the KL divergence, the closely related Rényi divergence, L2 distance, or other similar distances.
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.
Robbie automates cataloging sources, finding variables, and identifying transients in the image domain. It works in a batch processing paradigm with a modular design so components can be swapped out or upgraded to adapt to different input data while retaining a consistent and coherent methodological approach. Robbie is based on commonly used and open software, including AegeanTools (ascl:1212.009) and STILS/TOPCAT (ascl:1101.010).
LEMON is a differential-photometry pipeline, written in Python, that determines the changes in the brightness of astronomical objects over time and compiles their measurements into light curves. This code makes it possible to completely reduce thousands of FITS images of time series in a matter of only a few hours, requiring minimal user interaction.
PCCDPACK analyzes polarimetry data. The set of routines is written in CL-IRAF (including compiled Fortran codes) and analyzes dozens of point objects simultaneously on the same CCD image. A subpackage, specpol, is included to analyze spectropolarimetry data.
PASTA performs median stacking of astronomical sources. Written in Python, it can filter sources, provide stack statistics, generate Karma annotations, format source lists, and read information from stacked Flexible Image Transport System (FITS) images. PASTA was originally written to examine polarization stack properties and includes a Monte Carlo modeler for obtaining true polarized intensity from the observed polarization of a stack. PASTA is also useful as a generic stacking tool, even if polarization properties are not being examined.
VBBinaryLensing forward models gravitational microlensing events using the advanced contour integration method; it supports single and binary lenses. The lens map is inverted on a collection of points on the source boundary to obtain a corresponding collection of points on the boundaries of the images from which the area of the images can be recovered by use of Green’s theorem. The code takes advantage of a number of techniques to make contour integration much more efficient, including using a parabolic correction to increase the accuracy of the summation, introducing an error estimate on each arc of the boundary to enable defining an optimal sampling, and allowing the inclusion of limb darkening. The code is written as a C++ library and wrapped as a Python package, and can be called from either C++ or Python.
perfectns performs dynamic nested sampling and standard nested sampling for spherically symmetric likelihoods and priors, and analyses the samples produced. The spherical symmetry allows the nested sampling algorithm to be followed “perfectly” - i.e. without implementation-specific errors correlations between samples. It is intended for use in research into the statistical properties of nested sampling, and to provide a benchmark for testing the performance of nested sampling software packages used for practical problems - which rely on numerical techniques to produce approximately uncorrelated samples.
spops is a database of populations synthesis simulations of spinning black-hole binary systems, together with a python module to query it. Data are obtained with the startrack and precession [ascl:1611.004] numerical codes to consistently evolve binary stars from formation to gravitational-wave detection. spops allows quick exploration of the interplay between stellar physics and black-hole spin dynamics.
surfinBH predicts the final mass, spin and recoil velocity of the remnant of a binary black hole merger. Trained directly against numerical relativity simulations, these models are extremely accurate, reproducing the results of the simulations at the same level of accuracy as the simulations themselves. Fits such as these play a crucial role in waveform modeling and tests of general relativity with gravitational waves, performed by LIGO.
The Python QSO fitting code (PyQSOFit) measures spectral properties of quasars. Based on Shen's IDL version, this code decomposes different components in the quasar spectrum, e.g., host galaxy, power-law continuum, Fe II component, and emission lines. In addition, it can run Monto Carlo iterations using flux randomization to estimate the uncertainties.
NEBULA performs the radiative transfer of the 3He+ hyperfine transition, radio recombination lines (RRLs), and free-free continuum emission through a model nebula. The model nebula is composed of only H and He within a three-dimension Cartesian grid with arbitrary density, temperature, and ionization structure. The 3He+ line is assumed to be in local thermodynamic equilibrium (LTE), but non-LTE effects and pressure broadening from electron impacts can be included for the RRLs. All spectra are broadened by thermal and microturbulent motions.
Isca provides a framework for the idealized modeling of the global circulation of planetary atmospheres at varying levels of complexity and realism. Though Isca is an outgrowth of models designed for Earth's atmosphere, it may readily be extended into other planetary regimes. Various forcing and radiation options are available. At the simple end of the spectrum a Held-Suarez case is available. An idealized grey radiation scheme, a grey scheme with moisture feedback, a two-band scheme and a multi-band scheme are also available, all with simple moist effects and astronomically-based solar forcing. At the complex end of the spectrum the framework provides a direct connection to comprehensive atmospheric general circulation models.
qp manipulates parametrizations of 1-dimensional probability distribution functions, as suitable for photo-z PDF compression. The code helps determine a parameterization for storing a catalog of photo-z PDFs that balances the available storage resources against the accuracy of the photo-z PDFs and science products reconstructed from the stored parameters.
Nestcheck analyzes nested sampling runs and estimates numerical uncertainties on calculations using them. The package can load results from a number of nested sampling software packages, including MultiNest (ascl:1109.006), PolyChord (ascl:1502.011), dynesty (ascl:1809.013) and perfectns (ascl:1809.005), and offers the flexibility to add input functions for other nested sampling software packages. Nestcheck utilities include error analysis, diagnostic tests, and plots for nested sampling calculations.
dynesty is a Dynamic Nested Sampling package for estimating Bayesian posteriors and evidences. dynesty samples from a given distribution when provided with a loglikelihood function, a prior_transform function (that transforms samples from the unit cube to the target prior), and the dimensionality of the parameter space.
stepped_luneburg investigates the scattered light properties of a Luneburg lens approximated as a series of concentric shells with discrete refractive indices. The optical Luneburg lens has promising applications for low-cost, continuous all-sky monitoring to obtain transit light curves of bright, nearby stars. This code implements a stack-based algorithm that tracks all reflected and refracted rays generated at each optical interface of the lens as described by Snell's law. The Luneburg lens model parameters, such as number of lens layers, the power-law that describes the refractive indices, the number of incident rays, and the initial direction of the incident wavefront can be altered to optimize lens performance. The stepped_luneburg module can be imported within the Python environment or used with scripting, and it is accompanied by two other modules, enc_int and int_map, that help the user to determine the resolving power of the lens and the strength of scattered light haloes for the purpose of quality assessment.
MrMoose (Multi-Resolution Multi-Object/Origin Spectral Energy) fits user-defined models onto a set of multi-wavelength data using a Bayesian framework. The code can handle blended sources, large variation in resolution, and even upper limits consistently. It also generates a series of outputs allowing for an quick interpretation of the results. The code uses emcee (ascl:1303.002), and saves the emcee sampler object, thus allowing users to transfer the output to a personal graphical interface.
RequiSim computes the Variance Weighted Overlap, which is a measure of the bias on the lensing signal from power spectrum modelling bias for any non-linear model. It assumes that the bias on the power spectrum is Gaussian with a covariance described by a user-provided knowledge matrix that describes the covariance in the bias on the power spectrum. The data from the Euclid wide-field survey are included.
galfast generates catalogs for arbitrary, user-supplied Milky Way models, including empirically derived ones. The built-in model set is based on fits to SDSS stellar observations over 8000 deg2 of the sky and includes a three-dimensional dust distribution map. Because of the capability to use empirically derived models, galfast typically produces closer matches to the actual observed counts and color-magnitude diagrams. In particular, galfast-generated catalogs are used to derive the stellar component of “Universe Model” catalogs used by the LSST Project. A key distinguishing characteristic of galfast is its speed. Galfast uses the GPU (with kernels written in NVIDIA C/C++ for CUDA) to offload compute intensive model sampling computations to the GPU, enabling the generation of realistic catalogs to full LSST depth in hours (instead of days or weeks), making it possible to study proposed science cases with high precision.
Barcode (BAyesian Reconstruction of COsmic DEnsity fields) samples the primordial density fields compatible with a set of dark matter density tracers after cosmic evolution observed in redshift space. It uses a redshift space model based on the analytic solution of coherent flows within a Hamiltonian Monte Carlo posterior sampling of the primordial density field; this method is applicable to analytically derivable structure formation models, such as the Zel'dovich approximation, but also higher order schemes such as augmented Lagrangian perturbation theory or even particle mesh models. The algorithm is well-suited for analysis of the dark matter cosmic web implied by the observed spatial distribution of galaxy clusters, such as obtained from X-ray, SZ or weak lensing surveys, as well as that of the intergalactic medium sampled by the Lyman alpha forest. In these cases, virialized motions are negligible and the tracers cannot be modeled as point-like objects. Barcode can be used in all of these contexts as a baryon acoustic oscillation reconstruction algorithm.
JETGET accesses, visualizes, and analyses (magnetized-)fluid dynamics data stored in Hierarchical Data Format (HDF) and ASCII files. Although JETGET has been optimized to handle data output from jet simulations using the Zeus code (ascl:1306.014) from NCSA, it is also capable of analyzing other data output from simulations using other codes. JETGET can select variables from the data files, render both two- and three-dimensional graphics and analyze and plot important physical quantities. Graphics can be saved in encapsulated Postscript, JPEG, VRML, or saved into an MPEG for later visualization and/or presentations. The strength of JETGET in extracting the physics underlying such phenomena is demonstrated as well as its capabilities in visualizing the 3-dimensional features of the simulated magneto-hydrodynamic jets. The JETGET tool is written in Interactive Data Language (IDL) and uses a graphical user interface to manipulate the data. The tool was developed on a LINUX platform and can be run on any platform that supports IDL.
VaeX (Visualization and eXploration) interactively visualizes and explores big tabular datasets. It can calculate statistics such as mean, sum, count, and standard deviation on an N-dimensional grid up to a billion (109) objects/rows per second. Visualization is done using histograms, density plots, and 3d volume rendering, allowing interactive exploration of big data. VaeX uses memory mapping, zero memory copy policy and lazy computations for best performance, and integrates well with the Jupyter/IPython notebook/lab ecosystem.
STARRY computes light curves for various applications in astronomy: transits and secondary eclipses of exoplanets, light curves of eclipsing binaries, rotational phase curves of exoplanets, light curves of planet-planet and planet-moon occultations, and more. By modeling celestial body surface maps as sums of spherical harmonics, STARRY does all this analytically and is therefore fast, stable, and differentiable. Coded in C++ but wrapped in Python, STARRY is easy to install and use.
Echelle++ simulates realistic raw spectra based on the Zemax model of any spectrograph, with a particular emphasis on cross-dispersed Echelle spectrographs. The code generates realistic spectra of astronomical and calibration sources, with accurate representation of optical aberrations, the shape of the point spread function, detector characteristics, and photon noise. It produces high-fidelity spectra fast, an important feature when testing data reduction pipelines with a large set of different input spectra, when making critical choices about order spacing in the design phase of the instrument, or while aligning the spectrograph during construction. Echelle++ also works with low resolution, low signal to noise, multi-object, IFU, or long slit spectra, for simulating a wide array of spectrographs.
The 3D Monte Carlo radiative transfer code ARTES calculates reflected light and thermal radiation in a spherical grid with a parameterized distribution of gas, clouds, hazes, and circumplanetary material. Designed specifically for (polarized) scattered light simulations of planetary atmospheres, it can compute both reflected stellar light and thermal emission from the planet for an arbitrary atmospheric structure and distribution of opacity sources. Multiple scattering, absorption, and polarization are fully treated and the output includes an image, spectrum, or phase curve. Several tools are included to create opacities and scattering matrices for molecules and clouds.
The pycraf Python package provides functions and procedures for spectrum-management compatibility studies, such as calculating the interference levels at a radio telescope produced from a radio broadcasting tower. It includes an implementation of ITU-R Recommendation P.452-16 for calculating path attenuation for the distance between an interferer and the victim service. It supports NASA's Shuttle Radar Topography Mission (SRTM) data for height-profile generation, includes a full implementation of ITU-R Rec. P.676-10, which provides two atmospheric models to calculate the attenuation for paths through Earth's atmosphere, and provides various antenna patterns necessary for compatibility studies (e.g., RAS, IMT, fixed-service links). The package can also convert power flux densities, field strengths, transmitted and received powers at certain distances and frequencies into each other.
PyUltraLight computes non-relativistic ultralight dark matter dynamics in a static spacetime background. It uses pseudo-spectral methods to compute the evolution of a complex scalar field governed by the Schrödinger-Poisson system of coupled differential equations. Computations are performed on a fixed-grid with periodic boundary conditions, allowing for a decomposition of the field in momentum space by way of the discrete Fourier transform. The field is then evolved through a symmetrized split-step Fourier algorithm, in which nonlinear operators are applied in real space, while spatial derivatives are computed in Fourier space. Fourier transforms within PyUltraLight are handled using the pyFFTW pythonic wrapper around FFTW (ascl:1201.015).
ODTBX (Orbit Determination Toolbox) provides orbit determination analysis, advanced mission simulation, and analysis for concept exploration, proposal, early design phase, and/or rapid design center environments. The core ODTBX functionality is realized through a set of estimation commands that incorporate Monte Carlo data simulation, linear covariance analysis, and measurement processing at a generic level; its functions and utilities are combined in a flexible architecture to allow modular development of navigation algorithms and simulations. ODTBX is written in Matlab and Java.
Eclairs calculates matter power spectrum based on standard perturbation theory and regularized pertubation theory. The codes are written in C++ with a python wrapper which is designed to be easily combined with MCMC samplers.
GiRaFFE leverages the Einstein Toolkit's (ascl:1102.014) highly-scalable infrastructure to create large-scale simulations of magnetized plasmas in strong, dynamical spacetimes on adaptive-mesh refinement (AMR) grids. It is based on IllinoisGRMHD, a user-friendly, open-source, dynamical-spacetime GRMHD code, and is highly scalable, to tens of thousands of cores.
The catsHTM package quickly accesses and cross-matches large astronomical catalogs that have been reformatted into the HDF5-based file format. It performs efficient cone searches at resolutions from a few arc-seconds to degrees within a few milliseconds time, cross-match numerous catalogs, and can do general searches.
STiC is a MPI-parallel non-LTE inversion code for observed full-Stokes observations. The code processes lines from multiple atoms in non-LTE, including partial redistribution effects of scattered photons in angle and frequency of scattered photons (PRD), and can be used with model atmospheres that have a complex depth stratification without introducing artifacts.
cuFFS (CUDA-accelerated Fast Faraday Synthesis) performs Faraday rotation measure synthesis; it is particularly well-suited for performing RM synthesis on large datasets. Compared to a fast single-threaded and vectorized CPU implementation, depending on the structure and format of the data cubes, cuFFs achieves an increase in speed of up to two orders of magnitude. The code assumes that the pixels values are IEEE single precision floating points (BITPIX=-32), and the input cubes must have 3 axes (2 spatial dimensions and 1 frequency axis) with frequency axis as NAXIS1. A package is included to reformat data with individual stokes Q and U channel maps to the required format. The code supports both the HDFITS format and the standard FITS format, and is written in C with GPU-acceleration achieved using Nvidia's CUDA parallel computing platform.
XCLASS (eXtended CASA Line Analysis Software Suite) extends CASA (ascl:1107.013) with new functions for modeling interferometric and single dish data. It provides a tool for calculating synthetic spectra by solving the radiative transfer equation for an isothermal object in one dimension, taking into account the finite source size and dust attenuation. It also includes an interface for MAGIX (ascl:1303.009) to find the parameter set that most closely reproduces the data.
SOPHISM models astronomical instrumentation from the entrance of the telescope to data acquisition at the detector, along with software blocks dealing with, for example, demodulation, inversion, and compression. The code performs most analyses done with light in astronomy, such as differential photometry, spectroscopy, and polarimetry. The simulator offers flexibility and implementation of new effects and subsystems, making it user-adaptable for a wide variety of instruments. SOPHISM can be used for all stages of instrument definition, design, operation, and lifetime tracking evaluation.
APPLawD (Accurate Disk Potentials for Power Law Surface densities) determines the gravitational potential in the equatorial plane of a flat axially symmetric disk (inside and outside) with finite size and power law surface density profile. Potential values are computed on the basis of the density splitting method, where the residual Poisson kernel is expanded over the modulus of the complete elliptic integral of the first kind. In contrast with classical multipole expansions of potential theory, the residual series converges linearly inside sources, leading to very accurate potential values for low order truncations of the series. The code is easy to use, works under variable precision, and is written in Fortran 90 with no external dependencies.
Miex calculates Mie scattering coefficients and efficiency factors for broad grain size distributions and a very wide wavelength range (λ ≈ 10-10-10-2m) of the interacting radiation and incorporates standard solutions of the scattering amplitude functions. The code handles arbitrary size parameters, and single scattering by particle ensembles is calculated by proper averaging of the respective parameters.
DDS simulates scattered light and thermal reemission in arbitrary optically dust distributions with spherical, homogeneous grains where the dust parameters (optical properties, sublimation temperature, grain size) and SED of the illuminating/ heating radiative source can be arbitrarily defined. The code is optimized for studying circumstellar debris disks where large grains (i.e., with large size parameters) are expected to determine the far-infrared through millimeter dust reemission spectral energy distribution. The approach to calculate dust temperatures and dust reemission spectra is only valid in the optically thin regime. The validity of this constraint is verified for each model during the runtime of the code. The relative abundances of different grains can be arbitrarily chosen, but must be constant outside the dust sublimation region., i.e., the shape of the (arbitrary) radial dust density distribution outside the dust sublimation region is the same for all grain sizes and chemistries.
Firefly provides interactive exploration of particle-based data in the browser. The user can filter, display vector fields, and toggle the visibility of their customizable datasets all on-the-fly. Different Firefly visualizations, complete with preconfigured data and camera view-settings, can be shared by URL. As Firefly is written in WebGL, it can be hosted online, though Firefly can also be used locally, without an internet connection. Firefly was developed with simulations of galaxy formation in mind but is flexible enough to display any particle-based data. Other features include a stereoscopic 3D picture mode and mobile compatibility.
An extension to synphot (ascl:1811.001), stsynphot implements synthetic photometry package for HST and JWST support. The software constructs spectra from various grids of model atmosphere spectra, parameterized spectrum models, and atlases of stellar spectrophotometry. It also simulates observations specific to HST and JWST, computes photometric calibration parameters for any supported instrument mode, and plots instrument-specific sensitivity curves and calibration target spectra.
stginga customizes Ginga to aid data analysis for the data supported by STScI (e.g., HST or JWST). For instance, it provides plugins and configuration files that understand HST and JWST data products.
OCD (O'Connell Effect Detector using Push-Pull Learning) detects eclipsing binaries that demonstrate the O'Connell Effect. This time-domain signature extraction methodology uses a supporting supervised pattern detection algorithm. The methodology maps stellar variable observations (time-domain data) to a new representation known as Distribution Fields (DF), the properties of which enable efficient handling of issues such as irregular sampling and multiple values per time instance. Using this representation, the code applies a metric learning technique directly on the DF space capable of specifically identifying the stars of interest; the metric is tuned on a set of labeled eclipsing binary data from the Kepler survey, targeting particular systems exhibiting the O’Connell Effect. This code is useful for large-scale data volumes such as that expected from next generation telescopes such as LSST.
Synphot simulates photometric data and spectra, observed or otherwise. It can incorporate the user's filters, spectra, and data, and use of a pre-defined standard star (Vega), bandpass, or extinction law. synphot can also construct complicated composite spectra using different models, simulate observations, and compute photometric properties such as count rate, effective wavelength, and effective stimulus. It can manipulate a spectrum by, for example, applying redshift, or normalize it to a given flux value in a given bandpass. Synphot can also sample a spectrum at given wavelengths, plot a quick-view of a spectrum, and perform repetitive operations such as simulating the observations of multiple type of sources through multiple bandpasses. Synphot understands Astropy (ascl:1304.002) models and units and is an Astropy affiliated package.
DRAGONS (Data Reduction for Astronomy from Gemini Observatory North and South) is Gemini's Python-based data reduction platform. DRAGONS offers an automation system that allows for hands-off pipeline reduction of Gemini data, or of any other astronomical data once configured. The platform also allows researchers to control input parameters and in some cases will offer to interactively optimize some data reduction steps, e.g. change the order of fit and visualize the new solution.
binaryBHexp (binary black hole explorer) uses surrogate models of numerical simulations to generate on-the-fly interactive visualizations of precessing binary black holes. These visualizations can be generated in a few seconds and at any point in the 7-dimensional parameter space of the underlying surrogate models. These visualizations provide a valuable means to understand and gain insights about binary black hole systems and gravitational physics such as those detected by the LIGO gravitational wave detector.
SEP (Source Extraction and Photometry) makes the core algorithms of Source Extractor (ascl:1010.064) available as a library of standalone functions and classes. These operate directly on in-memory arrays (no FITS files or configuration files). The code is derived from the Source Extractor code base (written in C) and aims to produce results compatible with Source Extractor whenever possible. SEP consists of a C library with no dependencies outside the standard library and a Python module that wraps the C library in a Pythonic API. The Python wrapper operates on NumPy arrays with NumPy as its only dependency. It is generated using Cython.
From Source Extractor, SEP includes background estimation, image segmentation (including on-the-fly filtering and source deblending), aperture photometry in circular and elliptical apertures, and source measurements such as Kron radius, "windowed" position fitting, and half-light radius. It also adds the following features that are not available in Source Extractor: optimized matched filter for variable noise in source extraction; circular annulus and elliptical annulus aperture photometry functions; local background subtraction in shape consistent with aperture in aperture photometry functions; exact pixel overlap mode in all aperture photometry functions; and masking of elliptical regions on images.
Shark is a flexible semi-analytic galaxy formation model for easy exploration of different physical processes. Shark has been implemented with several models for gas cooling, active galactic nuclei, stellar and photo-ionization feedback, and star formation (SF). The software can determine the stellar mass function and stellar–halo mass relation at z=0–4; cosmic evolution of the star formation rate density, stellar mass, atomic and molecular hydrogen; local gas scaling relations; and structural galaxy properties. It performs particularly well for the mass–size relation for discs/bulges, the gas–stellar mass and stellar mass–metallicity relations. Shark is written in C++11 and has been parallelized with OpenMP.
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.
Flame reduces near-infrared and optical multi-object spectroscopic data. Although the pipeline was created for the LUCI instrument at the Large Binocular Telescope, Flame, written in IDL, is modular and can be adapted to work with data from other instruments. The software uses 2D transformations, thus using one interpolation step to wavelength calibrate and rectify the data. The γ(x, y) transformation also includes the spatial misalignment between frames, which can be measured from a reference star observed simultaneously with the science targets; sky subtraction can be performed via nodding and/or modelling of the sky spectrum.
Pylians facilitates the analysis of numerical simulations (both N-body and hydro). This set of libraries, written in python, cython and C, compute power spectra, bispectra, and correlation functions, identifies voids, and populates halos with galaxies using an HOD. Pylians can also apply HI+H2 corrections to the output of hydrodynamic simulations, makes 21cm maps, computes DLAs column density distribution functions, and plots density fields.
RLOS (Relativistic Line Of Sight) uses hydrocode output data, such as that from PLUTO (ascl:1010.045), to create synthetic images depicting what a model relativistic astrophysical jet looks like to a stationary observer. The approximate time-delayed imaging algorithm used is implemented within existing line-of-sight code. The software has the potential to study a variety of dynamical astrophysical phenomena in collaboration with other imaging and simulation tools.
MillCgs clusters galaxies from the semi-analytic models run on top of the Millennium Simulation to identify Compact Groups. MillCgs uses a machine learning clustering algorithm to find the groups and then runs analytics to filter out the groups that do not fit the user specified criteria. The package downloads the data, processes it, and then creates graphs of the data.
The SIM5 library contains routines for relativistic raytracing and radiation transfer in GR. Written C with a Python interface, it has a special focus on raytracing from accretion disks, tori, hot spots or any other 3D configuration of matter in Kerr geometry, but it can be used with any other metric as well. It handles both optically thick and thin sources as well as transport of polarization of the radiation and calculates the propagation of light rays from the source to an observer through a curved spacetime. It supports parallelization and runs on GPUs.
muLAn analyzes and fits light curves of gravitational microlensing events. The code includes all classical microlensing models (for example, single and binary microlenses, ground- and space-based parallax effects, orbital motion, finite-source effects, and limb-darkening); these can be combined into several time intervals of the analyzed light curve. Minimization methods include an Affine-Invariant Ensemble Sampler to generate a multivariate proposal function while running several Markov Chain Monte Carlo (MCMC) chains, for the set of parameters which is chosen to be fit; non-fitting parameters can be either kept fixed or set on a grid defined by the user. Furthermore, the software offers a model-free option to align all data sets together and allow inspection the light curve before any modeling work. It also comes with many useful routines (export publication-quality figures, data formatting and cleaning) and state-of-the-art statistical tools.
Modeling results can be interpreted using an interactive html page which contains all information about the light curve model, caustics, source trajectory, best-fit parameters and chi-square. Parameters uncertainties and statistical properties (such as multi-modal features of the posterior density) can be assessed from correlation plots. The code is modular, allowing the addition of other computation or minimization routines by directly adding their Python files without modifying the main code. The software has been designed to be easy to use even for the newcomer in microlensing, with external, synthetic and self-explanatory setup files containing all important commands and option settings. The user may choose to launch the code through command line instructions, or to import muLAn within another Python project like any standard Python package.
DiskSim is a source-code distribution of the SPH accretion disk modeling code previously released in a Windows executable form as FITDisk (ascl:1305.011). The code released now is the full research code in Fortran and can be modified as needed by the user.
pygad provides a framework for dealing with Gadget snapshots. The code reads any of the many different Gadget (ascl:0003.001) formats, allows easy masking snapshots to particles of interest, decorates the data blocks with units, allows to add automatically updating derived blocks, and provides several binning and plotting routines, among other tasks, to provide convenient, intuitive handling of the Gadget data without the need to worry about technical details. pygad provides access to single stellar population (SSP) models, has an interface to Rockstar (ascl:1210.008) output files, provides its own friends-of-friends (FoF) finder, calculates spherical overdensities, and has a sub-module to generate mock absorption lines.
radon performs a Fast Radon Transform (FRT) on image data for streak detection. The software finds short streaks and multiple streaks, convolves the images with a given PSF, and tracks the best S/N results and find a automatic threshold. It also calculates the streak parameters in the input image and the streak parameters in the input image. radon has a simulator that can make multiple streaks of different intensities and coordinates, and can simulate random streaks with parameters chosen uniformly in a user-defined range.
VoigtFit fits Voigt profiles to absorption lines. It fits multiple components for various atomic lines simultaneously, allowing parameters to be tied and fixed, and can automatically fit a polynomial continuum model together with the line profiles. A physical model can be used to constrain thermal and turbulent broadening of absorption lines as well as implementing molecular excitation models. The code uses a χ2 minimization approach to find the best solution and offers interactive features such as manual continuum placement locally around each line, manual masking of undesired fitting regions, and interactive definition of velocity components for various elements, improving the ease of estimating initial guesses.
Vplanet simulates planetary system evolution with a focus on habitability. Physical models, typically consisting of ordinary differential equations for stellar, orbital, tidal, rotational, atmospheric, internal, magnetic, climate, and galactic evolution, are coupled together to simulate evolution for the age of a system.
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.
PENTACLE calculates gravitational interactions between particles within a cut-off radius and a Barnes-Hut tree method for gravity from particles beyond. It uses FDPS (ascl:1604.011) to parallelize a Barnes-Hut tree algorithm for a memory-distributed supercomputer. The software can handle 1-10 million particles in a high-resolution N-body simulation on CPU clusters for collisional dynamics, including physical collisions in a planetesimal disc.
Pulsarhunter searches for and confirms pulsars; it provides a set of time domain optimization tools for processing timeseries data produced by SIGPROC (ascl:1107.016). The software can natively write candidate lists for JReaper (included in the package), removing the need to manually import candidates into JReaper; JReaper also reads the PulsarHunter candidate file format.
cuvarbase provides a Python (2.7+) library for performing period finding (Lomb-Scargle, Phase Dispersion Minimization, Conditional Entropy, Box-least squares) on astronomical time-series datasets. Speedups over CPU implementations depend on the algorithm, dataset, and GPU capabilities but are typically ~1-2 orders of magnitude and are especially high for BLS and Lomb-Scargle. Unit tested and available via pip or from source at GitHub.
This Python package allows the user to setup and run an agent-based simulation of a SETI survey. The package allows the creation of a population of observing and transmitting civilisations. Each transmitter and observer conducts their activities according to an input strategy. The success of observers and transmitters can then be recorded, and multiple simulations can be run for Monte Carlo Realisation.
This package is therefore a flexible framework in which to simulate and test different SETI strategies, both as an Observer and as a Transmitter. It is primarily designed with radio SETI in mind, but is sufficiently flexible to simulate all forms of electromagnetic SETI, and potentially neutrino and gravitational wave SETI.
WISP (Wenger Interferometry Software Package) is a radio interferometry calibration, reduction, imaging, and analysis package. WISP is a collection of Python code implemented through CASA (ascl:1107.013). Its generic and modular framework is designed to handle any continuum or spectral line radio interferometry data.
GLADIS (GLobal Accretion Disk Instability Simulation) computes the time-dependent evolution of a black hole accretion disk, in one-dimensional, axisymmetric, vertically integrated scheme. The code solves two partial-differential equations of hydrodynamics for surface density and temperature evolution, i.e., given by viscous diffusion and energy conservation. Accretion disks can be subject to radiation-pressure instability if the stress tensor is proportional to the total (gas plus radiation) pressure. In the gas-pressure dominated case there is no instability. An intermediate case is provided in the code by the square root of the gas and total pressures. GLADIS is parallelized with MPI, and sample .ini and run command files are provided with the code.
PFANT computes a synthetic spectrum assuming local thermodynamic equilibrium from a given stellar model atmosphere and lists of atomic and molecular lines; it provides large wavelength coverage and line lists from ultraviolet through the visible and near-infrared. PFANT has been optimized for speed, offers error reporting, and command-line configuration options.
aesop (ARC Echelle Spectroscopic Observation Pipeline) analyzes echelle spectra for observations made by the Astrophysics Research Consortium (ARC) Echelle Spectrograph on the ARC 3.5 m Telescope at Apache Point Observatory. It is a high resolution spectroscopy software toolkit that picks up where the traditional IRAF reduction scripts leave off, and offers blaze function normalization by polynomial fits to observations of early-type stars, a robust least-squares normalization method, and radial velocity measurements (or offset removals) via cross-correlation with model spectra, including barycentric radial velocity calculations. It also concatenates multiple echelle orders into a simple 1D spectrum and provides approximate flux calibration.
SPAMCART generates synthetic spectral energy distributions and intensity maps from smoothed particle hydrodynamics simulation snapshots. It follows discrete luminosity packets as they propagate through a density field, and computes the radiative equilibrium temperature of the ambient dust from their trajectories. The sources can be extended and/or embedded, and discrete and/or diffuse. The density is not mapped on to a grid, and therefore the calculation is performed at exactly the same resolution as the hydrodynamics. The code strictly adheres to Kirchhoff's law of radiation. The algorithm is based on the Lucy Monte Carlo radiative transfer method and is fairly simple to implement, as it uses data structures that are already constructed for other purposes in modern particle codes
Fermipy facilitates analysis of data from the Large Area Telescope (LAT) with the Fermi Science Tools. It is built on the pyLikelihood interface of the Fermi Science Tools and provides a set of high-level tools for performing common analysis tasks, including data and model preparation with the gt-tools, extracting a spectral energy distribution (SED) of a source, and generating TS and residual maps for a region of interest. Fermipy also finds new source candidates and can localize a source or fit its spatial extension. The package uses a configuration-file driven workflow in which the analysis parameters (data selection, IRFs, and ROI model) are defined in a YAML configuration file. Analysis is executed through a python script that calls the methods of GTAnalysis to perform different analysis operations.
ExoGAN (Exoplanets Generative Adversarial Network) analyzes exoplanetary atmospheres using an unsupervised deep-learning algorithm that recognizes molecular features, atmospheric trace-gas abundances, and planetary parameters. After training, ExoGAN can be applied to a large number of instruments and planetary types and can be used either as a final atmospheric analysis or to provide prior constraints to subsequent retrieval.
easyaccess facilitates access to astronomical catalogs stored in SQL Databases. It is an enhanced command line interpreter and provides a custom interface with custom commands and was specifically designed to access data from the Dark Energy Survey Oracle database, including autocompletion of tables, columns, users and commands, simple ways to upload and download tables using csv, fits and HDF5 formats, iterators, search and description of tables among others. It can easily be extended to other surveys or SQL databases. The package is written in Python and supports customized addition of commands and functionalities.
The stellar classification code galclassify is a stand-alone version of Galaxia (ascl:1101.007). It classifies and generates a synthetic population for each star using input containing observables in a fixed format rather than using a precomputed population over a large field. It is suitable for individual stellar classifications, but slow if you want to classify large samples of stars.
PynPoint processes and analyzes high-contrast imaging data of exoplanets and circumstellar disks. The generic, end-to-end pipeline's modular architecture separates the core functionalities and the pipeline modules. These modules have specific tasks such as background subtraction, frame selection, centering, PSF subtraction with principal component analysis, estimation of detection limits, and photometric and astrometric analysis. All modules store their results in a central database. Management of the available hardware by the backend of the pipeline is in particular an advantage for data sets containing thousands of images, as is common in the mid-infrared wavelength regime. This version of PynPoint is a significant rewrite of the earlier PynPoint package (ascl:1501.001).
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.
distlink computes the minimum orbital intersection distance (MOID), or global minimum of the distance between the points lying on two Keplerian ellipses by finding all stationary points of the distance function, based on solving an algebraic polynomial equation of 16th degree. The program tracks numerical errors and carefully treats nearly degenerate cases, including practical cases with almost circular and almost coplanar orbits. Benchmarks confirm its high numeric reliability and accuracy, and even with its error-controlling overheads, this algorithm is a fast MOID computation method that may be useful in processing large catalogs. Written in C++, the library also includes auxiliary functions.
Lightkurve analyzes astronomical flux time series data, in particular the pixels and light curves obtained by NASA’s Kepler, K2, and TESS exoplanet missions. This community-developed Python package is designed to be user friendly to lower the barrier for students, astronomers, and citizen scientists interested in analyzing data from these missions. Lightkurve provides easy tools to download, inspect, and analyze time series data and its documentation is supported by a large syllabus of tutorials.
GENGA (Gravitational ENcounters with Gpu Acceleration) integrates planet and planetesimal dynamics in the late stage of planet formation and stability analyses of planetary systems. It uses mixed variable integration when the motion is a perturbed Kepler orbit and combines this with a direct N-body Bulirsch-Stoer method during close encounters. It supports three simulation modes: 1.) integration of up to 2048 massive bodies; 2.) integration with up to a million test particles; and 3.) parallel integration of a large number of individual planetary systems.
Astrochemistry database of chemical species.
AUTOSPEC provides fast, automated extraction of high quality 1D spectra from astronomical datacubes with minimal user effort. AutoSpec takes an integral field unit (IFU) datacube and a simple parameter file in order to extract a 1D spectra for each object in a supplied catalogue. A custom designed cross-correlation algorithm improves signal to noise as well as isolates sources from neighboring contaminants.
Juliet essentially serves as a wrapper of other tools, including Batman (ascl:1510.002), George (ascl:1511.015), Dynesty (ascl:1809.013) and AstroPy (ascl:1304.002), to analyze and model transits, radial-velocities, or both from multiple instruments at the same time. Using nested sampling algorithms, it performs a thorough sampling of the parameter space and a model comparison via Bayesian evidences. Juliet also fits transiting and non-transiting multi-planetary systems, and Gaussian Processes (GPs) which might share hyperparameters between the photometry and radial-velocities simultaneously (e.g., stellar rotation periods).
psrqpy directly queries the Australia Telescope National Facility (ATNF) Pulsar Catalogue by downloading and parsing the full catalog database, which is cached and can be reused. The module assists astronomers who want access to the latest pulsar information via a script rather than through the standard web interface.
The OctApps library provides various functions, written in Octave, for performing searches for the weak signatures of continuous gravitational waves from rapidly-rotating neutron stars amidst the instrumental noise of the LIGO and Virgo detectors.
The Core Flight Executive is a portable, platform-independent embedded system framework that is the basis for flight software for satellite data systems and instruments; cFE can be used on other embedded systems as well. The Core Flight Executive is written in C and depends on the software library Operating System Abstraction Layer (OSAL), which is available at https://sourceforge.net/projects/osal/.
OCFit fits and analyzes O-C diagrams using Genetic Algorithms and Markov chain Monte Carlo methods. The MC method is used to determine a very good estimation of errors of the parameters. Unlike some other fitting routines, OCFit does not need any initial values of fitted parameters. An intuitive graphic user interface is provided for ease of fitting, and nine common models of periodic O-C changes are included.
The Core Cosmology Library (CCL) computes basic cosmological observables and provides predictions for many cosmological quantities, including distances, angular power spectra, correlation functions, halo bias and the halo mass function through state-of-the-art modeling prescriptions. Fiducial specifications for the expected galaxy distributions for the Large Synoptic Survey Telescope (LSST) are also included, together with the capability of computing redshift distributions for a user-defined photometric redshift model. Predictions for correlation functions of galaxy clustering, galaxy-galaxy lensing and cosmic shear are within a fraction of the expected statistical uncertainty of the observables for the models and in the range of scales of interest to LSST. CCL is written in C and has a python interface.
The unwise_psf Python module renders point spread function (PSF) models appropriate for use in modeling of unWISE coadd images. unwise_psf translates highly detailed single-exposure WISE PSF models in detector coordinates to the corresponding pixelized PSF models in coadd space, accounting for subtleties including the WISE scan direction and its considerable variation near the ecliptic poles. Applications of the unwise_psf module include performing forced photometry on unWISE coadds, constructing WISE-selected source catalogs based on unWISE coadds and masking unWISE coadd regions contaminated by bright stars.
Galaxia_wrap is a python wrap around the popular Galaxia tool (ascl:1101.007) for generating mock stellar surveys, such as a magnitude limited survey, using a built-in Galaxy model or directly from n-body data. It also offers n-body functionality and has been used to infer the age distribution of a specific stellar tracer population.
The ssos pipeline detects and identifies known and unknown Solar System Objects (SSOs) in astronomical images. ssos requires at least 3 images with overlapping field-of-views in the sky taken within a reasonable amount of time (e.g., 2 hours, 1 night). SSOs are detected mainly by judging the apparent motion of all sources in the images. The pipeline serves as a wrapper for the SExtractor (ascl:1010.064) and SCAMP (ascl:1010.063) software suites and allows different source extraction strategies to be chosen. All sources in the images are subject to a highly configurable filter pipeline. ssos is a versatile, light-weight, and easy-to-use software for surveys or PI-observation campaigns lacking a dedicated SSO detection pipeline.
Photon makes simple 1D plots in python. It uses mainly matplotlib and PyQt5 and has been build to be fully customizable, allowing the user to change the fontstyle, fontsize, fontcolors, linewidth of the axes, thickness, and other parameters, and see the changes directly in the plot. Once a customization is created, it can be saved in a configuration file and reloaded for future use, allowing reuse of the customization for other plots. The main tool is a graphical user interface and it is started using a command line interface.
SEDobs uses state-of-the-art theoretical galaxy SEDs (spectral energy distributions) to create simulated observations of distant galaxies. It used BC03 and M05 theoretical models and allows the user to configure the simulated observation that are needed. For a given simulated galaxy, the user is able to simulate multi-spectral and multi-photometric observations.
bettermoments measures precise line-of-sight velocities from Doppler shifted lines to determine small scale deviations indicative of, for example, embedded planets.
The Python suite eddy recovers precise rotation profiles of protoplanetary disks from Doppler shifted line emission, providing an easy way to fit first moment maps and the inference of a rotation velocity from an annulus of spectra.
Bilby provides a user-friendly interface to perform parameter estimation. It is primarily designed and built for inference of compact binary coalescence events in interferometric data, such as analysis of compact binary mergers and other types of signal model including supernovae and the remnants of binary neutron star mergers, but it can also be used for more general problems. The software is flexible, allowing the user to change the signal model, implement new likelihood functions, and add new detectors. Bilby can also be used to do population studies using hierarchical Bayesian modelling.
stellarWakes uses stellar kinematic data to search for dark matter (DM) subhalos through their gravitational perturbations to the stellar phase-space distribution.
Supernova Time Delays (SNTD) simulates and measures time delay of multiply-imaged supernovae, and offers an improved characterization of the uncertainty caused by microlensing. Lensing time delays can be determined by fitting the multiple light curves of these objects; measuring these delays provide precise tests of lens models or constraints on the Hubble constant and other cosmological parameters that are independent of the local distance ladder. Fitting the effects of microlensing without an accurate prior often leads to biases in the time delay measurement and over-fitting to the data; this can be mitigated by using a Gaussian Process Regression (GPR) technique to determine the uncertainty due to microlensing. SNTD can produce accurate simulations for wide-field time domain surveys such as LSST and WFIRST.
The Limited Post-Newtonian N-body code (LPNN) simulates post-Newtonian interactions between a massive object and many low-mass objects. The interaction between one massive object and low-mass objects is calculated by post-Newtonian approximation, and the interaction between low-mass objects is calculated by Newtonian gravity. This code is based on the sticky9 code, and can be accelerated with the use of GPU in a CUDA (version 4.2 or earlier) environment.
PyMF performs spatial filtering (matched filter, matched multifilter, constrained matched filter and constrained matched mutifilter) image processing that provides optimal reduction of the contamination introduced by sources that can be approximated by templates. These techniques use the flat-sky approximation.
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.
LiveData is a multibeam single-dish data reduction system for bandpass calibration and gridding. It is used for processing Parkes multibeam and Mopra data.
The RPFITS data file format records synthesis visibility data obtained from the Australia Telescope Compact Array (ATCA) at Narrabri, NSW. It is also used for single-dish spectral line data obtained from Parkes and Mopra, including Parkes multibeam data. RPFITS superficially resembles random group FITS, but differs in important respects, making it incompatible with standard FITS software such as FITSIO (ascl:1010.001) and FTOOLS (ascl:9912.002) and, in particular, it precludes the use of fv (ascl:1205.005). The RPFITS Fortran library contains routines for reading and writing RPFITS files. A header file, RPFITS.h, is provided to facilitate usage by C and C++ applications. Also included is rpfhdr, a utility for viewing RPFITS headers (it also works for standard FITS), and rpfex for extracting selected scans from an RPFITS file.
PINT (PINT Is Not Tempo3) analyzes high-precision pulsar timing data, enabling interactive data analysis and providing an extensible and flexible development platform for timing applications. PINT utilizes well-debugged public Python packages and modern software development practices (e.g., the NumPy and Astropy libraries, version control and development with git and GitHub, and various types of testing) for increased development efficiency and enhanced stability. PINT has been developed and implemented completely independently from traditional pulsar timing software such as TEMPO (ascl:1509.002) and Tempo2 (ascl:1210.015) and is a robust tool for cross-checking timing analyses and simulating data.
BELLAMY is a cross-matching algorithm designed primarily for radio images, that aims to match all sources in the supplied target catalogue to sources in a reference catalogue by calculating the probability of a match. BELLAMY utilises not only the position of a source on the sky, but also the flux data to calculate this probability, determining the most probable match in the reference catalog to the target source. Additionally, BELLAMY attempts to undo any spatial distortion that may be affecting the target catalogue, by creating a model of the offsets of matched sources which is then applied to unmatched sources. This combines to produce an iterative cross-matching algorithm that provides the user with an obvious measure of how confident they should be with the results of a cross-match.
Radynversion infers solar atmospheric properties during a solar flare. The code is based on an Invertible Neural Network (INN) that is trained to learn an approximate bijective mapping between the atmospheric properties of electron density, temperature, and bulk velocity (all as a function of altitude), and the observed Hα and Ca II λ8542 line profiles. As information is lost in the forward process of radiation transfer, this information is injected back into the model during the inverse process by means of a latent space; the training allows this latent space to be filled using an n-dimensional unit Gaussian distribution, where n is the dimensionality of the latent space. The code is based on a model trained by simulations made by RADYN, a 1D non-equilibrium radiation hydrodynamic model with good optically thick radiation treatment that does not consider magnetic effects.
ExPRES (Exoplanetary and Planetary Radio Emission Simulator) reproduces the occurrence of CMI-generated radio emissions from planetary magnetospheres, exoplanets or star-planet interacting systems in time-frequency plane, with special attention given to computation of the radio emission beaming at and near its source. Physical information drawn from such radio observations may include the location and dynamics of the radio sources, the type of current system leading to electron acceleration and their energy and, for exoplanetary systems, the magnetic field strength, the orbital period of the emitting body and the rotation period, tilt and offset of the planetary magnetic field. Most of these parameters can be remotely measured only via radio observations. ExPRES code provides the proper framework of analysis and interpretation for past (Cassini, Voyager, Galileo), current (Juno, ground-based radio telescopes) and future (BepiColombo, Juice) observations of planetary radio emissions, as well as for future detection of radio emissions from exoplanetary systems.
dyPolyChord implements dynamic nested sampling using the efficient PolyChord (ascl:1502.011) sampler to provide state-of-the-art nested sampling performance. Any likelihoods and priors which work with PolyChord can be used (Python, C++ or Fortran), and the output files produced are in the PolyChord format.
SpecViz interactively visualizes and analyzes 1D astronomical spectra. It reads data from FITS and ASCII tables and allows spectra to be easily plotted and examined. It supports instrument-specific data quality handling, flexible spectral units conversions, custom plotting attributes, plot annotations, tiled plots, among other features. SpecViz includes a measurement tool for spectral lines for performing and recording measurements and a model fitting capability for creating simple (e.g., single Gaussian) or multi-component models (e.g., multiple Gaussians for emission and absorption lines in addition to regions of flat continua). SpecViz is built on top of the Specutils (ascl:1902.012) Astropy-affiliated python library, providing a visual, interactive interface to the analysis capabilities in that library.
Specutils provides a basic interface for the loading, manipulation, and common forms of analysis of spectroscopic data. Its generic data containers and accompanying modules can be used to build a particular scientific workflow or higher-level analysis tool. It is an AstroPy (ascl:1304.002) affiliated package, and SpecViz (ascl:1902.011), which is built on top of Specutils, provides a visual, interactive interface to its analysis capabilities.
The FITS format (Flexible Image Transport System) is a widely used format to store astronomical data. It is used to store a lot of different types of data such as 1D or 2D spectra, 3D data cubes. It has been developed in the late 1970 to reach its final form almost two decades ago. FITS files are built with two components. The data themselves are stored as tables and contains any types of data. A header is built containing set of keywords-value pairs aiming at describing the data themselves.
Accessing and displaying metadata inside FITS files is important in order to get an overview of their content properties without having to read the data themselves. It is particularly useful when dealing with large amount of files at once. Tools have been already publicly available for years with the dfits and fitsort algorithms (the documentation is available here https://www.eso.org/sci/software/eclipse/eug/eug/node8.html). The main limitation is that they are stand-alone programs useable only in a terminal. They can not be used natively inside another program.
The python module presented here, dfitspy, is a project that migrates the main dfits and fitsort capabilities to python. It is a metadata searcher/displayer for FITS files. As dfits and fitsort, dfitspy is able to display in the terminal the result of a metadata search and is able to grep certain values of keywords inside large samples of files. Therefore it can be used directly with the command line interface. Nevertheless, dfitspy can be, and it is its strength, imported as a python module and the user can use these functionnalities inside another python code or the python interpretor.
SIXTE simulates X-Ray telescope observation; the software performs instrument performance analyses and produces simulated event files for mission and analysis studies. SIXTE strives to find a compromise between exactness of the simulation and speed. Using calibration files such as the PSF, RMF and ARF makes efficient simulations possible at comparably high speed, even though they include nonlinear effects such as pileup. Setups for some current and future missions, such as XMM-Newton and Athena, are included in the package; others can be added by the user with relatively little effort through specifying the main instrument characteristics in a flexible, human-readable XML-based format. Properties of X-ray sources to be simulated are described in a detector-independent format, i.e., the same input can be used for simulating observations with all available instruments, and the same input can also be used for simulations with the SIMX simulator. The input files are easily generated from standard data such as XSPEC (ascl:9910.005) spectral models or FITS images with tools provided with the SIXTE distribution. The input data scale well from single point sources up to very complicated setups.
allesfitter provides flexible and robust inference of stars and exoplanets given photometric and radial velocity (RV) data. The software offers a rich selection of orbital and transit models, accommodating multiple exoplanets, multi-star systems, star spots, stellar flares, and various noise models. It features both parameter estimation and model selection. A graphical user interface is used to specify input parameters, and to easily run a nested sampling or Markov Chain Monte Carlo (MCMC) fit, producing publication-ready tables, LaTex code, and plots. allesfitter provides an inference framework that unites the versatile packages ellc (ascl:1603.016), aflare (flare model; Davenport et al. 2014), dynesty (ascl:1809.013), emcee (ascl:1303.002) and celerite (ascl:1709.008).
brutifus aids in post-processing datacubes from integral field spectrographs. The set of Python routines in the package handle generic tasks, such as the registration of a datacube WCS solution with the Gaia catalogue, the correction of Galactic reddening, or the subtraction of the nebular/stellar continuum on a spaxel-per-spaxel basis, with as little user interactions as possible. brutifus is modular, in that the order in which the post-processing routines are run is entirely customizable.
Galmag computes galactic magnetic fields based on mean field dynamo theory. Written in Python, Galmag allows quick exploration of solutions to the mean field dynamo equation based on galaxy parameters specified by the user, such as the scale height profile and the galaxy rotation curves. The magnetic fields are solenoidal by construction and can be helical.
The R-package SimSpin measures the kinematics of a galaxy simulation as if it had been observed using an IFU. The functions included in the package can produce a kinematic data cube and measure the "observables" from this data cube, specifically the observable spin parameter λr. This package, once installed, is fully documented and tested.
ICSF (Intensity Conserving Spectral Fitting) "corrects" (x,y) data in which the ordinate represents the average of a quantity over a finite interval in the abscissa. A typical example is spectral data, where the average intensity over a wavelength bin (the measured quantity) is assigned to the center of the bin. If the profile is curved, the average will be different from the discrete value at the bin center location. ICSF, written in IDL and available separately and as part of SolarSoft (ascl:1208.013), corrects the intensity using an iterative procedure and cubic spline. The corrected intensity equals the "true" intensity at bin center, rather than the average over the bin. Unlike other methods that are restricted to a single fitting function, typically a spline, ICSF can be used with any function, such as a cubic spline or a Gaussian, with slight changes to the code.
NIFTy (Numerical Information Field Theory) facilitates the construction of Bayesian field reconstruction algorithms for fields being defined over multidimensional domains. A NIFTy algorithm can be developed for 1D field inference and then be used in 2D or 3D, on the sphere, or on product spaces thereof. NIFTy5 is a complete redesign of the previous framework (ascl:1302.013), and requires only the specification of a probabilistic generative model for all involved fields and the data in order to be able to recover the former from the latter. This is achieved via Metric Gaussian Variational Inference, which also provides posterior samples for all unknown quantities jointly.
PRF (Probabilistic Random Forest) is a machine learning algorithm for noisy datasets. The PRF is a modification of the long-established Random Forest (RF) algorithm, and takes into account uncertainties in the measurements (i.e., features) as well as in the assigned classes (i.e., labels). To do so, the Probabilistic Random Forest (PRF) algorithm treats the features and labels as probability distribution functions, rather than as deterministic quantities.
GalIMF (Galaxy-wide Initial Mass Function) computes the galaxy-wide initial stellar mass function by integrating over a whole galaxy, parameterized by star formation rate and metallicity. The generated stellar mass distribution depends on the galaxy-wide star formation rate (SFR, which is related to the total mass of a galalxy) and the galaxy-wide metallicity. The code can generate a galaxy-wide IMF (IGIMF) and can also generate all the stellar masses within a galaxy with optimal sampling (OSGIMF). To compute the IGIMF or the OSGIMF, the GalIMF module contains all local IMF properties (e.g. the dependence of the stellar IMF on the metallicity, on the density of the star-cluster forming molecular cloud cores), and this software module can, therefore, be also used to obtain only the stellar IMF with various prescriptions, or to investigate other features of the stellar population such as what is the most massive star that can be formed in a star cluster.
AsPy computes the determinants of aspherical fluctuations on the spherical collapse background. Written in Python, this procedure includes analytic factorization and cancellation of the so-called `IR-divergences'—spurious enhanced contributions that appear in the dipole sector and are associated with large bulk flows.
DAVE implements a pipeline to find and vet planets planets using data from NASA's K2 mission. The pipeline contains several modules tailored to particular aspects of the vetting procedures, using photocenter analysis to rule out background eclipsing binaries and flux time-series analysis to rule out odd–even differences, secondary eclipses, low-S/N events, variability other than a transit, and size of the transiting object.
Available in R and Python, the simple analytic scheme NFWdist performs highly efficient and exact sampling of the Navarro, Frenk & White (NFW) profile as a true probability distribution function, with the only variable being the concentration.
PLATON (PLanetary Atmospheric Transmission for Observer Noobs) calculates transmission spectra for exoplanets and retrieves atmospheric characteristics based on observed spectra; it is based on ExoTransmit (ascl:1611.005). PLATON supports the most common atmospheric parameters, such as temperature, metallicity, C/O ratio, cloud-top pressure, and scattering slope. It also has less commonly included features, such as a Mie scattering cloud model and unocculted starspot corrections.
The SPICE (Spacecraft Planet Instrument C-matrix [“Camera matrix”] Events) toolkit offers a set of building blocks for constructing tools supporting multi-mission, international space exploration programs and research in planetary science, heliophysics, Earth science, and for observations from terrestrial observatories. It computes many kinds of observation geometry parameters, including the ephemerides, orientations, sizes, and shapes of planets, satellites, comets and asteroids. It can also compute the orientation of a spacecraft, its various moving structures, and an instrument's field-of-view location on a planet's surface or atmosphere. It can determine when a specified geometric event occurs, such as when an object is in shadow or is in transit across another object. The SPICE toolkit is available in FORTRAN 77, ANSI C, IDL, and MATLAB.
SpiceyPy is a Python wrapper for the NAIF C SPICE Toolkit (ascl:1903.015). It is compatible with Python 2 and 3, and was written using ctypes.
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.
The Variable Star Analysis Library (JVarStar) is an open source Java Maven package that represents an accumulation of methods and techniques used in the analysis of variable star data for the purposes of pattern classification. Machine learning techniques, fundamental mathematical methods, and digital signal processing functions are included in this all-in-one package that can be externally referenced (i.e., from Python), or can be used for further Java development. In addition to the developed functionality, this library has dependencies on several open source packages such as: maven, Apache Math Commons, JUnit, JSOFA, etc. The unification of these dependencies along with the developed functionality, provides a developer with an easily accessible library from which to construct stable variable star analysis and classification code.
The ROSAT X-Ray Background Tool (sxrbg) calculates the average X-ray background count rate and statistical uncertainty in each of the six standard bands of the ROSAT All-Sky Survey (RASS) diffuse background maps (R1, R2, R4, R5, R6, R7) for a specified astronomical position and a search region consisting of either a circle with a specified radius or an annulus with specified inner and outer radii centered on the position. The values returned by the tool are in units of 10^-6 counts/second/arcminute^2. sxrbg can also create a count-rate-based spectrum file which can be used with XSpec (ascl:9910.005) to calculate fluxes and offers support for counts statistics (cstat), an alternative method for generating a background spectrum. HEASoft (ascl:1408.004) is a prerequisite for building. The code is in the public domain.
GALAXY evolves (almost) isolated, collisionless stellar systems, both disk-like and ellipsoidal. In addition to the N-body code galaxy, which offers eleven different methods to compute the gravitational accelerations, the package also includes sophisticated set-up and analysis software. While not as versatile as tree codes, for certain restricted applications the particle-mesh methods in GALAXY are 50 to 200 times faster than a widely-used tree code. After reading in data providing the initial positions, velocities, and (optionally) masses of the particles, GALAXY compute the gravitational accelerations acting on each particle and integrates forward the velocities and positions of the particles for a short time step, repeating these two steps as desired. Intermediate results can be saved, as can the final moment in a state from which the integration could be resumed. Particles can have individual masses and their motion can be integrated using a range of time steps for greater efficiency; message-passing-interface (MPI) calls are available to enable GALAXY's use on parallel machines with high efficiency.
CGS (Collisionless Galactic Simulator) uses Fourier techniques to solve the Possion equation ∇2Φ = 4πGρ, relating the mean potential Φ of a system to the mass density ρ. The angular dependence of the force is treated exactly in terms of the single-particle Legendre polynomials, which preserves accuracy and avoids systematic errors. The density is assigned to a radial grid by means of a cloud-in-cell scheme with a linear kernel, i.e., a particle contributes to the density of the two closest cells with a weight depending linearly on the distance from the center of the cell considered. The same kernel is then used to assign the force from the grid to the particle. The time step is chosen adaptively in such a way that particles are not allowed to cross more than one radial cell during one step. CGS is based on van Albada's code (1982) and is distributed in the NEMO (ascl:1010.051) Stellar Dynamics Toolbox.
SimCADO is a python package which allows the user to simulate observations with any NIR/Vis imaging system. The package was originally designed to simulate images for the European extremely large telescope (ELT) and MICADO, however with the proper input it is capable of simulating observations from many different Telescope + Instrument configurations.
The documentation can be found here: https://simcado.readthedocs.io/en/latest/
ehtim (eht-imaging) simulates and manipulates VLBI data and produces images with regularized maximum likelihood methods. The package contains several primary classes for loading, simulating, and manipulating VLBI data. The main classes are the Image, Array, Obsdata, Imager, and Caltable classes, which provide tools for loading images and data, producing simulated data from realistic u-v tracks, calibrating, inspecting, and plotting data, and producing images from data sets in various polarizations using various data terms and regularizers.
SMILI uses sparse sampling techniques and other regularization methods for interferometric imaging. The python-interfaced library is mainly designed for very long baseline interferometry, and has been under the active development primarily for the Event Horizon Telescope (EHT).
CDAWeb (Coordinated Data Analysis Workshop Web) enables viewing essentially any data produced in Common Data Format/CDF with the ISTP/IACG Guidelines and supports interactive plotting of variables from multiple instruments on multiple investigations simultaneously on arbitrary, user-defined time-scales. It also supports data retrieval in both CDF or ASCII format. NASA's GSFC Space Physics Data Facility maintains a publicly available database that includes approximately 600 data variables from Geotail, Wind, Interball, Polar, SOHO, ancilliary spacecraft and ground-based investigations. CDAWeb includes high resolution digital data products that support event correlative science. The system combines the client-server user interface technology of the Web with a powerful set of customized routines based in the COTS Interactive Data Language (IDL) package to leverage the data format standards.
AutoBayes automatically generates customized algorithms from compact, declarative specifications in the data analysis domain, taking a statistical model as input and creating documented and optimized C/C++ code. The synthesis process uses Bayesian networks to enable problem decompositions and guide the algorithm derivation. Program schemas encapsulate advanced algorithms and data structures, and a symbolic-algebraic system finds closed-form solutions for problems and emerging subproblems. AutoBayes has been used to analyze planetary nebulae images taken by the Hubble Space Telescope, and can be applied to other scientific data analysis tasks.
repack re-packs and compresses line-transition data for radiative-transfer calculations. It identifies the strong lines that dominate the spectrum from the large-majority of weaker lines, returning a binary line-by-line (LBL) file with the strong lines info (wavenumber, Elow, gf, and isotope ID), and an ASCII file with the combined contribution of the weaker lines compressed into a continuum extinction coefficient (in cm-1 amagat-1) as function of wavenumber and temperature.
Would you like to view a random code?