Output Files and Format

Controlling Outputs

A SLUG simulation produces output files whose names, locations, and types are controlled by the model_name, out_dir, and output_mode keywords in the Output Control Keywords section of The SLUG Input Deck.

The outputs are written in either HDF5 or ASCII format, depending on whether output_mode is set to "h5" (or "h5divided") or ascii. ASCII format is intended for small, quick simulations with small outputs, and is not recommended for large, production-scale runs. HDF5 format is recommended for all but the smallest runs, and is the only format that the Python interface can read, as detailed below. The "h5divided" option produces outputs that are identical to "h5" except that the outputs from different threads are left in separate HDF5 files rather than consolidated into a single one, which is preferable for very large runs where a monolithic HDF5 file would be unwieldy; the slugpy interface can read both formats transparently.

Outputs are placed in the directory specified by out_dir in the parameter file, which defaults to the current working directory if not specified. The output file name is constructed from the model_name keyword in the parameter file. For h5 output, the output file is named <model_name>.h5, while for h5divided output the output files are placed in a directory named <model_name>, with each thread’s output stored in a separate file in that directory called thread_<NNNN>.h5 where <NNNN> is the thread number. For ASCII output, there will be multiple file outputs, whose names follow the pattern <model_name>_<output_type>.txt. Which output types are produced is controlled by the Output Control Keywords section of The SLUG Input Deck.

If SLUG was built and run under MPI (see Running SLUG With MPI), each process’s (“rank’s”) own output is likewise kept separate – even for a single-rank run, since this naming is a property of the build, not of how many ranks a given run actually used – named rank_<NNNN>.h5 where <NNNN> is the rank number – or, if OpenMP threading is also in use within each rank, rank_<NNNN>_thread_<NNNN>.h5, combining both numbers. This naming only appears with h5divided output, or transiently with checkpointed h5 output before a checkpoint is consolidated; once an h5 run finishes, every rank’s and thread’s output is merged into the single <model_name>.h5 (or <model_name>_chk<NNNNN>.h5) file described above, and the per-rank/thread files are removed.

A full description of the format of the outputs is provided below.

Reading Outputs

Outputs in ASCII mode are simple text files that can be read with any text editor, and should be self-explanatory (though full details are provided below). To read outputs in HDF5 format, you can use any HDF5 reader, but the recommended approach is to use slugpy. A simulation output in HDF5 format can be read into Python simply by doing:

import slugpy
sim_result = slugpy.read("path/model_name")

The reader will automatically detect whether the output format is h5 or h5divided and read the outputs appropriately. The result returned by slugpy.read is a slugpy.slug_reader object, which is a lazy-reader that can be used safely even for very large outputs that will not fit in memory at once. See slugpy for details on how to use the slug_reader object to inspect the outputs of a simulation.

Full Documentation of the SLUG Output Format

Below is a full listing of every dataset and attribute that SLUG’s HDF5 and ASCII output can contain. Which of these actually appear in a given run’s own output depends on the parameter file used to produce it – e.g. cluster_phot (or <model_name>_cluster_phot.txt) only exists if photometry was requested, and a cluster-type simulation never produces any of the galaxy* outputs at all, since it has no Galaxy object – see The SLUG Input Deck for the keywords that control this.

HDF5 Format

Every dataset described below also has its own units attribute (a string, e.g. "Msun", or an empty string for a dimensionless quantity); rather than list this attribute separately under every single dataset, its value is simply given alongside each dataset below.

Top-level Attributes

These attributes are set directly on the output file itself, rather than on any group within it.

slug-hash: The git commit hash of the SLUG build that produced this file.
date: The local date (YYYY-MM-DD) on which this file was created.
time: The local time (HH:MM:SS) at which this file was created.
rng_state: The serialized state of the random number generator at the moment this file was opened.
trials_completed: The number of trials actually completed and written to this file (or, for one checkpoint of a checkpointed run, to that checkpoint) by the time it was closed. Under MPI, this is a run-wide total (the sum across every rank), kept identical in every rank’s own file, not just this one rank’s own share – see Running SLUG With MPI.
restart_uid: An internal identifier used to keep cluster/star ID numbering consistent across a run resumed with --restart; not generally meaningful on its own. Under MPI, each rank’s own output file has its own restart_uid (unlike trials_completed/max_trial, which are the same run-wide total in every rank’s file), since each rank’s ID numbering runs in its own, non-overlapping range – see Running SLUG With MPI.
max_trial: The largest trial number actually written to this file. Used internally when resuming a run from a checkpoint, so that trial numbering in the resumed session never collides with a trial number a previous session already used. Under MPI, this is likewise a run-wide value (the largest trial number any rank wrote), kept identical in every rank’s own file – see Running SLUG With MPI.

The `input_deck` Group

Holds a single dataset recording the parameter file that produced this simulation.

toml (string scalar): The full text of the TOML input deck used for this run, re-serialized – lets the exact parameters behind a given output file be recovered from the file itself. Empty if the SimControls driving this run was built directly from Python with no backing input deck at all.

The `clusters` Group

Holds one row per individually-tracked (stochastic) star cluster ever formed across every trial, whether or not that cluster survived to be observed at any output time. For a cluster-type simulation this is exactly one row per trial (each trial forms exactly one cluster); for a galaxy-type simulation, the number of rows varies from trial to trial, depending on the star formation history and the cluster mass function. Every dataset below has shape (n_clusters,), where n_clusters is this total row count.

trial (unitless integer): The trial number this cluster belongs to.
uid (unitless integer): This cluster’s unique identifier.
target_mass (Msun): The cluster mass drawn from the cluster mass function.
birth_mass (Msun): The cluster’s actual initial stellar mass, as realized by stochastically sampling individual stars from the IMF – generally close to, but not exactly equal to, target_mass, since a discrete set of stellar masses cannot sum to an arbitrary target exactly.
form_time (yr): The time at which this cluster formed. Always 0 for a cluster-type simulation, which forms its single population instantaneously.
feh (unitless): This cluster’s [Fe/H] metallicity.
rng (string): The serialized state of the random number generator at the moment this cluster was drawn, so that its own stochastic realization can be reproduced independently of the rest of the run.
A_V (mag; only present if extinct.model was set): The V-band extinction applied to this cluster’s starlight.
A_V_neb (mag; only present if extinct.model was set): The V-band extinction applied to this cluster’s nebular emission: A_V times a factor drawn from extinct.neb_factor (see Extinction Keywords), or equal to A_V if that keyword was not given.

The `cluster_spectra` Group

Holds the spectra of individually-tracked clusters. There is one row (in every extensible dataset below) per (cluster, output time) pair at which a spectrum was actually written; call this common row count n_rows.

Fixed wavelength/line grids, shared by every row:

wl (Angstrom, shape (n_wl,)): The rest-frame wavelength grid that every row’s spec/spec_neb value is tabulated on.
wl_extinct (Angstrom, shape (n_wl_extinct,); only if extinct.model was set): The wavelength grid for spec_extinct/spec_neb_extinct – may cover a narrower range than wl, since an extinction curve need not extend across the full spectral grid.
line_wl (Angstrom, shape (n_lines,); only if a nebular emission grid was requested): The rest-frame wavelength of each nebular emission line tabulated in neb_lines/neb_lines_extinct.
line_label (string, shape (n_lines,); only if a nebular emission grid was requested): A human-readable label (species/transition) identifying each entry of line_wl, in the same order.

Per-row datasets:

trial (unitless integer, shape (n_rows,)): The trial number this row belongs to.
time (yr, shape (n_rows,)): The output time this spectrum was computed at.
uid (unitless integer, shape (n_rows,)): The unique identifier of the cluster this spectrum belongs to.
spec (erg/(s Angstrom), shape (n_rows, n_wl)): The cluster’s un-extincted spectrum.
spec_extinct (erg/(s Angstrom), shape (n_rows, n_wl_extinct); only if extinct.model was set): The same spectrum after applying dust extinction.
spec_neb (erg/(s Angstrom), shape (n_rows, n_wl); only if a nebular emission grid was requested): The un-extincted spectrum including the nebular continuum.
spec_neb_extinct (erg/(s Angstrom), shape (n_rows, n_wl_extinct); only if both a nebular emission grid and extinct.model were requested): The nebular-inclusive spectrum after applying dust extinction.
neb_lines (erg/s, shape (n_rows, n_lines); only if a nebular emission grid was requested): The luminosity of each nebular emission line listed in line_wl/line_label, without extinction applied.
neb_lines_extinct (erg/s, shape (n_rows, n_lines); only if both a nebular emission grid and extinct.model were requested): The same line luminosities after applying dust extinction.

The `cluster_phot` Group

Holds the photometry of individually-tracked clusters, present only if photometry (phot.filters) or the bolometric luminosity was requested. There is one row per (cluster, output time) pair at which photometry was actually written; call this row count n_rows.

filters (attribute, array of strings): The ordered list of filter names corresponding to the columns of phot (and, where present, phot_extinct/phot_neb/phot_neb_extinct, excluding their own final entry – see below). Includes "Lbol" as its own final entry if the bolometric luminosity was requested.
trial (unitless integer, shape (n_rows,)): The trial number.
time (yr, shape (n_rows,)): The output time this photometry was computed at.
uid (unitless integer, shape (n_rows,)): The unique identifier of the cluster this photometry belongs to.
phot (shape (n_rows, n_filters); units given per-column by this dataset’s own units attribute, an array of strings matching filters, since different filters can report in different units): The un-extincted photometry in every requested filter, including a final "Lbol" column if the bolometric luminosity was requested.
phot_extinct (shape (n_rows, n_real_filters); only if extinct.model was set and at least one real filter was requested): The same photometry after applying dust extinction. Never includes an "Lbol" column: the bolometric luminosity is computed directly from the stellar tracks, not from the (extincted or nebular-inclusive) spectrum, so it has no extincted counterpart – n_real_filters excludes it even when phot itself includes it.
phot_neb (shape (n_rows, n_real_filters); only if a nebular emission grid was requested and at least one real filter was requested): The un-extincted photometry including the nebular continuum’s contribution.
phot_neb_extinct (shape (n_rows, n_real_filters); only if a nebular emission grid, extinct.model, and at least one real filter were all requested): The nebular-inclusive photometry after applying dust extinction.

Extinction curves cover only a limited range of wavelengths (for example, the Calzetti curves do not extend below 912 Angstrom), and the extincted spectrum is undefined outside that range. A value in phot_extinct or phot_neb_extinct is therefore NaN for any filter whose passband extends, even partly, past the edge of the extinction curve’s wavelength coverage, since the extincted photometry cannot be computed for that filter. For example, the ionizing-photon filter Q(HI) is NaN in phot_extinct when using a Calzetti curve, provided the stellar spectral library extends below 912 Angstrom, as libraries that include ionizing radiation do. If the passband also extends beyond the stellar spectral library’s wavelength range, only the part within the library’s range counts. A filter lying entirely outside the library’s range is never NaN, whether or not extinction is enabled: instead, a photon-count filter (e.g. Q(HI)) reports zero photons/s, and an energy-flux filter reports zero flux, which appears as an infinite magnitude if the photometric system is a magnitude system (AB, ST, or Vega).

The `cluster_yields` Group

Holds the nucleosynthetic yields of individually-tracked clusters, present only if at least one yield channel was requested (yields.channel1) and output.write_cluster_yields was not set to false – see Yields for how yields are computed. There is one row per (cluster, output time) pair; call this row count n_rows. Each row gives the total mass of each isotope produced by every star in the cluster that has died by that output time. Thus, if yields.no_decay is true, the yields of a given cluster never decrease from one output time to the next; otherwise the mass of an unstable isotope can also decrease as it decays. The isotopes, channels, models, and decomposed attributes describe how to interpret the columns of yields.

isotopes (attribute, array of strings): The isotopes for which yields are tabulated, each labeled by its element symbol followed by its mass number (e.g. "Fe56"), sorted by increasing atomic number and then increasing mass number. This is the set of isotopes selected by yields.isotopes, including the isotopes SLUG adds to it because they are linked to a listed isotope by radioactive decay (see Yields Control Keywords) or, if yields.isotopes was not given, every isotope tabulated by any requested yield model, plus their radioactive decay products.
channels (attribute, array of strings): The type of each requested yield channel (see Yields), in the order they were given in the input deck, i.e. channels[i] is the channel keyword of yields.channel<i+1>.
models (attribute, array of strings): The yield model used for each requested yield channel, in the same order as channels.
decomposed (attribute, boolean, stored as the integer 0 or 1): The value of yields.channel_decomposed, which determines the layout of yields.
trial (unitless integer, shape (n_rows,)): The trial number.
time (yr, shape (n_rows,)): The output time these yields were computed at.
uid (unitless integer, shape (n_rows,)): The unique identifier of the cluster these yields belong to.
yields (Msun, shape (n_rows, n_cols)): The yield of each isotope. If decomposed is true, n_cols is the number of channels times the number of isotopes, and the columns are ordered channel-major: the first len(isotopes) columns are the yields of every isotope from the first channel, the next len(isotopes) columns are the yields of every isotope from the second channel, and so on. That is, column i * len(isotopes) + j holds the yield of isotopes[j] from channels[i], using models[i]. If decomposed is false, n_cols is just the number of isotopes, and column j holds the yield of isotopes[j] summed over all channels. Whether these are the amounts of each isotope present at time or the total amounts ever produced depends on yields.no_decay.

The `cluster_feedback` Group

Holds the feedback (supernovae and stellar winds) of individually-tracked clusters, present only if output.write_cluster_feedback was not set to false – see Feedback for how feedback is computed. There is one row per (cluster, output time) pair; call this row count n_rows. Every dataset below has shape (n_rows,).

trial (unitless integer): The trial number.
time (yr): The output time this feedback was computed at.
uid (unitless integer): The unique identifier of the cluster this feedback belongs to.
n_sn (unitless): The cumulative number of core-collapse supernovae that have occurred in the cluster by time. This includes a contribution from the non-stochastic part of the stellar population, and thus need not be an integer (see Feedback).
mdot_wind (Msun/yr): The instantaneous mass flux of stellar winds from every star in the cluster that is alive at time.
pdot_wind (Msun km/(s yr)): The instantaneous momentum flux of those winds.
edot_wind (Lsun): The instantaneous kinetic energy flux of those winds.

The `galaxy` Group

Present only for a galaxy-type simulation. Holds one row per (trial, output time) pair actually written; call this row count n_rows (ordinarily n_trial times the number of output times per trial, though a stochastic output-time distribution can make different trials write different numbers of rows – see The SLUG Input Deck). Every dataset below has shape (n_rows,).

trial (unitless integer): The trial number.
time (yr): The output time this row was recorded at.
target_mass (Msun): The total stellar mass the galaxy’s own star formation history says should have formed by this time.
actual_mass (Msun): The total stellar mass actually realized (summed over every individually-tracked cluster and the continuous stellar population, if any) by this time.

The `galaxy_spectra` Group

Present only for a galaxy-type simulation with a spectral synthesizer requested. Identical in structure and meaning to the cluster_spectra group above – including its wl/wl_extinct/line_wl/line_label, spec/spec_extinct/spec_neb/spec_neb_extinct, and neb_lines/neb_lines_extinct datasets, all with the same meaning – but with no uid dataset, since a galaxy has no individual identity the way a cluster does: each row is one (trial, output time) pair (the whole galaxy’s own integrated spectrum), not one (cluster, output time) pair.

The `galaxy_phot` Group

Present only for a galaxy-type simulation with photometry or the bolometric luminosity requested. Identical in structure and meaning to the cluster_phot group above – including its filters attribute and phot/phot_extinct/phot_neb/phot_neb_extinct datasets – but with no uid dataset: each row is one (trial, output time) pair (the whole galaxy’s own integrated photometry), not one (cluster, output time) pair.

The `galaxy_yields` Group

Present only for a galaxy-type simulation with at least one yield channel requested and output.write_galaxy_yields not set to false. Identical in structure and meaning to the cluster_yields group above – including its isotopes, channels, models, and decomposed attributes and its yields dataset – but with no uid dataset: each row is one (trial, output time) pair (the yields of the whole galaxy), not one (cluster, output time) pair. The yields in each row are summed over every star that has died in the galaxy by that time, whether it formed in an individually-tracked cluster (including clusters that have since disrupted), as a field star, or as part of the continuous (non-stochastic) stellar population.

Note that in a galaxy-type simulation, the rows of cluster_yields are written only for clusters that have not yet disrupted at the output time in question, even though the yields of disrupted clusters are still included in the galaxy_yields totals.

The `galaxy_feedback` Group

Present only for a galaxy-type simulation with output.write_galaxy_feedback not set to false. Identical in structure and meaning to the cluster_feedback group above – including its n_sn, mdot_wind, pdot_wind, and edot_wind datasets – but with no uid dataset: each row is one (trial, output time) pair (the feedback of the whole galaxy), not one (cluster, output time) pair. The supernova count in each row is summed over every star that has exploded in the galaxy by that time, and the wind fluxes over every star alive at that time, whether it formed in an individually-tracked cluster (including clusters that have since disrupted), as a field star, or as part of the continuous (non-stochastic) stellar population.

As for yields, in a galaxy-type simulation the rows of cluster_feedback are written only for clusters that have not yet disrupted at the output time in question, even though the feedback of disrupted clusters is still included in the galaxy_feedback totals.

The `cluster_cloudy` Group

Not produced by SLUG itself. Instead, this group is created (and appended to) by slugpy’s own run_cloudy method, run with spec_type="cluster", which post-processes one or more of this file’s cluster_spectra rows through Cloudy to compute a photoionized nebula’s emergent continuum and emission lines – see Cloudy Nebular Processing for details of that process. Present only once run_cloudy has actually been called on this file at least once. There is one row per (cluster, output time) pair with a stored Cloudy run; call this row count n_rows.

uid (unitless integer, shape (n_rows,)): The unique identifier of the cluster this row’s Cloudy run was computed from.
time (yr, shape (n_rows,)): The output time of the spectrum this row’s Cloudy run was computed from.
nII (cm^-3, shape (n_rows,)): The number density of H nuclei assumed for this row’s HII region.
r0 (cm, shape (n_rows,)): The inner (wind-cleared cavity) radius assumed for this row’s HII region.
r1 (cm, shape (n_rows,)): The outer radius assumed for this row’s HII region.
U (unitless, shape (n_rows,)): The volume-averaged ionization parameter of this row’s HII region.
U0 (unitless, shape (n_rows,)): The ionization parameter at the inner radius r0 of this row’s HII region.
Omega (unitless, shape (n_rows,)): The dimensionless wind parameter of this row’s HII region.
wl (Angstrom, shape (n_wl_cloudy,); only present once at least one row has continuum output): The wavelength grid shared by spec_inc/spec_trans/spec_emit/spec_trans_emit below. Cloudy’s own output grid always shares the same maximum wavelength and spacing across runs, but the minimum wavelength can vary; this grid is the longest one seen among rows with continuum output, and rows whose own grid was shorter are zero-padded at the low-wavelength end.
spec_inc, spec_trans, spec_emit, spec_trans_emit (erg/(s Angstrom), shape (n_rows, n_wl_cloudy)): This row’s Cloudy-computed incident, transmitted, emitted, and transmitted-plus-emitted continuum, respectively. A row with no continuum output of its own (including any row written before the first row with continuum output was ever stored) is all zero.
line_wl (Angstrom, shape (n_lines_cloudy,); only present once at least one row has line output): The rest-frame wavelength of every distinct emission line reported by any stored row’s Cloudy run – since different runs need not report the same set of lines, this is the union of every one seen so far, sorted by wavelength.
line_label (string, shape (n_lines_cloudy,)): A short label identifying the species/transition of each entry of line_wl, in the same order.
line_lum (erg/s, shape (n_rows, n_lines_cloudy)): This row’s own Cloudy-reported luminosity for each line in line_wl/line_label, without extinction applied; zero for any line that row’s own run did not report, including an all-zero row for a row with no line output at all.

Since it is written by slugpy rather than by SLUG itself, cluster_cloudy has no ASCII counterpart: Cloudy post-processing results are only ever stored in an HDF5 output file.

The `galaxy_cloudy` Group

Identical in structure and meaning to the cluster_cloudy group above – including its physical-condition, continuum, and line datasets – except written by run_cloudy(spec_type="galaxy") from this file’s own galaxy_spectra rows, and with a trial dataset (the trial number of the row’s own galaxy spectrum) in place of uid, since a galaxy has no individual identity the way a cluster does.

ASCII Format

Every ASCII output file begins with two header rows (column names, then column units) and a row of dashes, followed by one data row per line, with columns laid out as fixed-width fields. Where a group above splits one physical quantity across several HDF5 datasets of different shapes (e.g. a 2D spec array alongside 1D trial/time/uid arrays), the corresponding ASCII file instead lays out one row per (cluster or trial, output time, wavelength or line) combination, repeating the trial/time/uid columns on every such row – there is no way to represent a ragged, multi-dimensional structure in a flat text table. Because of this, spectra and nebular-line files are generally far longer, row for row, than their HDF5 counterparts’ own row counts would suggest.

The `<model_name>_summary.txt` File

Always written, exactly once, regardless of what other output was requested. Holds the same top-level information the HDF5 format stores as file attributes, as plain key value lines, followed by the input deck’s own text in full:

slug-hash: The git commit hash of the SLUG build that produced this run.
date: The local date (YYYY-MM-DD) this run started.
time: The local time (HH:MM:SS) this run started.
rng_state: The serialized state of the random number generator at the start of the run.
input_deck: A label line, followed by the full text of the TOML input deck used for this run. Unlike HDF5’s trials_completed/restart_uid/ max_trial attributes, ASCII output has no corresponding fields, since checkpointing (and, with it, --restart) is only supported with HDF5 output.

The `<model_name>_clusters.txt` File

One row per individually-tracked cluster – see the clusters HDF5 group above for exactly which clusters that means and what each column means. Columns, in order: trial, uid, target_mass (Msun), birth_mass (Msun), form_time (yr), feh, a_v and a_v_neb (mag; only if extinct.model was set; the HDF5 group’s A_V and A_V_neb), rng.

The `<model_name>_cluster_spectra.txt` File

One row per (cluster, output time, wavelength) combination – i.e. every wavelength point of every spectrum gets its own row. Columns, in order: trial, time (yr), uid, wl (Angstrom), spec (erg/(s Angstrom)), spec_ex (erg/(s Angstrom); only if extinct.model was set), spec_neb (erg/(s Angstrom); only if a nebular emission grid was requested), spec_neb_ex (erg/(s Angstrom); only if both were requested). See the cluster_spectra HDF5 group above for what each column means – spec_ex/spec_neb/spec_neb_ex here correspond to that group’s own spec_extinct/spec_neb/spec_neb_extinct datasets.

The `<model_name>_cluster_neb_lines.txt` File

Only written if a nebular emission grid was requested. One row per (cluster, output time, emission line) combination. Columns, in order: trial, time (yr), uid, line_label (identifying which emission line this row is), wl (Angstrom, that line’s rest-frame wavelength), line_lum (erg/s, that line’s luminosity without extinction), line_lum_ex (erg/s; only if extinct.model was set, that line’s luminosity with extinction applied). Corresponds to the cluster_spectra HDF5 group’s own line_wl/line_label/neb_lines/neb_lines_extinct datasets.

The `<model_name>_cluster_phot.txt` File

Only written if photometry or the bolometric luminosity was requested. One row per (cluster, output time) pair. Columns, in order: trial, time (yr), uid, then one column per requested filter (named after the filter itself, e.g. HST.WFC3_UVIS1.F555W, or Lbol if the bolometric luminosity was requested), giving the un-extincted photometry. If extinct.model was set, one further <filter>_ex column follows per real filter (excluding Lbol, which has no extincted counterpart); if a nebular emission grid was requested, one further <filter>_neb column follows per real filter; if both were requested, one further <filter>_neb_ex column follows per real filter. See the cluster_phot HDF5 group above for what each of these means – <filter>_ex/<filter>_neb/<filter>_neb_ex here correspond to that group’s own phot_extinct/phot_neb/phot_neb_extinct datasets.

The `<model_name>_cluster_yields.txt` File

Only written if at least one yield channel was requested and output.write_cluster_yields was not set to false. One row per (cluster, output time) pair. Columns, in order: trial, time (yr), uid, then one column per isotope (if yields.channel_decomposed is false) or one column per (channel, isotope) pair (if it is true, the default), each in units of Msun. An isotope column is named after the isotope’s label, e.g. Fe56. A (channel, isotope) column is named <channel><N>_<isotope>, where <channel> is the channel type (ccsn or massive_star_winds), <N> is the channel’s own number in the input deck (so channel2 gives <N> = 2, even if it is the only channel of its type), and <isotope> is the isotope label, e.g. ccsn1_Fe56 or massive_star_winds2_H1. Columns are ordered channel-major, with the isotopes in each channel sorted by increasing atomic number and then mass number, matching the ordering of the yields dataset described in the cluster_yields HDF5 group above. Unlike the HDF5 output, the ASCII file has no separate record of which model was used for each channel; this is recorded in the input deck copy in the summary file.

The `<model_name>_cluster_feedback.txt` File

Only written if output.write_cluster_feedback was not set to false. One row per (cluster, output time) pair. Columns, in order: trial, time (yr), uid, n_sn, mdot_wind (Msun/yr), pdot_wind (Msun km/s/yr), edot_wind (Lsun). See the cluster_feedback HDF5 group above for what each column means. In the row of units in the header, the units of pdot_wind are written as Msun_km/s/yr, without spaces, so that the units row splits into exactly one token per column.

The `<model_name>_galaxy.txt` File

Only written for a galaxy-type simulation. One row per (trial, output time) pair. Columns, in order: trial, time (yr), target_mass (Msun), actual_mass (Msun) – see the galaxy HDF5 group above for what each means.

The `<model_name>_galaxy_spectra.txt` File

Only written for a galaxy-type simulation with a spectral synthesizer requested. Identical to <model_name>_cluster_spectra.txt above – same columns and meanings – except with no uid column, and one row per (trial, output time, wavelength) combination rather than (cluster, output time, wavelength), since each row describes the whole galaxy’s own integrated spectrum.

The `<model_name>_galaxy_neb_lines.txt` File

Only written for a galaxy-type simulation with a nebular emission grid requested. Identical to <model_name>_cluster_neb_lines.txt above, except with no uid column, and one row per (trial, output time, emission line) combination rather than (cluster, output time, emission line).

The `<model_name>_galaxy_phot.txt` File

Only written for a galaxy-type simulation with photometry or the bolometric luminosity requested. Identical to <model_name>_cluster_phot.txt above, except with no uid column, and one row per (trial, output time) pair describing the whole galaxy’s own integrated photometry rather than one individual cluster’s.

The `<model_name>_galaxy_yields.txt` File

Only written for a galaxy-type simulation with at least one yield channel requested and output.write_galaxy_yields not set to false. Identical to <model_name>_cluster_yields.txt above – same columns and meanings – except with no uid column, and one row per (trial, output time) pair describing the yields of the whole galaxy rather than one individual cluster’s.

The `<model_name>_galaxy_feedback.txt` File

Only written for a galaxy-type simulation with output.write_galaxy_feedback not set to false. Identical to <model_name>_cluster_feedback.txt above – same columns and meanings – except with no uid column, and one row per (trial, output time) pair describing the feedback of the whole galaxy rather than of one individual cluster.

Output Files and Format

Controlling Outputs

Reading Outputs

Full Documentation of the SLUG Output Format

HDF5 Format

Top-level Attributes

The input_deck Group

The clusters Group

The cluster_spectra Group

The cluster_phot Group

The cluster_yields Group

The cluster_feedback Group

The galaxy Group

The galaxy_spectra Group

The galaxy_phot Group

The galaxy_yields Group

The galaxy_feedback Group

The cluster_cloudy Group

The galaxy_cloudy Group

ASCII Format

The <model_name>_summary.txt File

The <model_name>_clusters.txt File

The <model_name>_cluster_spectra.txt File

The <model_name>_cluster_neb_lines.txt File

The <model_name>_cluster_phot.txt File

The <model_name>_cluster_yields.txt File

The <model_name>_cluster_feedback.txt File

The <model_name>_galaxy.txt File

The <model_name>_galaxy_spectra.txt File

The <model_name>_galaxy_neb_lines.txt File

The <model_name>_galaxy_phot.txt File

The <model_name>_galaxy_yields.txt File

The <model_name>_galaxy_feedback.txt File