ASCL.net

Astrophysics Source Code Library

Making codes discoverable since 1999

Browsing Codes

Order
Title Date
 
Mode
Abstract Compact
Per Page
50100250All
[ascl:2203.018] sympy2c: Generating fast C/C++ functions and ODE solvers from symbolic expressions

The Python package sympy2c allows creation and compilation of fast C/C++ based extension modules from symbolic representations. It can create fast code for the solution of high dimensional ODEs, or numerical evaluation of integrals where sympy fails to compute an anti-​derivative. Based on the symbolic formulation of a stiff ODE, sympy2c analyzes sparsity patterns in the Jacobian matrix of the ODE, and generates loop-​less fast code by unrolling loops in the internally used LU factorization algorithm and by avoiding unnecessary computations involving known zeros.

[ascl:2203.017] MaNGA-DAP: MaNGA Data Analysis Pipeline

The MaNGA data analysis pipeline (MaNGA DAP) analyzes the data produced by the MaNGA data-reduction pipeline (ascl:2203.016) to produced physical properties derived from the MaNGA spectroscopy. All survey-provided properties are currently derived from the log-linear binned datacubes (i.e., the LOGCUBE files).

[ascl:2203.016] MaNGA-DRP: MaNGA Data Reduction Pipeline

The MaNGA Data Reduction Pipeline (DRP) processes the raw data to produce flux calibrated, sky subtracted, coadded data cubes from each of the individual exposures for a given galaxy. The DRP consists of two primary parts: the 2d stage that produces flux calibrated fiber spectra from raw individual exposures, and the 3d stage that combines multiple flux calibrated exposures with astrometric information to produce stacked data cubes. These science-grade data cubes are then processed by the MaNGA Data Analysis Pipeline (ascl:2203.017), which measures the shape and location of various spectral features, fits stellar population models, and performs a variety of other analyses necessary to derive astrophysically meaningful quantities from the calibrated data cubes.

[ascl:2203.015] easyFermi: Fermi-LAT data analyzer

easyFermi provides a user-friendly graphical interface for basic to intermediate analysis of Fermi-LAT data in the framework of Fermipy (ascl:1812.006). The code can measure the gamma-ray flux and photon index, build spectral energy distributions, light curves, test statistic maps, test for extended emission, and relocalize the coordinates of gamma-ray sources. Tutorials for easyFermi are available on YouTube and GitHub.

[ascl:2203.014] AutoSourceID-Light: Source localization in optical images

AutoSourceID-Light (ASID-L) analyzes optical imaging data using computer vision techniques that can naturally deal with large amounts of data. The framework rapidly and reliably localizes sources in optical images.

[ascl:2203.013] PetroFit: Petrosian properties calculator and galaxy light profiles fitter

PetroFit calculates Petrosian properties, such as radii and concentration indices; it also fits galaxy light profiles. The package, built on Photutils (ascl:1609.011), includes tools for performing accurate photometry, segmentations, Petrosian properties, and fitting.

[ascl:2203.012] pyobs: Python framework for autonomous astronomical observatories

pyobs enables remote and fully autonomous observation control of astronomical telescopes. It provides an abstraction layer over existing drivers and a means of communication between different devices (called modules in pyobs). The code can also act as a hardware driver for all the devices used at an observatory. In addition, pyobs offers non-hardware-related modules for automating focusing, acquisition, guiding, and other routine tasks.

[ascl:2203.011] SATCHEL: Pipeline to search for long-period exoplanet signals

SATCHEL (Search Algorithm for Transits in the Citizen science Hunt for Exoplanets in Lightcurves) searches for individual signals of interest in time-series data classified through crowdsourcing. The pipeline was built for the purpose of finding long-period exoplanet transit signals in Kepler photometric time-series data, but may be adapted for searches for any kind of one-dimensional signals in crowdsourced classifications.

[ascl:2203.010] D2O: Distributed Data Object

D2O acts as a layer of abstraction between algorithm code and data-distribution logic to manage cluster-distributed multi-dimensional numerical arrays; this provides usability without losing numerical performance and scalability. D2O's global interface makes the cluster node's local data directly accessible for use in customized high-performance modules. D2O is written in Python; the code is portable and easy to use and modify. Expensive operations are carried out by dedicated external libraries like numpy and mpi4py and performance scales well when moving to an MPI cluster. In combination with NIFTy, D2O enables supercomputer based astronomical imaging via RESOLVE (ascl:1505.028) and D3PO (ascl:1504.018).

[ascl:2203.009] fleck: Fast starspot rotational modulation light curves

fleck simulates rotational modulation of stars due to starspots and is used to overcome the degeneracies and determine starspot coverages accurately for a sample of young stars. The code simulates starspots as circular dark regions on the surfaces of rotating stars, accounting for foreshortening towards the limb, and limb darkening. Supplied with the latitudes, longitudes, and radii of spots and the stellar inclinations from which each star is viewed, fleck takes advantage of efficient array broadcasting with numpy to return approximate light curves. For example, the code can compute rotational modulation curves sampled at ten points throughout the rotation of each star for one million stars, with two unique spots each, all viewed at unique inclinations, in about 10 seconds on a 2.5 GHz Intel Core i7 processor. This rapid computation of light curves en masse makes it possible to measure starspot distributions with techniques such as Approximate Bayesian Computation.

[ascl:2203.008] MIRaGe: Multi Instrument Ramp Generator

MIRaGe creates simulated exposures for NIRCam’s imaging and wide field slitless spectroscopy (WFSS) modes, NIRISS’s imaging, WFSS, and aperture masking interferometery (AMI) modes, and FGS’s imaging mode. It supports sidereal as well as non-sidereal tracking; for example, sources can be made to move across the field of view within an observation.

[ascl:2203.007] GAMERA: Source modeling in gamma astronomy

GAMERA handles spectral modeling of non-thermally emitting astrophysical sources in a simple and modular way. It allows the user to devise time-dependent models of leptonic and hadronic particle populations in a general astrophysical context (including SNRs, PWNs and AGNs) and to compute their subsequent photon emission. GAMERA can calculate the spectral evolution of a particle population in the presence of time-dependent or constant injection, energy losses and particle escape; it also calculates the radiation spectrum from a parent particle population.

[ascl:2203.006] starry_process: Interpretable Gaussian processes for stellar light curves

starry_process implements an interpretable Gaussian process (GP) for modeling stellar light curves. The code's hyperparameters are physically interpretable, and include the radius of the spots, the mean and variance of the latitude distribution, the spot contrast, and the number of spots, among others. The rotational period of the star, the limb darkening parameters, and the inclination (or marginalize over the inclination if it is not known) can also be specified.

[ascl:2203.005] pygacs: Toolkit to manipulate Gaia catalog tables

pygacs manipulates Gaia catalog tables hosted at ESA's Gaia Archive Core Systems (GACS). It provides python modules for the access and manipulation of tables in GACS, such as a basic query on a single table or crossmatch between two tables. It employs the TAP command line access tools described in the Help section of the GACS web pages. Both public and authenticated access have been implemented.

[ascl:2203.004] imexam: IMage EXAMination and plotting

imexam performs simple image examination and plotting, with similar functionality to IRAF's (ascl:9911.002) imexamine. It is a lightweight library that enables users to explore data from a command line interface, through a Jupyter notebook, or through a Jupyter console. imexam can be used with multiple viewers, such as DS9 (scl:0003.002) or Ginga (ascl:1303.020), or without a viewer as a simple library to make plots and grab quick photometry information. It has been designed so that other viewers may be easily attached in the future.

[ascl:2203.003] NIMBLE: Non-parametrIc jeans Modeling with B-spLinEs

NIMBLE (Non-parametrIc jeans Modeling with B-spLinEs) inferrs the cumulative mass distribution of a gravitating system from full 6D phase space coordinates of its tracers via spherical Jeans modeling. It models the Milky Way's dark matter halo using Gaia and Dark Energy Spectroscopic Instrument Milky Way Survey (DESI MWS) data. NIMBLE includes a basic inverse modeling Jeans routine that assumes perfect and complete data is available and a more complex forward modeling Jeans routine that deconvolves observational effects (uncertainties and limited survey volume) characteristic of Gaia and the DESI-MWS. It also includes tools for generating simple equilibrium model galaxies using Agama (ascl:1805.008) and imposing mock Gaia+DESI errors on 6D phase space input data.

[ascl:2203.002] exoVista: Planetary systems generator

exoVista generates a "universe" of planetary systems, creating thousands of models of quasi-self-consistent planetary systems around known nearby stars at scattered light wavelengths. It efficiently records the position, velocity, spectrum, and physical parameters of all bodies as functions of time. exoVista models can be used for simulating surveys using the direct imaging, transit, astrometric, and radial velocity techniques.

[ascl:2203.001] SISTER: Starshade Imaging Simulation Toolkit for Exoplanet Reconnaissance

SISTER (Starshade Imaging Simulations Toolkit for Exoplanet Reconnaissance) predicts how an exoplanet system would look in an instrument that utilizes an Starshade to block the light from the host star. The tool allows for controlling a set of parameters of the whole instrument for: (1) the Starshade design, (2) the exoplanetary system, (3) the telescope and (4) the camera. SISTER includes plotting software, and can also store simulations on disk for plotting with other software.

[submitted] RCETC: Roman Coronagraph Exposure Time Calculator

The Roman Coronagraph Exposure Time Calculator (Roman_Coronagraph_ETC for short) is the public version of the exposure time calculator of the Coronagraph Instrument aboard the Nancy Grace Roman Space Telescope funded by NASA. The methods used to estimate the integration times are based upon peer reviewed research articles (see Bibliography) and a collection of instrumental and modeling parameters of both the Coronagraph Instrument and the Nancy Grace Roman Space Telescope. The code is written in python. Visit https://github.com/hsergi/Roman_Coronagraph_ETC for more information.

[ascl:2202.026] topoaccel: Topological acceleration scripts

topoaccel calculates topological acceleration for several of the S^3 quotient spaces considered 'regular', in that they have a Platonic solid as one of their fundamental domain shapes, and are globally homogeneous. The topoaccel scripts can be run using the free-licensed software package Maxima (https://maxima.sourceforge.io/documentation.html).

[ascl:2202.025] INSANE: INflationary potential Simulator and ANalysis Engine

INSANE (INflationary potential Simulator and ANalysis Engine) takes either a numeric inflationary potential or a symbolic one, calculates the background evolution and then, using the Mukhanov-Sasaki equations, calculates the primordial power spectrum it yields. The package can analyze the results to extract the spectral index n_s, the index running alpha, the running of running and possibly higher moments. The package contains two main modules: BackgroundSolver solves the background equations, and the MsSolver module solves and analyses the MS equations.

[ascl:2202.024] SunnyNet: Neural network framework for solving 3D NLTE radiative transfer in stellar atmospheres

SunnyNet learns the mapping the between LTE and NLTE populations of a model atom and predicts the NLTE populations based on LTE populations for an arbitrary 3D atmosphere. To use SunnyNet, one must already have a set of LTE and NLTE populations computed in 3D, to train the network. These must come from another code, as SunnyNet is unable to solve the formal problem. Once SunnyNet is trained, one can feed it LTE populations from a different 3D atmosphere, and obtain predicted NLTE populations. The NLTE populations can then be used to synthesize any spectral line that is included in the model atom. SunnyNet's output is a file with predicted NLTE populations. SunnyNet itself does not calculate synthetic spectra, but a sample script written in the Julia language that quickly computes Hα spectra is included.

[ascl:2202.023] Starduster: Radiative transfer and deep learning multi-wavelength SED model

The deep learning model Starduster emulates dust radiative transfer simulations, which significantly accelerates the computation of dust attenuation and emission. Starduster contains two specific generative models, which explicitly take into account the features of the dust attenuation curves and dust emission spectra. Both generative models should be trained by a set of characteristic outputs of a radiative transfer simulation. The obtained neural networks can produce realistic galaxy spectral energy distributions that satisfy the energy balance condition of dust attenuation and emission. Applications of Starduster include SED-fitting and SED-modeling from semi-analytic models.

[ascl:2202.022] ASPIRED: Automated SpectroPhotometric Image REDuction

ASPIRED reduces 2D spectral data from raw image to wavelength and flux calibrated 1D spectrum automatically without any user input (quicklook quality), and provides a set of easily configurable routines to build pipelines for long slit spectrographs on different telescopes (science quality). It delivers near real-time data reduction, which can facilitate automated or interactive decision making, allowing "on-the-fly" modification of observing strategies and rapid triggering of other facilities.

[ascl:2202.021] popsynth: Observed surveys from latent population models

Popsynth provides an abstract way to generate survey populations from arbitrary luminosity functions and redshift distributions. Additionally, auxiliary quantities can be sampled and stored. Populations can be saved and restored via an HDF5 files for later use, and population synthesis routines can be created via classes or structured YAML files. Users can construct their own classes for spatial, luminosity, and other distributions, all of which can be connected to arbitrarily complex selection functions.

[ascl:2202.020] distance-omnibus: Distance estimation method for molecular cloud clumps in the Milky Way

distance-omnibus computes posterior DPDFs for catalog sources using the Bayesian application of kinematic distance likelihoods derived from a Galactic rotation curve with prior Distance Probability Density Functions (DPDFs) derived from ancillary data. The methodology and code base are generalized for use with any (sub-)millimeter survey of the Galactic plane.

[ascl:2202.019] Contaminante: Identify blended targets in Kepler, TESS, and K2 data

contaminante helps find the contaminant transiting source in NASA's Kepler, K2 or TESS data. When hunting for transiting planets, sometimes signals come from neighboring contaminants. This package helps users identify where the transiting signal comes from in their data. The code uses pixel level modeling of the TargetPixelFile data from NASA's astrophysics missions that are processed with the Kepler pipeline. The output of contaminante is a Python dictionary containing the source location and transit depth, and a contaminant location and depth. It can also output a figure showing where the main target is centered in all available TPFs, what the phase curve looks like for the main target, where the transiting source is centered in all available TPFs, if a transiting source is located outside the main target, or the transiting source phase curve, if a transiting source is located outside the main target.

[ascl:2202.018] Sculptor: Interactive modeling of astronomical spectra

Sculptor manipulates, models and analyzes spectroscopic data; the code facilitates reproducible scientific results and easy to inspect model fits. A built-in graphical user interface around LMFIT (ascl:1606.014) offers interactive control to set up and combine multiple spectral models to fully fit the spectrum of choice. Alternatively, all core functionality can be scripted to facilitate the design of spectral fitting and analysis pipelines.

[ascl:2202.017] GALLUMI: GALaxy LUMInosity function pipeline

GALLUMI (GALaxy LUMInosity) is a likelihood code that extracts cosmological and astrophysical parameters from the UV galaxy luminosity function. The code is implemented in the MCMC sampler MontePython (ascl:1307.002) and can be readily run in conjunction with other likelihood codes.

[ascl:2202.016] Find_Orb: Orbit determination from observations

Find_Orb takes a set of observations of an asteroid, comet, or natural or artificial satellite given in the MPC (Minor Planet Center) format, the ADES astrometric format, and/or the NEODyS or AstDyS formats, and finds the corresponding orbit.

[ascl:2202.015] SPARTAN: SPectroscopic And photometRic fiTting tool for Astronomical aNalysis

SPARTAN fits the spectroscopy and photometry of distant galaxies. The code implements multiple interfaces to help in the configuration of the fitting and the inspection of the results. SPARTAN relies on pre-computed input files (such as stellar population and IGM extinction), available for download, to save time in the fitting process.

[submitted] Mean Motion Resonances

Site with collection of codes and fundamental references on mean motion resonances.

[ascl:2202.014] Citlalicue: Create and manipulate stellar light curves

Citlalicue allows you to create synthetic stellar light curves (transits, stellar variability and white noise) and detrend light curves using Gaussian Processes (GPs). Transits are implemented using PyTransit (ascl:1505.024). Python notebooks are provided to demonstrate using Citlalicue for both functions.

[ascl:2202.013] PSLS: PLATO Solar-like Light-curve Simulator

PSLS simulates solar-like oscillators representative of PLATO targets. It includes planetary transits, stochastically-excited oscillations, granulation and activity background components, as well as instrumental systematic errors and random noises representative for PLATO.

[ascl:2202.012] fiducial_flare: Spectra and lightcurves of a standardized far ultraviolet flare

fiducial_flare generates a reasonable approximation of the UV emission of M dwarf stars over a single flare or a series of them. The simulated radiation is resolved in both wavelength and time. The intent is to provide consistent input for applications requiring time-dependent stellar UV radiation fields that balances simplicity with realism, namely for simulations of exoplanet atmospheres.

[ascl:2202.011] RFEP: Residual Feature Extraction Pipeline

Residual Feature Extraction Pipeline carries out feature extraction of residual substructure within the residual images produced by popular galaxy structural-fitting routines such as GALFIT (ascl:1104.010) and GIM2D (ascl:1004.001). It extracts faint low surface brightness features by isolating flux-wise and area-wise significant contiguous pixels regions by rigorous masking routine. The code accepts the image cubes (original image, model image, residual image) and generates several data products, such as an image with extracted features, a source extraction based segmentation map, and the background sky mask and the residual extraction mask. It uses a Monte Carlo approach-based area threshold above which the extracted features are identified. The pipeline also creates a catalog entry indicating the surface brightness and its error.

[ascl:2202.010] EDIVU: Exoplanet Detection Identifier Vetter Unplugged

The EDI (Exoplanet Detection Identifier) Vetter Unplugged software identifies false positive transit signals using Transit Least Squares (TLS) information and has been simplified from the full EDI-Vetter algorithm (ascl:2202.009) for easy implementation with the TLS output.

[ascl:2202.009] EDIV: Exoplanet Detection Identifier Vetter

EDI (Exoplanet Detection Identifier) Vetter identifies false positive transit signal in the K2 data set. It combines the functionalities of Terra (ascl:2202.008) and RoboVetter (ascl:2012.006) and is optimized to test single transiting planet signals. An easily implemented suite of vetting metrics built to run alongside TLS of EDI Vetter, EDI-Vetter Unplugged (ascl:2202.010), is also available.

[ascl:2202.008] TERRA: Transit detection code

TERRA (Transiting Exoearth Robust Reduction Algorithm) identifies and removes instrumental noise in Kepler photometry. This transit detection code is optimized to detect small planets around photometrically quiet stars. TERRA calculates photometry in the time domain, combs the calibrated photometry for periodic, box-shaped signals, fits promising signals, and rejects signals inconsistent with exoplanet transits.

[ascl:2202.007] SciCatalog: Tools for scientific data catalogs

SciCatalog handles catalogs of scientific data in a way that is easily extensible, including the ability to create nicely formatted AASTex deluxe tables for use in AAS Publishing manuscripts. It handles catalogs of values, their positive and negative uncertainties, and references for those values with methods for easily adding columns and changing values. The catalog is also backed up every time it is loaded under the assumption that it is about to be modified.

[ascl:2202.006] FIRE Studio: Movie making utilities for the FIRE simulations

FIRE Studio is a Python interface for C libraries that project Smoothed Particle Hydrodynamic (SPH) datasets. These C libraries can, in principle, be applied to any SPH dataset; the Python interface is specialized to conveniently load and format Gadget-derivative datasets such as GIZMO (ascl:1410.003). FIRE Studio is fast, memory efficient, and parallelizable. In addition to producing "1-color" projection maps for SPH datasets, the interface can produce "2-color" maps, where the pixel saturation is set by one projected quantity and the hue is set by another, and "3-color" maps, where three quantities are projected simultaneously and remapped into an RGB colorspace. FIRE Studio can model stellar emission and dust extinction to produce mock Hubble images (by default) or to model surface brightness maps for thirteen of the most common bands (plus the bolometric luminosity). It produces publication quality static images of simulation datasets and provides interpolation scripts to create movies that smoothly evolve in time (provided multiple snapshots in time of the data exist), view the dataset from different perspectives (taking advantage of shared memory buffers to allow massive parallelization), or both.

[ascl:2202.005] palettable: Color palettes for Python

Palettable is a library of color palettes for Python. The code is written in pure Python with no dependencies; it can be used to supply color maps for matplotlib plots, customize matplotlib plots, and to supply colors for a web application.

[ascl:2202.004] SUPPNet: Spectrum normalization neural network

SUPPNet performs fully automated precise continuum normalization of merged echelle spectra and offers flexible manual fine-tuning, if necessary. The code uses a fully convolutional deep neural network (SUPP Network) trained to predict a pseudo-continuum. The post-processing step uses smoothing splines that give access to regressed knots, which are useful for optional manual corrections. The active learning technique controls possible biases that may arise from training with synthetic spectra and extends the applicability of the method to features absent in this kind of spectra.

[ascl:2202.003] Zwindstroom: Cosmological growth factors from fluid calculations

Zwindstroom computes background quantities and scale-dependent growth factors for cosmological models with free-streaming species, such as massive neutrinos. Following the earlier REPS code (ascl:1612.022), the code uses a Newtonian fluid approximation with external neutrino sound speed to close the Boltzmann hierarchy. Zwindstroom supports multi-fluid models with distinct transfer functions and sound speeds. A flexible python interface facilitates interaction with CLASS (ascl:1106.020) through classy. There is also a Zwindstroom plugin for the cosmological initial conditions generator monofonIC (ascl:2008.024) that allows for higher-order LPT ICs for massive neutrino simulations in a single step.

[ascl:2202.002] NWelch: Spectral analysis of time series with nonuniform observing cadence

NWelch uses Welch's method to estimate the power spectra, complex cross-spectrum, magnitude-squared coherence, and phase spectrum of bivariate time series with nonuniform observing cadence. For univariate time series, users can apply the Welch's power spectrum estimator or compute a nonuniform fast Fourier transform-based periodogram. Options include tapering in the time domain and computing bootstrap false alarm levels. Users may choose standard 50%-overlapping Welch's segments or apply a custom-made segmentation scheme. NWelch was designed for Doppler planet searches but may be applied to any type of time series.

[submitted] frbmclust: Model-independent classification of events from the first CHIME/FRB Fast Radio Burst catalog

CHIME/FRB instrument has recently published a catalog containing about half of thousand fast radio bursts (FRB) including their spectra and several reconstructed properties, like signal widths, amplitudes, etc. We have developed a model-independent approach for the classification of these bursts using cross-correlation and clustering algorithms applied to one-dimensional intensity profiles, i.e. to amplitudes as a function of time averaged over the frequency. This approach is implemented in frbmclust package, which is used for classification of bursts featuring different waveform morphology.

[ascl:2202.001] GA Galaxy: Interacting galaxies model fitter

GA Galaxy fits models of interacting galaxies to synthetic data using a genetic algorithm and custom fitness function. The genetic algorithm is real-coded and uses a mixed Gaussian kernel for mutation. The fitness function incorporates 1.) a direct pixel-to-pixel comparison between the target and model images and 2.) a comparison of the degree of tidal distortion present in the target and model image such that target-model pairs which are similarly distorted will have a higher relative fitness. The genetic algorithm is written in Python 2.7 while the simulation code (SPAM: Stellar Particle Animation Module) is written in Fortran 90.

[ascl:2201.014] nProFit: n-Profile Fitting tool

nProFit analyzes surface brightness profiles. It obtains the best-fit structural, scale, and shape parameters of star clusters in Hubble Space Telescope images of nearby galaxies. The code fits dynamical models and can derive physically-relevant parameters. Among these are central volume and luminosity densities, total masses and luminosities, central velocity dispersions, core radius, half-light radius, tidal radius, and binding energy.

[ascl:2201.013] disnht: Absorption spectrum solver

disnht computes the absorption spectrum for a user-defined distribution of column densities. The input is a file including the array of column density values; a python routine is provided that can make logarithmic distribution of column density that can be used as an input. Other optional inputs are a cross-section file that includes the 2-d array [energy, cross-section]; a script is provided for computing cross sections for different abundance model for the interstellar medium (solar values). Other boolean flags can be used for input and output description, rebin, plot or save.

[ascl:2201.012] MAGRATHEA: Planet interior structure code

MAGRATHEA solves planet interiors and considers the case of fully differentiated interiors. The code integrates the hydrostatic equation in order to determine the correct planet radius given the mass in each layer. The code returns the pressure, temperature, density, phase, and radius at steps of enclosed mass. The code support four layers: core, mantle, hydrosphere, and atmosphere. Each layer has a phase diagram with equations of state chosen for each phase.

Would you like to view a random code?