_cpp_parameters

# name   type   default   ifdef
#
# note, name can have two values, as (a, b).  a will be the name used
# in the inputs file, b is the variable name in the C++ class.


@namespace: castro

#-----------------------------------------------------------------------------
# category: AMR
#-----------------------------------------------------------------------------

# highest order used in interpolation
state_interp_order           int           1

# how to do limiting of the state data when interpolating
# 0: only prevent new extrema
# 1: preserve linear combinations of state variables
# 2: preserve linear combinations and prevent new extrema
lin_limit_state_interp       int           0

# do we do the hyperbolic reflux at coarse-fine interfaces?
do_reflux                    bool          1

# whether to re-compute new-time source terms after a reflux
# Note: this only works for the CTU and simple-SDC time_integration_method
# drivers
update_sources_after_reflux  bool          1

# Castro was originally written assuming dx = dy = dz.  This assumption is
# enforced at runtime.  Setting allow_non_unit_aspect_zones = 1 opts out.
allow_non_unit_aspect_zones  bool          0


#-----------------------------------------------------------------------------
# category: hydrodynamics
#-----------------------------------------------------------------------------

# the coefficient of the artificial viscosity
difmag                       Real          0.1

# the small density cutoff.  Densities below this value will be reset
small_dens                   Real         -1.e200

# the small temperature cutoff.  Temperatures below this value will
# be reset
small_temp                   Real         -1.e200

# the small pressure cutoff.  Pressures below this value will be reset
small_pres                   Real         -1.e200

# the small specific internal energy cutoff.  Internal energies below this
# value will be reset
small_ener                   Real         -1.e200

# permits hydro to be turned on and off for running pure rad problems
do_hydro                     bool          true

# how do we advance in time? 0 = CTU + Strang, 1 is not used, 2 = SDC, 3 = simplified-SDC
time_integration_method      int           0

# do we use a limiter with the fourth-order accurate reconstruction?
limit_fourth_order           bool           1

# for fourth order, we usually assume that the initialization is done
# to cell centers and we convert to cell-averages.  With this option,
# we take the initialization as cell-averages (except for T, which we
# compute to fourth-order through the EOS after initialization).
initialization_is_cell_average  bool        0

# should we use a reconstructed version of Gamma_1 in the Riemann
# solver? or the default zone average (requires SDC
# integration, since we do not trace)
use_reconstructed_gamma1     bool          0

# if true, define an additional source term
add_ext_src                  bool          0

# whether to use the hybrid advection scheme that updates
# z-angular momentum, cylindrical momentum, and azimuthal
# momentum (3D only)
hybrid_hydro                 bool          0

# reconstruction type:
# 0: piecewise linear;
# 1: classic Colella \& Woodward ppm;
ppm_type                     int           1

# do we limit the ppm parabola?
ppm_do_limiting              bool           1

# For MHD + PLM, do we limit on characteristic or primitive variables
mhd_limit_characteristic     bool           1

# various methods of giving temperature a larger role in the
# reconstruction---see Zingale \& Katz 2015
ppm_temp_fix                 int           0

# for piecewise linear, reconstruction order to use
# 1 = piecewise constant, 2 = piecewise linear
plm_iorder                   int           2

# for piecewise linear, what limiter to use?
# 1 = 2nd order MC, 2 = 4th order MC
plm_limiter                  int           2

# do we drop from our regular Riemann solver to HLL when we
# are in shocks to avoid the odd-even decoupling instability?
hybrid_riemann               bool           0

# which Riemann solver do we use:
# 0: Colella, Glaz, \& Ferguson (a two-shock solver);
# 1: Colella \& Glaz (a two-shock solver)
# 2: HLLC
riemann_solver               int           0

# maximum number of iterations to used in the Riemann solver
# when solving for the star state
riemann_shock_maxiter                   int          12

# tolerance to use when finding the star stat
riemann_pstar_tol                       Real          1.0e-5

# for the Colella \& Glaz Riemann solver, what to do if
# we do not converge to a solution for the star state.
# 0 = do nothing; print iterations and exit
# 1 = revert to the original guess for p-star
# 2 = do a bisection search for another 2 * riemann_shock_maxiter iterations.
riemann_cg_blend                     int           2

# flatten the reconstructed profiles around shocks to prevent them
# from becoming too thin
use_flattening               bool           1

# after we add the transverse correction to the interface states, replace
# the predicted pressure with an EOS call (using :math:`e` and :math:`\rho`).
transverse_use_eos           bool           0

# if the transverse interface state correction, if the new density is
# negative, then replace all of the interface quantities with their
# values without the transverse correction.
transverse_reset_density     bool           1

# if the interface state for :math:`(\rho e)` is negative after we add the
# transverse terms, then replace the interface value of :math:`(\rho e)`
# with a value constructed from the :math:`(\rho e)` evolution equation
transverse_reset_rhoe        bool           0

# Threshold value of (E - K) / E such that above eta1, the hydrodynamic
# pressure is derived from E - K; otherwise, we use the internal energy
# variable UEINT.
dual_energy_eta1             Real          1.0e0

# Threshold value of (E - K) / E such that above eta2, we update the
# internal energy variable UEINT to match E - K. Below this, UEINT
# remains unchanged.
dual_energy_eta2             Real          1.0e-4

# for the piecewise linear reconstruction, do we subtract off :math:`(\rho g)`
# from the pressure before limiting?  This is a well-balanced method that
# does well with HSE
use_pslope                   bool           0

# for PPM, do we only use the perturbational pressure in the characteristic
# tracing?  This is more indepth than the simple `use_pslope` approach.
ppm_well_balanced            bool           0

# if we are using pslope, below what density to we turn off the well-balanced
# reconstruction?
pslope_cutoff_density        Real          -1.e20

# Should we limit the density fluxes so that we do not create small densities?
limit_fluxes_on_small_dens   bool           0

# Enforce the magnitude of the velocity to be no larger than this number (and
# optionally limit the fluxes as well). Only applies if it is greater than 0.
speed_limit                  Real          0.0

# permits sponge to be turned on and off
do_sponge                    bool           0

# if we are using the sponge, whether to use the implicit solve for it
sponge_implicit              bool           1

# if we are using user-defined source terms, are these solved implicitly?
ext_src_implicit             bool           0

# extrapolate the source terms (gravity and rotation) to :math:`n+1/2`
# timelevel for use in the interface state prediction
source_term_predictor        bool           0

# set the flattening parameter to zero to force the reconstructed profiles
# to be flat, resulting in a first-order method
first_order_hydro            bool           0

# if we are doing an external -x boundary condition, who do we interpret it?
# 1 = HSE
xl_ext_bc_type               int          -1

# if we are doing an external +x boundary condition, who do we interpret it?
# 1 = HSE
xr_ext_bc_type               int          -1

# if we are doing an external -y boundary condition, who do we interpret it?
# 1 = HSE
yl_ext_bc_type               int          -1

# if we are doing an external +y boundary condition, who do we interpret it?
# 1 = HSE
yr_ext_bc_type               int          -1

# if we are doing an external -z boundary condition, who do we interpret it?
# 1 = HSE
zl_ext_bc_type               int          -1

# if we are doing an external +z boundary condition, who do we interpret it?
# 1 = HSE
zr_ext_bc_type               int          -1

# if we are doing HSE boundary conditions, do we zero the velocity?
hse_zero_vels                bool           0

# if we are doing HSE boundary conditions, should we get the temperature
# via interpolation (constant gradient) or hold it constant?
hse_interp_temp              bool           0

# if we are doing HSE boundary conditions and holding the temperature constant,
# then set it to a fixed value at the boundaries (only if positive)
hse_fixed_temp               Real          -1.e200

# if we are doing HSE boundary conditions, how do we treat the velocity?
# reflect? or outflow?
hse_reflect_vels             bool           0

# fills physical domain boundaries with the ambient state
fill_ambient_bc              bool           0

# which direction do we do ambient BCs?  -1 = all, 0 = x, 1 = y, 2 = z
ambient_fill_dir             int           -1

# in the ambient region, do we do a basic outflow in the normal
# direction of the velocity (with a min/max to ensure it is outgoing)
ambient_outflow_vel          int           0

# clamps the ambient material to the ambient temperature
clamp_ambient_temp           bool           0

# specifies the upper limit, as a multiple of the ambient density, for
# operations that are applied to ambient material, such as clamping T.
ambient_safety_factor        Real          1.1e0

# density of the ambient material (should default to the same as small_dens)
ambient_density              Real          -1.e200

# temperature of the ambient material (should default to the same as small_temp)
ambient_temp                 Real          -1.e200

# energy of the ambient material (should default to the same as small_ener)
ambient_energy               Real          -1.e200

# integration order for SDC integration
# valid options are 2 and 4
sdc_order                    int           2

# which quadrature type to use with SDC?  0 = Gauss-Lobatto, 1 = Radau
sdc_quadrature               int           0

# number of extra SDC iterations to take beyond the order.  This only applies
# for true SDC.
sdc_extra                    int           0

# which SDC nonlinear solver to use?  1 = Newton, 2 = VODE, 3 = VODE for first iter
sdc_solver                   int           1

# Do we include geometry source terms due to local unit vectors in non-Cartesian Coord?
# We currently support R-Z cylinderical 2D (Bernand-Champmartin) and R-THETA spherical 2D
use_geom_source              bool          1

# for simplified-SDC, do we add the reactive source prediction to the interface states
# used in the advective source construction?
add_sdc_react_source_to_advection  bool     1

# In GPU builds, the hydro advance typically results in a large amount of extra
# temporary memory allocated due to the large tile sizes that are used for computational
# efficiency. If you want to constrain the code's GPU memory footprint at the expense
# of throughput, set the following parameter to some number greater than 0. This controls
# the ratio of additional extra memory that can be allocated by the hydro relative to the
# size of the base state (indirectly, by controlling the hydro tile size and then
# synchronizing each time the amount of currently allocated fab memory reaches the
# target limit). Choosing a value only slightly larger than 0 means that you want very
# little additional memory allocated, and you will take a relatively large performance
# hit, while choosing a value much greater than 1.0 would result in maximum throughput
# but also maximum memory footprint. You will likely have to experimentally find a good
# ratio for your use case, but a ratio around 2.0 - 4.0 is likely to yield a reasonable
# balance between memory footprint and throughput. Note: the first timestep will be very
# slow when using this option.
hydro_memory_footprint_ratio       real    -1.0

#-----------------------------------------------------------------------------
# category: timestep control
#-----------------------------------------------------------------------------

# a fixed timestep to use for all steps (negative turns it off)
fixed_dt                     Real         -1.0

# the initial timestep (negative uses the step returned from the timestep
# constraints)
initial_dt                   Real         -1.0

# the smallest valid timestep, as a fraction of the current simulation time.
# if we go below this, we abort.
dt_cutoff                    Real          1.e-12

# the largest valid timestep---limit all timesteps to be no larger than this
max_dt                       Real          1.e200

# the effective Courant number to use---we will not allow the hydrodynamic
# waves to cross more than this fraction of a zone over a single timestep
cfl                          Real          0.8

# a factor by which to reduce the first timestep from that requested by
# the timestep estimators
init_shrink                  Real          1.0

# the maximum factor by which the timestep can increase or decrease from
# one step to the next. Must be greater than 1.0---use max_dt to set a cap
# on the timestep.
change_max                   Real          1.1

# whether to check that we will take a valid timestep before the advance
check_dt_before_advance      bool           1

# whether to check that we took a valid timestep after the advance
check_dt_after_advance       bool           1

# enforce that the AMR plot interval must be hit exactly
plot_per_is_exact            bool           0

# enforce that the AMR small plot interval must be hit exactly
small_plot_per_is_exact      bool           0

# Retry a timestep if it violated the timestep-limiting criteria or
# other checks (negative density, burn failure) over the course of an
# advance. The criteria will suggest a new timestep that satisfies the
# criteria, and we will do subcycled timesteps on the same level until
# we reach the original target time.
use_retry                    bool           1

# When performing a retry, the factor to multiply the current
# timestep by when trying again.
retry_subcycle_factor        Real          0.5

# Skip retries for small (or negative) density if the zone's density prior
# to the update was below this threshold.
retry_small_density_cutoff   Real         -1.e200

# Set the threshold for failing the species abundance validity check.
abundance_failure_tolerance  Real          1.e-2

# Do not abort for invalid species abundances if the zone's density is below
# this threshold.
abundance_failure_rho_cutoff Real         -1.e200

# Regrid after every timestep.
use_post_step_regrid         bool           0

# Do not permit more subcycled timesteps than this parameter.
# Set to a negative value to disable this criterion.
max_subcycles                int           10

# Number of iterations for the simplified SDC advance.
sdc_iters                    int           2

# Field to use for determining whether to stop the simulation.
stopping_criterion_field     string        ""

# Threshold value for determining whether to stop.
stopping_criterion_value     Real          1.e200

#-----------------------------------------------------------------------------
# category: reactions
#-----------------------------------------------------------------------------

# Limit the timestep based on how much the burning can change the internal
# energy of a zone. The timestep is equal to
# ``dtnuc``  :math:`\cdot\,(e / \dot{e})`.
dtnuc_e                      Real          1.e200

# Limit the timestep based on how much the burning can change the species
# mass fractions of a zone. The timestep is equal to
# ``dtnuc``  :math:`\cdot\,(X / \dot{X})`.
dtnuc_X                      Real          1.e200

# If we are using the timestep limiter based on changes in $X$, set a threshold
# on the species abundance below which the limiter is not applied. This helps
# prevent the timestep from becoming very small due to changes in trace species.
dtnuc_X_threshold            Real          1.e-3

# permits reactions to be turned on and off -- mostly for efficiency's sake
do_react                     bool          true

# minimum temperature for allowing reactions to occur in a zone
react_T_min                  Real          0.0

# maximum temperature for allowing reactions to occur in a zone
react_T_max                  Real          1.e200

# minimum density for allowing reactions to occur in a zone
react_rho_min                Real          0.0

# maximum density for allowing reactions to occur in a zone
react_rho_max                Real          1.e200

# disable burning inside hydrodynamic shock regions
# note: requires compiling with `USE_SHOCK_VAR=TRUE`
disable_shock_burning        bool           0

# shock detection threshold for grad{P} / P
shock_detection_threshold    Real          0.6666666666666666666666_rt

# do we subtract off the hydrostatic pressure when evaluating a shock?
shock_detection_include_sources   bool      1

# initial guess for the temperature when inverting the EoS (e.g. when
# calling eos_input_re)
T_guess                     Real           1.e8

# if set to 1, we interpolate from the initial model to get the temperature
# used to call the burner.  This prevents reactions from going nonlinear
# and running away in place before a convective field is established.
drive_initial_convection     bool           0

# maximum time over which to do the drive_initial_convection procedure
drive_initial_convection_tmax   Real       1.e200

# frequency with which to re-initialize the thermodynamic data while preserving
# the velocity field during drive_initial_convection
drive_initial_convection_reinit_period   Real    1.e200

#-----------------------------------------------------------------------------
# category: diffusion
#-----------------------------------------------------------------------------

# enable thermal diffusion
diffuse_temp                 bool           0                  DIFFUSION

# set a cutoff density for diffusion -- we zero the term out below this density
diffuse_cutoff_density       Real          -1.e200            DIFFUSION

# secondary cutoff density -- there will be a linear dropoff in the diffusion
# coefficient between this and the primary cutoff density. This should be the
# larger of the two
diffuse_cutoff_density_hi    Real          -1.e200            DIFFUSION

# scaling factor for conductivity
diffuse_cond_scale_fac       Real          1.0                DIFFUSION


#-----------------------------------------------------------------------------
# category: gravity and rotation
#-----------------------------------------------------------------------------

# permits gravity calculation to be turned on and off
do_grav                      bool          true

# to we recompute the center used for the multipole gravity solve each step?
moving_center                bool           0

# determines how the gravitational source term is added to the momentum and
# energy state variables.
grav_source_type             int           4

# permits rotation calculation to be turned on and off
do_rotation                  bool          true

# the rotation period for the corotating frame
rotational_period            Real         -1.e200             ROTATION

# permits the centrifugal terms in the rotation to be turned on and off
rotation_include_centrifugal bool           1                  ROTATION

# permits the Coriolis terms in the rotation to be turned on and off
rotation_include_coriolis    bool           1                  ROTATION

# determines how the rotation source terms are added to the momentum and
# energy equations
rot_source_type              int           4                  ROTATION

# we can do a implicit solution of the rotation update to allow
# for better coupling of the Coriolis terms
implicit_rotation_update     bool           1                  ROTATION

# the coordinate axis for the rotation vector
# For Cartesian: (:math:`x=1`, :math:`y=2`, :math:`z=3`)
# For non-Cartesian coordinates, this parameter doesn't do anything because:
# For RZ (Cylindrical 2D), it is automatically set to z-axis (rot_axis = 2)
# For Spherical2D, it is also assumed to be in the z-axis
# i.e. cos(theta) r_hat - sin(theta) theta_hat in Spherical coordinate.
rot_axis                     int           3                  ROTATION

# include a central point mass
use_point_mass               bool           0                  GRAVITY

# mass of the point mass
point_mass                   Real          0.0                GRAVITY

# if we have a central point mass, we can prevent mass from building
# up in the zones adjacent to it by keeping their density constant and
# adding their mass to the point mass object
point_mass_fix_solution      bool           0                  GRAVITY

# Distance (in kpc) used for calculation of the gravitational wave amplitude
# (this will be calculated along all three coordinate axes). Only relevant if
# castro.sum_interval > 0 and if set to a positive number. A standard value
# in the literature is 10.0 (kpc).
gw_dist                      Real          0.0                GRAVITY

# This integer is used to activate parallel plane 1/r**2 gravity.
point_mass_offset_is_true    bool           0                  GRAVITY

# Distance, shifted from the origin, and used to compute the gravity on
# plane parallel due to the action of an star with a radius given by this offset.

point_mass_location_offset   Real          0.0                GRAVITY

#-----------------------------------------------------------------------------
# category: sponge
#-----------------------------------------------------------------------------

# Minimum simulation distance from center to start applying the sponge
sponge_lower_radius          Real         -1.0                SPONGE

# Simulation distance from the center at which the sponge is fully applied
sponge_upper_radius          Real         -1.0                SPONGE

# Minimum density at which to start applying the sponge
sponge_lower_density         Real         -1.0                SPONGE

# Density at which the sponge is fully applied
sponge_upper_density         Real         -1.0                SPONGE

# Minimum pressure at which to start applying the sponge
sponge_lower_pressure        Real         -1.0                SPONGE

# Pressure at which the sponge is fully applied
sponge_upper_pressure        Real         -1.0                SPONGE

# Scaling factor for the sponge below the low end
sponge_lower_factor          Real          0.0                SPONGE

# Scaling factor for the sponge above the high end
sponge_upper_factor          Real          1.0                SPONGE

# Target x-velocity for the sponge to drive to
sponge_target_x_velocity     Real          0.0                SPONGE

# Target y-velocity for the sponge to drive to
sponge_target_y_velocity     Real          0.0                SPONGE

# Target z-velocity for the sponge to drive to
sponge_target_z_velocity     Real          0.0                SPONGE

# Timescale on which the sponge operates
sponge_timescale             Real         -1.0                SPONGE


#-----------------------------------------------------------------------------
# category: parallelization
#-----------------------------------------------------------------------------

bndry_func_thread_safe       bool           1


#-----------------------------------------------------------------------------
# category: embiggening
#-----------------------------------------------------------------------------

# the factor by which to extend the domain upon restart for embiggening
grown_factor                 int           1

# used with the embiggening routines to determine how to extend the domain
star_at_center               bool          true


#-----------------------------------------------------------------------------
# category: self-consistent field initialization
#-----------------------------------------------------------------------------

# Should we use SCF to construct the initial model?
do_scf_initial_model         bool           0

# Maximum density on the domain when using SCF
scf_maximum_density          Real          -1.e6

# Equatorial and polar radii of the star constructed by SCF
scf_equatorial_radius        Real          -1.e9
scf_polar_radius             Real          -1.e9

# SCF relaxation tolerance
scf_relax_tol                Real          1.e-3

# Maximum number of SCF iterations
scf_max_iterations           int           30



#-----------------------------------------------------------------------------
# category: refinement
#-----------------------------------------------------------------------------


do_special_tagging           bool           0

# Maximum radius from the center (in units of the domain width)
# where tagging is allowed. The default choice implies no restriction.
max_tagging_radius           real          10.0e0



#-----------------------------------------------------------------------------
# category: diagnostics, I/O
#-----------------------------------------------------------------------------

# verbosity level (higher numbers mean more output)
(v, verbose)                 int           0

# do we dump the old state into the checkpoint files too?
dump_old                     bool           0

# do we assume the domain is plane parallel when computing some of the derived
# quantities (e.g. radial velocity).  Note: this will always assume that the
# last spatial dimension is vertical
domain_is_plane_parallel     bool           0

# display information about updates to the state (how much mass, momentum, energy added)
print_update_diagnostics     bool           (0, 1)

# how often (number of coarse timesteps) to compute integral sums (for runtime diagnostics)
sum_interval                 int           -1

# how often (simulation time) to compute integral sums (for runtime diagnostics)
sum_per                      Real          -1.0e0

# a string describing the simulation that will be copied into the
# plotfile's ``job_info`` file
job_name                     string        "Castro"

# write a final plotfile and checkpoint upon completion
output_at_completion         bool           1

# Do we want to reset the time in the checkpoint?
# This ONLY takes effect if amr.regrid_on_restart = 1 and amr.checkpoint_on_restart = 1,
# (which require that max_step and stop_time be less than the value in the checkpoint)
# and you set it to value greater than this default value.
reset_checkpoint_time        Real          -1.e200

# Do we want to reset the number of steps in the checkpoint?
# This ONLY takes effect if amr.regrid_on_restart = 1 and amr.checkpoint_on_restart = 1,
# (which require that max_step and stop_time be less than the value in the checkpoint)
# and you set it to value greater than this default value.
reset_checkpoint_step        int           -1

# Do we store the species creation rates in the plotfile?  Note, if this option is
# enabled then more memory will be allocated to hold the results of the burn
store_omegadot               bool            0

# Do we store the burn weights as a diagnostic in the plotfile?    Note, if this option is
# enabled then more memory will be allocated to hold the results of the burn
store_burn_weights           bool            0

# Do we abort the run if the inputs file specifies a runtime parameter that we don't
# know about?  Note: this will only take effect for those namespaces where 100%
# of the runtime parameters are managed by the python scripts.
abort_on_invalid_params      bool            0

#-----------------------------------------------------------------------------
# category: radiation-hydro
#-----------------------------------------------------------------------------

# do we enable radiation for a radiation-hydrodynamics run?
do_radiation                 bool           true



#-----------------------------------------------------------------------------
# category: particles
#-----------------------------------------------------------------------------

# permits tracer particle calculation to be turned on and off
do_tracer_particles          bool           0       AMREX_PARTICLES


@namespace: particles

# the level of verbosity for the tracer particle (0 or 1)
(v, particle_verbose)                int            0

# the name of an input file containing the total particle number and the initial position of each particle.
particle_init_file           string        ""

# the name of a file with new particles at restart
particle_restart_file        string        ""

# to restart from a checkpoint that was written with ``USE_PARTICLES`` =FALSE
restart_from_nonparticle_chkfile     bool      0

# the name of timestamp files.
particle_output_file         string        ""

# the name of a directory in which timestamp files are stored.
timestamp_dir                 string        ""

# whether the local densities at given positions of particles are stored in output files
timestamp_density            bool           1

# whether the local temperatures at given positions of particles are stored in output files
timestamp_temperature        bool           0



@namespace: gravity

# what type
gravity_type                 string        "fillme"


# if doing constant gravity, what is the acceleration
const_grav                   Real          0.0

# Check if the user wants to compute the boundary conditions using the
# brute force method.  Default is false, since this method is slow.
direct_sum_bcs               bool           0

# ratio of dr for monopole gravity binning to grid resolution
drdxfac                     int            1

# the maximum mulitpole order to use for multipole BCs when doing
# Poisson gravity
(max_multipole_order, lnum) int            0

# the level of verbosity for the gravity solve (higher number means more
# output on the status of the solve / multigrid
(v, verbose)                int            0

# do we perform the synchronization at coarse-fine interfaces?
no_sync                     bool            0

# should we apply a lagged correction to the potential that
# gets us closer to the composite solution? This makes the
# resulting fine grid calculation slightly more accurate,
# at the cost of an additional Poisson solve per timestep.
do_composite_phi_correction   bool            1

# For all gravity types, we can choose a maximum level for explicitly
# calculating the gravity and associated potential. Above that level,
# we interpolate from coarser levels.
max_solve_level              int           MAX_LEV-1

# For non-Poisson gravity, do we want to construct the gravitational
# acceleration by taking the gradient of the potential, rather than
# constructing it directly?
get_g_from_phi               bool            0

# how many FMG cycles?
mlmg_max_fmg_iter            int           0

# Do agglomeration?
mlmg_agglomeration           bool           1
mlmg_consolidation           bool           1

# Do N-Solve?
mlmg_nsolve                  bool           0

@namespace: diffusion

# the level of verbosity for the diffusion solve (higher number means
# more output)
(v, verbose)                int            0

# Use MLMG as the operator
mlmg_maxorder                int           4

@namespace: radsolve

# the linear solver option to use
level_solver_flag            int           1

use_hypre_nonsymmetric_terms bool           0

reltol                       Real          1.e-10

abstol                       Real          1.e-10

maxiter                      int           40

alpha                        Real          1.0

beta                         Real          1.0

(v, verbose)                 int           0


@namespace: radiation

prop_temp_floor              Real          0.0

flatten_pp_threshold         Real          -1.0

# are we in a comoving reference frame?
comoving                     bool           1

# which closure relation to use
# 0: f = lambda
# 1: f = 1/3
# 2: f = 1 - 2 * lambda
# 3: f = lambda + (lambda * R)^2
# 4: f = 1/3 + 2/3 (lambda * R)^2
closure                      int           3

# which limiter to use
# 0: no limiter
# 2: Lev-Pom limiter
# 12: Bruenn
# 22: square root
# 32: Minerbo
limiter                      int           2

# frequency space advection type
fspace_advection_type        int           2


# do we plot the flux limiter lambda?
plot_lambda                  bool           0

# do we plot the Planck mean opacity?
plot_kappa_p                 bool           0

# do we plot the Rosseland mean opacity?
plot_kappa_r                 bool           0

# do we plot the lab radiation energy?
plot_lab_Er                  bool           0

# do we plot the lab radiation flux?
plot_lab_flux                bool           0

# do we plot the comoving frame radiation flux?
plot_com_flux                bool           0