Input parameters

Entity reads almost all the information (except for the problem generator) about the simulation at runtime from an input file provided in a .toml format. The most up-to-date full version of the input file with all the possible input parameters with their descriptions and default values can be found in the root directory of the main repository in the input.default.toml.

Toml schema

The template input file is automatically generated from the entity.schema.json schema file, which can also be used with tools like tombi or taplo to verify the validity of your input toml file.

Accessing the parameters in the code

All the parameters listed below can be accessed at runtime from the code through the SimulationParams container object stored in the Simulation class and typically passed to the relevant functions. For example, to access the fiducial cyclotron frequency, you can do: params.template get<real_t>("scales.omegaB0"). Note that you need to explicitly specify the type of the variable to return.

required	These parameters are required to be specified for any simulation (i.e., no default)
inferred	These parameters are not directly specified by the user, but are inferred from other input parameters or command-line flags

parameter	type	description	default
simulation		Global simulation parameters
name	string	Name of the simulationThe name is used for the output files.
engine	string "SRPIC", "GRPIC"	Simulation engine to use
runtime	float > 0	Max runtime in physical (code) units
simulation.domain		Parameters specific to domain decomposition
number	int	Number of domains	1 [no MPI]; MPI_SIZE [MPI]
decomposition	array<int> size 1 :->: 3	Decomposition of the domain (for MPI) in each of the directions* -1 means the code will determine the decomposition in the specific direction automatically. * Automatic detection is either done by inference from # of MPI tasks, or by balancing the grid size on each domain.	$[-1, -1, -1]$
simulation.domain.load_balance		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.
enable	bool	Enable dynamic load balancing	false
interval	int	Run the rebalancer every interval timesteps (0 disables)	$0$
dimensions	array<int> 1, 2, 3	Dimensions along which load is redistributed (1 = x1, 2 = x2, 3 = x3)	$[1]$
tolerance	float	Skip rebalancing along a dim when (max - min) / mean of the per-slice particle count is below this fraction	$0.1$
max_shift	int	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.	N_GHOSTS
grid		Parameters specific to grid geometry
resolution	array<uint> size 1 :->: 3	Spatial resolution of the gridDimensionality is inferred from the size of this array.
extent	array<tuple<float>> size 1 :->: 3	Physical extent of the grid* For spherical geometry, only specify [[rmin, rmax]] , other values are set automatically. * For cartesian geometry, cell aspect ratio has to be 1: dx=dy=dz .
dim	short 1, 2, 3	Dimensionality of the grid
grid.metric		Metric-related parameters
metric	string "Minkowski", "Spherical", "QSpherical", "Kerr_Schild", "QKerr_Schild", "Kerr_Schild_0"	Metric on the grid
qsph_r0	float -∞ -> rmin	r0 paramter for the QSpherical metric x1 = log(r-r0)Negative values produce almost uniform grid in r.	$0.0$
qsph_h	float -1 :->: 1	h paramter for the QSpherical metric th = x2 + 2*h x2 (pi-2*x2)*(pi-x2)/pi^2	$0.0$
ks_a	float 0 :-> 1	Spin parameter for the Kerr Schild metric	$0.0$
coord	string "cartesian", "spherical", "qspherical"	Coordinate system on the grid
ks_rh	float	Size of the horizon for GR Kerr Schild
params	map<string, float>	A map of all metric-specific parameters together (for easy access)
grid.boundaries		Boundary-condition related parameters
fields	array<tuple<string>> "PERIODIC", "MATCH", "FIXED", "ATMOSPHERE", "CUSTOM", "HORIZON", "CONDUCTOR"	Boundary conditions for fields* When periodic in any of the directions, you should only set one value: [..., ["PERIODIC"], ...]. * In spherical, bondaries in theta/phi are set automatically (only specify bc @ [rmin, rmax] ): [["ATMOSPHERE", "MATCH"]]. * In GR, the horizon boundary is set automatically (only specify bc @ rmax): [["MATCH"]].
particles	array<tuple<string>> "PERIODIC", "ABSORB", "ATMOSPHERE", "CUSTOM", "REFLECT", "HORIZON"	Boundary conditions for particles* When periodic in any of the directions, you should only set one value [..., ["PERIODIC"], ...]. * In spherical, bondaries in theta/phi are set automatically (only specify bc @ [rmin, rmax] ) [["ATMOSPHERE", "ABSORB"]]. * In GR, the horizon boundary is set automatically (only specify bc @ rmax ): [["ABSORB"]].
grid.boundaries.match		Parameters specific to MATCH boundary conditions
ds	float or array<tuple<float>>	Size of the matching layer in each direction for fields in physical (code) unitsIn spherical, this is the size of the layer in r from the outer wall.	1% of the domain size (in shortest dimension)
grid.boundaries.absorb		Parameters specific to ABSORB boundary conditions
ds	float	Size of the absorption layer for particles in physical (code) units* In spherical, this is the size of the layer in r from the outer wall. * In cartesian, this is the same for all dimensions where applicable.	1% of the domain size (in shortest dimension)
grid.boundaries.atmosphere		Parameters specific to ATMOSPHERE boundary conditions
temperature	float	Temperature of the atmosphere in units of m0 c^2[required] if ATMOSPHERE is one of the boundaries.
density	float	Peak number density of the atmosphere at base in units of n0
height	float	Pressure scale-height in physical units
species	array<int> size 2	Species indices of particles that populate the atmosphere
ds	float	Distance from the edge to which the gravity is imposed in physical units0.0 means no limit.	$0.0$
g	float	Acceleration due to imposed gravity
scales		Fiducial scales that fix the code unit system
larmor0	float > 0.0	Fiducial larmor radius
skindepth0	float > 0.0	Fiducial plasma skin depth
dx0	float	fiducial minimum size of the cell
V0	float	fiducial elementary volume
n0	float	Fiducial number density
q0	float	Fiducial elementary charge
sigma0	float	Fiducial magnetization parameter
B0	float	Fiducial magnetic field
omegaB0	float	Fiducial cyclotron frequency
radiation		Radiative drag and photon emission parameters
radiation.drag		Radiation reaction (drag) parameters
radiation.drag.synchrotron		Synchrotron drag parameters
gamma_rad	float > 0.0	Radiation reaction limit gamma-factor for synchrotron[required] if one of the species has radiative_drag = "synchrotron" .	$1.0$
radiation.drag.compton		Compton drag parameters
gamma_rad	float > 0.0	Radiation reaction limit gamma-factor for Compton drag[required] if one of the species has radiative_drag = "compton" .	$1.0$
radiation.emission		Photon emission parameters
radiation.emission.synchrotron		Synchrotron emission parameters
gamma_qed	float > 1.0	Gamma-factor of a particle emitting synchrotron photons at energy m0 c^2 in fiducial magnetic field B0	$10.0$
photon_energy_min	float > 0.0	Minimum photon energy for synchrotron emission (units of m0 c^2)	$10^{-3}$
photon_weight	float > 0.0	Weights for the emitted synchrotron photons	$1.0$
photon_species	ushort > 0	Index of species for the emitted photon
nominal_probability	float	Nominal probability of the emission for a particle with gamma * beta = 1, charge-to-mass = q0 / m0
nominal_photon_energy	float	Nominal energy of the emitted photon for a particle with gamma * beta = 1, mass = m0
radiation.emission.compton		Inverse Compton emission parameters
gamma_qed	float > 1.0	Gamma-factor of a particle emitting inverse Compton photons at energy m0 c^2 in fiducial magnetic field B0	$10.0$
photon_energy_min	float > 0.0	Minimum photon energy for inverse Compton emission (units of m0 c^2)	$10^{-3}$
photon_weight	float > 0.0	Weights for the emitted inverse Compton photons	$1.0$
photon_species	ushort > 0	Index of species for the emitted photon
nominal_probability	float	Nominal probability of the emission for a particle with gamma * beta = 1, charge-to-mass = q0 / m0
nominal_photon_energy	float	Nominal energy of the emitted photon for a particle with gamma * beta = 1, mass = m0
algorithms		Algorithm and solver tuning
current_filters	ushort >= 0	Number of current smoothing passes	$0$
algorithms.timestep		Timestep parameters
CFL	float 0.0 -> 1.0	Courant-Friedrichs-Lewy numberCFL number determines the timestep duration.	$0.95$
correction	float	Correction factor for the speed of light used in field solver	$1.0$
dt	float	timestep duration
algorithms.deposit		Current deposition parameters
enable	bool	Enable the current deposition	true
team_policy_team_size	uint >= 0	Tiled-deposit work-group (team) size	$0$
tiled_deposit_team_size	uint >= 0	Tiled-deposit work-group (team) size0 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).	$0$
order	ushort 0 -> 10	order of the particle shape function
algorithms.gr		GR pusher parameters
pusher_eps	float > 0.0	Stepsize for numerical differentiation in GR pusher	$10^{-6}$
pusher_niter	ushort > 0	Number of iterations for the Newton-Raphson method in GR pusher	$10$
algorithms.gca		Guiding-center approximation parameters
e_ovr_b_max	float 0.0 -> 1.0	Maximum value for E/B allowed for GCA particles	$0.9$
larmor_max	float	Maximum Larmor radius allowed for GCA particles (in physical units)When larmor_max == 0, the limit is disabled.	$0.0$
algorithms.fieldsolver		Stencil coefficients for the field solver [notation as in Blinne+ (2018)]Standard Yee solver: delta_i = beta_ij = 0.0 .
enable	bool	Enable the fieldsolver	true
delta_x	float	delta_x coefficient (for F_{i +/- 3/2, j, k})	$0.0$
delta_y	float	delta_y coefficient (for F_{i, j +/- 3/2, k})Used only for 2D and 3D.	$0.0$
delta_z	float	delta_z coefficient (for F_{i, j, k +/- 3/2})Used only for 3D.	$0.0$
beta_xy	float	beta_xy coefficient (for F_{i +/- 1/2, j +/- 1, k})Used only for 2D and 3D.	$0.0$
beta_yx	float	beta_yx coefficient (for F_{i +/- 1, j +/- 1/2, k})Used only for 2D and 3D.	$0.0$
beta_xz	float	beta_xz coefficient (for F_{i +/- 1/2, j, k +/- 1})Used only for 3D.	$0.0$
beta_zx	float	beta_zx coefficient (for F_{i +/- 1, j, k +/- 1/2})Used only for 3D.	$0.0$
beta_yz	float	beta_yz coefficient (for F_{i, j +/- 1/2, k +/- 1})Used only for 3D.	$0.0$
beta_zy	float	beta_zy coefficient (for F_{i, j +/- 1, k +/- 1/2})Used only for 3D.	$0.0$
particles		Particle and species parameters
ppc0	float > 0.0	Fiducial number of particles per cell
use_weights	bool	Toggle for using particle weights	false
clear_interval	uint	Timesteps between particle re-sorting by tags (removing dead particles)Set to 0 to disable re-sorting.	$100$
spatial_sorting_interval	uint	Timesteps between spatial sorting of particles (for better cache performance)Set to 0 to disable spatial sorting.	$0$
nspec	uint	Number of particle species
particles.species		Particle species definitions
label	string	Label of the species <INDEX> is the index of the species in the list starting from 1.	"s<INDEX>"
mass	float >= 0.0	Mass of the species (in units of fiducial mass)
charge	float	Charge of the species (in units of fiducial charge)
maxnpart	uint > 0	Maximum number of particles per taskRead as a float, so exponential notation is fine (e.g. 1e8 ).
pusher	string "Boris", "Vay", "Boris,GCA", "Vay,GCA", "Photon", "None"	Pusher algorithm for the species	"Boris" [massive]; "Photon" [massless]
n_payloads_real	ushort	Number of additional real-valued variables (payloads) for each particle of the given species	$0$
n_payloads_int	ushort	Number of additional integer-valued variables (payloads) for each particle of the given speciesIf tracking is enabled, one or two extra integer payloads are reserved (depending on whether MPI is enabled).	$0$
tracking	bool	Enable tracking of particles using indices for the given species	false
radiative_drag	string "None", "Synchrotron", "Compton"	Radiation reaction to use for the species* Can also be coma-separated combination, e.g., "Synchrotron,Compton". * Relevant radiation.drag parameters should also be provided.	"None"
emission	string "None", "Synchrotron", "Compton", "Custom"	Particle emission policy for the species* Only one emission mechanism allowed. * Appropriate radiation drag flag will be applied automatically (unless explicitly set to "None").	"None"
spatial_sorting_interval	uint	Timesteps between spatial sorting of particles for given species* Set to 0 to disable spatial sorting. * Overrides particles.spatial_sorting_interval for the given species.	$0$
clear_interval	uint	Timesteps between particle re-sorting by tags (removing dead particles)* Set to 0 to disable re-sorting. * Overrides particles.clear_interval for the given species.	$100$
setup		Parameters for specific problem generators and setupsFree-form: keys are defined by the problem generator, so nothing here is validated.
output		Output parameters
format	string "disabled", "hdf5", "BPFile"	Output format	"bpfile"
interval	uint > 0	Number of timesteps between all outputsValue is overriden by output intervals for specific outputs.	$100$
interval_time	float	Physical (code) time interval between all outputs* When interval_time < 0, the output is controlled by interval , otherwise by interval_time . * Value is overriden by output intervals for specific outputs.	$-1.0$
output.fields		Field output parameters
enable	bool	Toggle for the field output	true
quantities	array<string> "E", "B", "J", "divE", "Rho", "Charge", "N", "Nppc", "T0i", "Tij", "Vi", "D", "H", "divD", "A"	Field quantities to output* For T , you can use unspecified indices: Tij , T0i , or specific ones: Ttt , T00 , T02 , T23 . * For T , in cartesian can also use "x" "y" "z" instead of "1" "2" "3". * By default, we accumulate moments from all massive species, one can specify only specific species: Ttt_1_2 , Rho_1 , Rho_3_4 .	[]
custom	array<string>	Custom (user-defined) field quantities	[]
interval	uint	Number of timesteps between field outputs* When != 0 , overrides output.interval . * When == 0 , output.interval is used.	$0$
interval_time	float	Physical (code) time interval between field outputs* When < 0 , the output is controlled by interval . * When specified, overrides output.interval_time .	$-1.0$
downsampling	uint or array<uint> >= 1	Downsample factor for the output of fields* The output is downsampled by the given factors in each direction. * If a scalar is given, it is applied to all directions.	$[1, 1, 1]$
output.fields.smoothing		Smoothing of the output moments
order	ushort	Smoothing order for the output of moments ("Rho", "Charge", "T", ...)	$0$
method	string "const", "spline"	Smoothing algorithm* When using "spline", order corresponds to the order of the polynomial used. * When using "const", the smoothing window is ceil(order / 2) in both directions.	"spline"
output.particles		Particle output parameters
enable	bool	Toggle for the particles output	true
species	array<int>	Particle species indices to outputIf empty, all species are output.	[]
stride	uint >= 1	Stride for the output of particles	$100$
interval	uint	Number of timesteps between particle outputs* When != 0 , overrides output.interval . * When == 0 , output.interval is used.	$0$
interval_time	float	Physical (code) time interval between particle outputs* When < 0 , the output is controlled by interval . * When specified, overrides output.interval_time .	$-1.0$
output.spectra		Spectra output parameters
enable	bool	Toggle for the spectra output	true
e_min	float	Minimum energy for the spectra output	$10^{-3}$
e_max	float	Maximum energy for the spectra output	$10^{3}$
log_bins	bool	Whether to use logarithmic bins for energy	true
n_bins	uint > 0	Number of energy bins for the spectra output	$200$
num_energy_bins	uint > 0	Number of energy bins for the spectra output	$200$
num_spatial_bins	array<uint> size 1 :->: 3	Number of spatial bins for the spectra output	$[1, 1, 1]$
interval	uint	Number of timesteps between spectra outputs* When != 0 , overrides output.interval . * When == 0 , output.interval is used.	$0$
interval_time	float	Physical (code) time interval between spectra outputs* When < 0 , the output is controlled by interval . * When specified, overrides output.interval_time .	$-1.0$
output.debug		Debug output parameters
as_is	bool	Output fields "as is" without conversions	false
ghosts	bool	Output fields with values in ghost cells	false
output.stats		Integrated statistics output parameters
enable	bool	Toggle for the stats output	true
interval	uint > 0	Number of timesteps between stat outputsOverriden if output.stats.interval_time != -1 .	$100$
interval_time	float	Physical (code) time interval between stat outputsWhen < 0 , the output is controlled by interval .	$-1.0$
quantities	array<string> "B^2", "E^2", "ExB", "N", "Npart", "Charge", "Rho", "T00", "T0i", "Tij"	Field quantities to output* For particle moments, ... * ... same notation is used as for output.fields.quantities .	[ "B^2" , "E^2" , "ExB" , "Rho" , "T00" ]
custom	array<string>	Custom (user-defined) stats	[]
checkpoint		Checkpointing parameters
interval	uint > 0	Number of timesteps between checkpoints	$1000$
interval_time	float > 0	Physical (code) time interval between checkpointsWhen < 0 , the output is controlled by interval .	$-1.0$
keep	int	Number of checkpoints to keep* 0 = disable checkpointing. * -1 = keep all checkpoints.	$2$
walltime	string	Write a checkpoint once after a fixed walltime* The format is "HH:MM:SS". * Empty string or "00:00:00" disables this functionality. * Writing checkpoint at walltime does not stop the simulation.	"00:00:00"
write_path	string	Parent directory to write checkpoints toThe directory is created if it does not exist.	<simname>.ckpt
read_path	string	Parent directory to use when resuming from a checkpoint	inherit write_path
is_resuming	bool	Whether the simulation is resuming from a checkpoint
start_step	uint	Timestep of the checkpoint used to resume
start_time	float	Time of the checkpoint used to resume
adios2		ADIOS2 BP5 tuning, applied to both [output] and [checkpoint] writers
aggregators_per_node	uint	Number of ADIOS2 aggregators per node* Set to either MPI ranks/node or NICs/node for best performance. * If set to 0, will use ADIOS2 default (one aggregator per node).	$0$
max_shm_size	uint	Maximum shared-memory segment size per node, in bytes (BP5 MaxShmSize)Lower this on memory-constrained nodes; matches ADIOS2's default.	$4294967296$
buffer_chunk_size	uint	Internal serialization buffer chunk size, in bytes (BP5 BufferChunkSize)Scales with per-rank output volume; matches ADIOS2's default.	$16777216$
render		In-situ renderer. Renders scalar fields on the GPU and writes PNG images directly to /renders/ each cadence -- no field data is written to storage, and the result is seamless across MPI domain boundaries.* 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). * 1D (and 3D non-Cartesian, which does not exist) is a no-op. * One PNG stream per scene (e.g. a density/|B|/|J| triptych).
enable	bool	Toggle for the on-the-fly renderer	false
interval	uint	Number of timesteps between renders* When != 0 , overrides output.interval . * When == 0 , interval_time (or output.interval ) is used.	$0$
interval_time	float	Physical (code) time interval between rendersWhen < 0 , the output is controlled by interval .	$-1.0$
width	int > 0	Image width in pixels (the rendered region; the PNG is wider if a colorbar margin is added, see colorbar_outside)	$1024$
height	int > 0	Image height in pixels	$1024$
resolution	int > 0	Convenience: force a square frame (sets width == height == resolution), the natural shape for a dome master. Overrides width/height when > 0.	0 (use width/height)
n_lut	int > 1	Number of entries in the color/opacity lookup table	$256$
background	array<float> size 3	Opaque background RGB (each channel 0..1) shown through transparent/low-opacity pixels; also fills the colorbar margin	$[0.0, 0.0, 0.0]$
colorbar	bool	Draw a colorbar (gradient + value ticks + label) on each PNG	true
colorbar_outside	bool	Draw the colorbar in an added right margin (the PNG becomes wider by a fixed strip) instead of overlaying it on the rendered volume	true
mirror	bool	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.	true
time_label	bool	Draw the current simulation time as a label ("T = ", 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.	false
axes	bool	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.* 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).	false
axis_labels	array<string> size <= 3	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).	[ "x" , "y" , "z" ]
axis_ticks	int >= 2	Target number of ticks per axis (actual count is rounded to nice values)	$5$
spine_width	float > 0.0	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.	$2.0$
render.extent		Limit the render region to axis-aligned box in physical/world coordinates. Left unset it spans the full domain. Clamped to the box.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.
x1	array<float> size 2	Axis-aligned render region [lo, hi] along x1, in physical/world coords. Left unset it spans the full domain. Clamped to the box.For a spherical 2D slice, x1 crops the radius r.	[] (full extent)
x2	array<float> size 2	Render region [lo, hi] along x2.For a spherical 2D slice, x2 crops the polar angle theta.	[] (full extent)
x3	array<float> size 2	Render region [lo, hi] along x3.	[] (full extent)
render.volume		Volume rendering parameters (3D Cartesian only)
samples	int > 0	Number of ray-march steps across the global box diagonalThe world-space step is box_diagonal / samples unless step_size is set. Higher = better quality, slower.	$400$
step_size	float >= 0.0	Fixed world-space step between ray samples0 derives the step from samples . The step is identical on all ranks, which is what makes the multi-domain composite seamless.	$0.0$
early_term_alpha	float 0.0 -> 1.0	Stop marching a ray once its accumulated opacity reaches this valuePure speed optimization; set to 1.0 to disable early termination.	$0.99$
render.moving_view		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.
velocity	array<float> size 2 or 3	Velocity of the moving camera in world units.	[] (static view)
start_time	float	Sim time at which the view starts moving (static before it, e.g. to let an initial ramp-up finish)	$0.0$
render.camera		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.
mode	string "orthographic", "perspective", "dome"	Projection mode. Overrides orthographic below when set."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).	(unset -> use orthographic)
position	array<float> size 3	Camera (eye) position in world (physical) coordinates	box center pushed back ~1.7 box-diagonals along (1, 1, 1); for mode = "dome", the domain center (interior eye)
look_at	array<float> size 3	Point the camera looks at, in world coordinates (the dome ZENITH target)	box center; for mode = "dome", the zenith defaults to +z
up	array<float> size 3	Camera up vector (dome: the disk's screen-up)	$[0.0, 0.0, 1.0]; for mode = "dome", [0.0, 1.0, 0.0]$
fov	float > 0.0	Vertical field of view in degrees (perspective only)	$35.0$
dome_fov	float > 0.0, <= 360.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).	$180.0$
dome_radius	float >= 0.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.0 disables the clip (rays march to the box boundary).	the largest sphere centered in the box (half the shortest side), so it touches the face centers and never a corner
ortho_height	float > 0.0	Vertical extent of the view in world units (orthographic only)	the global box diagonal (the whole box fits from any angle)
render.dome		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.* CARTESIAN -- the flat plane is warped radially into the disk; use fov /radius/center/projection below. * 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).
enable	bool	Build the fisheye dome master instead of the plain slice	false
fov	float > 0.0, <= 180.0	(Cartesian only) Full dome field of view in degrees (image radius maps linearly to the dome zenith angle: the rim is at fov/2)	180.0 # a full hemisphere
radius	float > 0.0	(Cartesian only) World radius of the circular cutout mapped onto the dome	half the shorter domain side (the largest centered disk that fits inside the box)
center	array<float> size 2	(Cartesian only) World-space center of the cutout	the domain center
projection	string "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)	(Cartesian only) How the dome zenith angle maps to a world radius on the flat slice	"equidistant"
render.fieldlines		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.
enable	bool	Build the field-line geometry this runimplied true if any scene sets fieldlines = true or uses field = "fieldlines" .	false
field	string "B", "E", "J"	Vector field to trace	"B"
bin	int 1..16	Field coarsening factor (simulation cells per coarse cell, per axis)larger = smoother "morphology" lines + cheaper replication (the coarse field is ~ N_cells / bin^D floats/rank; D = sim dimension).	$4$
seed_px	float > 0	(3D tubes) Seed-lattice spacing in screen pixels (sets line density)capped by seed_max ; if seed_px asks for more seeds than that, the spacing grows to fit and seed_px no longer governs.	$8$
seed_max	int > 0	(3D tubes) Hard cap on the seed count (lattice is n^3, 2 lines per seed)lower this for fewer / more widely spaced lines.	$4096$
levels	int > 0	(2D contours) Number of evenly-spaced flux-function contour levelsevenly-spaced psi levels => line density tracks |B| automatically.	$16$
tube_px	float > 0	Tube radius (3D) / contour line width (2D), in screen pixels	$2$
colormap	string "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 for the field lines (mapped by |B| along each line)	"inferno"
color	array<float> size 3	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	[] (empty => color by |B|)
log	bool	Map the tube color range logarithmicallyrequires min > 0.	false
min	float	Tube color range: lower bound on |field|when min >= max, the range is auto-set from |field| along the lines.	$0.0$
max	float	Tube color range: upper bound on |field|when min >= max, the range is auto-set from |field| along the lines.	$0.0$
step_frac	float > 0	(3D tubes) RK4 integration step as a fraction of one coarse cell	$0.5$
max_steps	int > 0	(3D tubes) Per-direction integration-step cap	$4000$
max_length	float > 0	(3D tubes) Maximum line length, in global box diagonals (per direction)	$3.0$
render.scene		One scene per scalar field -> one PNG stream. Repeat the table for each.
field	string (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"	Scalar field to render (a volume render needs a scalar, so vectors are given as a magnitude or a single component)* "{E,B,J}mag" = vector magnitude |.|; "B1"/"Bx", "J3"/"Jz", ... = a single (signed) physical component. * a bare vector ("E"/"B"/"J") is not renderable -- choose a component or the magnitude. * "N"/"Nppc" = number / per-cell count, "Rho" = mass density, "Charge" = charge density. * "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). * 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. * per-species selection with a "_<id>" suffix on moments, e.g. "N_1", "Rho_2", "Txy_1_2", "V1_3"; default = all massive species. * components are signed; pair a symmetric min /max with a diverging colormap ("cool2warm") to center zero. * "fieldlines" renders the magnetic field-line tubes on their own (no scalar volume sampled); see [render.fieldlines] below.
prefix	string	PNG filename prefix; files are .png	"<field>_"
label	string	Colorbar title	field
min	float	Lower bound of the value range mapped onto the colormap/opacity	$0.0$
max	float	Upper bound of the value range	$1.0$
log	bool	Map the value range logarithmicallyRequires min > 0 and max > 0.	false
colormap	string "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 name	"viridis"
alpha	array<tuple<float>>	Opacity transfer function: [position, opacity] control points, both in [0, 1], piecewise-linear in the normalized valueKeep the low end near 0 so empty regions stay transparent.	linear ramp (opacity = normalized value)
colorbar_ticks	array<float>	Explicit value(s) to label on the colorbarValues outside [min, max] are skipped.	5 evenly-spaced ticks between min and max
fieldlines	bool	Overlay the magnetic field-line tubes inside this scene's volumerequires the [render.fieldlines] enabled (3D only). A scene with field = "fieldlines" instead renders them alone.	false
diagnostics		Diagnostic logging parameters
interval	int > 0	Number of timesteps between diagnostic logs	$1$
blocking_timers	bool	Blocking timers between successive algorithms	false
colored_stdout	bool	Enable colored stdout	true
log_level	string "VERBOSE", "WARNING", "ERROR"	Specify the log level"VERBOSE" prints all messages, "WARNING" prints only warnings and errors, "ERROR" prints only errors.	"VERBOSE"