Skip to content

Instantly share code, notes, and snippets.

@nmearl
Created February 9, 2017 19:58
Show Gist options
  • Save nmearl/2465fe054a71ddaadba349398fa3e146 to your computer and use it in GitHub Desktop.
Save nmearl/2465fe054a71ddaadba349398fa3e146 to your computer and use it in GitHub Desktop.
Documentation for engine parameters files and output data

Currently Supported Calculation Modes (03-2016)

The following following JWST instrument/mode combinations are currently implemented, working, and part of the nightly regression tests:

  • miri:

    • imaging
    • mrs
    • coronagraphy
    • lrsslit
    • lrsslitless
  • nircam:

    • sw_imaging
    • lw_imaging
    • ssgrism
    • wfgrism
    • coronagraphy
  • nirspec:

    • ifu
    • msa
    • fixed_slit
  • niriss:

    • imaging
    • soss
    • ami
    • wfss

The following HST instrument/mode combination is not yet fully implemented, but will be available for engine testing and validation:

  • wfc3:
    • imaging

The following WFIRST instrument/mode combination is now implemented with very notional reference data:

  • wfirstimager:
    • imaging
    • ifu

Overview of Inputs

The engine input api is a dict. At the top level of the dict, there are:

background: string for notional background lookup, or see below

configuration: dict: camera/telescope configuration

scene: list: list of sources

strategy: dict: strategy configuration

calculation: dict: test interface

fake_exception: test interface

error, server_test: reserved by server

Details of Inputs for ETC Calculation

NOTE - keep all of the following in synch with: pandeia/engine/helpers/schema

As of now, the engine requires the following information to perform a calculation:

scene: list (no default) This is a list of Sources. Each Source is described by a dict with the following keys:

position: dict
  Source position parameters described by the following keys:

    x_offset: float (default 0.0)
        Detector plane X offset from FOV center in arcseconds. Positive to the right.
    y_offset: float (default 0.0)
        Detector plane Y offset from FOV center in arcseconds. Positive is up.
    orientation: float (default 0.0)
        Detector plane orientation in degrees. Positive is in direction of +X.
        (e.g. orientation=90 is UP, and orientation=-90 is DOWN)

shape: dict
  Source shape parameters described by the following keys:

    geometry: string (default "point")
        Supported geometries are "point", "gaussian2d", "flat", and "sersic". Required
        additional source shape parameters are contingent on this parameter:

            "point" requires no additional parameters.

            "gaussian2d", "flat", and "sersic" all require these parameters:
                major: float (default 0.1)
                    Semi-major axis in arcseconds. For "flat" this sets the size, for "gaussian2d"
                    this sets the sigma, and for "sersic" this sets a scale length where
                    I(r) = I(0)/e.
                minor: float (default 0.1)
                    Semi-minor axis in arcseconds

            "sersic" requires one additional parameter:
                sersic_index: float (default 1.0)
                    Power law index that sets the shape of a sersic profile.
                    sersic_index = 1.0 --> exponential
                    sersic_index = 0.5 --> gaussian
                    sersic_index = 4.0 --> de Vaucouleurs

spectrum: dict
  Source spectral parameters described by the following keys:

    redshift: float (default 0.0)
        Redshift to apply to the continuum. Since lines are added with physical units for their strength,
        they are added to the spectrum after normalization and redshift.

    extinction: dict
      Defines how the spectrum is reddened by interstellar dust

        law: string
            Extinction law to use. Supported laws are
                * ``mw_rv_31`` - WD01 Milky Way curve for an R_V value of 3.1 (default)
                * ``mw_rv_40`` - WD01 Milky Way curve for an R_V value of 4.0
                * ``mw_rv_55`` - WD01 Milky Way curve for an R_V value of 5.5
                * ``hd210121`` - WD01 Extinction curve for high-latitude molecular cloud hd210121 with C/H = b_C = 40 ppm
                                 in log-normal size dists
                * ``lmc_avg``  - WD01 Average extinction curve for the LMC with C/H = b_C = 20 ppm in log-normal size dists
                * ``lmc_2``    - WD01 LMC extinction curve with C/H = b_C = 10 ppm in log-normal size dists (30 Dor region)
                * ``smc_bar``  - WD01 Extinction curve in SMC bar with C/H = b_C = 0 ppm in log-normal size dists
                * ``chapman09`` - Chapman et al. (2009) mid-IR extinction curve derived from three molecular clouds:
                                  Ophiuchus, Perseus, and Serpens
        value: float
            Level of extinction in units of unit
        unit: string
            Units of extinction.  Allowed values are ``nh`` for hydrogen column density (cm^-2) and "mag" for magnitudes
            of extinction in specified bandpass, ext_bandpass
        bandpass: string
            Bandpass to which extinction is normalized to if unit="mag".  Allowed values are v, j, h, and k.

    normalization: dict
      Defines how the spectrum is to be scaled.

        type: string
            Method of normalization to perform.  Supported methods are
                * ``at_lambda`` - Specify norm_flux in fluxunit at a specfic wavelength, norm_wave
                * ``hst`` - Specify a bandpass in the form of an "obsmode" string to pass along to pysynphot along with fluxunit and norm_flux
                * ``jwst`` - Specify a bandpass as an instrument configuration in the form of a comma-separated string <instrument>,<mode>,<filter> along with fluxunit and norm_flux
                * ``photsys`` - Specify bandpass in the form of a comma-separated string <photsys>,<filter>
                * ``none`` - Do not normalize spectrum.  Only valid for a spectrum type of 'input'.

        norm_wave: float
            Reference wavelength in 'norm_waveunit' at which spectrum will be scaled for type 'at_lambda'.
            Ignored for other normalization types.
        norm_flux: float
            Reference flux in 'norm_fluxunit' to which spectrum will be scaled.
        norm_fluxunit: string
            Specify the flux units in which the normalization should occur.
            Supports flam, fnu, vegamag, abmag, mjy, ujy, njy, jy
        norm_waveunit: string
            Specify the wavelength units used in normalization
        bandpass: string
            Specifies the key used to obtain the normalization bandpass for
            types 'hst', 'jwst', and 'photsys'.

    sed: dict
      Defines the spectral energy distribution of the spectrum.

        sed_type: string
            Type of the spectral energy distribution. Each type requires its own set
            of parameters. The analytic sed_type's (none, flat, powerlaw, flat) all
            require 'wmin', 'wmax', and 'sampling' to define the range and wavelength
            sampling over which the model spectrum is calculated. However, they are only
            available in the API for testing purposes and should not be configured via
            the UI.

                **no_continuum** - No continuum, specifically Flux = 0.0 over specified range [wmin, wmax]
                    wmin: float (default 0.5)
                        Minimum wavelength in microns
                    wmax: float (default 30.0)
                        Maximum wavelength in microns
                    sampling: int (default 200)
                        Sets the logarithmic wavelength sampling of the model spectrum

                **flat** - Flat spectrum in specified units calculated over specified range [wmin, wmax]
                    wmin: float (default 0.5)
                        Minimum wavelength in microns
                    wmax: float (default 30.0)
                        Maximum wavelength in microns
                    sampling: int (default 200)
                        Sets the logarithmic wavelength sampling of the model spectrum
                    unit: string
                        Units of spectrum, either 'fnu' or 'flam'

                **powerlaw** - Powerlaw spectrum where F ~ lambda ^ index calculated over range [wmin, wmax]
                    wmin: float (default 0.5)
                        Minimum wavelength in microns
                    wmax: float (default 30.0)
                        Maximum wavelength in microns
                    sampling: int (default 200)
                        Sets the logarithmic wavelength sampling of the model spectrum
                    unit: string
                        Units of spectrum, either 'fnu' or 'flam'
                    index: float
                        Exponent of the power law

                **blackbody** - Blackbody spectrym calculated over range [wmin, wmax]
                    wmin: float (default 0.5)
                        Minimum wavelength in microns
                    wmax: float (default 30.0)
                        Maximum wavelength in microns
                    sampling: int (default 200)
                        Sets the logarithmic wavelength sampling of the model spectrum
                    temp: float
                        Temperature of the blackbody

                **phoenix** - Parameterized stellar atmosphere models calculated by the Phoenix group
                    key: string
                        In webapp mode, a key is used to look up a predefined set of parameters. If not
                        in webapp mode and if key is not provided, model parameters can be passed directly:
                    teff: float
                        Effective temperature. Allowed range is 2000 K to 70000 K
                    log_g: float
                        Surface gravity in log10(cgs) units. Allowed range is 0.0 to 5.5.
                    metallicity: float
                        Metallicity in units of log10(solar metallicity). Allowed range is -4.0 to 0.5.

                **hst_calspec** - HST standard star spectra
                    key: string
                        Key used to look up which spectrum load.

                **galaxies** - Integrated spectra of galaxies from Brown et al. (2014)
                    key: string
                        Key used to look up which spectrum load.

                **input** - spectrum provided via input arrays
                    spectrum: list-like or numpy.ndarray
                        The 0th index is taken to be wavelength in units of 'mJy'.
                        The 1st index is taken to be the flux in units of 'microns'.

    lines: list (default [])
      List of line definitions. Each definition is a dict with keys:

          name: string (default 'no name')
              Name of line (e.g. 'Hydrogen Alpha')
          center: float (default 5.2)
              Wavelength at line center in w_unit
          strength: float (default 1.0e-14)
              Strength of line in erg/cm^2/s for emission or
              optical depth for absorption
          profile: string
              Line profile type:
                * gaussian      *default*
                * voigt          NOT YET IMPLEMENTED
          emission_or_absorption: string
              Line type:
                * emission      *default*
                * absorption

        A profile type of **gaussian** requires one additional parameter:

          width: float (default 200.0)
              Full-width half-max of line in km/s

        When implemented, profile type of **voigt** will require two additional parameters:

          gaussian_fwhm: float (default 200.0)
              Full-width half-max of the gaussian core of the line in units of km/s
          lorentzian_fwhm: float (default 500.0)
              Full-width half-max of the lorentzian wings of the line in units of km/s

background: string (default 'medium') or list-like or numpy.ndarray Possible string values are: none, low, medium, and high. String values trigger the use of a notional background model. If a background spectrum is provided, it is assumed that the 0th index is the wavelength in microns and the 1st index is the background surface brightness in MJy/sr.

calculation: dict Set of boolean parameters to toggle the inclusion of different effects and noise parameters in a calculation. This section is optional and largely for testing purposes. Do not expect to support this in the UI.

noise: dict
  Noise components

    darkcurrent: bool
        Dark current
    crs: bool
        Cosmic rays
    rn_correlation: bool
        Correlated read noise
    ffnoise: bool
        Flat-field noise
    readnoise: bool
        Detector read-out noise

effects: dict
  Effects that can affect the noise or detector response or both

    ipc: bool
        Inter-pixel capacitance
    saturation: bool
        Pixel saturation
    background: bool
        Include background in calculation or not

configuration: dict This configuration for the instrument using the following keys:

instrument: dict
  The instrument configuration parameters

    instrument: string
      for JWST:
        * miri
        * nircam
        * nirspec
        * niriss

      for HST:
        * wfc3 (NOT IMPLEMENTED)

      for WFIRST:
        * wfirstimager
        * wfirstifu

    mode: string
      valid modes:
        * imaging
        * sw_imaging
        * lw_imaging
        * msa
        * mrs
        * soss
        * ifu
        * wfss
        * ssgrism
        * wfgrism
        * lrsslit
        * lrsslitless
        * fixed_slit
        * ami
        * coronagraphy

    filter: string
       (e.g. f070w)

    disperser: string
       (e.g. g235h)

    aperture: string
       (e.g. a200)

    shutter_location: string (only valid for NIRSpec MSA mode)
        Identifier string for slitlet position to use for MSA calculation

    slitlet_shape: list-like  (only valid for NIRSpec MSA mode)
        List of 2-element offsets describing set of shutters to be open. Offsets are from scene center
        in units of shutter spacing.

detector: dict
  Exposure configuration parameters.

    subarray: string
       full, 64x64, etc.; Instrument-dependent
    readmode: string
       Instrument-dependent
    ngroup: int
       Number of groups
    nint: int
       Number of integrations
    nexp: int
       Number of exposures

dynamic_scene: boolean
    Toggle whether to allow the size of the scene to expand dynamically to include all configured sources.

scene_size: float
    Default size of the scene in arcseconds. Used if dynamic_scene is True.

max_scene_size: float
    Maximum allowable scene_size in arcseconds.

strategy: dict Configuration parameters for observing strategy.

method: string
    Instrument and mode dependent. Currently supported methods are:
        * imagingapphot
        * specapphot
        * coronagraphy
        * ifuapphot
        * ifunodinscene
        * ifunodoffscene
        * msafullapphot
        * soss

    Planned methods that are not yet implemented include:
        imagingoptphot, specoptphot, speclinephot

units: string  (default: "arcsec")
    Angular units used by the strategy
target_source: string
    Sent by the UI client, but currently unused by the engine
target_type: string
    Sent by the UI client, but currently unused by the engine

The rest of the parameters will be method dependent.  The parameters required
for **imagingapphot**, **specapphot**, and **ifuapphot** are:

    aperture_size: float
        Size of extraction aperture in "units"
    sky_annulus: list-like of format (float, float)
        The inner and outer radii in "units" of sky region used for background subtraction
    target_xy: list-like of format (float, float)
        X and Y center position of the aperture and sky annulus.

The parameters required for **ifunodinscene** and **ifunodoffscene** are:

    aperture_size: float
        Size of extraction aperture in "units"
    target_xy: list-like of format (float, float)
        X and Y center position of the aperture and sky annulus.
    dithers: list of dicts with format {'x': <float>, 'y': <float>}
        Dither positions given in "units" from center of the Scene.

The parameters required for **msafullapphot** are:

    shutter_offset: list-like of format (float, float)
        Offset of shutter pattern from center of scene in "units"
    dithers: list of dicts
        Dither positions and MSA shutter configuration with the following format:
            x: float
                X position of the central shutter
            y: float
                Y position of the central shutter
            on_source: list of bool
                List of booleans denoting whether a shutter should be treated as source or sky.
                Must be of same length as "slitlet_shape" specified in the instrument configuration.

The parameters required for **soss** are:
    background_subtraction: boolean
        Toggle whether background subtraction is performed or not.
    order: int
        Specify which order to extract. Can be 1 or 2 with support for 3 forthcoming.

The parameters required for **coronagraphy** are:

    target_xy: two-element list-like (float, float)
        Position of extraction aperture
    aperture_size: float
        Radius of extraction aperture in 'units'
    sky_annulus: two-element list-like (float, float)
        Inner and outer radii of sky background estimation region
    contrast_azimuth: float
        Azimuth at which to calculate contrast curve
    pointing_error: two-element list-like (float, float)
        Amount to shift occulted source to emulate imperfect pointing
    delta_opd: float
        Change in system OPD
    scene_rotation: float
        Rotation angle to apply to scene
    psf_subtraction_source: Source dict in engine API format
        Definition of source to use for PSF subtraction
    psf_subtraction_xy: two-element list-like (float, float)
        Offset to apply to psf_subtraction_source
    unocculted_xy: two-element list-like (float, float)
        Offset to apply to source to measure contrast between occulted and unocculted observation

The parameters required for the planned methods will be defined as the methods
are implemented.

fake_exception: list of strings If present, this list is searched for control terms that cause perform_calculation to raise exceptions for testing purposes. Currently recognized strings are:

    'pyetc':
         raise PyetcException

    'exception':
         raise Exception

Other strings may be added later to add exceptions or modify
the details of the exception objects raised.

Description of Outputs from an ETC Calculation

Exceptions:

Normally expected exceptions are of base class etc3d.custom_exceptions.PyetcException The attribute .message contains a plain text description of the problem suitable for display to the user.

There are numerous subclasses of PyetcException that are not documented here, but can be seen in etc3d.custom_exceptions

The return value from perform_calcluation() is a dict. The rest of this document describes the keys in that dict.

error : string This string is not reported by the engine, but the name is reserved by the server. See doc/transactions/ws_trans.txt

admin_data : string This string is not reported by the engine, but the name is reserved by the server. See doc/transactions/ws_trans.txt

server_test : dict This data is not reported by the engine, but the name is reserved by the server. See doc/transactions/ws_trans.txt

transform: dict This contains the information that describes the axes in the 2D and 3D images (e.g. sizes, extents, and step sizes). This information is used to map pixel coordinates to world coordinates. There are two sets of numbers for the wavelength axis because the wavelength sampling of the spectrum used in the calculation is usually different from the wavelength sampling at the detector plane. The detector plane sampling is usually much finer. It would be inefficient to perform the ETC calculation at the full detector wavelength resolution if that's not required.

x_refpix: int
    Reference pixel for the X axis. Not sure when it wouldn't be 0.
x_refval: float
    Value of X at x_refpix.
x_max: float
    Maximum X value.
x_min: float
    Minimum X value.
x_step: float
    Size of pixel in X direction in arcseconds/pixel.
x_size: int
    Length of X axis.

y_refpix: int
    Reference pixel for the Y axis.
y_refval: float
    Value of Y at y_refpix.
y_max: float
    Maximum Y value.
y_min: float
    Minimum Y value.
y_step: float
    Size of pixel in Y direction in arcseconds/pixel.
y_size: int
    Length of Y axis.

wave_refpix: int
    Reference pixel for the wavelength axis.
wave_refval: float
    Value of wavelength at wave_refpix.
wave_max: float
    Maximum wavelength value.
wave_min: float
    Minimum wavelength value.
wave_step: float
    Size of pixel in wavelength axis in microns/pixel
wave_size: int
    Length of wavelength axis

wave_det_refpix: int
    Reference pixel for the detector-sampled wavelength axis
wave_det_refval: float
    Value of wavelength at wave_det_refval
wave_det_max: float
    Maximum wavelength value sampled at the detector plane
wave_det_min: float
    Minimum wavelength value sampled at the detector plane
wave_det_step: float
    Size of detector pixels in wavelength axis in microns/pixel
wave_det_size: int
    Length of the detector-sampled wavelength axis

.. image:: oapi_coords.gif

3d: dict The 3-D data products generated by the engine calculation

flux: list of numpy.ndarray (3-D)
    The model flux cubes used in the calculation, one per
    aperture. This includes only flux from sources in the scene.
background: list of numpy.ndarray (3-D) (not yet implemented per #158)
    The model background used in the calculation.
reconstructed: numpy.ndarray (3-D) (IFU calculations only)
    This is a reconstructed simulation of an observed flux cube
    generated by IFU calculations.
reconstructed_signal: numpy.ndarray (3-D) (IFU calculations only)
    The signal component of the reconstructed flux cube
reconstructed_noise: numpy.ndarray (3-D) (IFU calculations only)
    The noise component of the reconstructed flux cube
reconstructed_snr: numpy.ndarray (3-D) (IFU calculations only)
    reconstructed_signal divided by reconstructed_noise
reconstructed_saturation: numpy.ndarray (3-D) (IFU calculations only)
    Reconstructed saturation cube showing the maximum saturation at each pixel

2d: dict The 2-D data products generated by the engine calculation. Axis descriptions are given in 'transform'.

detector: numpy.ndarray (2-D)
    ['2d']['detector'](x,y) is the count rate at the detector in e-/sec.
    Shown in 'Detector' plot in GUI.

snr: numpy.ndarray (2-D)
    ['2d']['snr'](x,y) is the S/N at the detector.
    Shown in '2D S/N' plot in GUI.

saturation: numpy.ndarray (2-D)
    Saturation map at the detector. 0 -> no saturation, 1 -> soft saturation, 2 -> hard saturation

1d: dict The 1-D data products generated by the engine calculation. Here we use 'Target' to refer to the position within the Scene defined by the Strategy.

In these descriptions:
 - wave is wavelength in microns

wave_pix: numpy.ndarray (1-D)
    Wavelength in microns as sampled in pixels on the detector.

wave_calc: numpy.ndarray (1-D)
    Wavelength set used in the calculation before sampled and mapped
    onto the detector plane.

target: list [numpy.ndarray (1-D), numpy.ndarray (1-D)]
    Wavelength in microns, Input integrated scene flux (in mJy). This includes flux from all defined sources
    within the scene, but excludes background.
    Shown under 'Target Spectrum' in GUI.
    n.b. Target is the pixel specified as the target in the Strategy

fp: list [numpy.ndarray (1-D), numpy.ndarray (1-D)]
    Wavelength in microns, integrated scene count rate at the focal plane in e-/s/pixel/micron.
    This excludes background, but includes signal from all defined sources within the scene.
    This includes throughputs from filters, dispersers, and internal optics as well as detector QE.
    Shown under 'Focal Plane Rate' in GUI.

bg: list [numpy.ndarray (1-D), numpy.ndarray (1-D)]
    Wavelength in microns, input background surface brightness in MJy/sr
    This is the input background surface brightness binned to the wavelength
    scale used in the calculation, wave_calc.

bg_rate: list [numpy.ndarray (1-D), numpy.ndarray (1-D)]
    Wavelength in microns, Background count rate at focal plane
    This is the count rate per detector pixel in e-/sec/pixel and is spatially constant.
    This is NOT currently displayed in the GUI, but should be eventually.

sn: list [numpy.ndarray (1-D), numpy.ndarray (1-D)]
    Wavelength in microns, Signal/Noise Ratio
    Shown under 'Signal-to-Noise' in GUI.

extracted_flux: list [numpy.ndarray (1-D), numpy.ndarray (1-D)]
    Wavelength in microns, Target count rate on the detector
        in e-/sec, as extracted by the defined Strategy.
    NOT currently displayed on GUI

extracted_flux_plus_bg: list [numpy.ndarray (1-D), numpy.ndarray (1-D)]
    Wavelength in microns, Target count rate on the detector including
    background in e-/sec, as extracted by the defined Strategy.
    If background subtraction is being performed, this should be the same as extracted_flux.
    NOT currently displayed on GUI

total_flux: list [numpy.ndarray (1-D), numpy.ndarray (1-D)]
    Wavelength in microns, integrated scene count rate on the detector in e-/s. This includes signal from
    all sources within the scene, but does not include background.
    NOT currently displayed on GUI

extracted_bg_total: list [numpy.ndarray (1-D), numpy.ndarray (1-D)]
    Wavelength in microns, total background count rate in e-/sec. This includes all flux contained within
    the background extraction region and is normalized to the target extraction region by the ratio
    of the areas of the regions.
    NOT currently displayed on GUI

extracted_bg_only: list [numpy.ndarray (1-D), numpy.ndarray (1-D)]
    Wavelength in microns, background count rate in e-/sec. This includes only the flux due to the scene background
    and is normalized to the area of the target extraction region.
    NOT currently displayed on GUI

extracted_contamination: list [numpy.ndarray (1-D), numpy.ndarray (1-D)]
    Wavelength in microns, contamination count rate in e-/sec.  This is extracted_bg_total - extracted_bg_only and
    gives a measure of how much non-background flux (e.g. PSF wings or contamination sources) is contained within
    the background estimation region.  The count rate is normalized to the target extraction region area.

scalar: dict The scalar quantities generated by the Strategy passed to the engine. This is still not yet developed and will need to be populated as the work on Strategy is completed. As of now the following keys will be populated for imaging calculations. Other modes will likely have different sets of results. This section should populate the 'Report' tab on the GUI.

extracted_flux: float
    Total flux (e-/sec) within the extraction aperture. This is determined at the reference_wavelength for dispersed modes.
    Omitted for strategies that don't specify an extraction aperture.
extracted_noise: float
    Noise (e-/sec) within the extraction aperture. This is determined at the reference_wavelength for dispersed modes.
    Omitted for strategies that don't specify an extraction aperture.
sn: float
    Extracted signal-to-noise ratio (extracted_flux/extracted_noise). This is determined at the reference_wavelength for
    dispersed modes. Omitted for strategies that don't specify an extraction aperture.
background_total: float
    Extracted background flux (e-/sec) including all components. This is determined at the reference_wavelength
    for dispersed modes.
background_sky: float
    Extracted sky background flux (e-/sec) excluding any signal from the scene. This is determined at the reference_wavelength
    for dispersed modes.
contamination: float
    Fraction of background_total that is due to signal from the scene: (background_total-background_sky)/background_total
background: float
    Background surface brightness in MJy/sr at reference_wavelength.
reference_wavelength: float
    Wavelength where scalar values are determined, if applicable (i.e. for dispersed modes) (microns).
exposure_time: float
    Total exposure time for the observation as determined by the exposure specification (seconds).
all_dithers_time: float
    Total time for the observation including exposures from all configured dithers (seconds).
cr_ramp_rate: float
    Assumed cosmic ray rate in events/ramp where ramp time is determined by the exposure specification.
background_area: float or None
    Area in pixels of background estimation region. None if background subtraction is turned off.
extraction_area: float
    Area in pixels of target extraction region.
contrast_separation: float
    Radius in arcsec at which contrast is measured. Only applicable to coronagraphy.
contrast_azimuth: float
    Azimuth in degrees where contrast is measured. Only applicable to coronagraphy.
contrast: float
    Contrast measured at polar coords (contrast_separation, contrast_azimuth). Only applicable to coronagraphy.
filter: string
    Instrument filter, if any, used in calculation.
disperser: string
    Instrument disperser, if any, used in calculation.
x_offset: float
    X offset in arcsec of source extraction aperture
y_offset: float
    Y offset in arcsec of source extraction aperture
aperture_size: float
    Radius in arcsec of source extraction aperture

information: dict This contains other information provided by the engine that isn't the result of any calculation. This will also need to get fleshed out over time.

calc_type: string
    Type of calculation as reported by the engine ('spec' or 'image')

exposure_specification: dict
    nframe: int
        Number of frames read out and saved per group
    nskip: int
        Number of frames skipped per group
    ngroup: int
        Number of groups in a ramp
    nint: int
        Number of integrations per exposure
    nexp: int
        Number of exposures
    nramps: int
        Total number of ramps (nexp * nint)
    tframe: float
        Readout time per frame (seconds)
    tgroup: float
        Total time required per group (seconds)
    exposure_time: float
        Total exposure time for the observation (seconds)
    subarray: string
        Portion of detector being read out
    pattern: string
        Name of readout pattern

input: dict A copy of the input dict used in the calculation. This may be superfluous for most of our purposes. The GUI won't use it and testing doesn't require it, either.

sub_reports: list of dicts Calculations involving multiple pointings will include this. It is a list of engine output API format dicts containing with one entry per pointing.

warnings: dict This will contain any warnings or other messages. Not yet implemented and will eventually populate the 'Warnings' tab on the GUI.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment