Input and Output Files

COLT uses the Hierarchical Data Format (HDF5) library for reading and writing files (with C++ wrappers). This page explains the general structure and philosophy of initial conditions and simulation output files.

Supported Geometries

Plane-Parallel Slab (slab)

Spherical Shells (spherical)

Axisymmetric Cylindrical Grid (cylindrical)

3D Cartesian Grid (cartesian)

3D Block Cartesian Grid (block_cartesian)

Adaptive-Resolution Octree (octree)

Unstructured Voronoi Mesh (voronoi)

Secondary Outputs (module-specific)

Initial Conditions Files

The following example code outlines the general procedure for writing a COLT initial conditions file. Specific use cases can vary significantly, and many datasets are optional or can be overridden by configuration options. The presentation shows functional pseudo code with if statements to clarify geometry or module specific options.

COLT reads any available domain extent before processing module-specific configuration so that options expressed relative to the bounding box have a well-defined scale. Cartesian and Voronoi files describe that extent with either the scalar r_box attribute or the two-corner bbox dataset. Octree files use the root cell, while slab, spherical, and cylindrical files use their edge arrays. Voronoi files may continue to omit r_box and bbox; in that case COLT infers the extent from the completed mesh as before. Providing an explicit Voronoi extent is recommended when configuration itself depends on the box size.

Slab, spherical, and cylindrical edge arrays must contain at least two finite, strictly increasing values. Spherical radial derivative outputs require at least two cells. An octree must contain a root cell. The cylindrical cell-count product must fit the configured cell_t index type, including long_cells when enabled.

The block_cartesian geometry uses the same uniform cells and ray tracing as cartesian, but also accepts rank-three scalar datasets with axis order (nx, ny, nz). It reads them in bounded HDF5 hyperslabs, where chunk_size limits the number of cells read along each axis, and blocks at the high edge may be smaller. This limits temporary read buffers and optimizes data locality for better performance. The complete flattened fields still reside in memory. See Block Cartesian Parameters for dimension and bounding-box options.

FORTRAN_ORDERING selects COLT’s flattened indexing dimension order. It does not affect the axis order of rank-three HDF5 datasets. Flat scalar and vector field arrays must already follow the selected C or Fortran cell ordering. Vector fields retain the usual (n_cells, 3) layout, and COLT writes scalar outputs as (n_cells) in that same cell ordering. For entirely flat input, provide nx, ny, and nz as attributes or configuration values. The total cell count must not exceed INT_MAX, matching the runtime’s established loop-index range.

# Write colt file (generally uses cgs units)
filename = f'{colt_dir}/colt_{snap:03d}.hdf5'
with h5py.File(filename, 'w') as f:
    # Simulation properties
    if cosmological:
        f.attrs['redshift'] = z     # Redshift (enables cosmological mode by default)
        f.attrs['Omega0'] = Omega0  # Matter density [rho_crit_0]
        f.attrs['OmegaB'] = OmegaB  # Baryon density [rho_crit_0]
        f.attrs['h100'] = h         # Hubble constant [100 km/s/Mpc]
    else:
        f.attrs['time'] = time      # Simulation time [s]

    # Geometry properties
    # Note: Due to camera positioning, it is most convenient to center the box at [0,0,0]
    f.attrs['n_cells'] = np.int32(n_cells) # Total number of cells (optional)
    if geometry in ('cartesian', 'block_cartesian'):
        f.attrs['nx'] = np.int32(nx) # Number of x cells
        f.attrs['ny'] = np.int32(ny) # Number of y cells
        f.attrs['nz'] = np.int32(nz) # Number of z cells
        R = ...                     # Box radius [cm]
        f.attrs['r_box'] = R        # For irregular boxes use bbox instead
        # bbox = np.array([[-R,-R,-R],[R,R,R]], dtype=np.float64)
        # f.create_dataset('bbox', data=bbox) # Bounding box [cm]
        # f['bbox'].attrs['units'] = b'cm'
    elif geometry == 'octree':
        r = ...                     # Cell left corner positions [cm]
        w = ...                     # Cell widths [cm]
        f.create_dataset('r', data=r, dtype=np.float64)
        f['r'].attrs['units'] = b'cm'
        f.create_dataset('w', data=w, dtype=np.float64)
        f['w'].attrs['units'] = b'cm'
        parent = ...                # Cell parent indices
        child = ...                 # Cell child indices
        child_check = ...           # True if cell has children
        f.create_dataset('parent', data=parent, dtype=np.int32)
        f.create_dataset('child', data=child, dtype=np.int32)
        f.create_dataset('child_check', data=child_check, dtype=np.int32)
    elif geometry == 'slab':
        r_edges = ...               # Cell edge positions (1D) [cm]
        f.create_dataset('r_edges', data=r_edges, dtype=np.float64)
        f['r_edges'].attrs['units'] = b'cm'
    elif geometry == 'spherical':
        r_edges = ...               # Shell edge positions (1D) [cm]
        f.create_dataset('r_edges', data=r_edges, dtype=np.float64)
        f['r_edges'].attrs['units'] = b'cm'
    elif geometry == 'cylindrical':
        r_edges = ...               # Cylindrical radial edges [cm]
        z_edges = ...               # Vertical edges [cm]
        f.create_dataset('r_edges', data=r_edges, dtype=np.float64)
        f['r_edges'].attrs['units'] = b'cm'
        f.create_dataset('z_edges', data=z_edges, dtype=np.float64)
        f['z_edges'].attrs['units'] = b'cm'
    elif geometry == 'voronoi':
        R = ...                     # Box radius [cm]
        f.attrs['r_box'] = R        # For irregular boxes use bbox instead
        # bbox = np.array([[-R,-R,-R],[R,R,R]], dtype=np.float64)
        # f.create_dataset('bbox', data=bbox) # Bounding box [cm]
        # f['bbox'].attrs['units'] = b'cm'
        # If neither is specified then bbox is inferred from particle positions
        r = ...                     # Mesh generating points [cm]
        f.create_dataset('r', data=r, dtype=np.float64)
        f['r'].attrs['units'] = b'cm'

    # Gas properties
    v = ...                         # Velocities [cm/s] (optional)
    f.create_dataset('v', data=v, dtype=np.float64)
    f['v'].attrs['units'] = b'cm/s'
    if set_density_from_mass:
        m = ...                     # Masses [g]
        f.create_dataset('m', data=m, dtype=np.float64)
        f['m'].attrs['units'] = b'g'
    else:
        rho = ...                   # Densities [g/cm^3]; block grids may be [nx,ny,nz]
        f.create_dataset('rho', data=rho, dtype=np.float64)
        f['rho'].attrs['units'] = b'g/cm^3'
    if use_internal_energy:
        e_int = ...                 # Internal energies [cm^2/s^2]
        f.create_dataset('e_int', data=e_int, dtype=np.float64)
        f['e_int'].attrs['units'] = b'cm^2/s^2'
    else:
        T = ...                     # Temperatures [K]
        f.create_dataset('T', data=T, dtype=np.float64)
        f['T'].attrs['units'] = b'K'
    x_HI = ...                      # Neutral hydrogen fraction (optional)
    x_HII = ...                     # Ionized hydrogen fraction (optional)
    x_H2 = ...                      # Molecular hydrogen fraction (optional)
    x_HeI = ...                     # Neutral helium fraction (optional)
    x_HeII = ...                    # Ionized helium fraction (optional)
    x_e = ...                       # Electron fraction (optional)
    f.create_dataset('x_HI', data=x_HI, dtype=np.float64)
    f.create_dataset('x_HII', data=x_HII, dtype=np.float64)
    f.create_dataset('x_H2', data=x_H2, dtype=np.float64)
    f.create_dataset('x_HeI', data=x_HeI, dtype=np.float64)
    f.create_dataset('x_HeII', data=x_HeII, dtype=np.float64)
    f.create_dataset('x_e', data=x_e, dtype=np.float64)
    Z = ...                         # Metallicity [mass fraction] (optional)
    D = ...                         # Dust-to-gas ratio [mass fraction] (optional)
    f.create_dataset('Z', data=Z, dtype=np.float64)
    f.create_dataset('D', data=D, dtype=np.float64)
    # D_S = ...                       # Silicate dust-to-gas ratio [mass fraction] (optional)
    # D_PAH = ...                     # PAH dust-to-gas ratio [mass fraction] (optional)
    # f.create_dataset('D_S', data=D_S, dtype=np.float64)
    # f.create_dataset('D_PAH', data=D_PAH, dtype=np.float64)
    # B = ...                         # Magnetic field [G] (optional)
    # f.create_dataset('B', data=B, dtype=np.float64)
    # f['B'].attrs['units'] = b'G'
    # e_int = ...                     # Specific internal energy [cm^2/s^2] (optional)
    # f.create_dataset('e_int', data=e_int, dtype=np.float64)
    # f['e_int'].attrs['units'] = b'cm^2/s^2'
    # SFR = ...                       # Star formation rate [Msun/yr]
    # f.create_dataset('SFR', data=SFR, dtype=np.float64)
    # f['SFR'].attrs['units'] = b'Msun/yr'

    # Star properties
    f.attrs['n_stars'] = n_stars
    r_star = ...                    # Star positions [cm]
    f.create_dataset('r_star', data=r_star, dtype=np.float64)
    f['r_star'].attrs['units'] = b'cm'
    v_star = ...                    # Star velocities [cm]
    f.create_dataset('v_star', data=v_star, dtype=np.float64)
    f['v_star'].attrs['units'] = b'cm/s'
    m_star = ...                    # Star masses [Msun]
    f.create_dataset('m_star', data=m_star, dtype=np.float64)
    f['m_star'].attrs['units'] = b'Msun'
    m_init_star = ...               # Star initial masses [Msun]
    f.create_dataset('m_init_star', data=m_init_star, dtype=np.float64)
    f['m_init_star'].attrs['units'] = b'Msun'
    Z_star = ...                    # Star metallicity [mass fraction]
    f.create_dataset('Z_star', data=Z_star, dtype=np.float64)
    age_star = ...                  # Star ages [Gyr]
    f.create_dataset('age_star', data=age_star, dtype=np.float64)
    f['age_star'].attrs['units'] = b'Gyr'

Example Configuration File

While the format for configuration files was already described, we now provide a working example configuration file for H-alpha Monte Carlo radiative transfer.

# COLT config file
--- !mcrt                     # Monte Carlo radiative transfer module

init_dir: ics                 # Initial conditions directory (default: "ics")
init_base: colt               # Initial conditions base name (optional)
output_dir: Ha                # Output directory name (default: "output")
output_base: Ha               # Output file base name (default: "colt")

recombinations: true          # Include recombination emission
collisions: true              # Include collisional excitation

cosmological: true            # Indicates whether the simulation is cosmological
line: Balmer-alpha            # Name of the line (default "Lyman-alpha")
v_turb_kms: 10                # Microturbulent velocity [km/s]
dust_model: MW                # Dust model: SMC, MW, etc.

# Information about sources
n_photons: 1000000            # Number of photon packets (increase for production runs)
j_exp: 0.75                   # Luminosity boosting exponent

# Information about escape
output_photons: false         # Output escaped photon packets
spherical_escape: true        # Photons escape from a sphere
escape_radius_bbox: 0.9       # Escape radius relative to the bbox
emission_radius_bbox: 0.75    # Emission radius relative to the bbox

# Information about cameras
freq_min: -500                # Frequency minimum [km/s]
freq_max: 500                 # Frequency maximum [km/s]
n_bins: 500                   # Number of frequency bins
image_radius_bbox: 0.5        # Image radius relative to the bbox (1 Rvir)
n_pixels: 512                 # Number of image pixels
cameras:                      # Add camera directions manually
  - [0,0,1]
  - [1,0,0]
output_freq_stds: true        # Output frequency standard deviations (default: false)
output_freq2_images: true     # Frequency moment images (default: false)

Output Files

COLT writes self-describing HDF5 files organized into attributes, datasets, and module-specific groups. Scalar run metadata is generally stored as attributes, while cell, photon, spectrum, image, and convergence data are stored as datasets. Dataset units attributes record physical units where applicable. Spherical and cylindrical outputs also record the configured inner_boundary behavior as a root string attribute. See Escape Parameters for its effect on transport and projections.

Use h5ls -r output.hdf5 for a compact inventory or h5dump -A output.hdf5 to inspect attributes without loading the full file. In Python, the same structure can be explored with h5py:

import h5py

with h5py.File("output.hdf5", "r") as f:
    f.visit(print)  # List groups and datasets
    print(dict(f.attrs))  # Show root metadata

The module pages describe the configuration options that enable optional outputs, and Field Names and Descriptions documents commonly used field names and units.

The tree below provides a high-level view of the output file structure. Click a group or dataset name to view its schema. The tree includes alternatives from different modules. Only requested products are present in each output file.

output.hdf5
├── images  # Packet-sampled or stellar images
│   ├── data  # Surface brightness
│   ├── data2  # Statistical second moment
│   └── data_int, data_ext, freq, ...  # Emission variants and frequency moments
├── gas_images  # Gas continuum in escape_cont
│   └── data, data_int  # Attenuated and intrinsic surface brightness
├── proj_images  # Ray-integrated images in MCRT
│   └── data_int, data_ext  # Intrinsic and attenuated surface brightness
├── proj  # Standalone projections module
│   ├── rho_avg, T_avg, star_m_sum, ...  # Gas and stellar projected fields
│   └── <halo>  # Per-halo fields when requested
├── renders  # Transfer-function RGB and opacity
├── cubes, proj_cubes  # Sampled and ray-integrated spectral cubes
│   └── data, data_int, data_ext, ...  # Surface brightness per spectral bin
├── slits  # Spectra along image-plane slits
│   └── x, y  # Slits along the two image axes
├── radial_images, radial_cubes  # Radial profiles for each camera
│   └── data, data_int, data_ext, ...  # Broadband or spectral surface brightness
├── radial_avg, radial_cube_avg  # Angle-averaged radial profiles
│   └── data  # Broadband or spectral surface brightness
├── bin_images, proj_bin_images, bin_radial_images, bin_radial_avg  # Images and profiles by ionizing-energy bin
│   └── data, data_int, data_ext, data_ion, data_esc  # Emission and attenuation variants
├── map, mu  # Escape fractions by HEALPix direction or angular cosine
│   └── data, data2, freq, ...  # Escape fractions and statistical moments
├── flux_map, flux_mu  # Spectra by HEALPix direction or angular cosine
│   └── data  # Spectral flux
├── radial_map, cube_map, bin_radial_map  # Radial profiles over HEALPix directions
│   └── data  # Broadband, spectral, or energy-binned surface brightness
└── group, subhalo  # Per-group or per-subhalo observables
    └── map, flux_map, radial_map, radial_avg  # Angular maps and radial profiles

Cameras

The cameras data is stored at the root level and includes centering, directions, axes, and other camera parameters used in the simulation. For per-halo projections, each halo has its own camera_center dataset under proj/<halo>; camera count and orientation remain shared at the root.

Camera datasets
Dataset	Units	Type	Description	Configuration
`camera_center`	cm	f64[3]	Camera target position	`camera_center`, `focus_cameras_on_emission`

Camera attributes
Attribute	Units	Type	Description	Configuration
`n_cameras`	—	i32	Number of image planes	Camera selection

Note: i32 denotes a signed 32-bit integer and f64 a 64-bit floating-point value.

MCRT luminosities and aperture outputs

MCRT writes full-source summaries at the root of the output file. The scalar L_esc attribute gives the escaped luminosity and equals L_tot * f_esc. The L_escs dataset contains isotropic-equivalent luminosities for each camera, with shape (n_cameras,). output_mcrt_emission adds L_ints for intrinsic camera emission, and output_mcrt_attenuation adds L_exts for dust-attenuated emission. Camera luminosities are written with output_escape_fractions. output_collisions adds the corresponding _col products. All luminosities are f64 values in erg/s, with a units attribute on datasets.

Setting aperture_radius adds an aperture group while retaining the full outputs at their existing paths. Its radius attribute is in cm, and its center dataset contains the three coordinates of camera_center in cm. No aperture group is written when the radius is omitted.

The group includes the following selected counterparts of enabled outputs:

L_esc and freq_avg, freq_std, freq_skew, and freq_kurt are scalar attributes calculated from escaped packets whose outgoing rays pass within the aperture. They are available without cameras.
L_escs, L_ints, and L_exts contain camera luminosities. freq_avgs, freq_stds, freq_skews, and freq_kurts contain the requested camera frequency summaries. Intrinsic and attenuated products retain their _int and _ext suffixes, and collisional products retain _col.
fluxes and its intrinsic, attenuated, and collisional variants contain aperture-selected camera spectra. They share the root camera directions, spectral coordinates, and frequency offsets.

Luminosities and frequency summaries include the entire sampled spectrum. Camera spectra retain their configured frequency windows. Each aperture moment is normalized by its selected light. See Packet frequency moments for the weighting and directional normalization.

Angular maps, flux_avg, and spatially resolved products remain at their existing paths. Radial products and saved photon records allow additional aperture selections in postprocessing. Root-level escape fractions and source statistics remain global.

Images

The images group stores related surface-brightness arrays in MCRT, ionization, escape, and escape_cont outputs. Shared geometry is attached to the group, and each dataset carries its own units attribute:

with h5py.File("output.hdf5", "r") as f:
    images = f["images"]  # Collect (n_cameras, nx_pixels, ny_pixels) data
    data = images["data"][:]  # Surface-brightness images
    radius = images.attrs["radius"]  # Equal x/y half-widths [cm]
    units = images["data"].attrs["units"]  # erg/s/cm^2/arcsec^2

A product group is present whenever one of its datasets is requested. Its children depend on the output options; for example, proj_images can contain data_int without a data dataset. Camera parameters are described under Camera Parameters and Cameras.

Planar product groups
Group	Contents	Configuration
`images`	Primary images, moments, and sampled intrinsic/attenuated variants	`output_images` and related module options
`gas_images`	Gas continuum images in escape_cont	Gas continuum enabled; `output_emission` adds intrinsic images
`proj_images`	Intrinsic and dust-attenuated ray-integrated images in MCRT	`output_proj_emission`, `output_proj_attenuation`

All three groups carry the shared planar geometry. gas_images and proj_images also carry the integration attributes. Value units remain on individual datasets because moments and surface brightness use different units.

Image datasets, relative to their product group
Dataset	Units	Type	Description	Configuration
`data`	See `units` attribute	f64	Surface brightness `(n_cameras, nx_pixels, ny_pixels)`	`output_images: true` and at least one camera
`data2`	Same as `data` squared	f64	Event variance second moment estimate	`output_images2: true` and at least one camera
`data_int`, `data_ext`	Surface-brightness units	f64	Intrinsic or attenuation-only image	Module-specific emission and attenuation options
`freq`, `freq2`, `freq3`, `freq4`	Frequency units to the corresponding power	f64	Flux-weighted raw frequency moments in `images`	`output_freq_images` through `output_freq4_images`
`rgb`	—	f64	Frequency RGB image with a final axis of length 3	`output_rgb_images`

MCRT collision-separated variants retain the _col suffix within images and proj_images, for example data_col, data_int_col, and freq2_col. These variants require output_collisions and the corresponding output option.

The string units attribute for surface brightness is erg/s/cm^2 for non-cosmological MCRT and erg/s/cm^2/arcsec^2 for cosmological MCRT. Ionization and escape use photons/s/cm^2, while escape_cont uses erg/s/cm^2/angstrom for continuum spectral flux images. Dimensionless RGB datasets omit units. See MCRT output options, ionization output options, and escape output options for the corresponding source and transport calculations.

Shared planar geometry attributes
Attribute	Units	Type	Description	Configuration
`radius` or `radius_x`, `radius_y`	cm	f64	Half-width of the image along each axis	`image_radius`, `image_radii`
`width` or `width_x`, `width_y`	cm	f64	Full width of the image along each axis	`image_width`, `image_widths`
`n_pixels` or `nx_pixels`, `ny_pixels`	—	i32	Pixel count along each axis	`n_pixels`, `nx_pixels`, `ny_pixels`
`pixel_width` or `pixel_width_x`, `pixel_width_y`	cm	f64	Pixel width along each axis	`pixel_width`, `pixel_widths`, or image width and count
`pixel_area`	cm²	f64	Product of the two pixel widths	Image grid
`pixel_arcsec` or `pixel_arcsec_x`, `pixel_arcsec_y`	arcsec	f64	Angular pixel width along each axis	Image grid (cosmological mode only)
`pixel_arcsec2`	arcsec²	f64	Angular area of each pixel	Image grid (cosmological mode only)

Note: For each axis-dependent quantity, COLT writes a single scalar attribute when the x and y values are equal, or two axis-specific attributes otherwise. This choice is made independently for widths, radii, pixel counts, and pixel widths. For example, a rectangular image can have equal pixel widths.

Integration attributes on ray-integrated product groups
Attribute	Units	Type	Description	Configuration
`depth`	cm	f64	Full integration depth along the sightline	General Parameters
`adaptive`	—	i32	Adaptive integration flag	`adaptive`
`pixel_rtol`	—	f64	Relative integration tolerance	`pixel_rtol`

radius describes the image-plane half-width, while depth describes the full line-of-sight integration depth. The same integration attributes accompany proj_cubes and proj_bin_images. Each product carries its own integration settings.

Projection fields

The standalone projections module stores its fields in proj. Fields share the group’s planar geometry and retain individual dataset units:

with h5py.File("output.hdf5", "r") as f:
    proj = f["proj"]  # Collect (n_cameras, nx_pixels, ny_pixels) data
    rho_avg = proj["rho_avg"][:]  # Average density along sightline [g/cm^3]
    radius = proj.attrs["radius"]  # Image-plane half-width [cm]
    depth = proj.attrs["depth"]  # Integration depth [cm]

With use_all_groups or use_all_subhalos, fields are stored under proj/<halo> instead. Each halo group holds its own grid, integration depth, halo_radius, and camera_center. Shared projection settings and field counts remain on proj, alongside n_halos (i32 attribute) and halo_id (i32 dataset).

Projection datasets
Dataset	Units	Type	Description	Configuration
`<field>_<weight>`	Field/weight dependent	f64	Gas field `(n_cameras, nx_pixels, ny_pixels)`	`field_weight_pairs`
`<field>_<weight>_<hist>`	Field/weight dependent	f64	Gas histogram with an additional final bin axis	`field_weight_hists`
`star_<field>_<weight>`	Field/weight dependent	f64	Projected stellar field	`star_field_weight_pairs`

Sliced gas projections add a final axis of length n_slices. Histogram and slice metadata describe that additional axis; the shared planar geometry describes the first two spatial axes.

Projection metadata, relative to the group containing the fields
Name	Units	Type	Description	Configuration
`depth`	cm	f64 attributes	Full integration depth	Projection depth/radius options
`halo_radius`	cm	f64 attribute	Catalog halo radius used by `*_Rvir` options; independent of image extent and integration depth	Per-halo projections
`n_slices`	—	i32 attribute	Number of line-of-sight slices	`n_slices > 1`
`n_hists`	—	i32 attribute	Number of histogram fields	Histogram projections
`hist_keys`	—	i32 dataset	Histogram index for each projection	Histogram projections
`hist_names`	—	string dataset	Histogram field names	Histogram projections
`hist_logs`, `hist_n_bins`	—	i32 datasets	Log-spacing flags and bin counts	Histogram projections
`hist_mins`, `hist_maxs`	Field dependent	f64 datasets	Histogram bounds	Histogram projections

proj also holds n_projections and optional n_star_projections as i32 attributes. Integration flags (adaptive, perspective, override_volume, proj_sphere, proj_cylinder, fade, radial_fade) are i32 attributes; their enabled numeric settings are f64 attributes. Fade lengths and widths remain alongside the fields because they can vary by halo. See General Parameters for their definitions and activation options.

Spectral cubes and slits

cubes holds packet-sampled spectral images, while proj_cubes holds direct ray-integrated spectral images. Both use the planar geometry attributes with the configured cube grid. slits holds the two spectral slit directions on a shared slit grid. Each group has its own complete spectral attributes, even when its bins match the main spectrum.

Spectral camera datasets
Dataset	Units	Type	Description	Configuration
`cubes/data`	See `units`	f64	`(n_cameras, nx_pixels, ny_pixels, n_bins)`	`output_cubes`
`cubes/data_int`, `cubes/data_ext`	See `units`	f64	Intrinsic or attenuation-only sampled cube	`output_cubes` and `output_mcrt_emission` or `output_mcrt_attenuation`
`proj_cubes/data_int`, `proj_cubes/data_ext`	See `units`	f64	Intrinsic or attenuation-only ray-integrated cube	`output_proj_cube_emission`, `output_proj_cube_attenuation`
`slits/x`, `slits/y`	See `units`	f64	`(n_cameras, n_pixels, n_bins)` along each image axis	`output_slits`

proj_cubes/data_direct contains the unscattered line component with dust, enabled resonant-line extinction, and enabled electron scattering. It has the same f64 shape and units as data_ext and requires output_proj_cube_direct. Its directional finite-window luminosity fractions are stored in proj_cube_f_escs_direct. With output_collisions, the corresponding products are proj_cubes/data_direct_col and proj_cube_f_escs_direct_col.

The proj_cubes group records emission_profile (string), spectral_rtol (f64), and spectral_atol (f64). When direct light is requested, direct_extinction describes its extinction components. The tolerances are dimensionless. See Camera integration for their normalization and the direct-transfer model.

proj_cubes also carries integration attributes and can exist without cubes. Collision-separated direct projections retain the _col suffix: proj_cubes/data_int_col and proj_cubes/data_ext_col require output_collisions and the corresponding projection option. Spectral surface-brightness units are erg/s/cm^2/arcsec^2/angstrom in cosmological MCRT and erg/s/cm^2/Doppler or erg/s/cm^2/(km/s) otherwise.

Slit geometry attributes
Attribute	Units	Type	Description	Configuration
`n_pixels`	—	i32	Spatial pixels along each slit	`n_slit_pixels`
`radius`, `width`	cm	f64	Slit half-length and full length	Slit radius/width options
`aperture`	cm	f64	Slit width across the sampled axis	`slit_aperture`
`pixel_width`, `pixel_area`	cm, cm²	f64	Spatial step and rectangular pixel area	Slit grid
`aperture_arcsec`, `pixel_arcsec`, `pixel_arcsec2`	arcsec, arcsec, arcsec²	f64	Angular slit aperture, step, and area	Cosmological mode

Spectral attributes on each MCRT spectral product group
Attribute	Units	Type	Description	Configuration
`n_bins`	—	i32	Number of frequency bins	Product-specific bin count
`freq_min`, `freq_max`	Doppler or km/s	f64	Frequency bounds	Product-specific frequency range
`freq_bin_width`	Doppler or km/s	f64	Frequency-bin width	Frequency range and count
`observed_bin_width`	angstrom	f64	Observed wavelength-bin width	Cosmological mode

These attributes are also present on radial_cubes, radial_cube_avg, flux_map, cube_map, and flux_mu. The root spectral attributes remain available for the spatially integrated fluxes and flux_avg datasets. Ionizing-energy products instead share the module’s bin tables described below.

Radial images and profiles

Each radial product stores its arrays and radial geometry together. radial_images and radial_cubes retain a leading camera axis, while radial_avg and radial_cube_avg average over viewing directions.

Radial datasets
Dataset	Units	Type	Description	Configuration
`radial_images/data`	See `units`	f64	Surface brightness `(n_cameras, n_pixels)`	`output_radial_images`
`radial_images/data_int`, `radial_images/data_ext`	See `units`	f64	Intrinsic or attenuation-only radial image	Module emission/attenuation options
`radial_images/data2`, `radial_images/freq` through `freq4`, `radial_images/rgb`	As for image moments	f64	MCRT moments and RGB radial images, with a final axis of length 3 for RGB	Corresponding `output_*_radial_images` options
`radial_cubes/data`, `radial_cubes/data_int`, `radial_cubes/data_ext`	See `units`	f64	Spectral surface brightness `(n_cameras, n_pixels, n_bins)`	`output_radial_cubes` and MCRT emission/attenuation options
`radial_avg/data`	See `units`	f64	Angle-averaged surface brightness `(n_pixels)`	`output_radial_avg`
`radial_cube_avg/data`	See `units`	f64	Angle-averaged spectral profile `(n_pixels, n_bins)`	`output_radial_cube_avg`

Radial image and average units follow the image reference for the active module. radial_cubes and radial_cube_avg use the spectral surface-brightness units and carry spectral attributes.

Radial geometry attributes
Attribute	Units	Type	Description	Configuration
`n_pixels`	—	i32	Number of radial bins	Product-specific pixel count
`radius`	cm	f64	Outer radius	Product-specific radius
`pixel_width`	cm	f64	Uniform radial-bin width	Linear spacing
`min_radius`	cm	f64	Central disk radius; remaining bins are logarithmic	Positive minimum-radius option
`pixel_areas`	cm²	f64[n_pixels]	Area of each radial bin	Radial grid
`pixel_arcsec`	arcsec	f64	Uniform angular radial-bin width	Linear spacing, cosmological mode
`pixel_arcsec2`	arcsec²	f64[n_pixels]	Angular area of each radial bin	Cosmological mode

pixel_areas and pixel_arcsec2 are array attributes, shared by all camera directions, spectral bins, or halos in the product. Logarithmic grids write min_radius in place of pixel_width and omit pixel_arcsec.

Ionizing-energy images

Ionization and escape store energy-resolved images in their own groups. They carry an i32 n_bins attribute and the appropriate planar or radial geometry. The final dataset axis uses the shared energy edges in bin/edges_eV, and the remaining ion and energy tables stay under bin.

Ionizing-energy image datasets
Dataset	Units	Type	Description	Configuration
`bin_images/data`	photons/s/cm²	f64	`(n_cameras, nx_pixels, ny_pixels, n_bins)`	`output_bin_images`
`bin_images/data_int`, `bin_images/data_ext`	photons/s/cm²	f64	Intrinsic or attenuation-only bin image	Module emission/attenuation options
`proj_bin_images/data_int`, `proj_bin_images/data_ext`	photons/s/cm²	f64	Intrinsic or dust-attenuated ray-integrated image	`output_proj_bin_emission`, `output_proj_bin_attenuation`
`proj_bin_images/data_ion`, `proj_bin_images/data_esc`	photons/s/cm²	f64	Ionization-only or fully attenuated ray-integrated image	`output_proj_bin_ionization`, `output_proj_bin_escape`
`bin_radial_images/data`, `bin_radial_images/data_int`, `bin_radial_images/data_ext`	photons/s/cm²	f64	Radial profile `(n_cameras, n_pixels, n_bins)`	`output_bin_radial_images` and module emission/attenuation options
`bin_radial_avg/data`	photons/s/cm²	f64	Angle-averaged profile `(n_pixels, n_bins)`	`output_bin_radial_avg`

bin_images and proj_bin_images use the configured cube grid and the planar attribute names. proj_bin_images also carries integration attributes. Radial products use the radial attributes. These products integrate photon rates within each energy bin, i.e., their units are not divided by the bin width.

Ionization files also include bin/names when there are fewer than 300 bins. This one-dimensional string dataset contains n_bins + 1 energy-edge names aligned with bin/edges_eV, including the final max edge.

Directional maps

HEALPix products store n_side and n_pix as i32 attributes on each product group, where n_pix = 12 * n_side**2. Angular-cosine products use an i32 n_mu attribute instead, with uniform bins spanning \(-1 \leq \mu \leq 1\). Each map retains its own angular resolution, independently of the camera grid and other map products.

Directional datasets
Dataset	Units	Type	Description	Configuration
`map/data`, `mu/data`	—	f64	Directional escape fractions	`output_map`, `output_mu`
`map/data2`, `mu/data2`	—	f64	Second moment of packet contributions	`output_map2`, `output_mu2`
`map/freq` through `freq4`, `mu/freq` through `freq4`	Frequency units to the corresponding power	f64	Flux-weighted raw frequency moments	Corresponding MCRT frequency-moment options
`map/rgb`	—	f64	RGB map with a final axis of length 3	`output_rgb_map`
`flux_map/data`, `flux_mu/data`	See `units`	f64	Spectral flux `(n_pix, n_bins)` or `(n_mu, n_bins)`	`output_flux_map`, `output_flux_mu`
`radial_map/data`	See `units`	f64	Radial surface brightness `(n_pix, n_pixels)`	`output_radial_map`
`cube_map/data`	See `units`	f64	Radial spectral surface brightness `(n_pix, n_pixels, n_bins)`	`output_cube_map`
`bin_radial_map/data`	photons/s/cm²	f64	Energy-bin radial surface brightness `(n_pix, n_pixels, n_bins)`	`output_bin_radial_map`

flux_map, flux_mu, and cube_map carry the full MCRT spectral attributes. bin_radial_map carries n_bins and uses the shared bin/edges_eV energy table. Dimensionless escape fractions, statistical second moments, and RGB values omit units.

HEALPix radial maps

radial_map, cube_map, and bin_radial_map combine the directional attributes above with the radial geometry attributes. Geometry is attached to the group and units to its data dataset:

with h5py.File("output.hdf5", "r") as f:
    radial_map = f["radial_map"]
    data = radial_map["data"][:]
    radius = radial_map.attrs["radius"]  # Outer radius [cm]
    pixel_areas = radial_map.attrs["pixel_areas"]  # Radial-bin areas [cm^2]

The radial-bin areas are shared by every HEALPix direction and spectral bin in the product.

Halo products

MCRT and ionization use the same product layout inside group and subhalo. For example, group/map/data, group/radial_map/data, and group/radial_avg/data have a leading halo axis. Each product group contains its own angular, radial, or spectral attributes, and every halo of the same catalog type shares that product’s grid. Halo positions and other catalog properties remain on their existing parent groups.

map can also contain data_vir and data_gal for the virial and galaxy apertures, and data2_vir and data2_gal for their statistical second moments. Those arrays are controlled by the corresponding halo output options and can be present without observer-frame data. MCRT halo maps also support frequency moments, and flux_map/data stores their spectra.

Other module outputs

The product tables above describe shared transport-camera outputs. Output layout lists the atom module’s separate line-network and packet datasets. reionization grids describes its flat proj_<field>_<weight> arrays and cosmological unit scalings. ray extraction documents the per-field, per-ray layout, including variable-width photon-density and elemental-abundance arrays. These module-specific files should not be interpreted using the planar camera axis conventions.

Integer counts and indices normally use i32. Configured wide cell/neighbor indices and snapshot identifiers can use i64. Standard transport arrays use f64, while the reionization image writer and selected snapshot field storage use f32. HDF5 readers should inspect the actual datatype rather than inferring it from a product name. An array without a units attribute is not necessarily dimensionless.