Welcome to the GSFC Exoplanet Modeling and Analysis Center (EMAC)
EMAC serves as a catalog, repository and integration platform for modeling and analysis resources focused on the study of exoplanet characteristics and environments. EMAC is a key project of the GSFC Sellers Exoplanet Environments Collaboration (SEEC).
If you've used EMAC in any part of your research, please cite our RNAAS paper either in your methods section or in the "Software used" portion of any manuscripts; see the FAQ for more information.
More Information on EMAC for first-time visitors...If you make use of tools linked or hosted on EMAC: please use the following statement in your publication acknowledgements: “This research made use of the NASA Exoplanet Modeling and Analysis Center (EMAC), which is funded by the NASA Planetary Science Division's Internal Scientist Funding Model.”
Stay up to date with EMAC!- Subscribe to our monthly RSS messages on new updates and tools.
- Check out the Bluesky account @exoplanetmodels.bsky.social (not an official NASA account), where new tools and features are highlighted.
- Email us with general feedback at and tell us what you'd change or improve.
- Click the
icon in a resource box to provide suggestions for an individual tool or tools.
- EMAC is intended as a clearinghouse for the whole research community interested in exoplanets, where any software or model developer can submit their tool/model or their model output as a contribution for others to use.
- EMAC provides a searchable and sortable database for available source code and data output files - both resources hosted locally by EMAC as well as existing external tools and repositories hosted elsewhere.
- The EMAC team also helps develop new web interfaces for tools that can be run “on-demand” or model grids that can be interpolated for more individualized results.
- If you would like to submit a new tool/model to EMAC, please visit our Submit a Resource page.
- For help with tutorials for select resources/tools use the “Demo” buttons below and subscribe to our YouTube channel.
- Watch this video for a walk-through of the whole EMAC site, including how to submit a new tool and how to access information for each resource.
EMAC co-leads are Joe P. Renaud and Eric Lopez; more information on EMAC staffing and organization can be found on Our Team page.
EMAC has launched a new community-supported curator program, and we need your help! Check out our curator page to learn how exoplanet experts like yourself can support EMAC's mission, and help us spread the word about this new initiative!
eclipsoid: Open-source JAX-based Python package
Dholakia, Shashank; Dholakia, Shishir; Pope, Benjamin J. S.
Eclipsoid provides a general framework allowing rotational deformation to be modeled in transits, occultations, phase curves, transmission spectra and more of bodies in orbit around each other, such as an exoplanet orbiting a host star.
ExoLyn: a golden mean approach to multi-species cloud modelling in atmospheric retrieval
Huang, Helong; Ormel, Chris W.; Min, Michiel
ExoLyn is a 1D cloud model that balances physical consistency with computational efficiency. ExoLyn solves the transport equation of cloud particles and vapor under cloud condensation rates that are self-consistently calculated from thermodynamics. ExoLyn is a standalone, open source package capable to be combined with optool to calculate solid opacities and with petitRADTRANS to generate transmission or emission spectra. The efficiency of ExoLyn opens the possibility of joint retrieval of exoplanets' gas and cloud components. ExoLyn has been designed to study cloud formation across a variety of planets: hot Jupiters, sub- Neptunes, and self-luminous planets.
OrCAS: Origins, Compositions, and Atmospheres of Sub-neptunes
Crossfield, Ian J. M.; Polanski, Alex S.; Robertson, Paul; et al.
OrCAS is a survey to better elucidate the origins, compositions, and atmospheres of sub-Neptunes. This radial velocity survey uses a repeatable, quantifiable metric to select targets suitable for subsequent transmission spectroscopy and address key science themes about the atmospheric & internal compositions and architectures of these systems. Our survey targets 26 systems with transiting sub-Neptune planet candidates, with the overarching goal of increasing the sample of such planets suitable for subsequent atmospheric characterization.
Toy Coronagraph: Quantifying the Impact of Exozodiacal Dust on Exoplanet Detection
Lin, Yu-Chia
Toy Coronagraph is a Python package designed to quantify the impact of exozodiacal dust on exoplanet detection. It takes circularly symmetric disk images and point spread functions, and exoplanet orbital parameters to generate key metrics like contrast curves, signal-to-noise ratios, and dynamic visualizations of exoplanet motion under the dust background. The package also provides tools for generating vortex coronagraph PSFs and includes example disk images. Toy Coronagraph empowers researchers to understand exozodiacal dust, develop mitigation strategies, and optimize future telescope designs and mission time, ultimately advancing the search for potentially habitable worlds.
ExoSim 2: the next generation Exoplanet Observation Simulator
Mugnai, L. V. et al.
ExoSim 2 is the next generation of the Exoplanet Observation Simulator (ExoSim) tailored for the spectro-photometric observations of transiting exoplanets from space, ground, and sub-orbital platforms. The code execution in ExoSim 2 follows a three-step workflow: the creation of focal planes, the production of Sub-Exposure blocks, and the generation of non-destructive reads (NDRs). ExoSim 2 has demonstrated consistency in estimating photon conversion efficiency, saturation time, and signal generation. The simulator has also been validated independently for instantaneous read-out and jitter simulation, and for astronomical signal representation
SSOF: StellarSpectraObservationFitting, Data-Driven Modeling of Telluric Features and Stellar Variability
Gilbertson, C. et al.
StellarSpectraObservationFitting.jl is a Julia package for measuring Doppler shifts and creating data-driven models (with fast, physically-motivated Gaussian Process regularization) for the time-variable spectral features for both the telluric transmission and stellar spectrum, while accounting for the wavelength-dependent instrumental line-spread function.
GASTLI: GAS gianT modeL for Interiors
Acuña, Lorena; Kreidberg, Laura; Zhai, Meng; Mollière, Paul; Fouesneau, Morgan.
GASTLI (GAS gianT modeL for Interiors) calculates the interior structure models for volatile-rich exoplanets with H/He and water envelopes. The code computes mass-radius curves, thermal evolution curves, and interior composition retrievals to fit a interior structure model to your mass, radius, age, and if available, atmospheric metallicity data. GASTLI can also plot the results, including internal and atmospheric profiles, a pressure-temperature diagram, mass-radius relations, and thermal evolution curves.
ExoJAX: Differentiable Spectrum Modeling of Exoplanets/Brown Dwarfs using JAX
Kawahara, Hajime; Kawashima, Yui; The ExoJAX team; et al.
ExoJAX is designed to directly calculate cross-sections as functions of temperature and pressure, rather than interpolating tabulated data, to minimize errors in high-dispersion spectra modeling. Has developed differentiable radiative transfer schemes, including emission, transmission, and reflection spectroscopy. These enhancements significantly expand the range of applications.
speclib: Tools for interfacing with stellar spectral libraries.
Rackham, Benjamin V.
speclib is a Python package for working with grids of model stellar spectra. It can download PHOENIX spectra (Husser et al. 2013) on the fly and can also work with pre-downloaded libraries of MPS-Atlas (Witzke et al. 2021, Kostogryz et al. 2023) and SPHINX (Iyer et al. 2023) spectra.
Gen TSO: A graphical interface to simulate JWST time-series observations of exoplanets
Cubillos, Patricio E.
Gen TSO enables the estimation of signal-to-noise ratios for transit/eclipse depths through an interactive graphical interface, similar to the JWST Exposure Time Calculator (ETC). This interface leverages the ETC by combining its noise simulator, Pandeia, with additional exoplanet resources from the NASA Exoplanet Archive, the Gaia DR3 catalog, and the TrExoLiSTS database of JWST programs. Gen TSO allows users to calculate S/Ns for all JWST instruments for the spectroscopic time-series modes available as of the Cycle 4 GO call. It also allows users to simulate target acquisition on the science targets or, when needed, on nearby stellar targets.
MOOG: LTE line analysis and spectrum synthesis
Sneden, Chris
MOOG is a code that performs a variety of LTE line analysis and spectrum synthesis tasks. The typical use of MOOG is to assist in the determination of the chemical composition of a star. The basic equations of LTE stellar line analysis are followed, in particular using the formulation of F. N. Edmonds, Jr. (1969, JQSRT, 9, 1427). Much of the MOOG code follows in a general way the WIDTH and SYNTHE codes of R. L. Kurucz (see his web site: kurucz.harvard.edu)
GEOSCCM: Columbia River Flood Basalt Eruption Output
Guzewich, Scott; Oman, Luke; Richardson, Jacob; Whelley, Patrick; Bastelberger, Sandra; et al.
Selected output in NetCDF format from baseline and eruption simulations performed with the GEOSCCM global climate model. Used in the study of volcanic climate warming through radiative and dynamical feedbacks of SO2 Emissions.
The datasets for this resource can be found in the following repositories:
VBMicrolensing: Algorithms for multiple lensing with contour integration.
Bozza, V.; Saggese, V.; Covone, G.; Rota, P.; Zhang, J.
VBMicroLensing is a new public code built on our previous experience on binary lenses that introduces three new algorithms for the computation of magnification and astrometry in multiple microlensing. Besides the classical polynomial resolution, a multi-polynomial approach is introduced in which each root is calculated in a frame centered on the closest lens. In addition, a new algorithm is based on a modified Newton-Raphson method applied to the original lens equation without any numerical manipulation. These new algorithms are more accurate and robust compared to traditional single-polynomial approaches at a modest computational cost, opening the way to massive studies of multiple lenses.
resonances: Identify celestial bodies trapped in mean-motion resonances
Smirnov, E.
A python package to find, analyze, and plot two-body and three-body mean-motion eccentricity-type resonances in the Solar and other planetary systems. The package has a better accuracy than the automatic identification procedure for resonant objects compared to previous studies. Furthermore, it has built-in integrations with AstDyS and NASA JPL catalogues.
Sonora Diamondback: The Sonora Substellar Atmosphere Models
Morley, Caroline V.; Mukherjee, Sagnick; Marley, Mark S; et al.
This is a new grid of cloudy atmosphere and evolution models for substellar objects. These models include the effect of refractory cloud species, including silicate clouds, on the spectra and evolution. It includes effective temperatures from 900 to 2400 K and surface gravities from log g = 3.5 to 5.5, appropriate for a broad range of objects with masses between 1 and 84 M J.
linemake: An atomic and molecular line list generator
Placco, Vinicius M.; Sneden, Christopher; Roederer, Ian U.; et al.
linemake is an open-source atomic and molecular line list generator. It is a lightweight, easy-to-use tool to generate formatted and curated lists suitable for spectral synthesis work. linemake produces synthesis line lists compatible with those needed by the line analysis code MOOG. linemake is primarily suitable for spectroscopic studies of stars cooler than B spectral type.
TriArc: Bayesian Detection Threshold test for Atmospheric Species
Claringbold, A. B.
TriArc uses Bayesian statistics to determine the minimum abundance of an atmospheric species in a given model atmosphere (excluding the species of interest) and spectral noise profile. The current version is configured for transmission spectroscopy, but can be adjusted to emission spectroscopy on request. It is built using the forward modelling capabilities of petitRADTRANS. Utilised to calculated prebiosignature detection thresholds for various potential JWST targets in Claringbold et al. 2023.
StarFinder: A code for the deep analysis of stellar fields
Diolaiti, E. and Schreiber, L.
Starfinder is an IDL code for the deep analysis of stellar fields, designed for Adaptive Optics well-sampled images, characterized by a complex and highly structured Point Spread Function.
The Point Spread Function is extracted directly from the frame, to take into account the actual structure of the instrumental response and the atmospheric effects.
The code is written in IDL language and organized in the form of a self-contained widget-based application, provided with a series of tools for data visualization and analysis.
SAGE: Stellar Activity Grid for Exoplanets
Chakraborty, H. et al.
SAGE corrects the time-dependent impact of stellar activity on transmission spectra. It uses a pixelation approach to model the stellar surface with spots and faculae, while accounting for limb-darkening and rotational line-broadening. The code can be used to evaluate stellar contamination for F to M-type hosts, test various spot sizes and locations, and quantify the impact of limb-darkening. SAGE can also retrieve the properties and distribution of active regions on the stellar surface from photometric monitoring, and connect the photometric variability to the stellar contamination of transmission spectra.
MulensModel: A Microlensing Event Fitting Tool
Radek Poleski, Jennifer Yee
MulensModel is a package for modelling gravitational microlensing events. It's written in Python3 and is object-oriented. MulensModel allows calculating goodness of fit statistics and plotting several kinds of plots. It's accurate enough to model data from the upcoming Nancy Grace Roman Telescope (formerly WFIRST). There are many examples, a few tutorials, and full documentation of every public function. The code is continuously developed.
PyTransit: Fast and easy exoplanet transit light curve modelling in Python
Hannu Parviainen
PyTransit offers optimised CPU and GPU implementations of popular exoplanet transit models with a unified interface, and thrives to be the fastest and the most versatile tool for transit modelling in Python.
PyTransit makes transit model evaluation trivial whether modelling straightforward single-passband transit light curves or more complex science-cases, such as transmission spectroscopy or heterogeneous data sets. Further, the models are can be evaluated for a large number of parameter sets in parallel to optimize the evaluation speed with population-based MCMC samplers such as emcee. PyTransit has been used in research since 2010, and continues to be under active development in 2022.
MESA: Modules for Experiments in Stellar Astrophysics
MESA Team
The Joker: A custom Monte Carlo sampler for the two-body problem
A. Price-Whelan, D. W. Hogg, D. Foreman-Mackey
The Joker is a custom Monte Carlo sampler for the two-body problem that generates posterior samplings in Keplerian orbital parameters given radial velocity observations of stars. It is designed to deliver converged posterior samplings even when the radial velocity measurements are sparse or very noisy. It is therefore useful for constraining the orbital properties of binary star or star-planet systems. Though it fundamentally assumes that any system has two massive bodies (and only the primary is observed), The Joker can also be used for hierarchical systems in which the velocity perturbations from a third or other bodies are much longer than the dominant companion.
orbitize!: Package for Orbit-Fitting of Directly Imaged Objects
Sarah Blunt, Jason Wang, Henry Ngo, Isabel Angelo, et al. Full list here.
Orbitize! is a package for orbit-fitting of directly imaged objects (anything with relative astrometric measurements). It packages the OFTI algorithm and two flavors of MCMC into a consistent API. It’s written to be fast, extensible, and easy-to-use. Extensive tutorials are available here. Up-to-date documentation is available at orbitize.info.
FastChem: Ultra-fast Equilibrium Chemistry
Daniel Kitzmann, Joachim Stock
FastChem 2 is a new version of the established semi-analytical thermochemical equilibrium code FastChem. Whereas the original version of FastChem is limited to atmospheres containing a significant amount of the element hydrogen, FastChem 2 is now also applicable to chemical mixtures dominated by any other species such as CO2, N2, or Si for example. The code is written in object-oriented C++ and also offers an optional Python module.
BASTA: The BAyesian STellar Algorithm
The BASTA team
BASTA is a python-based fitting tool designed to determine properties of stars using a pre-computed grid of stellar models. It calculates the probability density function of a given stellar property based on a set of observational constraints defined by the user.
VLT-sphere: Automatic VLT/SPHERE data reduction and analysis
Arthur Vigan
The high-contrast imager SPHERE at the Very Large Telescope combines extreme adaptive optics and coronagraphy to directly image exoplanets in the near-infrared. The vlt-sphere package enables easy reduction of the data coming from IRDIS and IFS, the two near-infrared subsystems of SPHERE. The package relies on the official ESO pipeline (ascl:1402.010), which must be installed separately.
Tiberius: Time series spectral extraction and transit light curve fitting
Kirk, J.
Tiberius is a Python library for reducing time series spectra and fitting exoplanet transit light curves. This can be used to extract spectra from JWST (all 4 instruments), along with ground-based long-slit spectrographs and Keck/NIRSPEC echelle spectra (beta).
The light curve fitting routines can be used as as standalone to fit, for example, HST light curves extracted with other methods.
Eureka!: An End-to-End Pipeline for JWST Time-Series Observations
Bell, T. J. et al.
Eureka! is a data reduction and analysis pipeline for exoplanet time-series observations, with a particular focus on James Webb Space Telescope (JWST) data. The goal of Eureka! is to provide an end-to-end pipeline that starts with raw, uncalibrated FITS files and ultimately yields precise exoplanet transmission and/or emission spectra. The pipeline has a modular structure with six stages, each with intermediate figures and outputs that allow users to compare Eureka!’s performance using different parameter settings or to compare Eureka! with an independent pipeline.
TidalPy: TidalPy calculates the tidal response of moons, planets and exoplanets
Joe Renaud
TidalPy is an open-source software suite designed to assist researchers in the semi-analytic calculation of tidal dissipation and subsequent orbit-spin evolution for rocky and icy worlds. TidalPy serves as simple to install (cross-platform) and, hopefully, simple to use package that users can pick up and hit the ground running to answer basic questions about tidal dynamics.
photochem: A chemical model of planetary atmospheres
Wogan, Nicholas et al.
Photochem is a photochemical and climate model of planet's atmospheres. Given inputs, like the stellar UV flux, the atmospheric temperature structure, etc., this code will find the steady-state chemical composition of an atmosphere, or evolve atmospheres through time. The code also contains 1-D climate models.
EXOTIC (EXOplanet Transit Interpretation Code): EXOplanet Transit Interpretation Code
A Python 3 package for analyzing photometric data of transiting exoplanets into lightcurves and retrieving transit epochs and planetary radii.
EXOTIC can run on a Windows, Macintosh, or Linux/Unix computer. You can also use EXOTIC via the free Google Colab, which features cloud computing, many helpful plotting functions, and a simplified installation. However, if you are a user with many images or large images, we recommend running EXOTIC locally on your own computer.
RADIS: Fast Line-by-line code for infrared emission & absorption spectra at equilibrium & non-LTE
RADIS uses a new algorithm that can resolve spectra with millions of lines within seconds on a single-CPU, and can be GPU-accelerated for almost-instant-computation (up to 5e14 lines*spectral points/s).
It supports HITRAN, HITEMP and ExoMol out-of-the-box (auto-download), and therefore is particularly suitable to compute cross-sections or transmission spectra at high-temperature.
It includes equilibrium calculations for all species, and non-LTE for CO2 and CO.
The code is an open-source Python library (https://github.com/radis/radis) and can also be executed in an online environment with pre-configured HITEMP databases (https://radis.github.io/radis-lab/).
VIP: Vortex Image Processing package
V. Christiaens, C. A. Gomez Gonzalez, R. Farkas, C.-H. Dahlqvist, E. Nasedkin, J. Milli, O. Wertz, O. Absil. More contributors here.
VIP is a Python package for high-contrast imaging of exoplanets and circumstellar disks. The goal of VIP is to integrate open-source, efficient, easy-to-use and well-documented implementations of state-of-the-art high-contrast image processing algorithms. In addition, it also contains a number of routines for image preprocessing, performance assessment and the characterization of both point and extended sources.
VIP started as the effort of Carlos Alberto Gomez Gonzalez, a former PhD student of the VORTEX team (ULiège, Belgium). Since 2020, Dr. Valentin Christiaens (ULiège) has been in charge of VIP's maintenance and development lead.
HPIC: The Habitable Worlds Observatory Preliminary Input Catalog
Tuchow, Noah; Stark, Chris; Mamajek, Eric; Peacock, Sarah
The Habitable Worlds Observatory Preliminary Input Catalog (HPIC) is a list of ~13,000 nearby bright stars that will be potential targets for the Habitable Worlds Observatory in its search for Earth-sized planets around Sun-like stars. It was constructed using the TESS and Gaia DR3 catalogs, and uses an automated pipeline to compile stellar measurements and derived astrophysical properties for all stars.
Version 1.1 adds modeled UV fluxes for all objects.
MARDIGRAS: MAss-Radius DIaGRAm with Sliders
Aguichine, A. et al.
The MAss-Radius DIaGRAm with Sliders (MARDIGRAS) is a visualization tool that allows a simple and easy manipulation of mass-radius relationships (also known as iso-composition curves) with interactive sliders. Each slider controls one of the key parameters of the models implemented in the figure (core mass fraction, envelope mass fraction, equilibrium temperature, etc.).
To run the program, download the repository and run with python (no installation needed):
git clone https://github.com/an0wen/MARDIGRAS
cd MARDIGRAS
python mardigras.py
excalibuhr: A pipeline for high-resolution spectral data reduction
Zhang, Yapeng ; de Regt, Sam ; González Picos, Darío
excalibuhr is a Python package for data reduction of high-resolution spectroscopy of exoplanets and brown dwarfs. It has an end-to-end pipeline for VLT/CRIRES+.
ETHANE: Exoplanet Trend Haziness Analysis and Navigation Engine
Xinting Yu; Austin H. Dymont; David Murray; Emran Ismail; Connor Dickinson; Amaan Khwaja; Yash Rajpal
A web application that serves as a tool to understand photochemical hazes in temperate to warm exoplanet atmospheres. The exoplanet targets in this web application include exoplanets with equilibrium temperature < 1000 K, where photochemical hazes may exist to flatten their transmission spectra. The database allows us to examine relationships between exoplanet haziness and various planetary and stellar forcing parameters, so we can better understand the dominant process/property that affects how hazy an exoplanet is. Since the field is actively evolving with more upcoming data, this publicly available website allows us to add any new observations and to keep track of updated trends.
DART-Vetter: A Deep LeARning Tool for automatic vetting of candidates detected in transiting surveys
Fiscale, Stefano et al.
In the field of exoplanet detection, Machine Learning approaches have demonstrated their effectiveness in reliably classifying thousands of potential planetary signals detected by transit surveys, such as NASA's Kepler and TESS. However, existing models in the literature are typically trained to work on data from a single, specific mission. We introduce DART-Vetter, a Convolutional Neural Network designed to distinguish planetary transits from false positives of any transiting survey. By exclusively processing light curves, our model ensures ease of reproducibility and is lightweight enough to be executed on personal laptops.
HZ_evolution: A Package to Calculate Habitable Histories
Tuchow, Noah W. ; Wright, Jason T.
HZ_evolution is a Python package to characterize the habitable histories of exoplanets. Given inputs of a planet's current effective flux and host star properties, HZ_evolution calculates its instellation history, the evolution of the star's Habitable Zone, and the duration the planet spends inside or outside the Habitable Zone.
GRIP: Generic data Reduction for nulling Interferometry Package
Martinod, Marc-Antoine; Defrère, Denis; Laugier, Romain
The Generic data Reduction for nulling Interferometry Package (GRIP) aims to provide a universal pipeline to all existing and future nullers. GRIP aims to provide self-calibrated null depth measurements by fitting a model of the instrumental perturbations to histograms of data. The model is generated using a simulator of the instrument, which can be provided by the user or is built into the package for the main operating nullers
SpExoDisks: Spectra of Exoplanet forming Disks
Wheeler, Caleb, III; Hinkel, Natalie R.; Banzatti, Andrea
The Spectra of Exoplanet-forming Disks (SpExoDisks) database and web portal (spexodisks.com) provides infrared spectra of protoplanetary disks. The spectra included in SpExoDisks are contributed by individual researchers who have either taken the observations or obtained the data from archives, and who provided the fully reduced 1-dimensional spectra. All spectra are transformed into a standard format inside SpExoDisks which includes additional information as available (program number, PI, date, and references for the data reduction and for acknowledging use of the data).
easyCHEM: A Python package for calculating chemical equilibrium abundances in exoplanet atmospheres
Lei, Elise; Mollière, Paul
easyCHEM2 is a Python package for calculating chemical equilibrium abundances (including condensation) and adiabatic gradients by minimization of the so-called Gibbs free energy. Ancillary outputs are the atmospheric adiabatic temperature gradient and mean molar mass. easyCHEM is a clone of the equilibrium chemistry part of NASA’s CEA code, written from scratch and with numerical stability in mind.
pyTPCI
Rosener, Riley; Zhang, Michael; Bean, Jacob L.
pyTPCI is a Python wrapper which couples newer versions of hydrodynamics code PLUTO and gas microphysics code CLOUDY to self-consistently simulate escaping atmospheres in 1D. Following TPCI, we modify CLOUDY to read in depth-dependent wind velocities, and to output useful physical quantities (including mass density, number density, and mean molecular weight as a function of depth).
tglc (TESS-Gaia Light Curve): TESS FFI light curve based on point spread functions
Han & Brandt 2023
TESS-Gaia Light Curve (TGLC) is a PSF-based TESS full-frame image (FFI) light curve product. Using Gaia DR3 as priors, the team forward models the FFIs with the effective point spread function to remove contamination from nearby stars. The resulting light curves show a photometric precision closely tracking the pre-launch prediction of the noise level: TGLC's photometric precision consistently reaches ≲2% at 16th TESS magnitude even in crowded fields, demonstrating excellent decontamination and deblending power.
PHOEBE: PHysics Of Eclipsing BinariEs
Prša, Andrej; Conroy, Kyle; Hambleton, Kelly; Jones, David; DeGroote, Pieter; Fabry, Matthias; Pablo, Herbert; and Giammarco, Joseph
PHOEBE (PHysics Of Eclipsing Binaries) is an eclipsing binary modeling code - reproducing and fitting light curves, radial velocity curves, and spectral line profiles of eclipsing systems, including exoplanetary transits.
gaspery: Optimized Scheduling of Radial Velocity Follow-Up Observations for Active Host Stars
Lam, Christopher; Bedell, Megan; Zhao, Lily L.; Gupta, Arvind F.; Ballard, Sarah A.
gaspery employs a generalized formulation of the Fisher Information for RV time series that also incorporates information about stellar correlated noise. gaspery enables users to craft optimal and flexible strategies for exoplanet RV follow-up, and can be generalizable to other scheduling use cases.
ODUSSEAS: A Machine Learning Tool to Derive Effective Temperature and Metallicity for M Dwarf Stars
ODUSSEAS is an automatic computational tool able to quickly and reliably derive the Teff and [Fe/H] of M dwarfs using optical spectra obtained by different spectrographs with different resolutions.
It is based on the measurement of the pseudo equivalent widths for more than 4000 stellar absorption lines and on the use of the machine learning Python package “scikit-learn” for predicting the stellar parameters.
It is able to derive parameters accurately and with high precision, having precision errors of ~30 K for Teff and ~0.04 dex for [Fe/H]. The results are consistent for spectra with resolutions of between 48000 and 115000 and a signal-to-noise ratio above 20.
tshirt: Time Series Helper & Integration Reduction Tool
Everett Schlawin ; Kayli Glidic
The Time Series Helper & Integration Reduction Tool tshirt is a general-purpose tool for time series science. Its main application is to process raw data on exoplanet systems. tshirt can:
- Reduce raw data: flat field, bias subtract, gain correct, etc. This has been demonstrated to work with merged CCD images from Mont4K imager on the Kuiper-61 inch on Mt Bigelow, AZ.
- Extract Photometry
- Extract Spectroscopy
MARCS: Model Atmospheres with a Radiative and Convective Scheme
The Uppsala/Montpellier MARCS team
This is a grid of one-dimensional, hydrostatic, plane-parallel and spherical LTE model atmospheres. These may be used together with atomic and molecular spectral line data and software for radiative transfer to generate synthetic stellar spectra.
The MARCS site contains about 52,000 stellar atmospheric models of spectral types F, G, K, and M in 3 different formats and also flux sample files indicating rough surface fluxes.
IGRINS Transit
Megan Weiner Mansfield & Michael R. Line
IGRINS transit is a pipeline to take high-resolution observations of transiting exoplanets with Gemini-S/IGRINS and produce cross-correlation detections of molecules in the exoplanet's atmosphere.
NEMESISPY: A Python package for simulating and retrieving exoplanetary spectra
Yang, Jingxuan ; Alday, Juan ; Irwin, Patrick
NEMESISPY is a Python package developed for atmospheric retrievals, which is the inference of atmospheric properties such as chemical composition using spectroscopic data. The package contains code for radiative transfer calculation using the correlated-k approximation and for parametric atmospheric modelling. NEMESISPY is a recent and active development of the well-established Fortran NEMESIS library (Irwin et al., 2008), which has been applied to the atmospheric retrievals of both solar system planets and exoplanets employing numerous different observing geometries.
OCSVM-Transit-Detection: One-Class SVM model designed to detect exoplanet transit events.
Roche, Jakob
A One-Class Support Vector Machine (SVM) model designed to detect exoplanet transit events. One-Class SVMs can be fitted to data up to 84 times faster than simple CNNs and make predictions over 3 times faster on the same datasets using the same hardware. In addition, One-Class SVMs can be run smoothly on unspecialized hardware, removing the need for Graphics Processing Unit (GPU) usage. In cases where time and processing power are valuable resources, One-Class SVMs are able to minimize time spent on transit detection tasks while maximizing performance and efficiency.
ExoTR: Bayesian Statistical Analysis for Transmission Spectra Interpretation
Damiano, Mario ; Hu, Renyu
ExoTR (Exoplanetary Transmission Retrieval) is a Bayesian inverse retrieval algorithm to interpret exoplanetary transmission spectra.
The code can be used in two ways:
- leveraging the physics forward model only to generate synthetic planetary atmospheric transmission spectra (including the addition of errorbars);
- using a retrieval routine based on nested sampling (i.e. MultiNest) to extract physical and chemical information from the input transmission spectra.
NEXO: Nonsingular Estimator for Exoplanet Orbits
Stojanovski, Zvonimir ; Savransky, Dmitry
A new method for fitting exoplanet orbits to direct astrometric measurements, using nonlinear batch estimation and nonsingular orbital elements. The estimation technique is based on the unscented transform, which approximates probability distributions using finite, deterministic sets of weighted sample points. Furthermore, NEXO uses Gaussian mixtures to account for the strong nonlinearities in the measurement model. As a fitting basis, it uses a set of orbital elements developed specifically for directly observed exoplanets, combining features of the Thiele–Innes constants and the Cohen–Hubbard nonsingular elements.
plaNETic: A neural network-based Bayesian internal structure modelling framework for small exoplanets
Egger, Jo Ann et al.
plaNETic is a neural network-based Bayesian internal structure modelling framework for small exoplanets with masses between 0.5 and 15 Mearth, introduced in Egger et al. 2024. The code efficiently computes posteriors of a planet's internal structure based on its observed planetary and stellar parameters. It uses a full grid accept-reject sampling algorithm with neural networks trained on the interior model of the BICEPS code (Haldemann et al. 2024) as a forward model. Furthermore, it allows for different choices in priors concerning the expected abundance of water (formation inside vs. outside of iceline) and the planetary Si/Mg/Fe ratios (stellar vs. iron-enriched vs. free).
AstroNet: A Neural Network for Identifying Exoplanets in Light Curves
Shallue, Christopher J.
AstroNet is a Neural Network for identifying exoplanets in light curve data, implemented in TensorFlow.
It uses the Adam optimization algorithm to minimize the cross-entropy error function over the training set, and augments the training data by applying random horizontal reflections to the light curves during training. It also applies dropout regularization to the fully connected layers, which helps prevent overfitting by randomly “dropping” some of the output neurons from each layer during training to prevent the model from becoming overly reliant on any of its features.
AstroNet uses the Google-Vizier system for black-box optimization to automatically tune its hyper-parameters.
JKTEBOP: Analyzing Light Curves of Detached Eclipsing Binaries
Southworth, John
The JKTEBOP code calculates model light and radial velocity curves of eclipsing binary star and transiting planetary systems, and adjusts the parameters of the model to fit observed light curve, radial velocity curves, and times of mid-eclipse. It is a development of the original EBOP model by Paul B. Etzel. The fitting is performed using Levenberg-Marquart minimisation, and uncertainties can be obtained from the covariance matrix, bootstrapping simulations, a Monte Carlo algorithm, and residual-permutation simulations. The stars are treated as spheres for the calculation of eclipses, but the ellipsoidal and reflection effects are included. Limb darkening is implemented using the linear, sqr
flatstar: Make 2d intensity maps of limb-darkened stars
Dos Santos, L. A.
flatstar is an open-source Python tool for drawing stellar disks as numpy.ndarray objects with scientifically-rigorous limb darkening. Each pixel has an accurate fractional intensity in relation to the total stellar intensity of 1.0. It is ideal for ray-tracing simulations of stars and planetary transits.
ECCOplanets: Simulation and Analysis of Rocky Planets
Timmermann, Anina
A python code to simulate the formation of rocky planets in chemical equilibrium (based on a Gibbs free energy minimisation) and tools for the analysis of the simulated planet. The code includes a database of thermochemical data and a database of stellar abundance patterns.
radioBEAR: radio - BErkeley Atmospheric Radiative transfer
DeBoer, David
Radio BErkeley Atmospheric Radiative-transfer (RadioBEAR) is a planetary atmosphere code to calculate the brightness temperature of planetary atmospheres in the meter-to-millimeter wavelength range.
speedyfit
Vos, Joris
A python package to fit the photometric spectral energy distribution of stars. It uses a Markov chain Monte Carlo approach to determine the errors on the derived parameters.
Speedyfit is a command line tool writen in Python 3 that allows you to search the most common online databases for photometric observations of your target, and fit theoretical atmosphere models to the obtained photometry. Speedyfit can deal with both single and binary stars, and allows for the inclusion of constraints from other sources, as for example atmosphere parameters derived from spectroscopy, distances from GAIA or reddening.
PyExoCross: A Python program for generating spectra and cross-sections from molecular line lists
Zhang, Jingxin
PyExoCross is designed for postprocessing the huge molecular line lists generated by the ExoMol project and other similar initiatives such as the HITRAN and HITEMP. It generates LTE and non-LTE absorption and emission stick spectra, cross sections, and other properties (partition functions, specific heats, cooling functions, lifetimes, and oscillator strengths) based on molecular line lists. PyExoCross calculates cross sections with four line profiles: Doppler, Gaussian, Lorentzian, and Voigt; a number of options are available for computing Voigt profiles. PyExoCross can convert data format between ExoMol and HITRAN. PyExoCross supports line lists in the ExoMol and HITRAN/HITEMP formats.
The ExoMol database: Molecular line lists for exoplanets and other hot atmospheres
Tennyson, J. et al.
ExoMol is a database of molecular line lists that can be used for spectral characterization and simulation, and as input to atmospheric models of exoplanets, brown dwarfs and cool stars, and other models including those for combustion and sunspots.
kpic_pipeline
The KPIC Team
The data reduction pipeline for the Keck Planet Imager and Characterizer. It is used for processing high resolution spectroscopy data taken with KPIC to study exoplanet atmospheres. Designed to process and calibrate KPIC data to enable spectroscopic model fitting.
RTModel: Microlensing modeling - fast and efficient exploration of the parameter space
Bozza, Valerio
RTModel is a package for modeling and interpretation of microlensing events. It uses photometric time series collected from ground and/or space telescopes.
The modeling strategy is based on a grid search in the parameter space for single-lens models, whereas a template library for binary-lens models is used including all possible geometries of the source trajectory with respect to the caustics. In addition to this global search, planets are searched where maximal deviations from a Paczynski model occurs.
breads: Broad Repository for Exoplanet Analysis, Discovery, and Spectroscopy
Agrawal, Shubh et al.
breads, or the Broad Repository for Exoplanet Analysis, Detection, and Spectroscopy, is a flexible framework that allows forward modeling of data from moderate to high resolution spectrographs. The philosophy of breads is to have the users choose a data class, a forward model function, and a fitting strategy. Data classes normalize the data format, simplifying reduction across different spectrographs while allowing for specific behaviors of each instrument to also be coded into their own specific class. The forward model (FM) aims to reproduce the data (d) as d = FM + n, where n is the noise.
MOLPOP-CEP: An exact, fast line transfer code for multi-level line emission
Asensio Ramos, Andrés ; Elitzur, Moshe
MOLPOP-CEP is a universal line transfer code that allows the exact calculation of multi-level line emission from a slab with variable physical conditions for any arbitrary atom or molecule for which atomic data exist.
sunbather
Linssen, Dion et al.
sunbather performs simulations of escaping planet atmospheres and their transit signatures. The main use of the code is to construct 1D Parker wind profiles using the Python p-winds package, to simulate these with photoionization code Cloudy, and to postprocess the output with a custom radiative transfer module to predict the transmission spectra of exoplanets, for a nearly arbitrary chemical composition.
polyrot: A small package for computing polytropic models of rapidly rotating planets and stars.
Dewberry, Janosz W.
This package computes the equilibrium structure of rapidly rotating planets and stars modeled as "polytropes."
The Sonora Elf Owl Models: Substellar Atmosphere Models
Mukherjee, Sagnick et al.
The Sonora Elf Owl Models is a successor to the Sonora Bobcat and Sonora Cholla models. The Sonora Elf Owl model grid includes cloud-free radiative-convective equilibrium model atmospheres with vertical mixing induced disequilibrium chemistry with sub-solar to super-solar atmospheric metallicities and Carbon-to-Oxygen ratio. The atmospheric models have been computed using the open-source radiative-convective equilibrium model PICASO. The model grid samples equilibrium temperatures between 275-2400 K and log(g) between 3.25-5.5. The mixing parameter log(Kzz) has been varied from 2-9 in cgs units. The [M/H] and C/O has been varied between [M/H]=-1.0 to [M/H]=+1.0 and C/O=0.22 to C/O=1.14.
SpectralRadex
Holdship, J. ; Vermarien, G. ; Van der Tak, F. F. S. ; Black, J. H.
A python library that serves two purposes: run RADEX directly from python and create model spectra from RADEX outputs.
A number of libraries exist for the first purpose. However, most either launch the RADEX compiled binary as a subprocess or wrap the original code. In the former case, the creating of subprocesses can interfere with many Python multiprocessing methods. In the latter, running multiple models simultanously can be problematic due to the use of F77 common blocks in RADEX.
SpectralRadex uses F2PY to compile a version of RADEX written in modern Fortran, most importantly dropping the use of common blocks. As a result, RADEX models can be run in parallel.
The Giants Pipeline: An open-source Python package to search for exoplanets around evolved stars
Saunders, Nicholas et al.
An open-source TESS FFI pipeline to access TESS data, produce noise-corrected light curves, and search for planets transiting evolved stars, with an emphasis on detecting planets around subgiant and RGB stars. The giants pipeline produces a one-page PDF summary for each target including the following vetting materials. Built with Lightkurve.
TLCM: Transit and Light Curve Modeler
Csizmadia, Szilárd
TLCM is a software package to analyze the light curves of transiting exoplanets.
The code fits the light curves with quadratic limb darkening law, and the limb darkening coefficients can be different for the two objects considered.
OoT: Out-of-Transit Light Curve Generator
Penoyre, Z. ; Sandford, E.
OoT (Out-of-Transit) calculates the light curves and radial velocity signals due to a planet orbiting a star. It explicitly models the effects of tides, orbital motion, relativistic beaming, and reflection of the stars light by the planet. The code can also be used to model secondary eclipses.
SPCA: Spitzer Phase Curve Analysis
Dang, L ; Bell, T. J.
SPCA is an open-source, modular, and automated pipeline for Spitzer Phase Curve Analyses.
nuance
Garcia, L.
nuance uses linear models and gaussian processes (using JAX-based tinygp) to simultaneously search for planetary transits while modeling correlated noises (e.g. stellar variability) in a tractable way.
nuance is written for python 3 and can be installed using pip.
The NASA Exoplanet Archive: Data and Tools for Exoplanet Research
The NASA Exoplanet Archive is an online astronomical exoplanet and stellar catalog and data service that collates and cross-correlates astronomical data and information on exoplanets and their host stars, and provides tools to work with these data. The archive is dedicated to collecting and serving important public data sets involved in the search for and characterization of extrasolar planets and their host stars. These data include stellar parameters (such as positions, magnitudes, and temperatures), exoplanet parameters (such as masses and orbital parameters) and discovery/characterization data (such as published radial velocity curves, photometric light curves, images, and spectra).
Encyclopaedia of Exoplanetary Systems
This catalog is a working tool providing all the latest detections and data announced by professional astronomers, useful to facilitate progress in exoplanetology. It contains data about objects lighter than 60 Jupiter masses, which are orbiting stars/brown dwarf or are free floating. It also provides databases of planets in binary systems and circumstellar disks.
exovetter: Transiting exoplanet detection python vetter
The exovetter development team
The exovetter package provide statistical metrics and quick visualizations needed when evaluating a periodic transit found in time domain photometry, such as Kepler and TESS. This code wraps codes used to evaluate TESS, Kepler and K2 transit-like signals in order to remove obvious false positives.
TIKE: The Time Series Integrated Knowledge Engine
The MAST Team at STScI
The TIKE (Time series Integrated Knowledge Engine) is a new service being offered by STScI to support astronomers working with the time series data archived at MAST, such as data from NASA's TESS, Kepler and K2 missions. This tool is built on the Pangeo deployment of JupyterHub, using Kubernetes in AWS. TIKE is a platform where astronomers can make use of data science utilities, astronomy software, and community software packages to retrieve and analyze data sets without having to download the data to their machines or maintain their own set of python packages.
gollum: An intuitive programmatic and visual interface for precomputed synthetic spectral model grids
Shankar, S.; Gully-Santiago, M.; Morley, C.; Cao, J.; Kaplan, K.; Kimani-Stewart, K.; Gonzalez-Argueta, D.
Gollum is a tool for spectral visualization and analysis. It boasts both a programmatic interface and a visual interface that help users analyze stellar and substellar spectra, with support included for a set of precomputed synthetic spectral model grids.
ATMOSPHERIX: Data Processing Tool
Klein, B. et al.
A simple tool to process near-infrared high-resolution spectra for the atmospheric characterisation of transiting exoplanets. The code remove the stellar and Earth atmosphere spectra and correct for systematics in a data-driven way (e.g. principal component analysis or auto-encoders). It contains a planet atmosphere retrieval (nested sampling algorithm). The code is initially designed to work with telluric-corrected SPIRou transmission spectra, but could be easily adapted to other instruments (e.g. GEMINI-IGRINS, VLT-CRIRES+, ESO-NIRP) and to emission spectroscopy.
CONTROL: CUTE Autonomous Data Reduction Pipeline
Sreejith, A. G. et al.
V1.0 of CUTE data reduction pipeline.
This software is intented to be fully automated, aimed at producing science-quality output with a single command line with zero user interference for CUTE data. It can be easily used for any single order spectral data in any wavelength without any modification.
PyRADS: Python RADiation model for planetary atmosphereS
Koll, D. et al.
The Python line-by-line RADiation model for planetary atmosphereS (PyRADS) is a 1D line-by-line radiation code. The default version is for longwave radiation (no scattering), a version for shortwave radiation (with scattering) is also available on github.
Citation: Koll & Cronin (2018), Proceedings of the National Academy of Sciences, vol. 115, issue 41, pp.10293-10298.
TATOO: Tidal-chronology Age TOOl
Gallet, F.
Tidal-chronology standalone tool to estimate the age of massive close-in planetary systems.
This tool is specifically developed for massive close-in planetary systems: Mp > 0.5 Mjup and 0.5 < Mstar/Msun < 1.0.
TATOO currently only works with python3.5.
pile-up: Monte Carlo simulations of star-disk torques on hot Jupiters
Heller, R.
A gnuplot script for Monte Carlo simulations of disk and stellar tidal torques acting on hot Jupiters.
Details are described in the research paper by René Heller (2018), "Formation of hot Jupiters through Disk Migration and Evolving Stellar Tides", Astronomy & Astrophysics. This gnuplot script was used to generate Figure 3b in this paper.
Atmospheric Athena: 3D Atmospheric escape model with ionizing radiative transfer
Tripathi, A. ; Krumholz, M. R.
Atmospheric Athena is a code intended to simulate hydrodynamic escape from close-in giant planets in 3D. It uses the Athena hydrodynamics code (v4.1) with a new ionizing radiative transfer implementation based on Krumholz et al, 2007, to self-consistently model photoionization driven winds from the planet. The code is fully compatible with static mesh refinement and MPI parallelization.
exoTEDRF: exoplanet Transit and Eclipse Data Reduction Framework
Radica, M.
Formerly known as supreme-SPOON, exoTEDRF is an end-to-end pipeline for the reduction of JWST exoplanet time series observations (NIRISS and NIRSpec currently supported, MIRI in development).
APPleSOSS: A Producer of ProfiLEs for SOSS. Application to the NIRISS SOSS Mode
Radica, M. et al.
A tool to produce empirical 2D point spread functions for JWST NIRISS/SOSS observations. These PSFs are necessary input for the ATOCA extraction algorithm implemented in the STScI calibration pipeline.
optool: Command-line driven tool to create dust opacities.
Dominik, C. ; Min, M. ; Tazaki, R.
Optool computes dust opacities and scattering matrices, for specific grain sizes or averaged over size distributions. It is derived from OpacityTool (ascl:2104.009) and implements the Distribution of Hollow Spheres (DHS) statistical method to approximate irregular and low porosity grains. Mie theory is available as a limiting case of DHS. It also implements the Tazaki Modified Mean Field Theory (MMF) to treat fractal and highly porous aggregates. The refractive index data for many astronomically relevant materials are compiled into the code, and external refractive index data can be used as well.
GPS: Genesis Population Synthesis
Chakrabarty, A.; Mulders, G. D.
This is a Python-based population synthesis codebase that uses the Genesis database of planet formation models (Mulders et al. 2020). It consists of independent stages of internal structure and atmopsheric evolution models that can be used to synthesize a population of small exoplanets for comparison with observed domgraphics, e.g., from Kepler. It also offers statistical tools for drawing comparisons with observed distributions and studying occurrence trends. By invoking migration models (e.g., from Genesis), one can explore the occurrence patterns of the speculative water worlds and generate a list of potential targets using GPS.
CALCEPH: Planetary ephemeris files access code
Gastineau, M. et al. ; IMCCE ; Observatoire de Paris ; PSL University ; CNRS
The library CALCEPH accesses binary planetary ephemeris files, including INPOPxx, JPL DExxx, and SPICE ephemeris files. This library, available for the operating system Linux, MacOS and WIndows, provides a C Application Programming Interface (API) and, optionally, Fortran 77/2003, Python 2/3 and octave/Matlab interfaces to be called by the application. These functions provide access to many ephemeris file at the same time for parallel computations.
BOOTTRAN: Error Bars for Keplerian Orbital Parameters
Wang, S.X.; Wright, J.
BOOTTRAN calculates error bars for Keplerian orbital parameters for both single- and multiple-planet systems. It takes the best-fit parameters and radial velocity data (BJD, velocity, errors) and calculates the error bars from sampling distribution estimated via bootstrapping. It is recommended to be used together with the RVLIN (ascl:1210.031) package, which find best-fit Keplerian orbital parameters.
Posidonius: N-Body simulator for planetary and/or binary systems
Blanco-Cuaresma, S. et al.
Posidonius is a N-body code for simulating planetary and/or binary systems which implements the WHFAST/IAS15 integrators (Rein & Tamayo, 2015; Rein & Spiegel, 2015) and the tidal model used in Mercury-T (Bolmont et al. 2015). The bodies in the simulation can be static or follow predefined evolutionary models matching FGKML stars and gaseous planets. The simulations can account for several different effects such as tidal forces, rotational-flattening effects, general relativity corrections, protoplanetary disk, stellar wind. Posidonius has a better spin integration than Mercury-T, it's more than six times faster, it conserves the total angular momentum of the system one order of magnitude.
Difference Imaging Code and Visualization for TESS Full Frame Image Lightcurves
Oelkers, R. J. & Stassun, K.G.
This toolset includes a difference image analysis pipeline, which employs a delta-function kernel, useful for reducing TESS Full Frame Images. The data extracted using the pipeline for the first two years of TESS imagery is available for inspection at https://filtergraph.com/tess_ffi.
IsoFATE: Isotopic Fractionation via ATmospheric Escape
Cherubim, C. et al.
Open source code for the numerical model IsoFATE: Isotopic Fractionation via ATmospheric Escape. IsoFATE models mass fractionation of planetary atmospheres due to molecular diffusion for H, He, and an arbitrary number of trace species (e.g. D, O). The model includes EUV-driven photoevaporation and core-powered mass loss.
luas: A 2D Gaussian process package for systematics correlated in two dimensions
Fortune, M. et al.
luas (from the Irish word for speed) is a small library aimed at building Gaussian processes (GPs) primarily for two-dimensional data sets. This has particularly useful applications when it comes to joint-fitting spectroscopic transit light curves, as demonstrated in Fortune et al. (2024). By utilising different optimisations - such as using Kronecker product algebra - we can make the application of GPs to 2D data sets which may have dimensions of 100s-1000s along both dimensions possible within a reasonable timeframe. luas can be used with popular inference frameworks such as NumPyro and PyMC for which there are tutorials to help you get started.
coronagraph: Telescope Noise Modeling for Exoplanets in Python
Lustig-Yaeger et al.
A Python noise model for directly imaging exoplanets with a coronagraph-equipped telescope. The original IDL code for this coronagraph model was developed and published by Tyler Robinson and collaborators (Robinson, Stapelfeldt & Marley 2016). This open-source Python version has been expanded upon in a few key ways, most notably, the Telescope, Planet, and Star objects used for reflected light coronagraph noise modeling can now be used for transmission and emission spectroscopy noise modeling, making this model a general purpose exoplanet noise model for many different types of observations.
mini_chem: Miniature chemical kinetics model for gas giant GCMs
Lee, E. K.H.; Tsai, S.-M.
Mini-chem is a kinetic chemistry network solver primarily for gas giant atmospheric modelling, pared down from the large chemical networks. This makes use of 'net forward reaction tables', which reduce the number of reactions and species required to be evolved in the ODE solvers significantly. Mini-chem's NCHO network currently consists of only 12 species with 10 reactions, making it a lightweight and easy to couple network to large scale 3D GCM models, or other models of interest (such as 1D or 2D kinetic modelling efforts).
cortecs: Compressed representations of opacity for radiative transfer
Savel, A.; Bedell, M.; Kempton, E. M.-R.
cortecs is a Python package for compressing opacity files used in radiative transfer. We offer a few different types of compression methods with a range of flexibility, from polynomial to neural networks. We also provide utility functions for working with opacity files, such as chunking and interpolating them onto different grids.
TRES-exo: TRiple Evolution Simulation package
Columba, G.; Toonen, S.; Dorozsmai, A.; Danielski, C.
TRES is a numerical framework for simulating hierarchical triple systems of stars and giant planets (M>0.2 M_Jupiter). It accounts for three-body dynamics, stellar evolution and various interactions. TRES-exo is an extension of the original code (Toonen et al. 2016) specifically designed to simulate giant circumbinary planets and their evolution.
Spright: Bayesian mass-radius relation for small planets
Parviainen, H.; Luque, R.; Palle, E.
Spright is a fast Bayesian radius-density-mass relation for small planets. The package allows one to predict planetary masses, densities, and RV semi-amplitudes given the planet's radius or planetary radii given the planet's mass.
The package offers an easy-to-use command line script for people not overly interested in coding and a nearly-as-easy-to-use set of Python classes for those who prefer to code. The command line script can directly create publication-quality plots, and the classes offer a full access to the predicted numerical distributions.
VCAL-SPHERE: Hybrid pipeline for reduction of VLT/SPHERE data
Christiaens, Valentin et al.
VCAL-SPHERE, for VIP-based Calibration of VLT/SPHERE data, is a versatile pipeline for high-contrast imaging of exoplanets and circumstellar disks. The pipeline covers all steps of data reduction, including raw calibration, pre-processing and post-processing (i.e., modeling and subtraction of the stellar halo), for the IFS, IRDIS-DBI and IRDIS-CI modes (and combinations thereof) of the VLT instrument SPHERE. The three main steps of the reduction correspond to different modules, where the first follows the recommended EsoRex (ascl:1504.003) workflow and associated recipes with occasional inclusion of VIP (ascl:1603.003) routines.
deconfuser: An algorithm for fast orbit-fitting of directly imaged planets
Pogorelyuk, L. et al.
Fast orbit fitting of directly imaged multi-planetary systems. The deconfuser quickly fits orbits to planet detections in 2D images, guarantees that all orbits within a certain tolerance are found, and ranks partitions of detections by planets (decides which assignment of detection-to-planet fits the data best). Pogorelyuk et al. 2022 describes the deconfusion algorithm and estimates of confusion rates from simulated planetary systems using the deconfuser.
AESTRA: Auto-Encoding STellar Radial-velocity and Activity
Liang, Yan et al.
AESTRA (Auto-Encoding STellar Radial-velocity and Activity) is a deep learning method for precise radial velocity measurements in the presence of stellar activity noise. The architecture combines a convolutional radial-velocity estimator and a spectrum auto-encoder called spender. For an in-depth understanding of the spectrum auto-encoder, see Melchior et al. 2023 and Liang et al. 2023.
sai: Surface-Atmosphere Interactions on Warm Exoplanets
Byrne, Xander et al.
For warm rocky planets, broadly Venus-like planets, the high temperatures and moderate pressures at the base of their atmospheres may enable thermochemical equilibrium between rock and gas. This links the composition of the surface to that of the observable atmosphere. sai is a repository containing files for the GGchem equilibrium chemistry code, and associated helper functions, which we used to find a boundary in surface pressure-temperature space which simultaneously separates distinct mineralogical regimes and atmospheric regimes, potentially enabling inference of surface mineralogy from spectroscopic observations of the atmosphere (Byrne+23, MNRAS).
VSPEC: Variable Star PhasE Curve
VSPEC (Variable Star PhasE Curve) is an exoplanet modeling suite that combines NASA’s Planetary Spectrum Generator (PSG) with a custom variable star. Originally built to simulate the infrared excess of non-transiting planets, the code supports transit, eclipse, phase curve geometries as well as spots, faculae, flares, granulation, and the transit light source effect. Install it with pip or see the documentation linked below.
pycrires: Data reduction pipeline for VLT/CRIRES+
Stolker, Tomas; Landman, Rico
pycrires runs the CRIRES+ recipes of EsoRex. The pipeline organizes the raw data, creates SOF and configuration files, runs the calibration and science recipes, and creates plots of the images and extracted spectra. Additionally, it corrects remaining inaccuracies in the wavelength solution and the spectrum curvature. pycrires also provides dedicated routines for the extraction, calibration, and detection of spatially-resolved objects such as directly imaged planets.
ExPRES: Exoplanetary and Planetary Radio Emission Simulator
Louis, C. K. et al.
ExPRES (Exoplanetary and Planetary Radio Emission Simulator) is a versatile tool that computes the observation opportunities of planetary radio emissions, based on the radio source beaming patterns and the observer’s location.
The ExPRES code is assuming that auroral radio waves are emitted through the Cyclotron Maser Instability (CMI). This emission mechanism can transfer free energy present in the electron distribution function in the source, into the ambient electromagnetic fluctuation background, thus amplifying waves at a frequency close to the local electron cyclotron frequency, as a resonator.
MAGPy-RV: Modelling stellar Activity with Gaussian Processes in Radial Velocity
Rescigno, Federica ; Dixon, Bryce ; Haywood, Raphaëlle D.
MAGPy-RV models data with Gaussian Process regression and affine invariant Monte Carlo Markov Chain parameter searching. Developed to model intrinsic, quasi-periodic variations induced by the host star in radial velocity (RV) surveys for the detection of exoplanets and the accurate measurements of their orbital parameters and masses, it now includes a variety of kernels and models and can be applied to any time-series analysis. MAGPy-RV includes publication level plotting, efficient posterior extraction, and export-ready LaTeX results tables. It also handles multiple datasets at once and can model offsets and systematics from multiple instruments.
NcorpiON: An O(N) software for N-body integration in collisional and fragmenting systems
Couturier, J.; Quillen, A. C.; Nakajima, M.
NcorpiON is an N-body software developed for the time-efficient integration of collisional and fragmenting systems of planetesimals or moonlets orbiting a central mass. It features a fragmentation model, based on crater scaling and ejecta models, able to realistically simulate a violent impact.
NcorpiON is designed for the study of accreting or fragmenting disks of planetesimal or moonlets. It detects collisions and computes mutual gravity faster than REBOUND, and unlike other N-body integrators, it can resolve a collision by fragmentation. The fast multipole expansions are implemented up to order six to allow for a high precision in mutual gravity computation.
PBjam
Carboneau, Lindsey; Davies, Guy; Hall, Oliver; Lyttle, Alex; Nielsen, Martin
PBjam is toolbox for modeling the oscillation spectra of solar-like oscillators. This involves two main parts: identifying a set of modes of interest, and accurately modeling those modes to measure their frequencies.
Currently, the mode identification is based on fitting the asymptotic relation to the l=2,0 pairs, relying on the cumulative sum of prior knowledge gained from NASA's Kepler mission to inform the fitting process.
Modeling the modes, or 'peakbagging', is done using the HMC sampler from pymc3, which fits a Lorentzian to each of the identified modes, with much fewer priors than during he mode ID process.
DACE: Data & Analysis Center for Exoplanets
Ségransan, D. et al.
The Data & Analysis Center for Exoplanets (DACE) is a PlanetS web-platform located at the University of Geneva (CH) dedicated to extrasolar planets data visualisation, exchange and analysis. DACE provides the research and education community with an enhanced access to exoplanet data with a suite of statistical tools for data analysis. Published observational data such as high resolution spectra, radial velocities, photometric light curves and high contrast imaging measurements are available online. Planetary systems formation and evolution can be studied as well as their long term dynamical evolution.
tapify: A Multitaper Periodogram package for computing the power spectrum of a time-series with minimal spec
Patil, A. et al.
tapify is a Python package that implements a suite of multitaper spectral estimation techniques for analyzing time series data. It supports analysis of both evenly and unevenly sampled time series data.
The multitaper statistic was first proposed by Thomson (1982) as a non-parametric estimator of the spectrum of a time series. It is attractive because it tackles the problems of bias and consistency, which makes it an improvement over the classical periodogram for evenly sampled data and the Lomb-Scargle periodogram for uneven sampling. In basic statistical terms, this estimator allows us to confidently look at the properties of a time series in the frequency or Fourier domain.
MADYS: Isochronal parameter determination for young stellar and substellar objects
Squicciarini, V., & Bonavita, M.
MADYS (Manifold Age Determination for Young Stars) determines astrophysical parameters (such as age, mass, radius and Teff) of young stellar and substellar objects. The code automatically retrieves and cross-matches photometry from several catalogs, estimates interstellar extinction, and derives parameter estimates for individual objects through isochronal fitting. Harmonizing the heterogeneity of publicly-available isochrone grids, MADYS enables its users to choose amongst >140 grids from >20 models. Its versatility allows for a wide range of scientific applications, ranging from the characterization of directly imaged planets to the study of stellar associations.
ExoFOP: The Exoplanet Follow-up Observing Program
NASA Exoplanet Archive team at NExScI/IPAC
This website is designed to optimize resources and facilitate collaboration in follow-up studies of exoplanet candidates. ExoFOP serves as a repository for project and community-gathered data by allowing upload and display of data and derived astrophysical parameters.
pycdata: A module to import datasets from various instruments in pycheops
Jayshil A. Patel, Alexis Brandeker, Pierre Maxted
pycdata is a module to import datasets from various telescopes/instruments in pycheops. pycheops is a tool specifically designed to model CHEOPS observations of transits, eclipses and phase curves. While being a genius tool, what it lacks is a facility to model datasets from other telescopes/instruments, even the PSF photometry produced by PIPE. pycdata can be used to import datasets from PIPE, TESS and Kepler/K2 in pycheops thus enabling a joint lightcurve analysis of PIPE, TESS, Kepler/K2 data along with CHEOPS data in pycheops.
ExoMDN: Rapid Characterization of Exoplanet Interiors with Mixture Density Networks
Baumeister, P. and Tosi, N.
ExoMDN is a machine-learning-based exoplanet interior inference model using Mixture Density Networks. The model is trained on more than 5.6 million synthetic planet interior structures.
Given mass, radius, and equilibrium temperature, ExoMDN is capable of providing a full inference of the interior structure of low-mass exoplanets in under a second without the need for a dedicated interior model.
Exo_Transmit with Tholin Opacities
Corrales, Lia; Gavilan, Lisseth; Teal, D. J.; Kempton, E. M. R.
A static, refactored version of Exo_Transmit (Kempton et al. 2017, Teal et al. 2022, Corrales et al. 2023) for computing exoplanet transmission spectra with the new tholin species. This code uses optical constants from tholins grown in the laboratory and computed cross-sections (Mie) for a wide range of particle sizes, for wavelengths of 0.13-10 micron.
PCM_LBL: Planetary Climate Model (Line-By-Line)
Wordsworth, Robin et al.
PCM_LBL is a 1D radiative-convective code designed to simulate the climates of diverse planetary atmospheres, from present-day Earth to early Mars and exoplanets. The code is written in modular modern Fortran and uses a 'brute-force' spectral approach where absorption coefficients are computed on a fixed spectral grid directly from line data. This allows climate calculations to be performed more simply and at higher accuracy than in a correlated-k approach.
GEOCLIM: Global Silicate Weathering Estimation
Baum, Mark; Fu, Minmin
This module replicates some features of the GEOCLIM model, originally written in Fortran, but now in Julia to make them easier to use.
The module implements these formulations to estimate global silicate weathering rates from gridded climatology, typically taken from the results of a global climate model like CCSM or FOAM. It is intended to estimate weathering during periods of Earth history when the continental configuration was radically different, typically more than 100 million years ago. For more information about the original GEOCLIM, see the Methods/Supplement of Goddéris et al.
photoevolver
Fernández, Jorge
photoevolver is a Python module that evolves the gaseous envelope of planets backwards and forward in time, taking into account internal structure and cooling rate, atmospheric mass loss processes, and the stellar X-ray emission history.
smart: Spectral Modeling Analysis and RV Tool
Hsu, Chih-Chun; Burgasser, Adam; Theissen, Chris; Birky, Jessica
The smart is a Markov Chain Monte Carlo (MCMC) forward-modeling framework for spectroscopic data, currently working for high-resolution spectrometers including Keck/NIRSPEC, SDSS/APOGEE, Gemini/IGRINS, Lick/HPF, Keck/HIRES and medium-resolution spectrometers including Keck/OSIRIS and Keck/NIRES.
For NIRSPEC users, required adjustments need to be made before reducing private data using NIRSPEC-Data-Reduction-Pipeline(NSDRP), to perform telluric wavelength calibrations, and to forward model spectral data. The code is currently being developed.
CROCODILE: CROss-COrrelation retrievals of Directly-Imaged self-Luminous Exoplanets
Hayoz, J. et al. 2023
CROCODILE provides the statistical framework to interpret the three main observables of directly-imaged exoplanetary atmospheres, namely photometry, low-resolution spectroscopy, and medium (and higher) resolution cross-correlation spectroscopy. These will be measured by the next generation of instruments such as ERIS at the Very Large Telescope, MIRI aboard the James Webb Space Telescope, and METIS at the future Extremely Large Telescope.
mr-plotter: Mass-Radius Diagrams Plotter
A. Castro-González, J. Lillo-Box
Mister plotter (mr-plotter) is a user-friendly Python tool that creates paper-ready mass-radius diagrams with your favorite theoretical models. It also includes the ability to color-code diagrams based on any published stellar or planetary property collected in the NASA Exoplanet Archive.
MAGIC: Microlensing Analysis Guided by Intelligent Computation
Haimeng Zhao and Wei Zhu
MAGIC is a machine learning framework to efficiently and accurately infer the microlensing parameters of binary events with realistic data quality. In MAGIC, binary microlensing parameters are divided into two groups and inferred separately with different neural networks. The key feature of MAGIC is the introduction of neural controlled differential equation, which provides the capability to handle light curves with irregular sampling and large data gaps. MAGIC is able to locate degenerate solutions in real events even when large data gaps are introduced. As irregular samplings are common in astronomical surveys, it also has implications to other studies that involve time series.
SWAMPE: A Shallow-Water Atmospheric Model in Python for Exoplanets
Landgren, E. and Nadeau, A.
SWAMPE is a Python package for modeling the dynamics of exoplanetary atmospheres. SWAMPE is an intermediate-complexity, two-dimensional shallow-water general circulation model. Benchmarked for synchronously rotating hot Jupiters and sub-Neptunes, the code is modular and could be easily modified to model dissimilar space objects, from Brown Dwarfs to terrestrial, potentially habitable exoplanets. SWAMPE can be easily run on a personal laptop.
Bioverse: Simulation framework for Bayesian hypothesis testing of statistical exoplanet missions
Alex Bixel et al.
Bioverse is a quantitative framework for assessing the diagnostic power of a statistical exoplanet survey. It combines Gaia-based stellar samples with Kepler-derived exoplanet demographics and a mission simulator that enables exploration of a variety of observing, follow-up, and characterization strategies.
Uniquely, Bioverse contains a versatile module for population-level hypothesis testing supporting trade studies and survey optimization. It currently supports direct imaging or transit missions, but its modularity makes it adaptable to any mission concept that makes measurements on a sample of exoplanets.
TurbospectrumNLTE: Synthetic stellar spectra calculator LTE / NLTE
Plez, Bertrand; Gerber, Jeff; Magg, Ekaterina; Bergemann, Maria
Latest version of TS (Turbospectrum), with NLTE capabilities.
Computation of stellar spectra (flux and intensities) in 1D or average <3D> stellar atmosphere models.
In order to compute NLTE stellar spectra, additional data is needed, downloadable outside GitHub.
See documentation in DOC folder
Python wrappers are available at https://github.com/EkaterinaSe/TurboSpectrum-Wrapper/ and https://github.com/JGerbs13/TSFitPy
They allow interpolation between models and fitting of spectra to derive stellar parameters.
Applefy: Robust detection limits for high-contrast imaging
Bonse, Markus J.; Gebhard, Timothy D.
Applefy calculates detection limits for exoplanet high contrast imaging (HCI) datasets. The package provides a number of features and functionalities to improve the accuracy and robustness of contrast curve calculations. Applefy implements the classical approach based on the t-test as well as the parametric boostrap test for non-Gaussian residual noise. Written in Python, it computes contrast curves and contrast grids.
light-curve: Irregular time series analysis toolbox for Rust and Python
Malanchev, K.; Lavrukhina, A.
The "light-curve" project is a toolbox for analyzing irregular time-series data, consisting of two components: a feature extractor and a dm-dt mapper. Feature extraction is available as Rust and Python libraries, including various feature extractors like magnitude statistics, shape-based features, Lomb-Scargle periodogram peaks, and parametric fits. The dm-dt mapper represents observation pairs as 2-D points based on magnitude and time differences, available in the same Python library, the Rust library, and a binary executable for generating PNG images.
ExoCcycleGeo: Geophysical and geochemical controls on abiotic carbon cycling on Earth-like planets
Neveu, M. et al.
This model of geological carbon fluxes leverages widely used geochemical codes of solid-melt equilibria for silicate rocks (MELTS) and of equilibria and kinetics of water-rock interactions (PHREEQC). Coupled with a simple numerical computation of global thermal evolution, this model enables investigation of the effects of planet size (mass) and bulk, surface, and upper mantle composition on carbon cycling through geologic time. Its applicable size range (0.5 to 2 Earth masses) is limited by the fidelity of the geodynamic model. The applicable range of compositions is limited by those that can be handled by MELTS and PHREEQC.
MATRIX ToolKit: ToolKit for Multi-phAse Transits Recovery from Injected eXoplanets
Dévora-Pajares, Martín & Pozuelos, Francisco J.
The MATRIX ToolKit has been specially designed to establish detection limits of photometry data sets by performing robust injection-and-recovery analyses on a three dimensional grid of scenarios (orbital period vs planetary radius vs transit epoch). This kind of scientific detection threshold determination can now be done with a simple python command with the significant addition of taking into account different transit epochs, which helps to establish a more reliable detection rate for a given period and radius.
WATSON: Visual Vetting and Analysis of Transits from Space ObservatioNs
Dévora-Pajares, M.
WATSON (Visual Vetting and Analysis of Transits from Space ObservatioNs is a lightweight software package that enables a comfortable visual vetting of a transiting signal candidate from Kepler, K2 and TESS missions. WATSON looks for transit-like signals that could be generated by other sources or instrument artifacts. The code runs simplified tests on scenarios including:
- Transit shape model fit
- Odd-even transits checks
- Centroids shifts
- Optical ghost effects
- Transit source offsets
- and more...
PEPITA: Prediction of Exoplanet Transit Parameters Precisions using Information Analysis Techniques
Julio Hernandez Camero
PEPITA is a Python package that allows making predictions for the precision of exoplanet parameters using transit light-curves, without the need of performing a fit to the data. Behind scenes, it makes use of the Information Analysis techniques to predict the best precision that can be obtained by fitting a light-curve without actually needing to perform the fit.
PyMieScatt: The Python Mie Scattering package
Sumlin, B., Heinson, W., and Chakrabarty, R.
PyMieScatt is a comprehensive forward and inverse Mie theory solver for Python 3. This package calculates relevant parameters such as absorption, scattering, extinction, asymmetry, backscatter, and more. It also contains single-line functions to calculate optical coefficients (in Mm-1) of ensembles of particles in lognormal (with single or multiple modes) or custom size distributions.
The inverse calculations retrieve the complex refractive index from laboratory measurements of scattering and absorption (or backscatter), useful for studying atmospheric organic aerosol of unknown composition.
Read more in our JQSRT paper!
SHERLOCK: Searching for Hints of Exoplanets fRom Lightcurves Of spaCe-based seeKers
Dévora-Pajares, M. & Pozuelos, F. J. et al.
SHERLOCK is an end-to-end pipeline that allows the users to explore the data from space-based missions to search for planetary candidates. It can be used to recover alerted candidates by the automatic pipelines such as SPOC and the QLP, the so-called Kepler objects of interest (KOIs) and TESS objects of interest (TOIs), and to search for candidates that remain unnoticed due to detection thresholds, lack of data exploration or poor photometric quality.
PACMAN: A pipeline to reduce and analyze Hubble Wide Field Camera 3 IR Grism data
Zieba, Sebastian and Kreidberg, Laura
Here we present PACMAN, an end-to-end pipeline developed to reduce and analyze HST/WFC3 data. The pipeline includes both spectral extraction and light curve fitting. The foundation of PACMAN has been already used in numerous publications (e.g., Kreidberg et al., 2014; Kreidberg et al., 2018) and these papers have already accumulated hundreds of citations.
PHOTOe: An efficient Monte Carlo model for the slowing down of photoelectrons
Monte Carlo model for simulating the slowing down of photoelectrons in gases in the local deposition approximation.
Version v1 works with H and He atoms plus thermal electrons. The model is described in: García Muñoz, Icarus, Volume 392, 1 March 2023, 115373
The model is available on https://antoniogarciamunoz.wordpress.com/ and upon email request from the author.
Version v1 works with H and He atoms plus thermal electrons. The model is described in: García Muñoz, Icarus, Volume 392, 1 March 2023, 115373
The model is available on https://antoniogarciamunoz.wordpress.com/ and upon email request from the author.
SpecMatch-Empirical: Spectroscopic characterization of stars with an empirical spectral library
Yee, Samuel; Petigura, Erik; von Braun, Kaspar
We present SpecMatch-Empirical, a tool for measuring the fundamental properties of stars from their spectra by comparing them against an empirical spectral library of FGKM stars. The spectral library comprises high-resolution, high signal-to-noise observed spectra from Keck/HIRES for 404 touchstone stars with well-determined stellar parameters derived from interferometry, asteroseismology, and spectrophotometry. The code achieves accuracies of 100K, 15%, and 0.09 dex in Teff, Rstar, and [Fe/H] respectively for FGKM dwarfs.
Astroquery: Library with tools to query astronomical databases
Astroquery is a collection of tools for requesting data from databases hosted on remote servers with interfaces exposed on the internet, including those with web pages but without formal application program interfaces. These tools are built on the Python requests package, which is used to make HTTP requests, and astropy, which provides most of the data parsing functionality. Astroquery modules generally attempt to replicate the web page interface provided by a given service as closely as possible, making the transition from browser-based to command-line interaction easy. Astroquery enables the creation of fully reproducible workflows from data acquisition through publication.
spaceKLIP: Pipeline for reducing & analyzing JWST coronagraphy data with the help of pyKLIP
JWST ERS 1386 Team
The spaceKLIP pipeline enables to reduce & analyze JWST NIRCam & MIRI coronagraphy data. It provides functions to run the official jwst stage 1 and 2 data reduction pipelines with several modifications that were made to improve the quality of high-contrast imaging reductions. It then performs PSF subtraction based on the KLIP algorithm as implemented in the widely used pyKLIP package, outputs contrast curves, and enables forward model PSF fitting for any detected companions in order to extract their properties (offset and flux). The pipeline is still under heavy development.
Butterpy: realistic star spot evolution and light curves in Python
Claytor, Zachary R. et al.
Butterpy is a Python-based tool for simulating star spot emergence, evolution, and decay as well as stellar rotational light curves. It is adapted from the physically motivated model used by Aigrain et al. (2015, MNRAS, 450, 3211) to test the recovery of stellar rotation periods using different frequency analysis techniques. Butterpy allows the user to simulate light curves of stars with variable activity level, rotation period, spot lifetime, magnetic cycle duration and overlap, spot emergence latitudes, and latitudinal differential rotation shear.
The name Butterpy is a portmanteau of "butterfly" (like the solar butterfly diagram) and "Python."
Kiauhoku: Python utilities for stellar model grid interpolation
Claytor, Zachary R. et al.
Kiauhoku is a Python package for interacting with, interpolating, and fitting stellar evolutionary tracks to observational data. It includes popular stellar model grids like MIST, Dartmouth, and GARSTEC, as well as a few custom YREC grids, with more being added over time.
From Hawaiian:
1. vt. To sense the span of a star's existence (i.e., its age).
2. n. The speed of a star (in this case, its rotational speed).
This name was created in partnership with Dr. Larry Kimura and Bruce Torres Fischer, a student participant in A Hua He Inoa, a program to bring Hawaiian naming practices to new astronomical discoveries. We are grateful for their collaboration.
From Hawaiian:
1. vt. To sense the span of a star's existence (i.e., its age).
2. n. The speed of a star (in this case, its rotational speed).
This name was created in partnership with Dr. Larry Kimura and Bruce Torres Fischer, a student participant in A Hua He Inoa, a program to bring Hawaiian naming practices to new astronomical discoveries. We are grateful for their collaboration.
rfast: A fast tool for planetary spectral forward and inverse modeling.
T. Robinson
The rfast tool is an ultra-quick planetary spectrum simulator and remote sensing tool, originally designed for rapid retrieval explorations for mission concept studies. Through a convenient runscript, users can generate a noise-free spectrum of a planetary environment, add instrumental noise, and perform inverse modeling. The rfast tool is capable of applications to simulated and real observations spanning reflected-light, thermal emission, and transit transmission.
Molecfit: A general tool for telluric absorption correction
Molecfit is a tool to correct for telluric absorption lines based on synthetic modelling of the Earth’s atmospheric transmission. It can be used with data obtained with various ground-based telescopes and instruments. It combines a publicly available radiative transfer code, a molecular line database, atmospheric profiles, and various kernels to model the instrument LSF. The atmospheric profiles are created by merging a standard atmospheric profile representative of a given observatory’s climate, of local meteorological data, and of dynamically retrieved altitude profiles for temperature, pressure, and humidity.
Pyshellspec: Binary systems with circumstellar matter (β Lyrae)
Brož, M., Nemravová, J.
PYSHELLSPEC is an astrophysical tool for modeling of binary systems with circumstellar matter (e.g. accretion disk, jet, shell), computation of interferometric observables |V2|, arg T3, |T3|, |dV|, arg dV, comparison of light curves, spectro-interferometry, spectra, and SED with observations, and both global and local optimisation of system parameters. It is based on Shellspec, a long-characteristic LTE radiation transfer code by Budaj & Richards (2004).
AnalyticLC: An Accurate 3D Analytic Modeling Tool for Exoplanetary Photometry, Radial Velocity and Astrometry
Yair Judkovsky, Aviv Ofir and Oded Aharonson
AnalyticLC is an accurate photometry, radial velocity, and astrometry modeling tool. It is based on a fourth-order expansion of the Disturbing Function, incorporating 3D orbital dynamics. The analytic approach of AnalyticLC elucidates the relation between orbital dynamics and observable quantities. In addition, it offers advantages for analyzing observations with a long time span, a scenario becoming increasingly common in this era of multiple space missions. AnalyticLC has been used to interpret Kepler data and obtain estimates of more than a hundred exoplanets' physical and orbital properties.
Optimal BLS: Optimally-efficient code for transit searches in long time series
Aviv Ofir
Explicitly including Keplerian dynamics in the transit search allows Optimal BLS to enhance transit detectability while allowing such searches to be done with much-reduced resources and time. By using the (standard) BLS, one is either fairly insensitive to long-period planets or less sensitive to short-period planets and computationally slower by a significant factor of ~330 (for a 3 yr long dataset). Physical system parameters, such as the host star's size and mass, directly affect transit search. This understanding can then be used to optimize the search for every star individually. The code is well-used by the community.
pyPplusS: Fast and precise light-curve model for transiting exoplanets with rings
Eden Rein and Aviv Ofir
The Polygon + Segments model allows modeling the light curve of an exoplanet with rings. This high-precision model includes full ring geometry as well as possible ring transparency and the host star’s limb darkening. Additionally, it can model oblate ringless planets as an opaque “ring” (same shape as a planet). pyPplusS is also computationally efficient, requiring just a 1D integration over a small range, making it faster than existing techniques. The algorithm at its core is further generalized to compute the light curve of any set of convex primitive shapes in transit (e.g. multiple planets, oblate planets, moons, rings, combination thereof, etc.) while accounting for their overlaps.
PySME: Stellar Spectral Synthesis and Parameter Fitting
Wehrhahn, A., Piskunov, N., Valenti, J.
Spectroscopy Made Easy (SME) is a software tool that fits an observed spectrum of a star with a model spectrum. Since its initial release in 1996, SME has been a suite of IDL routines that call a dynamically linked library, which is compiled from C++ and Fortran. This classic IDL version of SME is available for download.
In 2018, we began began reimplementing the IDL part of SME in python 3, adopting an object oriented paradigm and continuous integration practices (code repository, build automation, self-testing, frequent builds).
ATOCA: Algorithm to Treat Order Contamination. Used to decontaminate and extract spectra from image.
ATOCA is used to extract and decontaminate spectroscopic images with multiple sources or diffraction orders. The inputs are, for all orders and sources: the wavelength solutions, the trace profiles, the throughputs and the spectral resolution kernels. From this, ATOCA can model simultaneously the detector and extract the spectra. See Darveau-Bernier et al. (2022) for more details.
FORECAST: Finely Optimised REtrieval of Companions of Accelerating STars
M. Bonavita, R. Gratton, C. Fontanive, A. Sozzetti
A significant proper motion difference between two catalogues for a given star is a good indication of the presence of a perturbing body. FORECAST allows you to identify the region where a companion compatible with the measured Δμ should appear if the star is directly imaged. It also provides an estimate of the mass of the companion compatible with the astrometric signal at each position in the allowed region. FORECAST maps can be used both to identify and confirm potential direct imaged sub-stellar candidates.
Exo-DMC: Exoplanet Detection Map Calculator
M. Bonavita, Silvano Desidera, Ernst de Moij, Arthur Vigan, Justine Lannier
Exo-DMC (Exoplanet Detection Map Calculator) is a Monte Carlo tool for the statistical analysis of exoplanet surveys results. It combines the information on the target stars with the instrument detection limits to estimate the probability of detection of a given synthetic planet population, ultimately generating detection probability maps. The Exo-DMC is the latest (although the first one in Python) rendition of the MESS (Multi-purpose Exoplanet Simulation System). Like MESS, the DMC allows for a high level of flexibility in terms of possible assumptions on the synthetic planet population to be used for the determination of the detection probability.
blase: An Interpretable Machine Learning Framework for Modeling High-Resolution Spectroscopic Data
Michael Gully-Santiago & Caroline V. Morley
Blasé introduces a powerful new approach to whole-spectrum fitting: clone 10,000+ spectral lines from a precomputed synthetic spectral model template, and then learn the perturbations to those lines through comparison to real data. Each spectral line has 4 parameters, yielding possibly 40,000+ parameters. The technique hinges on the magic of autodiff, the enabling technology behind Machine Learning, to tune all of those parameters precisely and quickly. The tool has conceivable extensions to Doppler imaging, Precision RV's, abundances, and more. It is built in PyTorch, with native GPU support.
SysSimPyPlots: Loading, analyzing, and plotting catalogs generated from the SysSim models
SysSimPyPlots is a Python package for loading, plotting, and otherwise visualizing the simulated catalogs generated from ExoplanetsSysSim, a comprehensive forward modeling framework for studying planetary systems based on the Kepler mission. In particular, it is designed to work with the SysSim clustered planetary system models (https://github.com/ExoJulia/SysSimExClusters) that characterize the underlying occurrence and intra-system correlations of multi-planet systems.
SysSimPyMMEN: Inferring Minimum-Mass Extrasolar Nebulae from the SysSim models
SysSimPyMMEN is a Python package for inferring the minimum-mass extrasolar nebula (MMEN), a power-law profile for the minimum mass in disk solids required to form the existing exoplanets if they formed in their present locations. It is designed to work with the SysSim clustered planetary system models (https://github.com/ExoJulia/SysSimExClusters) that characterize the underlying occurrence and intra-system correlations of multi-planet systems, but can be easily applied to any other planetary system by the user.
RAPOC: Rosseland And Planck Opacity Converter
Lorenzo V. Mugnai and Darius Modirrousta-Galian
RAPOC (Rosseland and Planck Opacity Converter) is a Python 3 code that calculates Rosseland and Planck mean opacities from wavelength-dependent opacities for a given temperature, pressure, and wavelength range. In addition to being user-friendly and rapid, RAPOC can interpolate between discrete data points, making it flexible and widely applicable to the astrophysical and Earth-sciences fields, as well as in engineering. For the input data, RAPOC can use ExoMol and DACE data, or any user-defined data, provided that it is in a readable format.
Kamodo: a CCMC tool for access, interpolation, and visualization of data in python.
The Community Coordinated Modeling Center at NASA GSFC
Kamodo allows model developers to represent simulation results as mathematical functions which may be manipulated directly by end users. Kamodo handles unit conversion transparently and supports interactive science discovery through jupyter notebooks with minimal coding and is accessible through python.
ECLIPS3D: Public code for linear wave and circulation calculations
F. Debras et al.
Public Fortran 90 code for linear wave and circulation calculations, developed originally for planetary atmospheres, with python scripts provided for data analysis.4 setups are provided:
2D_axi: eigenvector setup in spherical coordinates assuming axisymmetry around the axis of rotation. A longitudinal wavenumber, m, must therefore be provided.
2D_shallow: eigenvector setup for shallow water beta-plane. The latitude of the beta plane and characteristic height can be changed.
3D: eigenvector setup in full 3D, spherical coordinates.
3D_steady: linear circulation setup, hence matrix inversion. A forcing and a dissipation have to be implemented for a linear steady state to exist.
TESS-SIP: TESS Systematics Insensitive Periodogram
Hedges et al.
Tool for creating a Systematics-insensitive Periodogram (SIP) to detect long period rotation in NASA's TESS mission data. Read more in our published Research Note of the American Astronomical Society. SIP is a method of detrending telescope systematics (the TESS scattered light) simultaneously with calculating a Lomb-Scargle periodogram. This allows us to estimate of the rotation rate of variables with a period of >30days when there are multiple sectors. You can read a more in-depth work of how SIP is used in NASA's Kepler/K2 data here.
IGRINS RV: A Radial Velocity Pipeline for IGRINS
Stahl, A. et al. 2021; Tang, S-Y. et al. 2021
IGRINS RV is a python open source pipeline for extracting radial velocities (RVs) from spectra taken with the Immersion GRating INfrared Spectrometer (IGRINS). It uses a modified forward modeling technique that leverages telluric absorption lines as a common-path wavelength calibrator. IGRINS RV achieves an RV precision in the H and K bands of around 25-30 m/s for narrow-line stars, and it has successfully recovered the planet-induced RV signals of both HD 189733 and τ Boo A. Visit Stahl et al. 2021 to see the published paper.
AccretR: A planetary accretion and composition code in R
Mohit Melwani Daswani
AccretR is a planetary body accretion Monte Carlo code that calculates mass, radius and bulk composition along a specified growth track, for orderly/hierarchical, runaway, and random particle accretion models, optimized for icy ocean worlds in our Solar System (priors can be modified for other systems). Elements in the model include concentrations of: H, C, N, O, Na, Mg, Al, Si, S, Cl, K, Ca, and Fe. Maximal water is also computed, assuming all H goes into forming water. Accretional heat is also calculated.
Staralt: Calculating Object Visibility for Ground-based Telescopes
Isaac Newton Group of Telescopes
Staralt is a program that shows the observability of objects in various ways: either you can plot altitude against time for a particular night (Staralt), or plot the path of your objects across the sky for a particular night (Startrack), or plot how altitude changes over a year (Starobs), or get a table with the best observing date for each object (Starmult).
ExoAtmospheres: IAC community database for exoplanet atmospheric observations
The Exoplanets and Astrobiology group at IAC
The Exoplanet Atmospheres Database is built for the community and maintained by the community. Exoplanet atmospheres is an exciting and vibrant field of research, where new discoveries and publications occur at a very fast pace, and it is easy to miss many interesting results. The main purpose of this database is to become a quick and useful repository of all available exoplanet atmospheres observations, and also to help in the gathering of useful references for a given planet or planet types.
THAI: TRAPPIST Habitable Atmosphere Intercomparison GCM Data Repository
THAI Team (T. Fauchez et al.)
The TRAPPIST Habitable Atmosphere Intercomparison (THAI) project is a model inter-comparison effort between four GCMs: ExoCAM, LMD-G, ROCKE3D and the UM – examining a single interesting test case (TRAPPIST-1e) under several different atmosphere scenarios. The CKAN data repository provides NetCDF files for each case, allowing for examination and intercomparison of results from the different models. Scripts to process the data and plot them are available on our Github repository.
The TESS Triple-9 (TT9) Catalog: 999 uniformly vetted TESS candidate exoplanets
Luca Cacciapuoti et al.
The TESS Triple 9 Catalog (TT9, in short) contains dispositions for 999 candidate exoplanetary signals detected by the Transiting Exoplanet Survey Satellite (TESS). These signals were classified as Planet Candidate (PC), False Positive (FP) or Potential False Positive (PFP) based on TESS data (both light curves and images) as well as ancillary information such as stellar catalog. The data has been analyzed using the DAVE pipeline (https://github.com/exoplanetvetting/DAVE) and with the aid of Citizen Science, through the NASA funded Planet Patrol project (https://www.zooniverse.org/projects/marckuchner/planet-patrol).
DAVE pdf products are available on https://exofop.ipac.caltech.edu/tess
Prose: A Python framework for modular astronomical images processing
Lionel Garcia
Built for astronomy, Prose is instrument-agnostic and allows the construction of data reduction pipelines using a wide range of building blocks, pre-implemented or user-defined. Using its modular architecture, it features basic reduction pipelines to deal with common tasks such as automatic reduction and photometric extraction.
exoVista: Planetary System Models for Survey Analyses
Christopher Stark
ExoVista quickly produces a large number of planetary system models that can serve as a standard set for simulated study with the direct imaging, transit, astrometric, interferometric, and astrometric methods at scattered light wavelengths. ExoVista distributes planets consistent with the Kepler occurrence rates around Hipparcos stars within 50 pc, assigns a mass, radius, and albedo to each planet, checks for stability of the orbits, evolves all objects with a gravitational n-body integrator, and generates a quasi-self-consistent debris disk for each system consistent with the LBTI HOSTS exozodi survey.
M_-M_K-: Estimating realistic stellar masses from magnitudes
Andrew Mann et al.
Code converts absolute 2MASS Ks-band magnitude (or a distance and a Ks-band magnitude) into an estimate of the stellar mass using the empirical relation derived from the resolved photometry and orbits of astrometric binaries. The code outputs errors based on the relationship's scatter and errors in the provided distance and Ks magnitude.
DustPy: A Python Package for Dust Evolution in Protoplanetary Disks
Sebastian Markus Stammler ; Tilman Birnstiel
DustPy simulates the radial evolution of gas and dust in protoplanetary disks, including viscous evolution of the gas, advection and diffusion of the dust, as well as dust growth by solving the Smoluchowski equation.
ALMA: A Fortran program for computing the viscoelastic Love numbers of a spherically symmetric planet
Melini, D., Saliby, C., Spada, G.
ALMA is a Fortran code that computes loading and tidal Love numbers for a spherically symmetric, radially stratified, incompressible planet. ALMA can evaluate i) real (time-domain) Love numbers and their time derivatives for a Heaviside or ramp-shaped forcing time history, or ii) complex (frequency-domain) Love numbers for a periodic forcing. The planetary structure can include an arbitrary number of homogeneous layers, and each layer can have a different rheological law. ALMA can model the following linear rheologies: Elastic, Maxwell visco-elastic, Newtonian viscous fluid, Kelvin-Voigt solid, Burgers and Andrade transient rheologies. Additional rheological laws can be easily implemented.
VPLanet: The Virtual Planet Simulator
Rory Barnes et al.
VPLanet simulates planetary system evolution with a single executable: 1) thermal and magnetic evolution of terrestrial planets, 2) magma oceans, 3) radiogenic heating of interiors, 4) tidal effects, 5) rotational axis evolution, 6) stellar evolution, including pre-MS, XUV, and spin-down, 7) stellar flares, 8) climate via a 1-D EBM, 9) atmospheric escape, including water photolysis and H escape, 10) approximate orbital evolution, 11) exact orbital evolution, 12) circumbinary planet orbits, and 13) galactic perturbations on planetary systems. The code is validated by reproducing selected Solar System, exoplanet, and binary star properties. Documentation and numerous examples are provided.
Pytmosph3R: Transmission/emission spectra from 3D atmospheric simulations (GCMs, ...)
Falco, Aurélien ; Pluriel, William ; Leconte, Jérémy ; Caldas, Anthony
Pytmosph3R is a Python-3 library that computes transmission and emission spectra based on 3D atmospheric simulations, for example performed with the LMDZ generic global climate model.
Pytmosph3R can be used in notebooks or on the command line, using a configuration similar to that of TauREx.
The library should include a feature to generate phase/light-curves in the next release.
celmech: A Python package for celestial mechanics
Hadden, Sam; Tamayo, Daniel
An open-source Python package designed to facilitate a wide variety of celestial mechanics calculations. The package allows users to formulate and integrate equations of motion by incorporating user-specified terms from the classical disturbing function expansion. The package is designed to interface seamlessly with the popular REBOUND N-body code.
pycheops: Python package for the analysis of light curves from the ESA CHEOPS mission
Maxted et al.
The pycheops python module is an open-source software package that has been developed to easily and efficiently analyse CHEOPS light curve data using state-of-the-art techniques. The models in the package can also be applied to other types of data. The package included a "cook book" and examples, plus a command-line tool that aids in the preparation of observing requests for CHEOPS observers (make_xml_files).
For discussion and announcements, please join the pycheops google group.
HELIOS-K: A GPU opacity calculator for exoplanetary atmospheres
Simon Grimm, Kevin Heng
HELIOS-K calculates opacity functions for planetary atmopheres by using opacity line lists from different databases. Before the opacity functions can be calculated, the line lists need to be downloaded and preprocessed into binary files that can be read from HELIOS-K.
HELIOS-K provides tools to automatically download and preprocess files from the ExoMol, HITRAN, HITEMP, NIST, Kurucz and VALD3 databases.
HELIOS-K is running on GPUs and require a Nvidia GPU with compute capability of 3.0 or higher.
l1periodogram: Searching for planetary signatures in radial velocity time-series with a sparse recovery technique
Nathan C. Hara
The l1 periodogram is designed to search for periodicities in unevenly sampled time series. It can be used similarly as a Lomb-Scargle periodogram, and retrieves a figure which has a similar aspect but has fewer peaks due to aliasing. It is primarily designed for the search of exoplanets in radial velocity data, but can be also used for other purposes. It is based the sparse recovery technique called "Basis Pursuit" (Chen & Donoho 1998).
Magnitude-squared coherence: Frequency-domain view of the cross-correlation between RV and activity indicator time series
Dodson-Robinson, S. E., et al.
NWelch is a python3 implementation of Welch's method for estimating the magnitude-squared coherence (MSC) between contemporaneous RV and activity-indicator time series. While it's impossible to directly calculate the cross-correlation between two unevenly sampled time series, we can use a nonuniform fast Fourier transform to estimate the frequency-domain version of their cross-correlation - the MSC. Observers should be suspicious of planet candidates at frequencies with high MSC. For univariate time series (for example, RV only), Welch's method can deliver power spectrum estimates with lower variance than the Lomb-Scargle periodogram.
MARGE: A Python package to train and evaluate neural networks
Himes et al.
MARGE (Machine learning Algorithm for Radiative transfer of Generated Exoplanets) is an all-in-one package to generate exoplanet spectra across a defined parameter space, process the output, and train machine learning (ML) models as a fast approximation to radiative transfer (RT). Despite its backronym name, MARGE is a general package that can train neural networks on a provided data set of inputs and outputs.
MARGE is an open-source project under the Reproducible Research Software License and welcomes improvements from the community to be submitted via pull requests on Github.
HOMER: A Bayesian inverse modeling code
Himes et al.
HOMER (the Helper Of My Eternal Retrievals) is a Bayesian inverse modeling code. Given some data and uncertainties, the posterior distribution is determined for some model. HOMER allows for both nested sampling and Markov chain Monte Carlo (MCMC) frameworks.
HOMER's forward model is a neural network (NN) surrogate model trained by MARGE. For details on MARGE, see the MARGE User Manual at https://exosports.github.io/MARGE/doc/MARGE_User_Manual.html.
HOMER is released under the Reproducible Research Software License and welcomes community contributions via pull requests on Github.
Aladin: Aladin Sky Atlas
CDS - Centre de Données astronomiques de Strasourg, Université de Strasbourg/CNRS
Aladin is an interactive sky atlas allowing the user to visualize digitized astronomical images or full surveys, superimpose entries from astronomical catalogues or databases, and interactively access related data and information from the Simbad database, the VizieR service and other archives for all known astronomical objects in the field. The Aladin sky atlas is available in two modes: Aladin Desktop, a regular application and Aladin Lite an HTML5 javascript web widget.
FitsMap: A Simple, Lightweight Tool For Displaying Interactive Astronomical Image and Catalog Data
Ryan Hausen and Brant E. Robertson
The visual inspection of image and catalog data continues to be a valuable aspect of astronomical data analysis. As the scale of astronomical image and catalog data continues to grow, visualizing the data becomes increasingly difficult. In this work, we introduce FitsMap, a simple, lightweight tool for visualizing astronomical image and catalog data. FitsMap only requires a simple web server and can scale to over gigapixel images with tens of millions of sources. Further, the web-based visualizations can be viewed performantly on mobile devices. FitsMap is implemented in Python and is open source (https://github.com/ryanhausen/fitsmap).
exocartographer: Forward-model for constraining exoplanet maps and orbital parameters from reflected lightcurves
Farr, B., Farr, W., Cowan, N., Haggard, H., and Robinson, T.
A flexible, open-source, Bayesian framework for solving the exo-cartography inverse problem. The map is parameterized with equal-area HEALPix pixels with a Gaussian Process regularization.
SteParSyn: A Bayesian code to infer stellar atmospheric parameters using spectral synthesis
Tabernero, H. M. et al.
SteParSyn is a Python code designed to infer the stellar atmospheric parameters Teff, log(g), and [Fe/H] of late-type stars (FGKM) using the spectral synthesis method. It uses a Markov chain Monte Carlo (MCMC) sampler to explore the parameter space by comparing synthetic spectra to the observations. The code has been employed to study stars in open clusters, cepheids, stars in the Magellanic clouds, exoplanet hosts observed with ESPRESSO and CARMENES, and to characterize the first super-AGB candidate in our Galaxy. The code is available to the community in a GitHub repository.
PyExoRaMa: An Interactive Tool in Python to Investigate the Radius-Mass Diagram for Exoplanets
Amadori, F.; Damasso, M.; Zeng, L.; Sozzetti, A.
This is the python version of the software originally developed with Mathematica by Zeng et al (https://doi.org/10.5281/zenodo.5899463). The code represents a useful tool for visualizing and manipulating data related to extrasolar planets and their host stars in a multi-dimensional parameter space. It can be used to identify possible interdependence among several physical parameters and to compare observables with theoretical models describing the exoplanet composition and structure. Our transposition to Python presents some new features with respect to the original version
special: SPEctral Characterization of ImAged Low-mass companions
Valentin Christiaens
special is a package developed for the spectral characterization of directly imaged low-mass companions (MLT dwarfs). Nonetheless, this toolkit can also be used in a more general way for the characterisation of any object with a measured spectrum, provided an input model or template grid. The available tools range from the calculation of spectral covariance matrices (e.g. for IFS datacubes) and empirical spectral indices to the Bayesian inference of atmospheric parameters provided an input grid of models. In the latter case, an MCMC or nested sampler can be used, and additional parameters such as (extra) black body component(s) and extinction can be considered.
GENGA: A GPU N-body integrator for planet formation and planetary system evolution
Simon Grimm, Joachim Stadel
GENGA is a hybrid symplectic N-body integrator, designed to integrate planet and planetesimal dynamics in the late stage of planet formation and stability analysis of planetary systems. GENGA is based on the integration scheme of the Mercury code (Chambers 1999), which handles close encounters with very good energy conservation.
The GENGA code supports three simulation modes: Integration of up to 60000 - 100000 massive bodies, integration with up to a million test particles, or parallel integration of a large number of individual planetary systems. GENGA is written in CUDA C and runs on all NVidia GPUs with compute capability of at least 2.0.
SOAP 2.0: RV stellar activity simulation including spot and faculae
X. Dumusque, I. Boisse, N.Santos
SOAP 2.0 allows to model the RV effect (and the effect on the FWHM, CONTRAST and BIS SPAN of the CCF) induced
by magnetic regions (spot and faculae) on the surface of a star. The temperature of the magnetic features, their size, their location
on the stellar surface, the resolution of the instrument used, the stellar properties (radius, effective temperature, inclination), are all
parameters that can be adjusted. The code is efficient, as all the backend computation are performed in C, and is friendly to use as
the interface is in python.
NbodyGradient: Differentiable symplectic N-body code for arbitrary orbital architectures
Agol, E., Hernandez, D. & Langford, Z.
NbodyGradient is a symplectic integrator for Newtonian gravity and arbitrary N-body hierarchies. It computes the derivatives of the output with respect to the input coordinates with high numerical precision. It was developed for transit-timing analyses, and is the first code to give derivatives of the transit times with respect to the initial conditions (either masses & cartesian coordinates/velocities or orbital elements). It is written in the Julia language. It is being extended for modeling RV, astrometry, and photodynamics.
Roman Coronagraph Exposure Time Calculator: Estimates integration times for the Roman Coronagraph instrument
© 2021. Government sponsorship acknowledged. The research was carried out in part at the Jet Propulsion Laboratory, California Institute of Technology, under a contract with the National Aeronautics and Space Administration.
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. Roman_Coronagraph_ETC methods are based upon peer reviewed research articles and a collection of instrumental and modeling parameters of both the Coronagraph Instrument and the Nancy Grace Roman Space Telescope. The values in these files do not contain any ITAR or export control information. Roman_Coronagraph_ETC is licensed under Apache v2.
RASSINE: A tool for stellar spectrum continuum fitting
Michael Cretignier
RASSINE is a Python3 code dedicated to fitting stellar continuum using an alpha-shape algorithm.
The code is divided in a sequence of five consecutive steps (SNAKE) :
1) Smoothing
2) Neighbourhood local maxima
3) Alpha-shape
4) Killing outliers
5) Envelop interpolation
The code contains a fully automatic mode in case of 1d spectrum is given as input but the stellar spectrum can be also fitted by hand using the GUI interface.
SISTER: Starshade Imaging Simulation Toolkit for Exoplanet Reconnaissance
S.R. Hildebrandt and S.B. Shaklan are the principal authors of SISTER
The Starshade Imaging Simulations tool is a versatile tool designed to provide enough accuracy and variety when predicting how an exoplanet system would look like 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 that have to do with: (1) the Starshade design, (2) the exoplanetary system, (3) the optical system (telescope) and (4) the detector (camera). There is a built-in plotting software added, but the simulations may be stored on disk and be plotted with any other software.
SISTER has an online tutorial and has been published in JATIS. Visit sister.caltech.edu for details.
spectools_ir: A suite of tools designed for analysis of medium/high-resolution IR molecular spectra
Colette Salyk
Spectools_ir is a small suite of tools designed for analysis of medium/high-resolution IR molecular astronomical spectra. It consists of three main sub-modules (flux_calculator, slabspec, and slab_fitter) as well as a 'utils' sub-module, with a few additional functions.
Spectools_ir was written with infrared medium/high-resolution molecular spectroscopy in mind. It often assumes spectra are in units of Jy and microns, and it uses information from the HITRAN molecular database. Some routines are more general, but users interested in other applications should proceed with caution.
ROCKE-3D: A fully coupled ocean atmosphere 3-D General Circulation Model
Resolving Orbital and Climate Keys of Earth and Extraterrestrial Environments with Dynamics (ROCKE-3D) is a three-dimensional General Circulation Model (GCM) developed at the NASA Goddard Institute for Space Studies for the modeling of atmospheres and oceans of solar system and exoplanetary terrestrial planets.
dips: Detrending strictly periodic signals
A. Prsa
dips is an algorithm for detrending timeseries of strictly periodic signals. It does not assume any functional form for the signal or the background or the noise; it disentangles the strictly periodic component from everything else. We use it in astronomy for detrending Kepler, K2 and TESS timeseries of periodic variable stars, eclipsing binary stars, exoplanets etc. The algorithm is described in detail in Prša, Zhang and Wells (2019), PASP 131, 8001. A new, generalized version of dips will be explained in Horvat and Prša (2022), currently in preparation.
Isca: Idealized global circulation modeling: A flexible GCM for modelling planetary atmospheres.
Isca is a framework for the construction of models of the global circulation of planetary atmospheres at varying levels of realism and complexity. Isca itself is not a single model, nor is it intended to provide a fully ‘comprehensive’ model capable of weather forecasts or climate projections for policy use. Rather, our intent is to enable the user to make appropriate models for the planet or problem of interest. Isca can and has been used for Earth, Mars, Jupiter, Titan and various exoplanets.
LDTk: Limb Darkening Toolkit
Hannu Parviainen
LDTk is a Python toolkit for calculating stellar limb darkening profiles and model-specific limb darkening coefficients using the stellar atmosphere spectrum library by Husser et al. (2013). The first version of the toolkit was described in Parviainen & Aigrain, MNRAS 453, 3821–3826 (2015), and the latest version (v1.4, published in August 2020) contains several speed and usability improvements.
SERVAL: Spectrum radial velocity analyser
Mathias Zechmeister
Serval measures and analyses precise radial velocities in stellar spectra using least square fitting.
MAGRATHEA: Planetary interior structure code
Huang, C., Rice D.R., and Steffen, J. H.
A planet structure code which considers the case of fully differentiated interiors. The code integrates the hydrostatic equation in order to shoot for 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 4 layers: core, mantle, hydrosphere, and atmosphere. Each layer has a phase diagram with equations of state chosen for each phase. Users can easily adjust the model to their preferred phase diagram and equations of state.
P-winds: An open-source Python code to model planetary outflows and upper atmospheres
Leonardo A. Dos Santos, Aline A. Vidotto, Shreyas Vissapragada, et al.
Python implementation of Parker wind models for planetary atmospheres. The main goal of this code is to produce simplified, 1-D models of the upper atmosphere of a planet, and perform radiative transfer to calculate observable spectral signatures. The scalable implementation of 1D models allows for atmospheric retrievals to calculate atmospheric escape rates and temperatures. In addition, the modular implementation allows for a smooth plugging-in of more complex descriptions to forward model their corresponding spectral signatures (e.g., self-consistent or 3D models).
TULIPS: Tool for Understanding the Lives, Interiors, and Physics of Stars
TULIPS creates diagrams of the structure and evolution of stars based on the output of one-dimensional stellar evolution simulations and is optimized for MESA. Instead of complex diagrams, TULIPS represents stars as circles of varying size and color. TULIPS' capabilities include visualizing the size and perceived color of stars, their interior mixing and nuclear burning processes, their chemical composition, and comparing different stellar structures. TULIPS is described in this paper. Examples and tutorials can be found here.
PyMieDAP: Radiative Transfer of Polarized Light in Planetary Atmospheres
Rossi, L. et al.
PyMieDAP (Python Mie Doubling Adding Program) is a Fortran-Python package to make light scattering computations with Mie scattering and radiative transfer computations
with full orders of scattering, using the Doubling-Adding method. PyMieDAP takes into account the polarization of the light scattered.
Full planet modeling at any phase angle is possible. Inhomogeneous planets can be modeled.
With the subpackage exopy, it is also possible to simulate systems with a star, a planet and a possible moon.
Nii: A Bayesian orbit retrieval code applied to differential astrometry
Sheng Jin
Here we present an open-source Python-based Bayesian orbit retrieval code (Nii) that implements an automatic parallel tempering Markov chain Monte Carlo (APT-MCMC) strategy. Nii provides a module to simulate the observations of a space-based astrometry mission in the search for exoplanets, a signal extraction process for differential astrometric measurements using multiple reference stars, and an orbital parameter retrieval framework using APT-MCMC. We further verify the orbit retrieval ability of the code through two examples corresponding to a single-planet system and a dual-planet system. In both cases, efficient convergence on the posterior probability distribution can be achieved.
EVolve: Growth and evolution of volcanically-derived atmospheres
Philippa Liggins, incorporating the FastChem 2.0 model of Daniel Kitzmann & Joachim Stock
EVolve calculates the chemical composition and surface pressure of a ID atmosphere on a rocky planet which is being produced by volcanic activity, as it grows over time. Once the initial volatile content of the planet's mantle, and the composition & resultant surface pressure of any pre-existing atmosphere is set, a volcanic degassing model (EVo) will calculate the amount and speciation of any volcanic gases released into the atmosphere over each time step. Thermochemical equilibrium is assumed so the final chemical composition of the atmosphere is calculated according to the pre-set surface temperature. Future versions will include hydrogen escape as a loss mechanism.
gCMCRT: A GPU accelerated MCRT code for (exo)planetary atmospheres
Elspeth K. H. Lee
gCMCRT (gpu Cloudy Monte Carlo Radiative Transfer) is a 3D Monte Carlo Radiative-Transfer (MCRT) and ray-tracing hybrid code suitable for a wide variety of synthetic spectra modeling for (exo)planetary atmospheres, using GPU hardware to accelerate the RT calculation.
Primarily aimed at post-processing 1D global averaged or 3D GCM model output, gCMCRT can calculate albedo, emission and transmission spectra as well as phase curves from model outputs. gCMCRT has functionality to model high-resolution spectra including doppler shifting effects.
gCMCRT also contains an opacity mixer/interpolator (optools) as well as a Mie theory solver to help produce the opacity structures of the atmosphere.
Exodetbox: Underlying Methods for Calculating Integration Time Adjusted Completeness
Dean Keithly
This code repository contains methods for quickly determining the apparent planet-star separation extrema and difference in magnitude extrema of any given Keplerian orbital elements.
It additionally contains methods for calculating when along the planet's orbit it has a specific planet-star separation and specific difference in magnitude.
Using a coronagraph, or starshade's, inner working angle, outer working angle, and photometric limit of integration, planet visibility windows can be calculated and tabulated to compute an Integration Time Adjusted Completeness.
Methods implemented in this code is presented in Keithly, Savransky, "Integration Time Adjusted Completeness", JATIS, 2021.
ThERESA: Three-Dimensional Eclipse Mapping with Spectroscopic Lightcurves
Ryan C. Challener, Emily Rauscher
ThERESA is a 3D exoplanet atmospheric retrieval package. ThERESA individually fits 2D temperature maps for each lightcurve in a spectroscopic eclipse (or phase curve) observation using maximally-informative "eigencurves." It then places these 2D maps in 3D space, using a variety of models, to retrieve the planet's 3D temperature structure. ThERESA then calculates thermochemical equilibrium abundances and emission across the planet, which is then integrated spectrally and spatially to compare with all lightcurves simultaneously. This is repeated behind MCMC to obtain accurate parameter uncertainty estimates. Analyses can take a few days to a few weeks, depending on model complexity.
Exo-REM: 1D self-consistent radiative-equilibrium model for exoplanetary atmospheres
Baudino, J.-L.; Bézard, B.; Charnay, B. and Blain, D.
Exo-REM is a 1D radiative-equilibrium model developed for the simulation of the atmosphere of H2-dominated exoplanetary atmospheres. Fluxes are calculated using the two-stream approximation. The radiative-convective equilibrium is solved assuming that the net flux (radiative + convective) is conservative. The conservation of flux over the pressure grid is solved iteratively using a constrained linear inversion method. Rayleigh scattering as well as absorption and scattering by clouds (calculated from extinction coefficient, single scattering albedo, and asymmetry factor interpolated from precomputed tables for a set of wavelengths and particle radii) are also taken into account.
UBER: Universal Boltzmann Equation Solver
Zheng, L. et al.
UBER is a Fortran library that solves the general form of Fokker-Planck equation and Boltzmann equation, diffusive or non-diffusive, that appear in modeling planetary radiation belts. Users can freely specify (1) the coordinate system, (2) boundary geometry and boundary conditions, and (3) the equation terms and coefficients. The solver works for problems in one to three spatial dimensions. The solver is based upon the mathematical theory of stochastic differential equations which is of Monte Carlo nature, and the solution stochastic uncertainty may be dictated arbitrarily small at the cost of longer iterations.
zeus: A Python implementation of ensemble slice sampling for efficient Bayesian parameter inference
M. Karamanis, F. Beutler, J.A. Peacock
We introduce zeus, a well-tested Python implementation of the Ensemble Slice Sampling (ESS) method for Bayesian parameter inference. ESS is a novel Markov chain Monte Carlo (MCMC) algorithm specifically designed to tackle the computational challenges posed by modern astronomical and cosmological analyses. In particular, the method requires only minimal hand--tuning of 1-2 hyper-parameters that are often trivial to set; its performance is insensitive to linear correlations and it can scale up to 1000s of CPUs without any extra effort. Furthermore, its locally adaptive nature allows to sample efficiently even when strong non-linear correlations are present.
The all-sky PLATO input catalogue
The ESA PLAnetary Transits and Oscillations of stars (PLATO) mission will search for terrestrial planets in the habitable zone of solar-type stars. Because of telemetry limitations, PLATO targets need to be pre-selected. We present an all sky catalog that will be fundamental to select the best PLATO fields and the most promising target stars, derive their fundamental parameters, analyze the instrumental performances, and then plan and optimize follow-up observations. This catalog also represents a valuable resource for the general definition of stellar samples optimized for the search of transiting planets.
The Photometry Pipeline (PP): Automated photometry pipeline for small to medium-sized observatories
Michael Mommert
The Photometry Pipeline (PP) is a Python 3 software package for automated photometric analysis of imaging data from small to medium-sized observatories. It uses Source Extractor and SCAMP to register and photometrically calibrate images based on catalogs that are available online; photometry is measured using Source Extractor aperture photometry. PP has been designed for asteroid observations, but can be used with any kind of imaging data. (No longer maintained)
ExoInt: A devolatilization and interior modeling package for rocky planets
Haiyang S. Wang
Purpose: devolatilize stellar abundances to produce rocky exoplanetary bulk composition, with which constraining the modeling of the exoplanet interiors.
A moderate updated version (v1.2) is available under the folder "v1.2".
A Python version corresponding to the v1.2 (IDL) version is available under the folder "pyExoInt".
Please refer to 'About' for how to run the codes. For questions, comments, and suggestions, please raise them in the 'Issues' tab or otherwise directly send to Haiyang Wang at haiwang@phys.ethz.ch (for requests, in particular).
TRAN_K2: Search for planetary transits embedded in stellar variability and systematic effects
Geza Kovacs
TRAN_K2 is standalone Fortran code to search for planetary transits under the colored noise of stellar variability and instrumental effects. Stellar variability is represented by a Fourier series and, when necessary, by an autoregressive model aimed at avoiding excessive Gibbs overshoots at the edges. For the treatment of systematics, a co-trending and an external parameter decorrelation are employed. The filtering is done within the framework of the standard weighted least squares, where the weights are determined iteratively, to allow a robust fit and to separate the transit signal from stellar variability and systematics.
PlanetPack: Command-line Tool for Radial Velocity and Transit Lightcurves Fitting
R.V. Baluev
PlanetPack is a software tool developed to facilitate the radial-velocity and transit data analysis for the goal of exoplanets detection, characterization, and basic dynamical simulations.
The description of the main theoretic concepts, statistical methods and algorithms that PlanetPack implements, is given in the following refereed papers:
R.V. Baluev 2013, Astronomy & Computing, V. 2, P. 18 (initial release);
R.V. Baluev 2018, Astronomy & Computing, V. 25, P. 221 (update 3.0).
SMINT: Structure Model INTerpolator
Caroline Piaulet, with models from several published papers (see documentation)
Using mass-radius grids for water- or hydrogen-enveloped small planets, astronomers can infer the range of plausible compositions that a planet may have based on its mass, radius, age and/or level of insolation. In its present form, smint presents a tool to leverage in this way several published mass-radius grids in a Bayesian framework. The interface is user-friendly: the user can input the parameters of the planet of interest with specifications on the priors that should be used, and the tool returns publication-ready plots presenting the joint parameters constraints obtained from interpolating the interior models grid of interest as well as confidence intervals for each parameter.
TRIPPy: Python based Trailed Source Photometry
Wesley C. Fraser
TRIPPy is a python package aimed to perform all the steps required to measure accurate photometry of both trailed and non-trailed (stationary) astronomical sources. This includes the ability to generate stellar and trailed point source functions, and to use circular and pill shaped apertures to measure photometry and estimate appropriate aperture corrections. Tools for source fitting with a model PSF (both MCMC and classical least-squares minimizers) are available.
Citation: If you use TRIPPy in your science works, please cite Fraser, W. et al., 2016, Astronomical Journal, 151. DOI at Zenodo.
PEP: The Planetary Ephemeris Program
Developed by many; original: Michael Ash; most recent and longest- time-involved: John Chandler
This Fortran computer program models orbital motion in the solar system, including almost 100 individual asteroids as well as all of the planets and some moons, along with a detailed model of our moon, and a model of pulsar motions and of distant radio sources. It takes as input diverse astrometric data: radio, radar, laser, timing of signal arrivals, and VLBI. The program can solve for well over 100 parameters, including orbital and (for some bodies) rotational initial conditions, sky coordinates for radio sources, plasma densities, the second harmonic of the Sun's gravitational field, and those related to tests of fundamental physics.
DYNAMITE: DYNAmical Multi-planet [System Architecture] Injection [via Monte Carlo Integrations] TEster
Dietrich, J., Apai, D., et al.
We start with the specific (yet often incomplete) data on the orbital and physical parameters for the planets in any given system's architecture. We combine that with detailed statistical population models and a dynamical stability criterion to predict the likelihood for the parameters of one additional planet in the system. These predictions are given in the form of observable values (transit depth measurements, RV semi-amplitudes, or direct imaging separation and contrast) that can be tested by follow-up observations.
This work was done as a member of the Earths in Other Solar Systems and Alien Earths projects, funded by NASA with grant nos. 3013511 and 80NSSC21K0593
VULCAN: Photochemical kinetics for planetary atmospheres
Shang-Min "Shami" Tsai
Photochemical kinetics for (exo-)planetary atmospheres, a fast and easy-to-use python code. The model has hierarchical C-H-N-O-S networks and treats thermochemistry, photochemistry, eddy diffusion, advection transport, condensation, and various boundary conditions.
APOLLO: MCMC Exoplanet Atmosphere Retrieval Code
Alex Howe & Arthur Adams
APOLLO is an exoplanet atmosphere retrieval code designed for flexibility and comparison of models. The code computes 1-D forward models of exoplanet spectrum in transit or emission and fits them to observations using an MCMC method. APOLLO includes options for multiple radiative transfer algorithms, temperature-pressure profiles, and cloud parameterizations, allowing for comparison of models using different physics prescriptions. APOLLO can also generate synthetic spectra in the JWST spectroscopic modes, as well as compute photometric fluxes.
IcyDwarf: IcyDwarf computes the coupled geophysical-chemical-orbital evolution of an icy dwarf planet or moon
Neveu, M. from a geophysical evolution code initially developed by Desch, S. et al. (2009)
IcyDwarf calculates:
- The thermal evolution of one or more icy moon(s) or dwarf planet(s), with no chemistry, but with rock hydration, dehydration, hydrothermal circulation, core cracking, tidal heating, and porosity. The depth of cracking and a bulk water:rock ratio by mass in the rocky core are also computed, as well as moon orbital evolution.
- Whether cryovolcanism is possible by the exsolution of volatiles from cryolavas.
- Equilibrium fluid and rock chemistries resulting from water-rock interaction in subsurface oceans in contact with a rocky core, up to 200ºC and 1000 bar
STARRY: Analytic Occultation Light Curves
Rodrigo Luger, Eric Agol, Daniel Foreman-Mackey, David P. Fleming, Jacob Lustig-Yaeger, Russell Deitrick
WEB TOOL DEVELOPMENT IN PROGRESS —
The STARRY code package enables the computation of 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.
Deep-Transit: Identify Transit Signals with Deep Learning Based Object Detection Algorithm
Cui, K. et al.
Deep-Transit is an open-source Python package designed for transit detection with a deep learning based 2D object detection algorithm. For simple usage, Deep-Transit can handle your light curve and then output the transiting candidates' bounding boxes and confidence scores. Deep-Transit has already been trained for Kepler and TESS data, but can be easily extended to other photometric surveys, even ground-based observations. Deep-Transit also provides the interface to train on your own datasets.
ATES: ATmospheric EScape
The ATES hydrodynamics code computes the temperature, density, velocity and ionization fraction profiles of highly irradiated planetary atmospheres, along with the current, steady-state mass loss rate. ATES solves the one-dimensional Euler, mass and energy conservation equations in radial coordinates through a finite-volume scheme. The hydrodynamics module is paired with a photoionization equilibrium solver that includes cooling via bremsstrahlung, recombination and collisional excitation/ionization for the case of an atmosphere of primordial composition (i.e., pure atomic hydrogen-helium), while also accounting for advection of the different ion species.
GRIT: Gravitational Rigid-body InTegrators
Chen, Renyi; Li, Gongjie and Tao, Molei
This is a package dedicated to the simulation of N gravitationally interacting rigid/point mass bodies. Tidal forces and general relativity correction are supported. Multiscale splittings are included to boost the simulation speed. Multiple schemes with different orders of convergences and splitting strategies are available. Force evaluations can be parallelized. Floating-point format can be customized as float / double / long double globally.
ExoPlaSim: Extending the Planet Simulator for Exoplanets
Paradise, A. et al.
A modified version of the PlaSim 3D climate model, designed to simulate planets with Earth-like atmospheric compositions across a wide parameter space, including tidally-locked rotation, 0.1-10 bars surface pressure, and a range of stellar spectra. ExoPlaSim has a Python API for configuring and running models, as well as utilities for interacting with and analyzing the netCDF output files. ExoPlaSim is also pip-installable. As an intermediate-complexity model, ExoPlaSim trades some complexity for speed, and is able to run on a range of hardware including personal laptops and high-performance computing clusters, with typical performance of 1 year of climate at T21 resolution in 1-5 minutes.
Hypatia Catalog: Database of stellar elemental abundances for solar neighborhood stars
The Hypatia Catalog is a comprehensive collection of literature data and the largest database of stellar abundances for stars near to the Sun (Hinkel et al. 2014}. The multidimensional database currently spans 78 unique elements and species in ~9400 stars, ~1300 of which are planet hosts, within 500 pc of the Sun, including all exoplanet host stars regardless of distance. Hypatia was compiled from ~215 literature source abundance measurements that were re-normalized to the same solar scale, so that all values were on a common baseline.
KOBE: Kepler Observes Bern Exoplanets
KOBE adds the geometrical limitations and the physical detection biases of the transit method to a given population of theoretical planets. In addition, it also adds the completeness and reliability of a transit survey.
For more details, click here.
Pyratbay: A Forward-modeling and retrieval code to model exoplanet atmospheres and spectra
Cubillos, P. E. and Blecic, J.
The Pyrat Bay framework is an open-source pack for exoplanet atmospheric modeling, spectral synthesis, and Bayesian retrieval. The modular design of the code allows the users to generate atmospheric 1D parametric models of the temperature, abundances (equilibrium or constant profiles), and altitude profiles in hydrostatic equilibrium; sample ExoMol and HITRAN line-by-line cross sections with custom resolving power and line-wing cutoff values; compute emission or transmission spectra considering cross sections from molecular line transitions, collision-induced absorption, Rayleigh scattering, gray clouds, and alkali resonance lines; and perform Markov chain Monte Carlo atmospheric retrievals.
SparseBLS: Box-Fitting Least Squares implementation for sparse data
Aviad Panahi, Shay Zucker
A new implementation of the commonly used Box-fitting Least Squares (BLS) algorithm, for the detection of transiting exoplanets in photometric data. Unlike BLS, our new implementation—Sparse BLS, does not use binning of the data into phase bins, nor does it use any kind of phase grid. Thus, its detection efficiency does not depend on the transit phase, and is therefore slightly better than that of BLS. For sparse data, it is also significantly faster than BLS. It is therefore perfectly suitable for large photometric surveys producing unevenly-sampled sparse light curves, such as Gaia.
RadVel: Radial Velocity Fitting Toolkit: General Toolkit for Modeling Radial Velocities
BJ Fulton, Erik Petigura, Sarah Blunt, and Evan Sinukoff
RadVel is a tool designed to fit Keplerian orbits to radial velocity datasets. Multiple planets, multiple instruments, and multiple sources of white and red noise are supported out of the box. RadVel is written in an extensible object-oriented framework which allows for custom models, priors, or samplers.
SpaceHub: A high-performance gravity integration toolkit for few-body problems in astrophysics
Yihan Wang, Nathan Leigh, Bin Liu and Rosalba Perna
SpaceHub uses unique algorithms for fast, precise and accurate computations for few-body problems, ranging from interacting black holes to planetary dynamics. This few-body gravity integration toolkit can treat black hole dynamics with extreme mass ratios, extreme eccentricities and very close encounters. SpaceHub offers a bulk of regularized integrator and other cutting edge few body methods and can handle extremely eccentric orbits and close approaches in long-term integrations.
Astronet-Triage: A Neural Network for TESS Light Curve Triage
Yu, L. et al.
Astronet-Triage is a deep learning model capable of performing triage on TESS candidates. It is trained and tested on real TESS light curves and can distinguish transit-like signals (planet candidates and eclipsing binaries) from stellar variability and instrumental noise with an average precision of 97.0% and an accuracy of 97.4%. For the vetting version of this model, see Astronet Vetting.
FALCO: Wavefront Estimation and Control Software for Coronagraphs
Riggs, A J Eldorado
The Fast Linearized Coronagraph Optimizer (FALCO) is an open-source, modular software collection for the design, modeling, or testbed operation of coronagraphic optical systems. Users can build PROPER models of their optical systems and then use FALCO as a wrapper for performing wavefront correction simulations. FALCO contains working examples of published wavefront estimation and control techniques. The software can be easily ported to different testbeds and is already being used to run benches at Caltech and JPL.
exoscene: A Python library for simulating direct images of exoplanetary systems
Zimmerman, Neil
exoscene is a library of classes and utility functions for simulating direct images of exoplanetary systems. The package was developed by Neil Zimmerman (NASA/GSFC), with source code contributions from Maxime Rizzo, Christopher Stark, and Ell Bogat. This work was funded in part by a WFIRST/Roman Science Investigation Team contract (PI: Margaret Turnbull).
ESO SkyCalc: Web and API interface to The Cerro Paranal Advanced Sky Model
SkyCalc is a web application based on the Cerro Paranal Advanced Sky Model, which was developed in particular to be used in the ESO Exposure Time Calculators, by a team of astronomers at the Institute for Astro- and Particle Physics at the University of Innsbruck, as part of an Austrian in-kind contribution to ESO.
A command-line tool skycalc_cli is available to execute the SkyCalc backend engine through an API.
The C source code is available to download.
pyLIMA: Microlensing Modeling and Simulation
Bachelet, E. et al.
The python Lightcurve Identification and Microlensing Analysis (pyLIMA) is the first microlensing software fully open-source. Motivated by the data deluge that the Roman telescope microlensing survey will collect, it is designed to allow easy and efficient modeling of microlensing data (including parallalization), but is also capable of simulations. It is mainly written in python and object oriented. The codes contains lot of examples, a complete documentation and is continuously developed.
RVLIN: A Fast Maximum Likelihood Method for Fitting Multiplanet Keplerian Curves to RV Data Coded in IDL
Jason Wright and Andrew Howard
An IDL routine for fitting multiple Keplerian curves (i.e. those that neglect planet-planet interactions) to radial velocity data. Handles heteroschedastic data, and constraints on P, e, phase, and transit timing. It is fast because it solves, via maximum likelihood, for all parameters other than P, e, and phase with a linear least-squares matrix inversion. It then determines the remaining 3*n parameters (where n is the number of planets) via a Levenberg-Marquardt optimization. The method is described in Wright & Howard ApJS 182, 205. Uncertainties in the fitted parameters can be determined via bootstrapping using BOOTTRAN (Wang et al. ApJ 761, 46).
ExoplAn3T: Exoplanet Analysis and 3D visualization Tool
Zinzi, A.; Turrini, D.; Alei E.; Verrecchia F.
ExoplAn3T is the SSDC scientific webtool providing access to several on-line exoplanet catalogues (i.e., NASA Exoplanetary Archive, The Extrasolar Planet Encyclopedia and ExoMerCat) and is designed and optimized for the study of exoplanetary systems as a whole, rather than to extract information on single planets.
The tool applies a two step procedure: a "planetary query", aimed at finding exoplanets having the characteristics required by the user and a series of "system queries" (one query for every exosystem found in the first step) looking for all the planets belonging to each exosystem in which the exoplanets of the "planetary query" are found.
Gemini Planet Imager Data Reduction Pipeline: Official data reduction pipeline for the GPI instrument integral field spectrograph
The Gemini Planet Imager Data Pipeline allows transformation of raw data from GPI into calibrated spectral and polarimetric data cubes. It also provides some basic capabilities for PSF suppression through differential imaging, and for astrometry and spectrophotometry of detected sources. See complete documentation here.
Habitable-exoplanets-visualisation: Visualization of the NASA Exoplanets Archive open data of exoplanets that are similar to the Earth.
Ermishin Andrey
Visualization of the open data from the NASA Exoplanets Archive of planets outside the solar system that are similar to the Earth and habitable.
By means of NASA API exoplanets were parsed and stored to SQLite database: "content.sqlite".
There are two visualizations of the parsed data:
- Python 3 file "khistogram.py" samples data into "khistogram.js" which is used by "khistogram.htm" to visualize data with D3.js library;
- Python 3 file"kbchart.py" samples data into "kbchart.js" which is used by "kbchart.htm" to visualize data with Google BubbleChart.
HARDCORE Web Interface
Yosef Miller
The HARDCORE Web Interface tool is a user-friendly web-based application of HARDCORE. This tool allows users to easily calculate minimum, maximum, and marginal core radius fractions (CRFmin, CRFmax, CRFmarg) for a solid exoplanet based on mass and radius limits.
ARTES: Radiative transfer of polarized light in 3D exoplanet atmospheres
Tomas Stolker
ARTES is a 3D Monte Carlo radiative transfer code for polarized scattered light simulations of exoplanet atmospheres. The code can be used for post-processing of a pre-calculated or parametrized atmosphere structure. Multiple scattering, absorption, and polarization are fully treated and the output includes an image, spectrum, or phase curve of reflected stellar light or thermal photons. Several tools are included for calculating opacities and scattering matrices of molecules and clouds but the user can also adopt their own opacities.
TTVFaster: First Order Eccentricity Transit Timing Variations (TTVs)
Agol & Deck (2016)
Analytic model for transit-timing variations which is accurate to first order in eccentricity and mass-ratio.
Exorings: Python Tools for Displaying and Fitting Giant Extrasolar Planet Ring Systems
M. Kenworthy
Exorings is a Python 3 package that simulates giant Hill sphere ring systems, and generates the resultant light curve when a star passes behind the rings. The star and rings are modelled on a Cartesian grid with no optimisation for calculation speed. The module can create plots of the ring system using vector graphics in a PDF suitable for publications. There is an interactive ring fitting code that allows manual addition and removal of ring edges and optical depths, with Amoeba optimization for the ring transmissions. The rings are saved in a FITS table with ring system metadata.
EDI-Vetter Unplugged: Transit Signal False Positive Vetting Tool
Zink, J. K.
This program was originally designed to identify false positive transit signals in K2 photometry, but has been modified to play nicely with the Transit Least Squares software package. It contains several thresholds which mimic visual inspection and help automate the transit detection process.
SWEET-Cat: A catalog of stellar parameters for stars with planets
Planet team at the Instituto de Astrofísica e Ciências do Espaço
A catalog of atmospheric parameters for planet-host stars. It compiles sets of atmospheric parameters previously published in literature (including Teff, logg, and [Fe / H]) and, whenever possible, derives them using the same uniform methodology.
MCMCI: MCMC-based analysis of light curves or RV time series with interpolation within stellar isochrones
Bonfanti A., Gillon M.
The MCMCI tool offers the opportunity to perform an integrated analysis of an exoplanetary system without splitting it into the preliminary stellar characterisation through theoretical models.The MCMCI combines the Markov chain Monte Carlo approach of analysing photometric or radial velocity time series with a proper interpolation within stellar evolutionary isochrones and tracks, to be performed at each chain step, to retrieve stellar theoretical parameters such as age, mass, and radius. This approach favours a close interaction between lightcurve analysis and isochrones, so that the parameters recovered at each step of the MCMC enter as inputs for purposes of the isochrone placement.
PlanetSlicer: Phase Curve Fitting for Emission and Reflection via the Orange Slice Model
Thorngren, Daniel P.; Mayorga, Laura C.
This is a small package for fitting brightness maps to phase curves using the "orange-slice" method. For self-luminous objects, this follows Cowan and Agol (2008) "Inverting Phase Functions to Map Exoplanets". We have extended this approach to diffuse reflected light assuming Lambertian reflectance, in Mayorga et. al (2020). In both cases, the model supposes that a spherical object can be divided into slices of constant brightness (or albedo) which may be integrated to yield the total flux observed, given the angles of observation.
kima: Exoplanet detection in RVs with DNest4 and GPs
Faria et al. 2018, JOSS, 3, 487
kima is a package for the detection and characterization of exoplanets using RV data. It fits a sum of Keplerian curves to a time series of RV measurements and calculates the evidence for models with a fixed number Np of Keplerian signals, or after marginalising over Np. A Gaussian process with a quasi-periodic kernel can be used as a noise model, to deal with activity-induced signals. The hyperparameters of the GP are inferred together with the orbital parameters. The code is written in C++ and includes a helper Python package, pykima, which facilitates the analysis of the results.
ShellSpec: Lightcurves, spectra and images of binaries and exoplanets with moving circum-object material
Jan Budaj
Program SHELLSPEC is designed to calculate lightcurves, spectra and images of interacting binaries and extrasolar planets immersed in a moving circumstellar matter (CM). It solves a simple radiative transfer along the line of sight in 3D moving CM. Roche model with a reflection effect and synthetic spectra from the stellar atmosphere models can be used as a boundary condition for the radiative transfer. Dust, including non-isotropic Mie scattering, can also be taken into account. The assumptions include LTE and optional known state quantities and velocity fields in 3D.
EXOCROSS: A general program for generating spectra from molecular line lists
ExoCross is a Fortran code for generating spectra (emission, absorption) and thermodynamic properties (partition function, specific heat etc.) from molecular line lists including ExoMol and HITRAN. Input is taken in several formats, including ExoMol and HITRAN formats. ExoCross can work with several line profiles such as Doppler, Lorentzian and Voigt and support several broadening schemes. ExoCross supports calculations of lifetimes, cooling functions, specific heats and other properties. It is capable of simulating non-LTE spectra using a two-temperature approach as well as custom-built models.
Spotrod: A Semi-analytic Model for Transits of Spotted Stars
Bence Béky; David M. Kipping; Matthew J. Holman
A library for numerical simulation of transit lightcurves for a planet transiting a star with homogeneous, circular spots. Homogeneous umbra and homogeneous penumbra can be modelled using two concentric spots. Written in C, with Python bindings.
MAYONNAISE processing pipeline: A morphological components analysis pipeline for circumstellar disks and exoplanets imaging
Pairet, B. et al.
MAYO is a pipeline for exoplanet and disk high-contrast imaging from ADI datasets. For more information, please refer to Pairet, Benoît, Faustine Cantalloube, and Laurent Jacques. "MAYONNAISE: a morphological components analysis pipeline for circumstellar disks and exoplanets imaging in the near infrared.", Monthly Notices of the Royal Astronomical Society, 2021.
VARTOOLS: Command-line program for analyzing astronomical time-series data
Hartman, J.D. and Bakos, G.A.
The VARTOOLS program is a command line utility that provides tools for processing and analyzing astronomical time series data, especially light curves. It includes methods for calculating variability/periodicity statistics of light curves; for filtering, transforming, and otherwise modifying light curves; and for modeling light curves. It is intended primarily for batch processing a large number of light curves. The program is run by issuing a sequence of commands to perform actions on light curves, each command is executed in turn with the resulting light curves passed to the next command. Statistics computed by each command are sent to stdout as an ascii table.
Kepler DR25 Robovetter: Automatic vetting of Kepler DR25 TCEs into Planet Candidates and False Positives
Thompson et al. 2018, ApJS, 235, 38
The DR25 Kepler Robovetter is a robotic decision-making code that dispositions each Threshold Crossing Event (TCE) from the Kepler pipeline into Planet Candidates (PCs) and False Positives (FPs). The Robovetter also provides four major flags to designate each FP TCE as Not Transit-Like (NTL), a Stellar Eclipse (SS), a Centroid Offset (CO), and/or an Ephemeris Match (EM). It also produces a score ranging from 0.0 to 1.0 that indicates the Robovetter's disposition confidence, where 1.0 indicates strong confidence in PC, and 0.0 indicates strong confidence in FP. Finally, the Robovetter provides comments in a text string that indicate the specific tests each FP TCE fails.
ChromaStarPy: Transit light-curve modelling integrated with stellar atmosphere and surface intensity modeling
Short, C. Ian and Bennett, Philip D.
An approximate stellar atmosphere and spectrum modelling code in Python that includes in situ modelling of the transit light-curve due to a "small" exo-planet occulting the computed stellar surface intensity distribution.
Catwoman: A transit modelling Python package for asymmetric light curves
Kathryn Jones & Néstor Espinoza
Catwoman is a Python package that models asymmetric transit lightcurves where planets are modelled as two semi-circles with different radii in any orientation, for any radially symmetric stellar limb darkening law. It uses the integration algorithm developed in (Kreidberg, 2015) and implemented in the batman library, from which Catwoman builds upon. It is fast and efficient and open source with full documentation available to view here.
SPInS: Stellar Parameters INferred Systematically
Reese, D. R. and Lebreton, Y.
SPInS is a Python tool that takes in a set of photometric, spectroscopic, interferometric, and/or global asteroseismic observational constraints, and uses a Bayesian approach to find the probability distribution functions of stellar parameters, such as the age, mass, and radius of a star, as well as error bars and correlations between these parameters. At the heart of the code is a Markov chain Monte Carlo solver coupled with interpolation within a pre-computed grid of stellar models. Priors can be considered, such as the initial mass function or the stellar formation rate. SPInS can characterize single stars or coeval stars, such as members of binary systems or of stellar clusters.
ATMO: 1D-2D radiative/convective atmospheric code
Tremblin P. et al. (see description)
ATMO is a 1D-2D atmospheric code for the study of the atmosphere of brown dwarfs and exoplanets. The code has originally been developed at the University of Exeter (here) and is currently a collaboration between different groups across the globe. The main developers are:
1D and 2D newton solver: P. Tremblin
Radiative transfer: D. Amundsen, P. Tremblin
Opacities: D. Amundsen, M. Phillips, R. Ridgway, J. Goyal
Equilibrium chemistry: P. Tremblin, B. Drummond, J. Goyal
Condensation and rainouts: P. Tremblin, J. Goyal
Out-of-equilibrium chemistry: O. Venot, E. Hebrard, B. Drummond
Convection: P. Tremblin, M. Phillips
Retrieval: D. Sing
EvapMass: Minimum mass of planets predictor
Owen, James E. & Campos Estrada, Beatriz
EvapMass predicts the minimum masses of planets in multi-planet systems using the photoevaporation-driven evolution model. The planetary system requires both a planet above and below the radius gap to be useful for this test. EvapMass includes an example Jupyter notebook for the Kepler-36 system. EvalMass can be used to identify TESS systems that warrant radial-velocity follow-up to further test the photoevaporation model.
Lightkurve Web Interface: Easy to use Web Interface of the Lightkurve Python Package
Yosef Miller
The Lightkurve Web Interface tool is a user-friendly web-based application of the Lightkurve python package. This tool allows users to quickly produce light curves based on time series data obtained by NASA's Kepler, K2, and TESS missions.
Stella: Convolutional Neural Networks for Flare Identification in TESS 2-minute Data
Feinstein et al. 2020a,b
The purpose of stella is to identify flares in TESS short-cadence data with a convolutional neural network (CNN). In its simplest form, stella takes a pre-trained CNN (available on MAST: https://archive.stsci.edu/hlsp/stella) and a light curve (time, flux, and flux error) and returns a probability light curve. The cadences in the probability light curve are values between 0 and 1, where 1 means the CNN believes there is a flare there. It takes < 1 minute to predict flares on a single light curve. Users also have the ability to train their own customized CNN architecture. The stella software also includes modules to measure rotation periods and fit flares using simple exponential models.
RV Jitter prediction code: Predicting RV jitter due to stellar oscillations and granulation using stellar parameters
Yu et al. 2018
Radial-velocity jitter due to intrinsic stellar variability introduces challenges when characterizing exoplanet systems, particularly when studying small (sub-Neptune-sized) planets orbiting solar-type stars. This code will be valuable for anticipating the radial-velocity stellar noise level of exoplanet host stars, and hence be useful for their follow-up spectroscopic observations. Our prediction can be also used to set a prior for the jitter term as a component when modeling the Keplerian orbits of the exoplanets.
TRICERATOPS: Bayesian Vetting and Validation Tool for Transiting Exoplanet Candidates
Giacalone, S. et al.
TRICERATOPS is a Bayesian vetting and validation tool for TESS planet candidates. For a given planet candidate, the tool calculates the probabilities of several astrophysical transit-producing scenarios using the TESS light curve, information about nearby stars, and follow-up observations (e.g., high-resolution imaging, spectroscopy, and time-series photometry). Using these probabilities, TRICERATOPS calculates a false positive probability (the overall probability of the transit being caused by an astrophysical false positive) and a nearby false positive probability (the probability of the transit being caused by an off-target event around a nearby star).
xwavecal: A Blind Wavelength Calibration Algorithm for Echelle Spectrographs
Brandt, G. M. et al.
A library of routines for wavelength calibrating echelle spectrographs for high precision radial velocity work. Calibrates the instrument without any input for known emission line wavelengths and positions. A limited data-reduction pipeline is included.
Wotan: Remove Trends from Time-series Data
Michael Hippke
Wotan offers free and open source algorithms to automagically remove trends from time-series data. Python open source.
Available detrending algorithms include: Time-windowed sliders with location estimates, splines, polynomials and sines, regressions, fitting a model that is a sum of Gaussian bases, Gaussian Processes. Available features: Filter lengths, break tolerances, edge cutoffs, tuning parameters, transit masks.
Juliet: A Versatile Modeling tool for Transiting and Non-transiting Exoplanetary Systems
Espinoza et al.
Juliet is a versatile modelling tool for transiting and non-transiting exoplanetary systems that allows to perform quick-and-easy fits to data coming from transit photometry, radial velocity or both using bayesian inference and, in particular, using Nested Sampling in order to allow both efficient fitting and proper model comparison. This pip-installable python library (pip install juliet) also allows to model these time-series using either simple linear models and/or more involved correlated noise on both photometry and radial-velocities through Gaussian Processes. Full documentation is available here.
THOR: Flexible Global Circulation Model to Explore Planetary Atmospheres
Mendonça, J. et al. 2016; Deitrick, R., et al. 2020
THOR is a GCM that solves the three-dimensional non-hydrostatic Euler equations on an icosahedral grid. THOR was designed to run on Graphics Processing Units (GPUs).
pyaneti: A multi-planet Radial Velocity and Transit fit software
v1.0
Barragán O., Gandolfi D. & Antoniciello G.
pyaneti is a multi-planet radial velocity and transit fit software. The code uses Markov chain Monte Carlo (MCMC) methods with a Bayesian approach and a parallelized ensemble sampler algorithm in Fortran which makes the code fast. It creates posteriors, correlations, and ready-to-publish plots automatically, and handles circular and eccentric orbits. It is capable of multi-planet fitting and handles stellar limb darkening, systemic velocities for multiple instruments, and short and long cadence data, and offers additional capabilities.
Aeolus: Python Library for Object-Oriented Analysis of Atmospheric Model Output
Sergeev, D. E.
Aeolus is a library for analysis and plotting of a climate model output, primarily of the UK Met Office Unified Model when it is used to simulate various planetary atmospheres. Aeolus is built on top of iris and has various functions tailored to exoplanet research, e.g. in the context of tidally-locked exoplanets.
POET: Planetary Orbital Evolution due to Tides - Calculate secular orbital evolution
Kaloyan Penev, Luke Bouma, and Joshua Schussler
Calculate secular orbital evolution for star-planet and star-star systems under the combined influence of:
- Tides in one or both of the objects
- Age dependent stellar structure
- Stars losing angular momentum to wind
- The internal redistribution of angular momentum between the surface and the interior of stars
EMAC CKAN Data Repository: Repository for Large EMAC-Related Datasets
https://ckan.emac.gsfc.nasa.gov
The EMAC Comprehensive Knowledge Archive Network (CKAN) data portal provides a resource to the exoplanet modeling and analysis community for hosting data sets related to exoplanet modeling and analysis. These datasets can either be input data (i.e. opacity tables, stellar flux models, etc) or output data (output grids or data sets from exoplanet modeling/analysis software). If you are interested in using this service, submit a request through the EMAC email.
ExoplanetsSysSim.jl: The SysSim Planet Population Simulator
Eric B. Ford, Matthias He, Danley Hsu, Darin Ragozzine
The ExoplanetsSysSim.jl package generates populations of planetary systems, simulates observations of those systems with a transit survey, and facilitates comparisons of simulated and observed catalogs of planetary systems. Critically, ExoplanetsSysSim accounts for intrinsic correlations in the sizes and orbital periods of planets within a planetary system.
AAS - Timeseries: Read in and Manipulate Time Series in Astropy
Thomas Robitaille, American Astronomical Society (AAS)
The aas-timeseries package has been developed as part of a project between AAS Publishing and the Astropy Project. The goal of this project is to provide astronomers with all the tools needed to make it possible for astronomers to use Astropy to read in and manipulate time series data sets, such as exoplanet transit light curves, produce interactive figures, and easily embed these in a paper. The package is general enough to be usable in other contexts, for example to embed interactive time series figures in personal web pages, or for use in Jupyter notebooks and Jupyter Lab.
ARCHI: An expansion to the CHEOPS mission official pipeline
ARCHI, An expansion to the CHEOPS mission official pipeline, is an additional open-source pipeline to analyse the background stars present in CHEOPS images that are not tracked by the official pipeline. This tool opens a potential for the use of CHEOPS to produce photometric time-series of several close-by targets at once, as well as to use different stars in the image to calibrate systematic errors. Furthermore, there might be cases where the study of the companion light curve can be important for the understanding of contaminations on the main target .
VBBinaryLensing: Computation of Microlensing Light Curves and Astrometry
Valerio Bozza, in collaboration with Etienne Bachelet, Fran Bartolic, Ava Hoagg, Thomas Heintz, Markus Hundertmark, Elahe Khalouei
Library for the computation of microlensing light curves and astrometric centroid based on contour integration scheme. The code covers single-lens and binary-lens microlensing, includes finite size of the source, limb darkening, annual and satellite parallax, orbital motion.
Largely been replaced by VBMicrolensing (EMAC citation 2503-008)
CHIMERA: Exoplanet Emission/Transmission Atmospheric Retrieval Tool
M. Line et al. (J. Lustig-Yaeger, N. Batalha, M. Marley, X. Zhang, A. Wolf)
Flexible atmospheric retrieval tool for exoplanet atmospheres. Can be used for both transmission and emission geometries with options for both the "free" and "chemically consistent" abundance retrievals. Uses correlated-K opacities (R=100) with the random-overlap resort-rebin procedure (Amundsen et al. 2017). Includes full multiple scattering in emission (both planetary and stellar reflected light) using a two stream approximation variant (Toon et al. 1989). Various cloud parameterizations ranging from "grey+power-law" to the "Ackerman & Marley 2001" eddy-sed routine in both emission and transmission. Includes multiple Bayesian samplers, including PyMultiNest (recommended) and Dynesty.
Forecaster: Empirical, Probabilistic Predictions of Exoplanet Masses & Radii
Jingjing Chen, David Kipping
Forecaster predicts a planet’s mass, based on its radius -OR- predicts a planet’s radius, based on its mass. Forecaster works with both summary statistics and posterior samples. What distinguishes forecaster from other codes is that it is empirical and probabilistic. This means that the algorithm has been trained using the masses and radii of over 300 worlds with precise measurements of their masses and radii. No theoretical relations are used or assumed, the mass-radius relation is simply learned from the data. This also means that the predictions are intrinsically probabilistic (and not deterministic). For a given planetary mass, there isn’t just one possible radius, but a range of radii.
AstroBEAR: An Adaptive Mesh Refinement Code for Computational Astrophysics
Jonathan Carroll-Nellenback, Adam Frank, Baowei Liu, Shule Li, Erica Fogerty, Andrew Cunningham, Sorin Mitran, Zhuo Chen, Kris Yirak, Eddie Hansen, Martin Huarte-Espinosa, Luke Chamandy, Alex Debrecht, Yangyuxin Zou, Atma Anand
AstroBEAR is a parallelized hydrodynamic/MHD simulation code suitable for a variety of astrophysical problems. Derived from the BearCLAW package written by Sorin Mitran, AstroBEAR is designed for 2D and 3D adaptive mesh refinement (AMR), multi-physics simulations. Users write their own project modules by specifying initial conditions and continual processes (such as an inflow condition). In addition, AstroBEAR comes with a number of pre-built physical phenomena such as clumps and winds that can be loaded into a user module.
SVO Filter Profile Service: A repository of Filter information for the Virtual Observatory
Carlos Rodrigo, Spanish Virtual Observatory, CAB, CSIC-INTA.
The SVO Filter Profile Service provides standardized information, including transmission curves and calibration, about more than 6100 astronomical filters. The service is designed to be compliant to the Virtual Observatory Photometry Data Model and all the information is provided both as a web portal and VO services so that other services and applications can access the relevant properties of a filter in a simple way.
SVO Theoretical Spectra Server: A Server of Data for over 60 Collections of Theoretical Spectra and Observational Templates
Carlos Rodrigo, Spanish Virtual Observatory, CAB, CSIC-INTA
The SVO Theory Server provides data for more than 60 collections of theoretical spectra and observational templates.
Using this web page you can search for spectra in each collection in terms of the corresponding grid parameter ranges, visualize the spectra and/or download them in ascii or VOTable format. You will be able to compare spectra from different collections too.
Synthetic Photometry is also available for these spectra and all the filters in the SVO Filter Profile Service.
tpfplotter: TESS Target Pixel File Creator
J. Lillo-Box (Aller et al., 2020, A&A, 635, 128)
tpfplotter is a user-friendly tool to create the TESS Target Pixel Files of your favorite source overplotting the aperture mask used by the SPOC pipeline and the Gaia catalogue to check for possible contaminations within the aperture. Create paper-ready figures (1-column) overplotting the Gaia DR2 catalog to the TESS Target Pixel Files. You can create plots for any target observed by TESS! Even if you do not have a TIC number, you can search by coordinates now (see examples in Github)!
PEXO: A Tool for Precise Modeling and Fitting for Timing, Radial Velocity and Astrometry Data
PEXO is a package for making precise exoplanetology. Compared with previous models and packages, PEXO is general enough to account for binary motion and stellar reflex motions induced by planetary companions. PEXO is precise enough to treat various relativistic effects both in the Solar System and in the target system (Roemer, Shapiro, and Einstein delays).
PEXO is able to model timing to a precision of 1 ns, astrometry to a precision of 1 μas, and radial velocity to a precision of 1 μm/s. There are pdf and html versions of the manual available for instructions of how to use PEXO. The fitting mode and a python wrapper are in development and expected to be released soon.
Exostriker: Transit and Radial velocity Interactive Fitting tool for Orbital analysis and N-body simulations
Trifon Trifonov, MPIA Heidelberg;
Exostriker analyzes exoplanet orbitals, performs N-body simulations, and models the RV stellar reflex motion caused by dynamically interacting planets in multi-planetary systems. It offers a broad range of tools for detailed analysis of transit and Doppler data, including power spectrum analysis for Doppler and transit data; Keplerian and dynamical modeling of multi-planet systems; MCMC and nested sampling; Gaussian Processes modeling; and a long-term stability check of multi-planet systems. The Exo-Striker can also perform Mean Motion Resonance (MMR) analysis, create fast fully interactive plots, and export ready-to-use LaTeX tables with best-fit parameters, errors, and statistics.
ExoCAM: Exoplanet Extension for the CAM GCM
Wolf, E.T.
ExoCAM is a model extension to the National Center for Atmospheric Research (NCAR) Community Earth System Model (CESM) 3-D general circulation and climate system model, which facilitates simulations of exoplanetary atmospheres. This software contains system configuration files, source code, initial condition files, namelists, and some basic analysis scripts. Familiarity with CESM is prerequisite. CESM must be downloaded separately. The radiative transfer component of ExoCAM is stored in a separate GitHub link , and can be run independently or coupled with ExoCAM/CESM.
BEM: Beyond the Exoplanet Mass-radius Relation with Random Forest
S. Ulmer-Moll, N.C Santos, P.Figueira, J. Brinchmann, J.P. Faria
Bem allows you to predict the planetary radius based on several other planetary and stellar parameters. We worked with a database of confirmed exoplanets with known radii and masses, as well as the planets from our Solar System. Using random forests, a machine learning algorithm, we computed the radius of exoplanets and compared the results to the published radii. The estimated radii reproduces the spread in radius found for high mass planets better than previous mass-radius relations. The average radius error is 1.8R⊕ across the whole range of radii from 1–22R⊕. Bem is able to derive reliable radii, especially for planets between 4 R⊕ and 20 R⊕ for which the error is under 25%.
JET: JWST Exoplanet Targeting Program
Charles Fortenbach, Courtney Dressing, et al.
JWST will devote significant observing time to the study of exoplanets. It will not be serviceable as was the Hubble, and therefore the spacecraft/instruments will have a relatively limited life. It is important to get as much science as possible out of this limited observing time. We provide a computer tool, JET, to optimize lists of exoplanet targets for atmospheric characterization. JET takes catalogs of planet detections; categorizes the targets by radius and equilibrium temp.; estimates planet masses; generates model spectra and simulated instrument spectra; performs a statistical analysis to confirm an atmospheric detection; and finally, ranks the targets by observation time required.
REBOUND: A Flexible Multi-Integrator N-body Code
Hanno Rein, Dan Tamayo
REBOUND is an N-body integrator, i.e. a software package that can integrate the motion of particles under the influence of gravity. The particles can represent stars, planets, moons, ring or dust particles. REBOUND is very flexible and can be customized to accurately and efficiently solve many problems in astrophysics. It includes symplectic integrators (WHFast, WHFastHelio, SEI, LEAPFROG), high order symplectic integrators (SABA, WH Kernel methods)
as well as high accuracy non-symplectic integrator with adaptive timestepping (IAS15).
Barycorrpy: Precise Barycentric Correction for Stellar and Solar Radial Velocities and Time-stamps
Shubham Kanodia, Jason Wright, Joe Ninan
Barycorrpy is an open source code written in Python based on Barycorr in IDL (Wright and Eastman 2014) to calculate the barycentric correction for any time series observations of stellar sources, and to convert JDUTC to BJDTDB time stamps (Kanodia and Wright 2018).
Update August 2020: It can now also be used to calculate the barycentric correction for Solar observations, as well as reflected light observations of solar system objects (Wright and Kanodia 2020).
MRExo: Nonparametric Mass-radius Modelling for Exoplanets
Shubham Kanodia, Gudmundur Stefansson , Angie Wolfgang, Bo Ning, Suvrath Mahadevan
MRExo is a Python script for non-parametric fitting and analysis of the Mass-Radius (M-R) relationship for exoplanets.
We translate Ning et al. (2018)'s R script into a publicly available Python package called MRExo. It offers tools for fitting the M-R relationship to a given data set. Along with the MRExo installation, the fit results from the M dwarf sample dataset from Kanodia et al. (2019) and the Kepler exoplanet sample from Ning et al. (2018) are included. The code also includes predicting functions (M->R, and R->M), and plotting functions to generate the plots used in the below manuscript.
For detailed description of the code please see Kanodia et al. (2019)
Lightweight Space Coronagraph Simulator: Simulator of High-Contrast Space Telescopes
Leonid Pogorelyuk
Simulator of high-contrast space telescopes in a linear regime of small wavefront perturbations about the nominal dark hole. Used for testing high-order wavefront sensing and control as well as post-processing algorithms. Models broadband images with sensor noise, wavefront drift, actuators drift and residual effects from low-order wavefront sensing. Currently supports a model of the Roman Space Telescope Hybrid Lyot Coronagraph based on its FALCO model. Comes with and example of dark hole maintenance using an Extended Kalman Filter and Electric Field Conjugation.
HARDCORE: A Core Radius Fractions Exoplanet Calculator
Gabrielle Suissa, Jingjing Chen, David Kipping
HARDCORE exploits boundary conditions on exoplanet internal composition to solve for the minimum, maximum, and marginal core radius fractions (CRFmin, CRFmax, CRFmarg) for a solid exoplanet based on mass and radius limits. The original source code was developed for the study by Suissa et al. 2018.
PynPoint: Pipeline for Processing and Analyzing High-Contrast Image Data of Exoplanets and Brown Dwarfs
Tomas Stolker, Markus Bonse, Sascha Quanz, Adam Amara, et al.
PynPoint is a generic, end-to-end pipeline for processing and analysis of high-contrast imaging data of exoplanets and brown dwarfs. The software architecture has a modular and scalable design. A variety of pipeline modules are available for pre-processing, PSF subtraction with principal component analysis (PCA), photometric and astrometric measurements, and estimation of detection limits. The package supports post-processing with ADI, RDI, and SDI techniques.
The Opacity Wizard: A Tool for Visualizations of Opacity and Abundance Data for Exoplanet and Brown Dwarf Atmospheres
Caroline Morley
This tool was developed to allow for easy and fast visualizations of opacity and abundance data for exoplanet and brown dwarf atmospheres. In particular, it was designed to be used by observers studying these substellar objects as an easy way of exploring which molecules are most important for a given planet and predict where the absorption features of those molecules will be. It is simple to use for non-python experts and requires only Python/NumPy/Matplotlib/Jupyter.
Haystacks: High-fidelity Planetary System Models for Simulating Exoplanet Imaging
A. Roberge and the Haystacks Team
Haystacks models are high-fidelity spatial and spectral models of complete planetary systems including star, planets, interplanetary dust, and astrophysical background sources. They are intended for use in simulations of direct imaging and spectroscopy with high-contrast instruments on exoplanet missions. The Haystacks Project will help prepare for future exoEarth observations by better defining the challenge, using the knowledge gained through decades of Solar System and extrasolar planetary studies.
REPAST: Rocky ExoPlanet Albedo Spectra Tool
Adam J. R. W. Smith, Avi Mandell, Geronimo Villanueva
Here we present a database of albedo spectra for rocky, Earth-sized and Earth-mass exoplanets, as computed with the NASA Planetary Spectrum Generator tool (psg.gsfc.nasa.gov; Villanueva et al. 2018). The database is presented in two Python .pickle files containing pandas DataFrame objects. The DataFrame index values are wavelength, in micrometers; while the column name values contain the encoded parameters represented in the model object's albedo spectra contained with in that column. Each cell then gives the calculated geometric albedo value for the column-named model planet at the row-indicated wavelength.
species: Toolkit for atmospheric characterization of directly imaged exoplanets
Tomas Stolker
The species toolkit provides a coherent framework for spectral and photometric analysis of directly imaged exoplanets which builds on publicly-available data and models from various resources. There are tools available for both grid retrievals and free retrievals with Bayesian inference, color-magnitude and color-color diagrams, empirical spectral analysis, spectral and photometric calibration, and synthetic photometry.
EqTide: Tidal Evolution Simulator
Rory Barnes
EqTide simulates the tidal evolution of two bodies using the equilibrium tide theory. Six ordinary differential equations for the semi-major axis, eccentricity, both rotation rates, and both obliquities are integrated for a user-specified amount of time. Additionally the tidal power generated in each body is calculated. EqTide specifically simulates the constant-phase-lag model of Ferraz-Mello et al. (2008) and the constant-time-lag model of Leconte et al. (2010).
eleanor: Python Package that Extracts TESS Target Pixel Files and Produces Systematics-Corrected Light Curves
Feinstein, A. D., Montet, B. T., Foreman-Mackey, D., et al.
Eleanor is a Python package that extracts target pixel files from TESS Full Frame Images and produces systematics-corrected light curves for any star observed by the TESS mission. In its simplest form, eleanor takes a TIC ID, a Gaia source ID, or (RA, Dec) coordinates of a star observed by TESS and returns, as a single object, a light curve and accompanying target pixel data. Paper: Feinstein et al., eleanor: An open-source tool for extracting light curves from the TESS Full-Frame Images, 2019
EightBitTransit: Cython Code that can Calculate the Light Curve of any Pixelated Image
Emily Sandford, David Kipping
EightBitTransit is an MIT-licensed Cython code that can calculate the light curve of any pixelated image transiting a star, and invert a light curve to recover the "shadow image" that produced it. The methodology behind the code is available in Sandford & Kipping 2018 (here).
Lightkurve: Python Package that Analyzes Astronomical Flux Time Series Data
v2.5.0
Vinícius, Barentsen, Hedges, et al.
The lightkurve Python package offers a beautiful and user-friendly way to analyze astronomical flux time series data, in particular the pixels and lightcurves obtained by NASA’s Kepler, K2, and TESS missions.
Coronagraphic Mission Simulator: Simplified Coronagraph Simulator Tool
Arney et al.
This simplified coronagraph simulator tool is based on the coronagraph noise model in Robinson et al. 2016, adapted by J. Lustig-Yaeger, G. Arney and J. Tumlinson. The tool was developed for the LUVOIR mission concept, but can be used to simulated observations for any exoplanet coronagraphy mission.
Exo-CCMC Heliophysics Models: View and Analyze Heliophysics Models Carried Out by SWMF, PWOM and ALF3D
SWMF team, Glocer, Usmanov, et al.
In the initial CCMC exoplanet applications adaptation, users are able to view and analyze simulations carried out with three different models: SWMF, PWOM and ALF3D. These simulations are used to demonstrate how heliophysics models hosted at CCMC can be used to explore exoplanetary problems. Please follow the links to individual models for more details and to access the simulation results.
Multipolator: Model Grid Interpolator
Carlos E. Munoz Romero
The multipolator package is a fast routine written in C that performs N-dimensional interpolation on a grid of astronomical models. The code finds the two closest neighbors to the input parameters in each dimension, constructs an N-dimensional hypercube, and interpolates the nearest models through inverse distance weighting.
PandExo: JWST/HST Simulator
Batalha et al.
PandExo is both an online tool and a Python package for generating instrument simulations of JWST's NIRSpec, NIRCam, NIRISS and NIRCam and HST WFC3. It uses throughput calculations from STScI's Exposure Time Calculator, Pandeia.
EXOFAST: Fitting Tool for RV and Astrometric Datasets Observed with any Combination of Wavelengths
Jason Eastman et al.
EXOFASTv2 can fit an arbitrary number of planets, radial velocity datasets, astrometric datasets, and/or transits observed with any combination of wavelengths. We model the star simultaneously in the fit and provide several state-of-the-art ways to constrain its properties, including taking advantage of the now-ubiquitous all-sky catalog photometry and Gaia parallaxes. EXOFASTv2 can model the star by itself, too. Multi-planet systems are modeled self-consistently with the same underlying stellar mass that defines their semi-major axes through Kepler's law and the planetary period. Transit timing, duration, and depth variations can be modeled with a simple command line option.
Transit Least Squares: A Least Square Algorithm to Detect Planetary Transits from Time-Series Photometry
Michael Hippke, René Heller
The Transit Least Squares (TLS) algorithm is a method to detect planetary transits from time-series photometry. While the commonly used Box Least Squares (BLS, Kovács et al. 2002) algorithm searches for rectangular signals in stellar light curves, TLS searches for transit-like features with stellar limb-darkening and including the effects of planetary ingress and egress. Moreover, TLS analyses the entire, unbinned data of the phase-folded light curve. These improvements yield a ~10 % higher detection efficiency (and similar false alarm rates) compared to BLS.
CGP: Reflection Spectra Repository for Cool Giant Planets
2
Ryan J. MacDonald; Mark S. Marley; Jonathan J. Fortney; Nikole K. Lewis
We present an extensive parameter space survey of the prominence of H2O in reflection spectra of cool giant planets. We explore the influence of a wide range of effective temperatures, gravities, metallicities, and sedimentation efficiencies, providing a grid of >50,000 models for the community. Our models range from Teff = 150 → 400 K, log(g) = 2.0–4.0 (cgs), fsed = 1–10, and log(m) = 0.0–2.0 ́ solar. We discretize this parameter space into intervals of ΔTeff = 10 K, Δlog(g) = 0.1 dex, Δfsed = 1, and Δlog(m) = 0.5 dex, generating reflection spectra both with and without H2O opacity.
petitRADTRANS: Tool for Calculating Transmission and Emission Spectra of Exoplanets with Clear and Cloudy Atm.
Paul Mollière
PetitRADTRANS (pRT) is a Python package for calculating transmission and emission spectra of exoplanets, at low (𝜆/Δ𝜆=1000) and high (𝜆/Δ𝜆=106) resolution, for clear and cloudy atmospheres. pRT offers a large variety of atomic and molecular gas opacities, cloud cross-sections from optical constants, or parametrized cloud models using either opacity power laws or grey cloud decks. The code also calculation of emission and transmission contribution functions, and contains a PHOENIX/ATLAS9 spectral library for host stars to calculate planet-to-star contrasts. Implemented examples for MCMC retrievals with pRT can be found on the code website.
Exoplanet Boundaries Calculator: An Online Condensations Boundary Calculator
1.1
Kopparapu et al.
The Exoplanet Boundaries Calculator (EBC) is an online calculator that provides condensation boundaries (in stellar fluxes) for ZnS, H2O, CO2 and CH4 for the following planetary radii that represent transition to different planet regimes: 0.5, 1, 1.75, 3.5, 6, and 14.3 RE. The purpose is to classify planets into different categories based on a species condensing in a planet's atmosphere. These boundaries are applicable only for G-dwarf stars.
Exoplanet Composition Interpolator: Interpolation of Pre-Computed Planet Evolution Models to Explore Structures of Transiting Exoplanets
1
Eric Lopez, NASA GSFC
This tool allows the user to load pre-computed planet evolution models and interpolate between those models to explore the possible structures of transiting exoplanets. Select a planet mass, radius, age, and irradiation and this tool will estimate its possible present-day gaseous envelope mass, rocky core mass, and thermal brightness.
BATMAN: A Python Package for Fast Calculation of Exoplanet Transit Light Curves
Laura Kreidberg
BATMAN is a Python package for fast calculation of exoplanet transit light curves. The package supports calculation of light curves for any radially symmetric stellar limb darkening law, using a new integration algorithm for models that cannot be quickly calculated analytically. In typical use, BATMAN can calculate a million model light curves in well under 10 minutes for any limb darkening profile.
TROPF: Tidal Response Of Planetary Fluids
Robert Tyler
The TROPF (Tidal Response Of Planetary Fluids) software package is a MATLAB/Octave package that enables efficient terrestrial fluid tidal studies across a wide range of parameter space. TROPF includes several different solutions to the governing equations in classical tidal theory, and can calculate millions of such solutions on several-minute-long timescales. A comprehensive manual is included in the distribution directory. To help improve the development of TROPF, or become involved in future releases, please send feedback to rtyler@umbc.edu.
LAPS: The Live Atmosphere-of-Planets Simulator
Martin Turbet (LMD), Cédric Schott (ESEP) and the LMD team
LAPS was developed to easily simulate the climate of planets similar to Earth (i.e., terrestrial but not giant planets). This model is based on the LMD (Laboratoire de Météorologie Dynamique) Global Climate Model (GCM), a complex 3-D numerical model of climate solving equations of thermodynamics, radiative transfer and hydrodynamics. This complex 3-D model has been simplified to a 1-D code (Turbet et al. 2016, 2017), which is therefore much faster to run and can now be used online in an interactive fashion.
PICASO: Open-Source RT Model for Computing Reflected Exoplanet Light at any Phase Geometry
Natasha Batalha, Mark Marley, Nikole Lewis, Jonathon Fortney
The Planetary Intensity Code for Atmospheric Scattering Observations (PICASO) is an open-source radiative transfer model for computing the reflected light of exoplanets at any phase geometry. This code, written in Python, has heritage from a decades old, well-known Fortran model used for several studies of planetary objects within the Solar System and beyond. We have adopted it to include several methodologies for computing both direct and diffuse scattering phase functions, and have added several updates including the ability to compute Raman scattering spectral features.
Atmos: Packaged Photochemical and Climate Model
Atmos is a package containing two atmospheric models, along with scripts to couple them together. One of the atmospheric models is a 1D photochemical model that calculates the profiles of chemical species, including both gaseous and aerosol phases. The second model is a 1D climate model that calculates the temperature profile. While individually these models may be run for useful information, when coupled they offer a detailed analysis of atmospheric steady-state structures.
ATMO Generic Grid @ ExoCTK: A Generic Model Grid of Planetary Transmission Spectra
Jayesh Goyal et al.
A generic model grid of planetary transmission spectra, scalable to a wide range of H2/He dominated atmospheres. The grid is computed using the 1D/2D atmosphere model ATMO for two different chemical scenarios, first considering local condensation only, secondly considering global condensation and removal of species from the atmospheric column (rainout). Using the model grid as a framework, we allow you to rescale your models with custom temperature, gravity, and radius values. The web interface is hosted and maintained by the STScI Exoplanet Characterization ToolKit.
Planetary Spectrum Generator: An Online Tool for Synthesizing Planetary Spectra
Villanueva et al.
The Planetary Spectrum Generator (PSG) is an online tool for synthesizing planetary spectra (atmospheres and surfaces) for a broad range of wavelengths (100 nm to 100 mm, UV/Vis/near-IR/IR/far-IR/THz/sub-mm/Radio) from any observatory (e.g., JWST, ALMA, Keck, SOFIA).
EXOSIMS: Python Based Framework for the Simulation and Analysis of Exoplanet Imaging Space Missions
Savransky et al.
EXOSIMS is a modular, open source, Python-based framework for the simulation and analysis of exoplanet imaging space missions. The base code is highly extensible and allows for the end-to-end simulation of imaging missions, taking into account details about the spacecraft, its orbit, the instrumentation, the assumed population of exoplanets, and the mission operating rules.
ATMO Exoplanet-Specific Grid: A Grid of Forward Model Transmission Spectra
Jayesh Goyal et al.
A grid of forward model transmission spectra, adopting an isothermal temperature-pressure profile, alongside corresponding equilibrium chemical abundances for 117 observationally significant hot exoplanets (equilibrium temperatures of 547–2710 K). This model grid has been developed using a 1D radiative–convective–chemical equilibrium model termed ATMO, with up-to-date high-temperature opacities.
AstroImageJ: Image Display Environment and Tools for Calibration and Data Reduction
Collins, K., Kielkopf, J., Stassun, K., and Hessman, F.
AstroImageJ (AIJ) provides an astronomy-focused image display environment and tools for image calibration and data reduction. AIJ maintains the general purpose image processing capabilities of ImageJ, but AIJ is streamlined for time-series differential photometry, light curve detrending and fitting, and light curve plotting, especially for applications requiring ultra-precise light curves (e.g., exoplanet transits). AIJ reads and writes standard Flexible Image Transport System (FITS) files, as well as other common image formats, provides FITS header viewing and editing, and is World Coordinate System aware, including an automated interface to astrometry.net for plate solving images.
StaggerGrid: A Grid of 3D stellar spectra with StaggerCode
Chiavassa, A.; Casagrande, L.; Collet, R.; Magic, Z.; Bigot, L.; Thévenin, F.; Asplund, M.
StaggerCode is a 3D radiation-hydrodynamic (RHD) simulation code for convection at the surface of late-type stars. The code solves the full set of hydrodynamical equations for the conservation of mass, momentum, and energy coupled to an accurate treatment of the radiative transfer. StaggerCode uses a realistic equation-of-state that accounts for ionization, recombination, and dissociation and both continuous and line opacities. Model atmosphere grids, which we call StaggerGrid, were performed with the StaggerCode for a range of temperature from 4000 to 7000 K; log(g) from 1.5 to +5.0; and metallicity of [Fe/H] = +0.5 to -4.0.
The grid is available online at the Pollux database.
The grid is available online at the Pollux database.
PLATON: PLanetary Atmospheric Tool for Observer Noobs
Michael Zhang, Yayaati Chachan, Eliza Kempton, Heather Knutson
PLATON is a Python package that can calculate transmission and emission spectra for exoplanets, as well as retrieve atmospheric characteristics based on observed spectra. PLATON is easy to install and use, with common use cases taking no more than a few lines of code. It is also fast, with the forward model taking less than 100 ms and a typical retrieval finishing in ~10 min on an ordinary desktop. 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.
PyATMOS: Software Package to Configure and Run the Virtual Planetary Laboratories' ATMOS Software
William Fawcett et al.
PyATMOS is a software package able to configure and run the Virtual Planetary Laboratories' ATMOS software, which is an exoplanetary atmosphere simulator. PyATMOS is written in Python, allowing easy user configuration and running, and is optionally configurable with Docker and therefore can be used on any machine with Docker and Python installed, regardless of the operating system. PyATMOS can be used in "single-use" mode, simulating a single exoplanet atmosphere with a given set of atmospheric parameters, but also in a parallel mode, whereby a grid of possible parameters for many atmospheres is supplied. PyATMOS will explore this parameter space and produce a database of the results.
Allesfitter: Package for Modeling Photometric and RV Data
Günther, M., and Daylan, T.
Allesfitter (Günther & Daylan, 2019 and in prep.) is a public and user-friendly astronomy software package for modeling photometric and RV data. It can accommodate multiple exoplanets, multi-star systems, star spots, stellar flares, and various noise models. A graphical user interface allows definition of all input. Then, allesfitter automatically runs a nested sampling or MCMC fit, and produces ASCII tables, LaTeX tables, and plots. For all this, allesfitter constructs an inference framework that unites the versatile packages ellc (Maxted 2016), aflare (Davenport et al. 2014), dynesty (Speagle 2019), emcee (Foreman-Mackey et al. 2013) and celerite (Foreman-Mackey et al. 2017).
Agatha: A Framework of Periodograms to Disentangle Periodic Signals from Correlated Noise
Feng, F., Tuomi, M., Jones, H. R. A.
Agatha is a framework of periodograms used to disentangle periodic signals from correlated noise and to solve the two-dimensional model selection problem: signal dimension and noise model dimension. Agatha is based on the Bayes factor periodogram (BFP) and the marginalized likelihood periodogram (MLP). Agatha outperforms other periodograms in terms of removing correlated noise and assessing the significances of signals with more robust metrics, and has been used successfully to identify planetary signals in high-precision radial velocity (RV) data. Moreover, it can be used to select the optimal noise model and to test the consistency of signals in time.
PyATMOS NExSci Repository: A Dataset of ~125,000 Simulated 1-D Exoplanet Atmospheres
William Fawcett et al.
The PyATMOS NExSci dataset comprises ~125,000 simulated 1-D exoplanet atmospheres. All of these exoplanets are based around an Earth-like planet that orbits a star similar to the Sun, but with different gas mixtures in their atmospheres. The atmospheres were generated using the PyATMOS code. The parameter space was created by incrementally varying the concentrations of carbon dioxide, oxygen, water vapour, methane, hydrogen, and nitrogen; and for each point in the parameter space an atmosphere was simulated. Other gases with negligible concentrations, such as ozone, were not varied. The planet's composition, orbital parameters and stellar parameters were also not varied.
pyKLIP: Tool for the Characterization of Directly-Imaged Exoplanets and Circumstellar Disk
Wang, J. et al.
pyKLIP subtracts out the stellar PSF to search for and characterize directly-imaged exoplanets and circumstellar disks using a Python implementation of the Karhunen-Loève Image Projection (KLIP) algorithm. pyKLIP supports using ADI, SDI, and RDI observing techniques and parallelizes the KLIP algorithm to speed up the reduction. pyKLIP supports data from most high-contrast imaging instruments and provides libraries to both detect and characterize astrophysical sources in the data.
EPOS: The Exoplanet Population Observation Simulator
Gijs Mulders
The Exoplanet Population Observation Simulator is a software package to simulate observations of exoplanet populations. It provides an interface between planet formation simulations and exoplanet surveys such as Kepler, accounting for detection biases in transit and radial velocity surveys.
HELIOS: 1D radiative-convective model for exoplanetary atmospheres
Malik et al.
HELIOS is an open-source radiative transfer code designed to study exoplanetary atmospheres, from rocky terrestrial planets to ultra-hot Jupiters. For given opacities and planetary parameters, HELIOS finds the atmospheric temperature profile in radiative-convective equilibrium and the synthetic planetary emission spectrum. HELIOS is written in Python, with the core computations parallelized to run on a GPU. HELIOS is part of the Exoclimes Simulation Platform.