The Roman Coronagraph Community Participation Program: corgisim - a simulation suite for the Nancy Grace Roman Space Telescope Coronagraph Instrument

arXiv:2608.17257 · astro-ph.IM, astro-ph.EP · Submitted 2026-08-18 · Read on arXiv

Listen

Transcript

Introduction to the show: ident: Astrophysics. The day in astrophysics: observations, models and what the data forces.

Vera: We're looking at the paper: "The Roman Coronagraph Community Participation Program".

Jocelyn: Here's the gist of the paper. NASA’s Roman Space Telescope will feature a pathfinder Coronagraph Instrument to demonstrate advanced high-contrast imaging from space, paving the way for future missions like the Habitable Worlds Observatory<ref:2608.17257#pg2> The Coronagraph Instrument could obtain imaging, polarimetry and spectroscopy of Jupiter analogs in reflected visible light for the first time<ref:2608.17257#pg2> We present the development of an open-source simulation package “corgisim” as part of the Roman Coronagraph Community Participate Program<ref:2608.17257#pg4> Built on established optical propagation libraries including PROPER and CGISim, corgisim provides a user-friendly, publicly available Python framework for end-to-end simulations of the Coronagraph Instrument observations<ref:2608.17257#pg3> The package produces high-fidelity, format-compliant data for pre-launch calibration, pipeline testing, and community applications such as target selection and observation planning<ref:2608.17257#pg4> Simulation Workflow Description The simulation flow implemented in corgisim starts from the inputs, defines the astrophysical scene, propagates the source light through the coronagraph optical model, places the resulting noiseless image on the EMCCD detector, and writes the simulated products to FITS files<ref:2608.17257#pg5> The package provides two ways for specifying simulation inputs: direct configuration through PYTHON or through Roman’s Command Product Generation Software (CPGS) files<ref:2608.17257#pg6> CPGS generates XML files which describe an observation scenario, typically consisting of a High Order Wavefront Sensing and Control (HOWFSC) sequence to dig the dark hole followed by several visits on a reference star and a target star<ref:2608.17257#pg7> The Scene object can include a host star, one or more companions, and an optional two-dimensional (2D) scene such as a circumstellar disk<ref:2608.17257#pg10> The instrument configuration is handled by the CorgiOptics object, which defines the highlevel observing setup including the cgi mode, bandpass, telescope diameter, roll angle, and image oversampling Detailed optical settings are provided through the optics keywords dictionary to simulate optical propagation through the Coronagraph Instrument using established models like PROPER Detector modeling is handled by the CorgiDetector object, which uses the emccd detect package to simulate EMCCD response based on parameters specified in the emccd keywords dictionary Optical Modeling Capabilities corgisim supports imaging, polarimetry, and spectroscopy simulations using different configurations defined by the CorgiOptics object For broadband imaging mode, the host star's on-axis coronagraphic point-spread function (PSF) is generated at each sampled wavelength and integrated to produce the broadband residual stellar image In polarimetry mode, corgisim includes the Wollaston-prism configuration and computes the polarization signal of the stellar speckle field by propagating its built-in Jones pupil model through the coronagraph Companion polarimetry is treated separately by transforming each companion Stokes vector from sky frame to instrument frame via a Mueller matrix and multiplying it by band-averaged instrument Mueller matrices In spectroscopy mode, corgisim uses the SPC spectroscopic coronagraph configuration and applies selected slit and prism models to generate the simulated spectroscopic image The framework allows for direct comparison of broadband imaging, slit-limited imaging, and dispersed spectroscopic products by running simulations with varying configurations Detector Simulation Details The CorgiDetector class uses the emccd detect package to simulate detector effects such as EM gain, dark current, clock-induced charge, read noise, and cosmic rays For non-polarimetric simulations, the noiseless image is placed onto the detector at a selected location before generating noisy detector images For polarimetric simulations, CorgiDetector places two images corresponding to the two polarization channels onto the EXCAM frame at their expected separated detector locations The final step applies detector effects including read-out smearing and digitization into detector counts Validation and Future Work Validation involves installation tests, reference validation against direct CGISim simulations for standard cases, and checks on roll-angle coordinate conversions and L1-style FITS headers Representative simulation cases demonstrate the capabilities of corgisim across various modes, including HLC imaging, SPC wide-field imaging with disks, HLC polarimetry, and SPC bowtie spectroscopy Future development will focus on time-dependent speckle simulations for time-series observations and polarimetric propagation of two-dimensional scenes The goal is to provide realistic and configurable speckle variability for pipeline and science-performance studies rather than fully accurate on-the-fly predictions corgisim is a Python simulation framework that connects astrophysical scene generation, optical propagation with the Roman preflight PROPER model, and EMCCD detector modeling It supports imaging, polarimetry, and spectroscopy of host stars, companions, and extended sources along with effects like telescope roll and pointing jitter The package produces both noiseless optical subframes and full frame L1 FITS products with compatible headers following Roman’s official naming conventions This open-source, end-to-end framework supports pre-launch calibration, pipeline development, observation planning, and broader community studies of the Coronagraph Instrument APPENDIX A Details

Title and authors: Vera: Let’s talk about the title and who wrote this. "The Roman Coronagraph Community Participation Program: corgisim - a simulation suite for the Nancy Grace Roman Space Telescope Coronagraph Instrument". It really tells you exactly what this is for, which is supporting the CPP program to prepare for technology demonstration observations of the instrument.

Jocelyn: And it’s authored by Jingwen Zhanga, Sophie Noiretb, Maxwell A. Millar Blanchaera, Jason Wangc, Alexis Laub, Neil Zimmermand, Jessica Gersh-Rangee, Eric Shena, Kevin Ludwickf, Taichi Uyamag, Chen Xieh and Vanessa P. Baileyi. A pretty big team of people collaborating on this simulation suite.

Subrahmanyan: From a theoretical perspective, having this suite means we can start testing how the physical parameters of the instrument—like image oversampling or roll angle—actually affect the resulting data before we commit to launching it into space and actually collecting those specific signals.

Vera: Exactly. It’s about using this simulation suite to validate key techniques for future flagship missions, specifically mentioning something like the Habitable Worlds Observatory, which aims to characterize Earth-like planets in habitable zones of Sun-like stars.

Jocelyn: And the core idea is that corgisim is designed to simulate realistic raw datasets of the Coronagraph Instrument so researchers can support pre-launch calibration and observation planning. It’s about testing things before you launch into space.

Subrahmanyan: That simulation suite needs to handle the complexity of how light propagates through a coronagraph, which involves modeling things like the host star, its companions, or even an extended two-dimensional scene like a circumstellar disk.

Vera: And it does that by defining a Scene object that can include those things—a host star, companions, and optional 2D scenes—and then feeding those inputs into the CorgiOptics object which defines the high-level observing setup <ref:2608.17257#pg1>.

The paper's summary: Jocelyn: Moving on to what the paper actually summarizes. It explains that corgisim provides a user friendly Python framework that integrates established optical and detector modeling tools, specifically PROPER for light propagation and CorgiOptics for the observing setup.

Vera: And it shows how this framework connects everything by defining the astrophysical scene, propagating the source light through the coronagraph optical model, placing that noiseless image onto an EMCCD detector, and finally writing all those simulated products to FITS files.

Subrahmanyan: So it’s a complete flow: from inputs to a final simulated product file. It supports two ways of specifying simulation inputs: direct configuration through Python or through Roman’s Command Product Generation Software files.

Jocelyn: And those CPGS files generate XML that describe an observation scenario, which typically involves a High Order Wavefront Sensing and Control sequence to dig the dark hole, followed by visits on a reference star and a target star.

Vera: The scene object itself can include things like contrast in magnitudes relative to the host star and specify paths to FITS images for extended sources, like a disk model path. It’s very configurable right there.

Subrahmanyan: The instrument configuration is handled by the CorgiOptics object which sets up the observing setup, defining things like the cgi mode, bandpass, telescope diameter, and roll angle. It even lets you provide detailed optical settings through an optics keywords dictionary for simulating propagation through the Coronagraph Instrument using established models.

Jocelyn: And detector simulation is handled by the CorgiDetector object which uses the emccd detect package to simulate effects like EM gain, dark current, clock-induced charge, read noise and cosmic rays. This is how you get those realistic detector images.

The paper's improvements: Vera: The paper highlights several improvements in corgisim that make it more useful for real science. For example, it includes optional finite stellar diameter and pointing jitter effects through the stellar diam and jitter keywords input when you define the scene.

Subrahmanyan: That’s crucial because those effects introduce PSF broadening and contrast degradation due to finite source size or pointing instability, which gives us realistic performance metrics for science studies instead of just perfect theoretical predictions.

Jocelyn: They also detail how the polarimetry mode works, where corgisim includes the Wollaston-prism configuration and computes the polarization signal of the stellar speckle field by propagating its built-in Jones pupil model through that coronagraph.

Vera: And for spectroscopy, they use the SPC spectroscopic coronagraph configuration and apply selected slit and prism models to generate simulated spectroscopic images. This lets users directly compare broadband imaging, slit-limited imaging, and dispersed spectroscopic products.

Subrahmanyan: The framework allows you to run simulations with varying configurations in all these modes to see how different observational strategies perform against each other. It’s a powerful comparison tool.

Jocelyn: They also mention that the output products include full-frame detector simulations saved as L1 FITS products that contain a primary HDU with global metadata, including exposure, detector, observing-mode, roll angle and polarization.

Vera: And those headers are ready for processing by the data-reduction pipeline immediately. It ensures the data is usable by ground support systems right away. This level of output is what makes it useful for pre-launch calibration and pipeline testing.

Conclusion: Jocelyn: So to wrap up, corgisim is presented as a Python simulation framework that connects astrophysical scene generation, optical propagation with the Roman preflight PROPER model, and EMCCD detector modeling. It supports imaging, polarimetry, and spectroscopy of host stars, companions and extended sources along with effects like telescope roll and pointing jitter.

Vera: And it produces both noiseless optical subframes and full frame L1 FITS products following Roman’s official naming conventions. This open-source, end-to-end framework supports pre-launch calibration, pipeline development, observation planning, and broader community studies of the Coronagraph Instrument.

Subrahmanyan: For me, this means we can test the dynamic observing procedures based on realistic and configurable speckle variability rather than just static fields. That capability to provide realistic speckle variability for pipeline and science-performance studies is where the real value is for structure formation studies.

Jocelyn: And from a radio astronomy standpoint, having these robust simulation tools means we can optimize observation sequences before launch by simulating scenarios directly from CPGS files, specifying companions and targets to be simulated along with the main scene.

Vera: It’s about providing researchers with a way to test data reduction pipelines before the actual launch. It’s a tool that helps connect the dots between what we observe in space and how we process that data on Earth.

Subrahmanyan: And ultimately, this paper on corgisim is an important step in preparing the community for demonstrating advanced high-contrast imaging capabilities from space, paving the way for future missions like the Habitable Worlds Observatory.

Jocelyn: That’s what it is. We’ll keep an eye on how this simulation suite develops as we move toward those more complex science goals and look at what comes next in the community.

Department of Physics University of California Santa Barbara · Aix Marseille Universitée CNRS CNES LAM · Center for Interdisciplinary Exploration and Research in Astrophysics Northwestern University · NASA Goddard Space Flight Center · DM Telescopes LLC · University of Alabama at Huntsville · National Astronomical Observatory of Japan · Space Telescope Science Institute NASA Jet Propulsion Laboratory California Institute of Technology

astro-ph.IM, astro-ph.EP

Submitted: 2026-08-18

Updated: 2026-08-18

Comments: Proceedings of SPIE Astronomical Telescopes + Instrumentation 2026 (Paper No.14145-182)

Journal ref: Proc. SPIE 14145, 141454R (2026)

DOI: 10.1117/12.3103057

Code: https://github.com/roman-corgi/corgisim

License: http://creativecommons.org/licenses/by/4.0/

Importance score: 89/100

The gist: NASA’s Roman Space Telescope will feature a pathfinder Coronagraph Instrument to demonstrate advanced high-contrast imaging from space, paving the way for future missions like the Habitable Worlds

Key concepts

corgisim: A user-friendly Python framework that simulates the Roman Coronagraph Instrument's observations end-to-end. It connects astrophysical scene generation, optical propagation using PROPER models, and EMCCD detector modeling to produce high-fidelity data in FITS files.
Optical Propagation Modeling: This involves simulating how light travels through the coronagraph's optics. corgisim uses established libraries like PROPER to model this path, allowing users to test different configurations for imaging, polarimetry, and spectroscopy before actual flight.
EMCCD Detector Simulation: The CorgiDetector class simulates the behavior of an EMCCD detector. It models real-world effects such as gain, dark current, read noise, and cosmic rays. This ensures that simulated images accurately reflect how the detector will respond to the light being imaged.
CPGS Files: These are command files generated by Roman's Command Product Generation Software (CPGS). They describe specific observation scenarios, such as sequences involving wavefront sensing and control, which corgisim can use as input to simulate realistic mission observations.

Terminology

Polarization — 18× in this paper · explained in 2 episodes
Calibration — 11× in this paper · explained in 9 episodes
Oversampling — 5× in this paper · explained in 2 episodes
Roman Coronagraph Community Participation Program — 5× in this paper
Command Product Generation Software — 3× in this paper
Society of Photo-Optical Instrumentation Engineers — 3× in this paper
Fidelity — 2× in this paper · explained in 2 episodes
Hybrid Lyot Coronagraph — 2× in this paper
Steering — 2× in this paper · explained in 2 episodes
Accuracy — 1× in this paper · explained in 1 episode
Core — 1× in this paper · explained in 2 episodes
Shaped Pupil Coronagraph — 1× in this paper

Summary

NASA’s Roman Space Telescope will feature a pathfinder Coronagraph Instrument to demonstrate advanced high-contrast imaging from space, paving the way for future missions like the Habitable Worlds Observatory<ref:2608.17257#pg2> The Coronagraph Instrument could obtain imaging, polarimetry and spectroscopy of Jupiter analogs in reflected visible light for the first time<ref:2608.17257#pg2> We present the development of an open-source simulation package “corgisim” as part of the Roman Coronagraph Community Participate Program<ref:2608.17257#pg4> Built on established optical propagation libraries including PROPER and CGISim, corgisim provides a user-friendly, publicly available Python framework for end-to-end simulations of the Coronagraph Instrument observations<ref:2608.17257#pg3> The package produces high-fidelity, format-compliant data for pre-launch calibration, pipeline testing, and community applications such as target selection and observation planning<ref:2608.17257#pg4>

Simulation Workflow Description

The simulation flow implemented in corgisim starts from the inputs, defines the astrophysical scene, propagates the source light through the coronagraph optical model, places the resulting noiseless image on the EMCCD detector, and writes the simulated products to FITS files<ref:2608.17257#pg5> The package provides two ways for specifying simulation inputs: direct configuration through PYTHON or through Roman’s Command Product Generation Software (CPGS) files<ref:2608.17257#pg6> CPGS generates XML files which describe an observation scenario, typically consisting of a High Order Wavefront Sensing and Control (HOWFSC) sequence to dig the dark hole followed by several visits on a reference star and a target star<ref:2608.17257#pg7> The Scene object can include a host star, one or more companions, and an optional two-dimensional (2D) scene such as a circumstellar disk<ref:2608.17257#pg10> The instrument configuration is handled by the CorgiOptics object, which defines the highlevel observing setup including the cgi mode, bandpass, telescope diameter, roll angle, and image oversampling Detailed optical settings are provided through the optics keywords dictionary to simulate optical propagation through the Coronagraph Instrument using established models like PROPER Detector modeling is handled by the CorgiDetector object, which uses the emccd detect package to simulate EMCCD response based on parameters specified in the emccd keywords dictionary

Optical Modeling Capabilities

corgisim supports imaging, polarimetry, and spectroscopy simulations using different configurations defined by the CorgiOptics object For broadband imaging mode, the host star's on-axis coronagraphic point-spread function (PSF) is generated at each sampled wavelength and integrated to produce the broadband residual stellar image In polarimetry mode, corgisim includes the Wollaston-prism configuration and computes the polarization signal of the stellar speckle field by propagating its built-in Jones pupil model through the coronagraph Companion polarimetry is treated separately by transforming each companion Stokes vector from sky frame to instrument frame via a Mueller matrix and multiplying it by band-averaged instrument Mueller matrices In spectroscopy mode, corgisim uses the SPC spectroscopic coronagraph configuration and applies selected slit and prism models to generate the simulated spectroscopic image The framework allows for direct comparison of broadband imaging, slit-limited imaging, and dispersed spectroscopic products by running simulations with varying configurations

Detector Simulation Details

The CorgiDetector class uses the emccd detect package to simulate detector effects such as EM gain, dark current, clock-induced charge, read noise, and cosmic rays For non-polarimetric simulations, the noiseless image is placed onto the detector at a selected location before generating noisy detector images For polarimetric simulations, CorgiDetector places two images corresponding to the two polarization channels onto the EXCAM frame at their expected separated detector locations The final step applies detector effects including read-out smearing and digitization into detector counts

Validation and Future Work

Validation involves installation tests, reference validation against direct CGISim simulations for standard cases, and checks on roll-angle coordinate conversions and L1-style FITS headers Representative simulation cases demonstrate the capabilities of corgisim across various modes, including HLC imaging, SPC wide-field imaging with disks, HLC polarimetry, and SPC bowtie spectroscopy Future development will focus on time-dependent speckle simulations for time-series observations and polarimetric propagation of two-dimensional scenes The goal is to provide realistic and configurable speckle variability for pipeline and science-performance studies rather than fully accurate on-the-fly predictions

Summary of Utility

corgisim is a Python simulation framework that connects astrophysical scene generation, optical propagation with the Roman preflight PROPER model, and EMCCD detector modeling It supports imaging, polarimetry, and spectroscopy of host stars, companions, and extended sources along with effects like telescope roll and pointing jitter The package produces both noiseless optical subframes and full frame L1 FITS products with compatible headers following Roman’s official naming conventions This open-source, end-to-end framework supports pre-launch calibration, pipeline development, observation planning, and broader community studies of the Coronagraph Instrument

APPENDIX A Details

Improvements for AI systems

Simulation of realistic raw datasets for pre-launch calibration can be performed by corgisim, which provides a user friendly Python framework for end-to-end simulations of the Coronagraph Instrument observations. This allows researchers to test data reduction pipelines before actual launch.
Integration of established optical and detector modeling tools enables detailed simulation flows where the package defines the astrophysical scene, propagates the source light through the coronagraph optical model, places the resulting noiseless image on the EMCCD detector, and writes the simulated products to FITS files. This capability supports comprehensive end-to-end system validation.
Advanced polarimetry can be simulated by propagating linear polarization states through an optical model using the Wollaston-prism configuration and calculating the polarized intensity of a specific analyzer channel. This allows for the characterization of polarization-dependent speckle structure introduced by the coronagraph.
Spectroscopy simulations allow users to compare different observational strategies by enabling the simulation of broadband imaging, slit-limited imaging, and dispersed spectroscopic products using the SPC spectroscopic coronagraph configuration. This supports direct comparison between different data products.
Simulation of practical observational effects can be achieved by including finite stellar diameter and pointing jitter effects in corgisim to capture the PSF broadening and contrast degradation introduced by finite source size and pointing instability. This provides realistic performance metrics for science studies.
The system can be used for target planning by simulating scenarios from CPGS files, allowing users to specify a companion with its position and magnitude, which will be added to the scene and simulated along with the target. This assists in optimizing observation sequences before launch.
Output products include full-frame detector simulations saved as L1 FITS products that contain a primary HDU with global metadata, including exposure, detector, observing-mode, roll-angle, polarization, ready for processing by the data-reduction pipeline. This ensures data is immediately usable by ground support systems.
Future development will focus on time-dependent speckle simulations to support tests of observing strategies and calibration methods in time series observations. This enables the testing of dynamic observing procedures based on realistic, configurable speckle variability rather than just static fields.

Abstract

NASA's Roman Space Telescope will feature a pathfinder Coronagraph Instrument to demonstrate advanced high-contrast imaging from space, paving the way for future missions like the Habitable Worlds Observatory. The Coronagraph Instrument could obtain imaging, polarimetry and spectroscopy of Jupiter analogs in reflected visible light for the first time. We present the development of an open-source simulation package ``corgisim'' as part of the Roman Coronagraph Community Participate Program. Built on established optical propagation libraries including PROPER and CGISim, corgisim provides a user-friendly, publicly available Python framework for end-to-end simulations of the Coronagraph Instrument observations. The package produces high-fidelity, format-compliant data for pre-launch calibration, pipeline testing, and community applications such as target selection and observation planning. We will give an overview of corgisim's infrastructure, functionalities, and current implementation across planned imaging, polarimetry, and spectroscopy modes, including the ability to simulate host stars, injected companions, and extended disks. We will also highlight suitable applications of corgisim and provide guidance on how users can access and employ the software.