input.default.toml

# Global simulation parameters
[simulation]
  # Name of the simulation
  #   @required
  #   @type: string
  #   @note: The name is used for the output files
  name    = ""
  # Simulation engine to use
  #   @required
  #   @type: string
  #   @enum: "SRPIC", "GRPIC"
  engine  = "SRPIC"
  # Max runtime in physical (code) units
  #   @required
  #   @type: float [> 0]
  #   @example: 1e5
  runtime = 1.0

  # Parameters specific to domain decomposition
  [simulation.domain]
    # Number of domains
    #   @type: int
    #   @default: 1 [no MPI]; MPI_SIZE [MPI]
    number        = 1
    # Decomposition of the domain (for MPI) in each of the directions
    #   @type: array<int> [size 1 :->: 3]
    #   @default: [-1, -1, -1]
    #   @note: -1 means the code will determine the decomposition in the
    #          specific direction automatically
    #   @note: Automatic detection is either done by inference from # of MPI
    #          tasks, or by balancing the grid size on each domain
    #   @example: [2, 2, 2] (total of 8 domains)
    decomposition = [-1, -1, -1]

    # Diffusion-style dynamic load balancing. Domain boundaries between MPI
    # neighbors are nudged to equalize the active-particle count per rank. All
    # inter-rank traffic uses only the existing nearest-neighbor field/particle
    # communication paths.
    [simulation.domain.load_balance]
      # Enable dynamic load balancing
      #   @type: bool
      #   @default: false
      enable     = false
      # Run the rebalancer every `interval` timesteps (0 disables)
      #   @type: int
      #   @default: 0
      interval   = 0
      # Dimensions along which load is redistributed (1 = x1, 2 = x2, 3 = x3)
      #   @type: array<int> [subset of {1, 2, 3}]
      #   @default: [1]
      #   @enum: 1, 2, 3
      dimensions = [1]
      # Skip rebalancing along a dim when (max - min) / mean of the per-slice
      # particle count is below this fraction
      #   @type: float
      #   @default: 0.1
      tolerance  = 0.1
      # Maximum cell-shift per interior boundary per event; clamped at compile
      # time to N_GHOSTS so the migrating field strip is already cached in the
      # rank's ghost zone.
      #   @type: int
      #   @default: N_GHOSTS
      max_shift  = 0

# Parameters specific to grid geometry
[grid]
  # Spatial resolution of the grid
  #   @required
  #   @type: array<uint> [size 1 :->: 3]
  #   @note: Dimensionality is inferred from the size of this array
  #   @example: [1024, 1024, 1024]
  resolution = [1]
  # Physical extent of the grid
  #   @required
  #   @type: array<tuple<float>> [size 1 :->: 3]
  #   @note: For spherical geometry, only specify `[[rmin, rmax]]`, other values
  #          are set automatically
  #   @note: For cartesian geometry, cell aspect ratio has to be 1: `dx=dy=dz`
  #   @example: [[0.0, 1.0], [-1.0, 1.0]]
  extent     = [[0.0, 0.0]]

  # @inferred:
  # - dim
  #     @brief: Dimensionality of the grid
  #     @type: short
  #     @enum: 1, 2, 3
  #     @from: `grid.resolution`

  # Metric-related parameters
  [grid.metric]
    # Metric on the grid
    #   @required
    #   @type: string
    #   @enum: "Minkowski", "Spherical", "QSpherical", "Kerr_Schild",
    #          "QKerr_Schild", "Kerr_Schild_0"
    metric  = "Minkowski"
    # `r0` paramter for the QSpherical metric `x1 = log(r-r0)`
    #   @type: float [-inf -> rmin]
    #   @default: 0.0
    #   @note: Negative values produce almost uniform grid in r
    qsph_r0 = 0.0
    # `h` paramter for the QSpherical metric `th = x2 + 2*h x2
    # (pi-2*x2)*(pi-x2)/pi^2`
    #   @type: float [-1 :->: 1]
    #   @default: 0.0
    qsph_h  = 0.0
    # Spin parameter for the Kerr Schild metric
    #   @type: float [0 :-> 1]
    #   @default: 0.0
    ks_a    = 0.0

    # @inferred:
    # - coord
    #     @brief: Coordinate system on the grid
    #     @type: string
    #     @enum: "cartesian", "spherical", "qspherical"
    #     @from: `grid.metric.metric`
    # - ks_rh
    #     @brief: Size of the horizon for GR Kerr Schild
    #     @type: float
    #     @from: `grid.metric.ks_a`
    # - params
    #     @brief: A map of all metric-specific parameters together (for easy
    #             access)
    #     @type: map<string, float>
    #     @from: `grid.metric`

  # Boundary-condition related parameters
  [grid.boundaries]
    # Boundary conditions for fields
    #   @required
    #   @type: array<tuple<string>> [size 1 :->: 3]
    #   @enum: "PERIODIC", "MATCH", "FIXED", "ATMOSPHERE", "CUSTOM", "HORIZON",
    #          "CONDUCTOR"
    #   @note: When periodic in any of the directions, you should only set one
    #          value: [..., ["PERIODIC"], ...]
    #   @note: In spherical, bondaries in theta/phi are set automatically (only
    #          specify bc @ `[rmin, rmax]`): [["ATMOSPHERE", "MATCH"]]
    #   @note: In GR, the horizon boundary is set automatically (only specify bc
    #          @ rmax): [["MATCH"]]
    #   @example: [["CUSTOM", "MATCH"]] (for 2D spherical `[[rmin, rmax]]`)
    fields    = [["PERIODIC"]]
    # Boundary conditions for particles
    #   @required
    #   @type: array<tuple<string>> [size 1 :->: 3]
    #   @enum: "PERIODIC", "ABSORB", "ATMOSPHERE", "CUSTOM", "REFLECT",
    #          "HORIZON"
    #   @note: When periodic in any of the directions, you should only set one
    #          value [..., ["PERIODIC"], ...]
    #   @note: In spherical, bondaries in theta/phi are set automatically (only
    #          specify bc @ `[rmin, rmax]`) [["ATMOSPHERE", "ABSORB"]]
    #   @note: In GR, the horizon boundary is set automatically (only specify bc
    #          @ `rmax`): [["ABSORB"]]
    #   @example: [["PERIODIC"], ["PERIODIC"]]
    particles = [["PERIODIC"]]

    # Parameters specific to MATCH boundary conditions
    [grid.boundaries.match]
      # Size of the matching layer in each direction for fields in physical
      # (code) units
      #   @type: float | array<tuple<float>>
      #   @default: 1% of the domain size (in shortest dimension)
      #   @note: In spherical, this is the size of the layer in `r` from the
      #          outer wall
      #   @example: `ds = 1.5` (will set the same for all directions)
      #   @example: `ds = [[1.5], [2.0, 1.0], [1.1]]` (will duplicate 1.5 for
      #             +/- `x1` and 1.1 for +/- `x3`)
      #   @example: `ds = [[], [1.5], []]` (will only set for x2)
      ds = 1.0

    # Parameters specific to ABSORB boundary conditions
    [grid.boundaries.absorb]
      # Size of the absorption layer for particles in physical (code) units
      #   @type: float
      #   @default: 1% of the domain size (in shortest dimension)
      #   @note: In spherical, this is the size of the layer in `r` from the
      #          outer wall
      #   @note: In cartesian, this is the same for all dimensions where
      #          applicable
      ds = 1.0

    # Parameters specific to ATMOSPHERE boundary conditions
    [grid.boundaries.atmosphere]
      # Temperature of the atmosphere in units of `m0 c^2`
      #   @type: float
      #   @note: [required] if `ATMOSPHERE` is one of the boundaries
      temperature = 0.0
      # Peak number density of the atmosphere at base in units of `n0`
      #   @type: float
      density     = 0.0
      # Pressure scale-height in physical units
      #   @type: float
      height      = 1.0
      # Species indices of particles that populate the atmosphere
      #   @type: array<int> [size 2]
      species     = [1, 1]
      # Distance from the edge to which the gravity is imposed in physical units
      #   @type: float
      #   @default: 0.0
      #   @note: 0.0 means no limit
      ds          = 0.0

      # @inferred:
      # - g
      #     @brief: Acceleration due to imposed gravity
      #     @type: float
      #     @from: `grid.boundaries.atmosphere.temperature`,
      #             `grid.boundaries.atmosphere.height`
      #     @value: `temperature / height`

# Fiducial scales that fix the code unit system
[scales]
  # Fiducial larmor radius
  #   @required
  #   @type: float [> 0.0]
  larmor0    = 1.0
  # Fiducial plasma skin depth
  #   @required
  #   @type: float [> 0.0]
  skindepth0 = 1.0

  # @inferred:
  # - dx0
  #     @brief: fiducial minimum size of the cell
  #     @type: float
  #     @from: `grid`
  # - V0
  #     @brief: fiducial elementary volume
  #     @type: float
  #     @from: `grid`
  # - n0
  #     @brief: Fiducial number density
  #     @type: float
  #     @from: `particles.ppc0`, `grid`
  #     @value: `ppc0 / V0`
  # - q0
  #     @brief: Fiducial elementary charge
  #     @type: float
  #     @from: `scales.skindepth0`, `scales.n0`
  #     @value: `1 / (n0 * skindepth0^2)`
  # - sigma0
  #     @brief: Fiducial magnetization parameter
  #     @type: float
  #     @from: `scales.larmor0`, `scales.skindepth0`
  #     @value: `(skindepth0 / larmor0)^2`
  # - B0
  #     @brief: Fiducial magnetic field
  #     @type: float
  #     @from: `scales.larmor0`
  #     @value: `1 / larmor0`
  # - omegaB0
  #     @brief: Fiducial cyclotron frequency
  #     @type: float
  #     @from: `scales.larmor0`
  #     @value: `1 / larmor0`

# Radiative drag and photon emission parameters
[radiation]

  # Radiation reaction (drag) parameters
  [radiation.drag]

    # Synchrotron drag parameters
    [radiation.drag.synchrotron]
      # Radiation reaction limit gamma-factor for synchrotron
      #   @type: float [> 0.0]
      #   @default: 1.0
      #   @note: [required] if one of the species has `radiative_drag =
      #          "synchrotron"`
      gamma_rad = 1.0

    # Compton drag parameters
    [radiation.drag.compton]
      # Radiation reaction limit gamma-factor for Compton drag
      #   @type: float [> 0.0]
      #   @default: 1.0
      #   @note: [required] if one of the species has `radiative_drag =
      #          "compton"`
      gamma_rad = 1.0

  # Photon emission parameters
  [radiation.emission]

    # Synchrotron emission parameters
    [radiation.emission.synchrotron]
      # Gamma-factor of a particle emitting synchrotron photons at energy `m0
      # c^2` in fiducial magnetic field `B0`
      #   @type: float [> 1.0]
      #   @default: 10.0
      gamma_qed         = 10.0
      # Minimum photon energy for synchrotron emission (units of `m0 c^2`)
      #   @type: float [> 0.0]
      #   @default: 1e-3
      photon_energy_min = 1e-3
      # Weights for the emitted synchrotron photons
      #   @type: float [> 0.0]
      #   @default: 1.0
      photon_weight     = 1.0
      # Index of species for the emitted photon
      #   @required
      #   @type: ushort [> 0]
      photon_species    = 1

      # @inferred:
      # - nominal_probability
      #     @brief: Nominal probability of the emission for a particle with
      #             `gamma * beta = 1`, charge-to-mass = `q0 / m0`
      #     @type: float
      #     @from: `.gamma_qed`, `.photon_weight`,
      #             `...drag.synchrotron.gamma_rad`, `scales.omegaB0`,
      #             `algorithms.timestep.dt`
      #     @value: `0.1 * omegaB0 * dt * (gamma_qed / gamma_rad)^2 /
      #             photon_weight`
      # - nominal_photon_energy
      #     @brief: Nominal energy of the emitted photon for a particle with
      #             `gamma * beta = 1`, mass = `m0`
      #     @type: float
      #     @from: `.gamma_qed`
      #     @value: `(1 / gamma_qed)^2`

    # Inverse Compton emission parameters
    [radiation.emission.compton]
      # Gamma-factor of a particle emitting inverse Compton photons at energy
      # `m0 c^2` in fiducial magnetic field `B0`
      #   @type: float [> 1.0]
      #   @default: 10.0
      gamma_qed         = 10.0
      # Minimum photon energy for inverse Compton emission (units of `m0 c^2`)
      #   @type: float [> 0.0]
      #   @default: 1e-3
      photon_energy_min = 1e-3
      # Weights for the emitted inverse Compton photons
      #   @type: float [> 0.0]
      #   @default: 1.0
      photon_weight     = 1.0
      # Index of species for the emitted photon
      #   @required
      #   @type: ushort [> 0]
      photon_species    = 1

      # @inferred:
      # - nominal_probability
      #     @brief: Nominal probability of the emission for a particle with
      #             `gamma * beta = 1`, charge-to-mass = `q0 / m0`
      #     @type: float
      #     @from: `.gamma_qed`, `.photon_weight`, `...drag.compton.gamma_rad`,
      #             `scales.omegaB0`, `algorithms.timestep.dt`
      #     @value: `0.1 * omegaB0 * dt * (gamma_qed / gamma_rad)^2 /
      #             photon_weight`
      # - nominal_photon_energy
      #     @brief: Nominal energy of the emitted photon for a particle with
      #             `gamma * beta = 1`, mass = `m0`
      #     @type: float
      #     @from: `.gamma_qed`
      #     @value: `(1 / gamma_qed)^2`

# Algorithm and solver tuning
[algorithms]
  # Number of current smoothing passes
  #   @type: ushort [>= 0]
  #   @default: 0
  current_filters = 0

  # Timestep parameters
  [algorithms.timestep]
    # Courant-Friedrichs-Lewy number
    #   @type: float [0.0 -> 1.0]
    #   @default: 0.95
    #   @note: CFL number determines the timestep duration
    CFL        = 0.95
    # Correction factor for the speed of light used in field solver
    #   @type: float
    #   @default: 1.0
    correction = 1.0

    # @inferred:
    # - dt
    #     @brief: timestep duration
    #     @type: float
    #     @from: `algorithms.timestep.CFL`, `scales.dx0`
    #     @value: `CFL * dx0`

  # Current deposition parameters
  [algorithms.deposit]
    # Enable the current deposition
    #   @type: bool
    #   @default: true
    enable                  = true
    # Tiled-deposit work-group (team) size
    #   @type: uint [>= 0]
    #   @default: 0
    #   @deprecated: removed in 1.6+, use `tiled_deposit_team_size` instead
    team_policy_team_size   = 0
    # Tiled-deposit work-group (team) size
    #   @type: uint [>= 0]
    #   @default: 0
    #   @note: 0 keeps Kokkos::AUTO (backend occupancy heuristic); a positive
    #          value overrides it, clamped to the backend/scratch maximum at
    #          launch. Only used in `tiled_deposit=ON` builds. Pick a multiple
    #          of the device subgroup width for best occupancy (see
    #          ideal_tile_size.py)
    tiled_deposit_team_size = 0

    # @inferred:
    # - order
    #     @brief: order of the particle shape function
    #     @type: ushort [0 -> 10]
    #     @from: compile-time definition `shape_order`

  # GR pusher parameters
  [algorithms.gr]
    # Stepsize for numerical differentiation in GR pusher
    #   @type: float [> 0.0]
    #   @default: 1e-6
    pusher_eps   = 1e-6
    # Number of iterations for the Newton-Raphson method in GR pusher
    #   @type: ushort [> 0]
    #   @default: 10
    pusher_niter = 10

  # Guiding-center approximation parameters
  [algorithms.gca]
    # Maximum value for E/B allowed for GCA particles
    #   @type: float [0.0 -> 1.0]
    #   @default: 0.9
    e_ovr_b_max = 0.9
    # Maximum Larmor radius allowed for GCA particles (in physical units)
    #   @type: float
    #   @default: 0.0
    #   @note: When `larmor_max` == 0, the limit is disabled
    larmor_max  = 0.0

  # Stencil coefficients for the field solver [notation as in Blinne+ (2018)]
  #   @note: Standard Yee solver: `delta_i = beta_ij = 0.0`
  [algorithms.fieldsolver]
    # Enable the fieldsolver
    #   @type: bool
    #   @default: true
    enable  = true
    # delta_x coefficient (for `F_{i +/- 3/2, j, k}`)
    #   @type: float
    #   @default: 0.0
    delta_x = 0.0
    # delta_y coefficient (for `F_{i, j +/- 3/2, k}`)
    #   @type: float
    #   @default: 0.0
    #   @note: Used only for 2D and 3D
    delta_y = 0.0
    # delta_z coefficient (for `F_{i, j, k +/- 3/2}`)
    #   @type: float
    #   @default: 0.0
    #   @note: Used only for 3D
    delta_z = 0.0
    # beta_xy coefficient (for `F_{i +/- 1/2, j +/- 1, k}`)
    #   @type: float
    #   @default: 0.0
    #   @note: Used only for 2D and 3D
    beta_xy = 0.0
    # beta_yx coefficient (for `F_{i +/- 1, j +/- 1/2, k}`)
    #   @type: float
    #   @default: 0.0
    #   @note: Used only for 2D and 3D
    beta_yx = 0.0
    # beta_xz coefficient (for `F_{i +/- 1/2, j, k +/- 1}`)
    #   @type: float
    #   @default: 0.0
    #   @note: Used only for 3D
    beta_xz = 0.0
    # beta_zx coefficient (for `F_{i +/- 1, j, k +/- 1/2}`)
    #   @type: float
    #   @default: 0.0
    #   @note: Used only for 3D
    beta_zx = 0.0
    # beta_yz coefficient (for `F_{i, j +/- 1/2, k +/- 1}`)
    #   @type: float
    #   @default: 0.0
    #   @note: Used only for 3D
    beta_yz = 0.0
    # beta_zy coefficient (for `F_{i, j +/- 1, k +/- 1/2}`)
    #   @type: float
    #   @default: 0.0
    #   @note: Used only for 3D
    beta_zy = 0.0

# Particle and species parameters
[particles]
  # Fiducial number of particles per cell
  #   @required
  #   @type: float [> 0.0]
  ppc0                     = 1.0
  # Toggle for using particle weights
  #   @type: bool
  #   @default: false
  use_weights              = false
  # Timesteps between particle re-sorting by tags (removing dead particles)
  #   @type: uint
  #   @default: 100
  #   @note: Set to 0 to disable re-sorting
  clear_interval           = 100
  # Timesteps between spatial sorting of particles (for better cache
  # performance)
  #   @type: uint
  #   @default: 0
  #   @note: Set to 0 to disable spatial sorting
  spatial_sorting_interval = 0

  # @inferred:
  # - nspec
  #     @brief: Number of particle species
  #     @type: uint
  #     @from: `particles.species`

  # Particle species definitions
  [[particles.species]]
    # Label of the species
    #   @type: string
    #   @default: "s<INDEX>"
    #   @note: `<INDEX>` is the index of the species in the list starting from 1
    #   @example: "e-"
    label                    = "s<INDEX>"
    # Mass of the species (in units of fiducial mass)
    #   @required
    #   @type: float [>= 0.0]
    mass                     = 0.0
    # Charge of the species (in units of fiducial charge)
    #   @required
    #   @type: float
    charge                   = 0.0
    # Maximum number of particles per task
    #   @required
    #   @type: uint [> 0]
    #   @note: Read as a float, so exponential notation is fine (e.g. `1e8`)
    maxnpart                 = 1.0
    # Pusher algorithm for the species
    #   @type: string
    #   @default: "Boris" [massive]; "Photon" [massless]
    #   @enum: "Boris", "Vay", "Boris,GCA", "Vay,GCA", "Photon", "None"
    pusher                   = "Boris"
    # Number of additional real-valued variables (payloads) for each particle of
    # the given species
    #   @type: ushort
    #   @default: 0
    n_payloads_real          = 0
    # Number of additional integer-valued variables (payloads) for each particle
    # of the given species
    #   @type: ushort
    #   @default: 0
    #   @note: If tracking is enabled, one or two extra integer payloads are
    #          reserved (depending on whether MPI is enabled)
    n_payloads_int           = 0
    # Enable tracking of particles using indices for the given species
    #   @type: bool
    #   @default: false
    tracking                 = false
    # Radiation reaction to use for the species
    #   @type: string
    #   @default: "None"
    #   @enum: "None", "Synchrotron", "Compton"
    #   @note: Can also be coma-separated combination, e.g.,
    #          "Synchrotron,Compton"
    #   @note: Relevant radiation.drag parameters should also be provided
    radiative_drag           = "None"
    # Particle emission policy for the species
    #   @type: string
    #   @default: "None"
    #   @enum: "None", "Synchrotron", "Compton", "Custom"
    #   @note: Only one emission mechanism allowed
    #   @note: Appropriate radiation drag flag will be applied automatically
    #          (unless explicitly set to "None")
    emission                 = "None"
    # Timesteps between spatial sorting of particles for given species
    #   @type: uint
    #   @default: 0
    #   @note: Set to 0 to disable spatial sorting
    #   @note: Overrides `particles.spatial_sorting_interval` for the given
    #          species
    spatial_sorting_interval = 0
    # Timesteps between particle re-sorting by tags (removing dead particles)
    #   @type: uint
    #   @default: 100
    #   @note: Set to 0 to disable re-sorting
    #   @note: Overrides `particles.clear_interval` for the given species
    clear_interval           = 100

# Parameters for specific problem generators and setups
#   @note: Free-form: keys are defined by the problem generator, so nothing here
#          is validated
[setup]

# Output parameters
[output]
  # Output format
  #   @type: string
  #   @default: "bpfile"
  #   @enum: "disabled", "hdf5", "BPFile"
  format        = "bpfile"
  # Number of timesteps between all outputs
  #   @type: uint [> 0]
  #   @default: 100
  #   @note: Value is overriden by output intervals for specific outputs
  interval      = 100
  # Physical (code) time interval between all outputs
  #   @type: float
  #   @default: -1.0
  #   @note: When `interval_time` < 0, the output is controlled by `interval`,
  #          otherwise by `interval_time`
  #   @note: Value is overriden by output intervals for specific outputs
  interval_time = -1.0

  # Field output parameters
  [output.fields]
    # Toggle for the field output
    #   @type: bool
    #   @default: true
    enable        = true
    # Field quantities to output
    #   @type: array<string>
    #   @default: []
    #   @enum: "E", "B", "J", "divE", "Rho", "Charge", "N", "Nppc", "T0i",
    #          "Tij", "Vi", "D", "H", "divD", "A"
    #   @note: For `T`, you can use unspecified indices: `Tij`, `T0i`, or
    #          specific ones: `Ttt`, `T00`, `T02`, `T23`
    #   @note: For `T`, in cartesian can also use "x" "y" "z" instead of "1" "2"
    #          "3"
    #   @note: By default, we accumulate moments from all massive species, one
    #          can specify only specific species: `Ttt_1_2`, `Rho_1`, `Rho_3_4`
    quantities    = []
    # Custom (user-defined) field quantities
    #   @type: array<string>
    #   @default: []
    custom        = []
    # Number of timesteps between field outputs
    #   @type: uint
    #   @default: 0
    #   @note: When `!= 0`, overrides `output.interval`
    #   @note: When `== 0`, `output.interval` is used
    interval      = 0
    # Physical (code) time interval between field outputs
    #   @type: float
    #   @default: -1.0
    #   @note: When `< 0`, the output is controlled by `interval`
    #   @note: When specified, overrides `output.interval_time`
    interval_time = -1.0
    # Downsample factor for the output of fields
    #   @type: uint | array<uint> [>= 1]
    #   @default: [1, 1, 1]
    #   @note: The output is downsampled by the given factors in each direction
    #   @note: If a scalar is given, it is applied to all directions
    downsampling  = [1, 1, 1]

    # Smoothing of the output moments
    [output.fields.smoothing]
      # Smoothing order for the output of moments ("Rho", "Charge", "T", ...)
      #   @type: ushort
      #   @default: 0
      order  = 0
      # Smoothing algorithm
      #   @type: string
      #   @default: "spline"
      #   @enum: "const", "spline"
      #   @note: When using "spline", `order` corresponds to the order of the
      #          polynomial used
      #   @note: When using "const", the smoothing window is `ceil(order / 2)`
      #          in both directions
      method = "spline"

  # Particle output parameters
  [output.particles]
    # Toggle for the particles output
    #   @type: bool
    #   @default: true
    enable        = true
    # Particle species indices to output
    #   @type: array<int>
    #   @default: []
    #   @note: If empty, all species are output
    species       = []
    # Stride for the output of particles
    #   @type: uint [>= 1]
    #   @default: 100
    stride        = 100
    # Number of timesteps between particle outputs
    #   @type: uint
    #   @default: 0
    #   @note: When `!= 0`, overrides `output.interval`
    #   @note: When `== 0`, `output.interval` is used
    interval      = 0
    # Physical (code) time interval between particle outputs
    #   @type: float
    #   @default: -1.0
    #   @note: When `< 0`, the output is controlled by `interval`
    #   @note: When specified, overrides `output.interval_time`
    interval_time = -1.0

  # Spectra output parameters
  [output.spectra]
    # Toggle for the spectra output
    #   @type: bool
    #   @default: true
    enable           = true
    # Minimum energy for the spectra output
    #   @type: float
    #   @default: 1e-3
    e_min            = 1e-3
    # Maximum energy for the spectra output
    #   @type: float
    #   @default: 1e3
    e_max            = 1e3
    # Whether to use logarithmic bins for energy
    #   @type: bool
    #   @default: true
    log_bins         = true
    # Number of energy bins for the spectra output
    #   @type: uint [> 0]
    #   @default: 200
    #   @deprecated: removed in 1.6+, use `num_energy_bins` instead
    n_bins           = 200
    # Number of energy bins for the spectra output
    #   @type: uint [> 0]
    #   @default: 200
    num_energy_bins  = 200
    # Number of spatial bins for the spectra output
    #   @type: array<uint> [size 1 :->: 3]
    #   @default: [1, 1, 1]
    num_spatial_bins = [1, 1, 1]
    # Number of timesteps between spectra outputs
    #   @type: uint
    #   @default: 0
    #   @note: When `!= 0`, overrides `output.interval`
    #   @note: When `== 0`, `output.interval` is used
    interval         = 0
    # Physical (code) time interval between spectra outputs
    #   @type: float
    #   @default: -1.0
    #   @note: When `< 0`, the output is controlled by `interval`
    #   @note: When specified, overrides `output.interval_time`
    interval_time    = -1.0

  # Debug output parameters
  [output.debug]
    # Output fields "as is" without conversions
    #   @type: bool
    #   @default: false
    as_is  = false
    # Output fields with values in ghost cells
    #   @type: bool
    #   @default: false
    ghosts = false

  # Integrated statistics output parameters
  [output.stats]
    # Toggle for the stats output
    #   @type: bool
    #   @default: true
    enable        = true
    # Number of timesteps between stat outputs
    #   @type: uint [> 0]
    #   @default: 100
    #   @note: Overriden if `output.stats.interval_time != -1`
    interval      = 100
    # Physical (code) time interval between stat outputs
    #   @type: float
    #   @default: -1.0
    #   @note: When `< 0`, the output is controlled by `interval`
    interval_time = -1.0
    # Field quantities to output
    #   @type: array<string>
    #   @default: ["B^2", "E^2", "ExB", "Rho", "T00"]
    #   @enum: "B^2", "E^2", "ExB", "N", "Npart", "Charge", "Rho", "T00", "T0i",
    #          "Tij"
    #   @note: For particle moments, ...
    #   @note: ... same notation is used as for `output.fields.quantities`
    quantities    = ["B^2", "E^2", "ExB", "Rho", "T00"]
    # Custom (user-defined) stats
    #   @type: array<string>
    #   @default: []
    custom        = []

# Checkpointing parameters
[checkpoint]
  # Number of timesteps between checkpoints
  #   @type: uint [> 0]
  #   @default: 1000
  interval      = 1000
  # Physical (code) time interval between checkpoints
  #   @type: float [> 0]
  #   @default: -1.0
  #   @note: When `< 0`, the output is controlled by `interval`
  interval_time = -1.0
  # Number of checkpoints to keep
  #   @type: int
  #   @default: 2
  #   @note: 0 = disable checkpointing
  #   @note: -1 = keep all checkpoints
  keep          = 2
  # Write a checkpoint once after a fixed walltime
  #   @type: string
  #   @default: "00:00:00"
  #   @note: The format is "HH:MM:SS"
  #   @note: Empty string or "00:00:00" disables this functionality
  #   @note: Writing checkpoint at walltime does not stop the simulation
  walltime      = "00:00:00"
  # Parent directory to write checkpoints to
  #   @type: string
  #   @default: `<simname>.ckpt`
  #   @note: The directory is created if it does not exist
  write_path    = ""
  # Parent directory to use when resuming from a checkpoint
  #   @type: string
  #   @default: inherit `write_path`
  read_path     = ""

  # @inferred:
  # - is_resuming
  #     @brief: Whether the simulation is resuming from a checkpoint
  #     @type: bool
  #     @from: command-line flag
  # - start_step
  #     @brief: Timestep of the checkpoint used to resume
  #     @type: uint
  #     @from: automatically determined during restart
  # - start_time
  #     @brief: Time of the checkpoint used to resume
  #     @type: float
  #     @from: automatically determined during restart

# ADIOS2 BP5 tuning, applied to both [output] and [checkpoint] writers
[adios2]
  # Number of ADIOS2 aggregators per node
  #   @type: uint
  #   @default: 0
  #   @note: Set to either MPI ranks/node or NICs/node for best performance
  #          If set to 0, will use ADIOS2 default (one aggregator per node)
  aggregators_per_node = 0
  # Maximum shared-memory segment size per node, in bytes (BP5 MaxShmSize)
  #   @type: uint
  #   @default: 4294967296
  #   @note: Lower this on memory-constrained nodes; matches ADIOS2's default
  max_shm_size         = 4294967296
  # Internal serialization buffer chunk size, in bytes (BP5 BufferChunkSize)
  #   @type: uint
  #   @default: 16777216
  #   @note: Scales with per-rank output volume; matches ADIOS2's default
  buffer_chunk_size    = 16777216

# In-situ renderer. Renders scalar fields on the GPU and writes PNG images
# directly to `<simname>/renders/` each cadence -- no field data is written to
# storage, and the result is seamless across MPI domain boundaries.
#   @note: two modes, selected automatically by the simulation dimension:
#          - 3D Cartesian (Minkowski): volume ray-march (uses `samples`,
#          `step_size`, `early_term_alpha`, and the [camera] table)
#          - 2D (Minkowski, Spherical/QSpherical, and all GR Kerr-Schild): flat
#          slice rasterizer. Cartesian shows the (x, y) plane; spherical shows
#          the meridional (r, theta) half-plane mapped to Cartesian (X = r sin
#          th, Z = r cos th), optionally mirrored (see `mirror`). The
#          `samples`/`step_size`/`early_term_alpha`/[camera] keys are ignored in
#          2D (one opaque sample per pixel).
#   @note: 1D (and 3D non-Cartesian, which does not exist) is a no-op
#   @note: One PNG stream per scene (e.g. a density/|B|/|J| triptych)
[render]
  # Toggle for the on-the-fly renderer
  #   @type: bool
  #   @default: false
  enable           = false
  # Number of timesteps between renders
  #   @type: uint
  #   @default: 0
  #   @note: When `!= 0`, overrides `output.interval`
  #   @note: When `== 0`, `interval_time` (or `output.interval`) is used
  interval         = 0
  # Physical (code) time interval between renders
  #   @type: float
  #   @default: -1.0
  #   @note: When `< 0`, the output is controlled by `interval`
  interval_time    = -1.0
  # Image width in pixels (the rendered region; the PNG is wider if a colorbar
  # margin is added, see `colorbar_outside`)
  #   @type: int [> 0]
  #   @default: 1024
  width            = 1024
  # Image height in pixels
  #   @type: int [> 0]
  #   @default: 1024
  height           = 1024
  # Convenience: force a square frame (sets width == height == resolution), the
  # natural shape for a dome master. Overrides `width`/`height` when > 0.
  #   @type: int [> 0]
  #   @default: 0 (use width/height)
  resolution       = 0
  # Number of entries in the color/opacity lookup table
  #   @type: int [> 1]
  #   @default: 256
  n_lut            = 256
  # Opaque background RGB (each channel 0..1) shown through
  # transparent/low-opacity pixels; also fills the colorbar margin
  #   @type: array<float> [size 3]
  #   @default: [0.0, 0.0, 0.0]
  background       = [0.0, 0.0, 0.0]
  # Draw a colorbar (gradient + value ticks + label) on each PNG
  #   @type: bool
  #   @default: true
  colorbar         = true
  # Draw the colorbar in an added right margin (the PNG becomes wider by a fixed
  # strip) instead of overlaying it on the rendered volume
  #   @type: bool
  #   @default: true
  colorbar_outside = true
  # 2D spherical slice only: mirror the meridional half-plane across the
  # symmetry axis to render a full disk from one axisymmetric half. No effect on
  # Cartesian or 3D rendering.
  #   @type: bool
  #   @default: true
  mirror           = true
  # Draw the current simulation time as a label ("T = <value>", fixed to 2
  # decimals) in the upper-right corner of the render region, in a contrasting
  # color, vertically centered between the frame top and the colorbar.
  #   @type: bool
  #   @default: false
  time_label       = false
  # Draw a spine (frame) + axis ticks + labels around the rendered region. The
  # PNG gains left/bottom margins (background-filled) for the tick labels and
  # axis names, so they never overlap the data.
  #   @type: bool
  #   @default: false
  #   @note: 2D Cartesian = a rectangular frame with linear spatial ticks;
  #          2D spherical = polar axes (an "R" radial axis on the symmetry axis
  #          with R=0 centered, and a "Theta" axis along the curved outline /
  #          spine);
  #          3D = the global box projected to a wireframe with ticks on the
  #          three silhouette edges (x bottom, y & z on the left)
  axes             = false
  # Axis names. 3D uses all three; the 2D slice uses the first two. When unset,
  # the 2D slice defaults to "x","y" (Cartesian) or "X","Z" (spherical).
  #   @type: array<string> [size <= 3]
  #   @default: ["x", "y", "z"]
  axis_labels      = ["x", "y", "z"]
  # Target number of ticks per axis (actual count is rounded to nice values)
  #   @type: int [>= 2]
  #   @default: 5
  axis_ticks       = 5
  # 3D only: target width (pixels) of the box wireframe "spine". The spine is
  # drawn inside the ray-march (opaque, depth-occluded by the volume); its width
  # is floored by the ray step, so for a crisper thin line raise `samples` as
  # well.
  #   @type: float [> 0.0]
  #   @default: 2.0
  spine_width      = 2.0

  # Limit the render region to axis-aligned box in physical/world coordinates.
  # Left unset it spans the full domain. Clamped to the box.
  #   @note: 3D -> the volume is depth-clipped to this box, the wireframe/axes
  #          frame it, and the default camera zooms to it; 2D -> the slice
  #          window is framed to it
  [render.extent]
    # Axis-aligned render region [lo, hi] along x1, in physical/world coords.
    # Left unset it spans the full domain. Clamped to the box.
    #   @type: array<float> [size 2]
    #   @default: [] (full extent)
    #   @note: For a spherical 2D slice, x1 crops the radius r.
    #   @example: x1 = [-64.0, 64.0]
    x1 = []
    # Render region [lo, hi] along x2.
    #   @type: array<float> [size 2]
    #   @default: [] (full extent)
    #   @note: For a spherical 2D slice, x2 crops the polar angle theta.
    x2 = []
    # Render region [lo, hi] along x3.
    #   @type: array<float> [size 2]
    #   @default: [] (full extent)
    x3 = []

  # Volume rendering parameters (3D Cartesian only)
  [render.volume]
    # Number of ray-march steps across the global box diagonal
    #   @type: int [> 0]
    #   @default: 400
    #   @note: The world-space step is `box_diagonal / samples` unless
    #          `step_size` is set. Higher = better quality, slower.
    samples          = 400
    # Fixed world-space step between ray samples
    #   @type: float [>= 0.0]
    #   @default: 0.0
    #   @note: 0 derives the step from `samples`. The step is identical on all
    #          ranks, which is what makes the multi-domain composite seamless.
    step_size        = 0.0
    # Stop marching a ray once its accumulated opacity reaches this value
    #   @type: float [0.0 -> 1.0]
    #   @default: 0.99
    #   @note: Pure speed optimization; set to 1.0 to disable early termination
    early_term_alpha = 0.99

  # Translate the render region (and, in 3D, the camera), to keep a propagating
  # feature (e.g. a shock) in frame. Pair with x{1,2,3} extent to crop the
  # moving window.
  [render.moving_view]
    # Velocity of the moving camera in world units.
    #   @type: array<float> [size 2 or 3]
    #   @default: [] (static view)
    #   @example: velocity = [0.9, 0.0]   # pan along +x1 at 0.9 c
    velocity   = []
    # Sim time at which the view starts moving (static before it, e.g. to let an
    # initial ramp-up finish)
    #   @type: float
    #   @default: 0.0
    start_time = 0.0

  # Camera (3D volume mode only; ignored by the 2D slice rasterizer). Defaults
  # frame the whole global box from outside, looking down the (1,1,1) diagonal
  # -- the production setup for which the structured composite is provably
  # seamless.
  [render.camera]
    # Projection mode. Overrides `orthographic` below when set.
    #   @type: string
    #   @default: (unset -> use `orthographic`)
    #   @enum: "orthographic", "perspective", "dome"
    #   @note: "dome" is a fulldome azimuthal-equidistant fisheye rendered from
    #          an INTERIOR eye (the domain center by default), i.e. a 3D
    #          planetarium dome master. It uses a depth-resolved (A-buffer)
    #          composite that is seamless across a full 3D domain decomposition
    #          (unlike ortho/perspective, which need the eye outside the box).
    #          Set a square frame (`resolution`, or width == height). `forward`
    #          is the dome ZENITH (screen-up defaults to +y for a +z zenith).
    mode         = "orthographic"
    # Camera (eye) position in world (physical) coordinates
    #   @type: array<float> [size 3]
    #   @default: box center pushed back ~1.7 box-diagonals along (1, 1, 1);
    #             for `mode = "dome"`, the domain center (interior eye)
    position     = [0.0, 0.0, 0.0]
    # Point the camera looks at, in world coordinates (the dome ZENITH target)
    #   @type: array<float> [size 3]
    #   @default: box center; for `mode = "dome"`, the zenith defaults to +z
    look_at      = [0.0, 0.0, 0.0]
    # Camera up vector (dome: the disk's screen-up)
    #   @type: array<float> [size 3]
    #   @default: [0.0, 0.0, 1.0]; for `mode = "dome"`, [0.0, 1.0, 0.0]
    up           = [0.0, 0.0, 1.0]
    # Vertical field of view in degrees (perspective only)
    #   @type: float [> 0.0]
    #   @default: 35.0
    fov          = 35.0
    # Full dome field of view in degrees (dome mode only): the image rim is at
    # dome_fov/2 from the zenith (180 = a full hemisphere down to the horizon).
    #   @type: float [> 0.0, <= 360.0]
    #   @default: 180.0
    dome_fov     = 180.0
    # Dome far-clip radius in world units (dome mode only): each ray stops this
    # far from the eye, so the sampled region is a half-ball (hemisphere) of
    # this radius rather than the whole box -> uniform path length and no box
    # corner/edge projection artifacts. `samples` then counts steps across this
    # radius.
    #   @type: float [>= 0.0]
    #   @default: the largest sphere centered in the box (half the shortest
    #             side), so it touches the face centers and never a corner
    #   @note: 0 disables the clip (rays march to the box boundary)
    dome_radius  = 0.0
    # Vertical extent of the view in world units (orthographic only)
    #   @type: float [> 0.0]
    #   @default: the global box diagonal (the whole box fits from any angle)
    ortho_height = 1.0

  # Fulldome fisheye ("planetarium dome master"). 2D only; a circular image is
  # centered in the frame's inscribed circle with the corners left as the
  # background (the dome master's black border). Set `width == height` (e.g.
  # 4096) for a square master. When enabled, the axes and the outside colorbar
  # strip are suppressed so the PNG stays exactly width x height. Seamless
  # across MPI domains (the pixel->world map is a shared, deterministic function
  # and the tiles stay disjoint). Ignored (with a warning) for 3D.
  #   @note: CARTESIAN -- the flat plane is warped radially into the disk; use
  #          `fov`/`radius`/`center`/`projection` below.
  #   @note: SPHERICAL / GR Kerr-Schild -- the meridional slice is ALREADY a
  #          disk, so dome mode only mirrors it to a full disk (see `mirror`
  #          above; keep it true) and fits it to the inscribed circle. The
  #          `fov`/`radius`/`center`/`projection` keys are ignored (the native
  #          (X, Z) meridional map is used, with image radius proportional to
  #          the physical radius r, r=0 at the disk center).
  [render.dome]
    # Build the fisheye dome master instead of the plain slice
    #   @type: bool
    #   @default: false
    enable     = false
    # (Cartesian only) Full dome field of view in degrees (image radius maps
    # linearly to the dome zenith angle: the rim is at fov/2)
    #   @type: float [> 0.0, <= 180.0]
    #   @default: 180.0   # a full hemisphere
    fov        = 180.0
    # (Cartesian only) World radius of the circular cutout mapped onto the dome
    #   @type: float [> 0.0]
    #   @default: half the shorter domain side (the largest centered disk that
    #             fits inside the box)
    radius     = 1.0
    # (Cartesian only) World-space center of the cutout
    #   @type: array<float> [size 2]
    #   @default: the domain center
    center     = [0.0, 0.0]
    # (Cartesian only) How the dome zenith angle maps to a world radius on the
    # flat slice
    #   @type: string
    #   @default: "equidistant"
    #   @enum: "equidistant"  (r proportional to angle; the fulldome image
    #          standard -- a straight radial scaling of the cutout), "gnomonic"
    #          (r ~ tan(angle); the slice as a flat "ceiling" tangent to the
    #          dome -- straight sim lines stay straight), "stereographic" (r ~
    #          tan(angle/2); conformal, preserves shapes), "orthographic" (r ~
    #          sin(angle); the slice as seen face-on)
    projection = "equidistant"

  # Magnetic field lines, drawn from a coarse, MPI-replicated copy of the field
  # so the geometry is global and seamless across domains (the coarsening is
  # what makes this cheap -- no parallel particle advection / flux scan).
  # - 3D (Cartesian): traced as solid tubes, colored by |field|, composited
  # inside the volume ray-march so the volume correctly occludes them.
  # - 2D (Cartesian): iso-contours of the flux function psi (Bx = d psi/dy, By =
  # -d psi/dx), i.e. the in-plane field lines, colored by |B|.
  # - 2D (spherical / Kerr-Schild): traced meridional streamlines of the
  # poloidal (Br, Btheta) field (nt2py style).
  # Built once per frame and shared by every scene that opts in (per-scene
  # `fieldlines = true`) and by any standalone `field = "fieldlines"` scene.
  [render.fieldlines]
    # Build the field-line geometry this run
    #   @type: bool
    #   @default: false
    #   @note: implied true if any scene sets `fieldlines = true` or uses `field
    #          = "fieldlines"`
    enable     = false
    # Vector field to trace
    #   @type: string
    #   @default: "B"
    #   @enum: "B", "E", "J"
    field      = "B"
    # Field coarsening factor (simulation cells per coarse cell, per axis)
    #   @type: int [1..16]
    #   @default: 4
    #   @note: larger = smoother "morphology" lines + cheaper replication (the
    #          coarse field is ~ N_cells / bin^D floats/rank; D = sim dimension)
    bin        = 4
    # (3D tubes) Seed-lattice spacing in screen pixels (sets line density)
    #   @type: float [> 0]
    #   @default: 8
    #   @note: capped by `seed_max`; if seed_px asks for more seeds than that,
    #          the spacing grows to fit and seed_px no longer governs
    seed_px    = 8
    # (3D tubes) Hard cap on the seed count (lattice is n^3, 2 lines per seed)
    #   @type: int [> 0]
    #   @default: 4096
    #   @note: lower this for fewer / more widely spaced lines
    seed_max   = 4096
    # (2D contours) Number of evenly-spaced flux-function contour levels
    #   @type: int [> 0]
    #   @default: 16
    #   @note: evenly-spaced psi levels => line density tracks |B| automatically
    levels     = 16
    # Tube radius (3D) / contour line width (2D), in screen pixels
    #   @type: float [> 0]
    #   @default: 2
    tube_px    = 2
    # Colormap for the field lines (mapped by |B| along each line)
    #   @type: string
    #   @default: "inferno"
    #   @enum: "viridis", "inferno", "plasma", "cool2warm", "gray", "RdBu_r",
    #          and the CMasher maps (BSD-3, https://cmasher.readthedocs.io):
    #          "dusk", "cosmic", "freeze", "apple", "gothic", "sunburst",
    #          "voltage", "ocean", "fusion", "prinsenvlag" (an optional "cmr."
    #          prefix is ok)
    colormap   = "inferno"
    # Monochrome override: draw the lines in a single [r,g,b] color (each 0..1)
    # instead of the |B| colormap -- reads well as an overlay on another volume
    #   @type: array<float> [size 3]
    #   @default: [] (empty => color by |B|)
    #   @example: [1.0, 1.0, 1.0]   # white field lines
    color      = []
    # Map the tube color range logarithmically
    #   @type: bool
    #   @default: false
    #   @note: requires min > 0
    log        = false
    # Tube color range: lower bound on |field|
    #   @type: float
    #   @default: 0.0
    #   @note: when min >= max, the range is auto-set from |field| along the
    #          lines
    min        = 0.0
    # Tube color range: upper bound on |field|
    #   @type: float
    #   @default: 0.0
    #   @note: when min >= max, the range is auto-set from |field| along the
    #          lines
    max        = 0.0
    # (3D tubes) RK4 integration step as a fraction of one coarse cell
    #   @type: float [> 0]
    #   @default: 0.5
    step_frac  = 0.5
    # (3D tubes) Per-direction integration-step cap
    #   @type: int [> 0]
    #   @default: 4000
    max_steps  = 4000
    # (3D tubes) Maximum line length, in global box diagonals (per direction)
    #   @type: float [> 0]
    #   @default: 3.0
    max_length = 3.0

  # One scene per scalar field -> one PNG stream. Repeat the table for each.
  [[render.scene]]
    # Scalar field to render (a volume render needs a scalar, so vectors are
    # given as a magnitude or a single component)
    #   @required
    #   @type: string
    #   @enum: (fields): "{E,B,J}mag"; "{E,B,J}{1,2,3}" or "{E,B,J}{x,y,z}",
    #          (moments): "N", "Nppc", "Rho", "Charge"; "T{i}{j}"; "V{i}";
    #          "Vmag"
    #   @note: "{E,B,J}mag" = vector magnitude |.|; "B1"/"Bx", "J3"/"Jz", ... =
    #          a single (signed) physical component
    #   @note: a bare vector ("E"/"B"/"J") is not renderable -- choose a
    #          component or the magnitude
    #   @note: "N"/"Nppc" = number / per-cell count, "Rho" = mass density,
    #          "Charge" = charge density
    #   @note: "T{i}{j}" = one stress-energy component, i,j in {t,x,y,z} or
    #          {0,1,2,3} (e.g. "Txx", "Ttt", "T0x"); "V{i}" = one bulk-velocity
    #          component, i in {x,y,z} or {1,2,3} (e.g. "Vx", "V1"); "Vmag" =
    #          bulk-velocity magnitude sqrt(V1^2+V2^2+V3^2)
    #   @note: moments follow the engine: SRPIC = tetrad-basis bulk 3-velocity
    #          and stress-energy; GRPIC = Eckart-frame 4-velocity (so "Vt"/"V0"
    #          = u^0 = Gamma/alpha is also valid) and contravariant T
    #   @note: per-species selection with a "_<id>" suffix on moments, e.g.
    #          "N_1", "Rho_2", "Txy_1_2", "V1_3"; default = all massive species
    #   @note: components are signed; pair a symmetric `min`/`max` with a
    #          diverging colormap ("cool2warm") to center zero
    #   @note: "fieldlines" renders the magnetic field-line tubes on their own
    #          (no scalar volume sampled); see [render.fieldlines] below
    field          = ""
    # PNG filename prefix; files are `<prefix><cycle>.png`
    #   @type: string
    #   @default: "<field>_"
    prefix         = "<field>_"
    # Colorbar title
    #   @type: string
    #   @default: `field`
    label          = ""
    # Lower bound of the value range mapped onto the colormap/opacity
    #   @type: float
    #   @default: 0.0
    min            = 0.0
    # Upper bound of the value range
    #   @type: float
    #   @default: 1.0
    max            = 1.0
    # Map the value range logarithmically
    #   @type: bool
    #   @default: false
    #   @note: Requires min > 0 and max > 0
    log            = false
    # Colormap name
    #   @type: string
    #   @default: "viridis"
    #   @enum: "viridis", "inferno", "plasma", "cool2warm", "gray", "RdBu_r",
    #          and the CMasher maps (BSD-3, https://cmasher.readthedocs.io):
    #          "dusk", "cosmic", "freeze", "apple", "gothic", "sunburst",
    #          "voltage", "ocean", "fusion", "prinsenvlag" (an optional "cmr."
    #          prefix is ok)
    colormap       = "viridis"
    # Opacity transfer function: [position, opacity] control points, both in [0,
    # 1], piecewise-linear in the normalized value
    #   @type: array<tuple<float>>
    #   @default: linear ramp (opacity = normalized value)
    #   @note: Keep the low end near 0 so empty regions stay transparent
    #   @example: [[0.0, 0.0], [0.3, 0.1], [1.0, 0.7]]
    alpha          = []
    # Explicit value(s) to label on the colorbar
    #   @type: array<float>
    #   @default: 5 evenly-spaced ticks between min and max
    #   @note: Values outside [min, max] are skipped
    #   @example: [0.0, 0.5, 1.0]
    colorbar_ticks = []
    # Overlay the magnetic field-line tubes inside this scene's volume
    #   @type: bool
    #   @default: false
    #   @note: requires the [render.fieldlines] enabled (3D only). A scene with
    #          field = "fieldlines" instead renders them alone.
    fieldlines     = false

# Diagnostic logging parameters
[diagnostics]
  # Number of timesteps between diagnostic logs
  #   @type: int [> 0]
  #   @default: 1
  interval        = 1
  # Blocking timers between successive algorithms
  #   @type: bool
  #   @default: false
  blocking_timers = false
  # Enable colored stdout
  #   @type: bool
  #   @default: true
  colored_stdout  = true
  # Specify the log level
  #   @type: string
  #   @default: "VERBOSE"
  #   @enum: "VERBOSE", "WARNING", "ERROR"
  #   @note: "VERBOSE" prints all messages, "WARNING" prints only warnings and
  #          errors, "ERROR" prints only errors
  log_level       = "VERBOSE"