Enzo-E / Cello Parameters

This page documents all current parameters implemented in Enzo-E / Cello. Each parameter is summarized, its type or types are listed, and the default value (if any) is provided. The scope of the parameter is also listed, which is either “Cello” or “Enzo”, depending on whether the parameter is associated with Cello framework or Enzo-E application. Any assumptions associated with a parameter are also listed; for example, a parameter may only be valid if some other parameter is set to a certain value.

If you find any errors in the documentation, or have any specific suggestions, please contact the Enzo Project developers at github.

Adapt

Adapt parameters define how the mesh hierarchy dynamically adapts to the solution. It is closely related to the Mesh parameters, which defines the root grid size, number of blocks in the root grid, and size of blocks.

Parameter: Adapt : interval
Summary: Number of cycles between adapt steps
Type: integer
Default: 1
Scope: Cello

The interval parameter is used to set the number of root-level cycles between mesh adaptation. The default is 1.

Parameter: Adapt : max_level
Summary: Maximum level in the adaptive mesh hierarchy
Type: integer
Default: 0
Scope: Cello

This parameter specifies the level of the most highly refined Block in the mesh hierarchy. The default is 0, meaning there is no refinement past the initial root-level grid.

Parameter: Adapt : min_level
Summary: Minimum level in the adaptive mesh hierarchy
Type: integer
Default: 0
Scope: Cello

This parameter specifies the coarsest level of “sub-root” Blocks, and must non-positive. This is used primarily for multigrid methods, such as in the “mg0” solver. The default is 0, meaning no sub-root Blocks are created. If multigrid is used, then both Adapt:min_level and Method:<mg-solver>:min_level must be set..

Parameter: Adapt : list
Summary: List of refinement criteria
Type: list ( string )
Default: []
Scope: Cello

List of mesh refinement criteria, each of which has its own associated Adapt:<criteria> parameters. When multiple criteria are used, if all refinement criteria evaluate to “coarsen”, then the block will be tagged to coarsen; if any refinement criteria evaluate as “refine”, then the block will be tagged to refine. (Note that a particular block will coarsen only if it and all other sibling blocks are tagged to coarsen as well.)

The items in the list need not be the same as the (required) Adapt:<criterion>:type parameter; they are solely used to identify and distinguish between different criteria in the simulation. This allows the user to use multiple criteria of the same type but with different parameters, e.g. “mask” with different masks:

Adapt {
   list = ["criterion_1", "criterion_2"];
   criterion_1 {
      type = "shock";
   }
   criterion_2 {
      type = "shear";
   }
}

Parameter: Adapt : min_face_rank
Summary: Minimum rank of Block faces to check for 2:1 refinement restriction
Type: integer
Default: 0
Scope: Cello

Many numerical methods require a 2:1 refinement restriction on adaptive meshes, such that no Block in level i is adjacent to another Block in a level j with |i - j|>1. This assumption may be required across corners and edges as well as 2D faces. This parameter specifies the minimum rank (dimensionality) of Block faces across which to enforce the 2:1 refinement restriction.

Parameter: Adapt : <criterion> : field_list
Summary: List of field the refinement criterion is applied to
Type: [ string | list ( string ) ]
Default: [] ( all fields )
Scope: Cello

This parameter specifies the fields that the refinement criteria is applied to. For example, if type = “slope” and field_list = [“density”], then the “refine by slope” refinement criterion is applied to the density field.

Parameter: Adapt : <criterion> : level_exponent
Summary: Level exponent parameter
Type: float
Default: 0.0
Scope: Cello
Assumes: <criterion> is of type “mass”

The level exponent parameter is used in the “mass” refinement criterion type only. It is used as a scaling factor for the refinement criteria for different mesh levels.

Parameter: Adapt : <criterion> : max_coarsen
Summary: Cutoff value for coarsening a block
Type: [ float | list ( float ) ]
Default: 0.5*min_refine
Scope: Cello

A block may coarsen if the refinement criterion applied to the block is smaller than this value everywhere in the block. A list is used for the “shock” refinement criterion type, in which case the first value is for pressure and the second is for the energy ratio.

Parameter: Adapt : <criterion> : include_ghosts
Summary: Whether to include ghost zones when applying the refinement criterion
Type: logical
Default: false
Scope: Cello

When applying a mesh refinement criterion, this parameter specifies whether to apply it to ghost zones in the block as well as non-ghost zones.

Parameter: Adapt : <criterion> : min_refine
Summary: Cutoff value for refining a block
Type: [ float | list ( float ) ]
Default: 0.3
Scope: Cello

A block must refine if the refinement criterion applied to the block is larger than this value anywhere in the block. A list is used for the “shock” refinement criterion type, in which case the first value is for pressure and the second is for the energy ratio.

Parameter: Adapt : <criterion> : output
Summary: Name of a field in which to store the result of the refinement criterion
Type: string
Default: “”
Scope: Cello

In addition to evolved field values, one may also output the refinement criteria. This may be useful for example for debugging or for finding appropriate values for :p:`max_coarsen and min_refine. A value of -1 specifies coarsening, +1 for refining, and 0 for staying the same.`

Parameter: Adapt : <criterion> : max_level
Summary: Maximum level to refine using this refinement criterion
Type: integer
Default: max (integer)
Scope: Cello

Adapt will not refine past max_level when using this refinement criterion. Note if the global Adapt:max_level is smaller, than that takes precidence; also, another criterion may refine past this if both Adapt:max_level and Adapt : <criterion> : max_level for the other criterion are both larger.

Parameter: Adapt : <criterion> : type
Summary: Type of mesh refinement criteria
Type: string
Default: “unknown”
Scope: Cello

Type of mesh refinement criteria. This is a required parameter, and must be one of “slope”, “shear”, “mask”, “mass”, “density”, “shock”, “particle_mass”, or “particle_count”.

Balance

Parameters for controlling dynamic load balancing are enclosed within the Balance group. Currently only one Balance parameter is available, which is used to control how frequently load balancing is performed.

Parameter: Balance : schedule
Summary: Scheduling parameters for dynamic load balancing
Type: subgroup
Default: none
Scope: Cello

See the schedule subgroup for parameters used to define when to trigger the dynamic load balancing operation.

Boundary

Boundary group parameters define boundary conditions. For simple (non-mixed) boundary conditions, only the type parameter is required, e.g. Boundary { type = “periodic”; }. For more complicated boundary conditions, the list parameter is used to define Boundary subgroups, where each subgroup specifies boundary conditions for some subset of the domain. The axis and face parameters are available to restrict boundary conditions to a subset of faces, whereas the mask parameter is available for even finer control of mixed boundary conditions, which may be time-dependent. Inflow boundary conditions use the value parameter/subgroup to specify field values at the boundary.

Parameter: Boundary : list
Summary: List of boundary condition subgroups
Type: [ string | list ( string ) ]
Default: []
Scope: Cello

For mixed boundary conditions, the list parameter specifies the list of names of subgroups that define boundary conditions on each portion of the domain boundary. Boundary conditions in each subgroup are applied in the order listed. In the example below, two subgroups “one” and “two” are defined, which specify reflecting boundary conditions along the x-axis and outflow boundary conditions along the y-axis:

Boundary {
   list = ["one", "two"];
   one {
      type = "reflecting";
      axis = "x";
   }
   two {
      type = "outflow";
      axis = "y";
   }
}

Parameter: Boundary : <condition> : type
Summary: Type of boundary condition
Type: string
Default: “undefined”
Scope: Cello

Boundary conditions in Enzo-E include “reflecting” , “outflow” , “inflow” , and “periodic”. Other boundary condition types can be implemented by either a) modifying the existing EnzoBoundary class or b) creating a new class inherited from the Boundary base class.

“inflow” boundary conditions additionally require the value parameter or subgroup and, in certain cases, the field_list parameter.

Parameter: Boundary : <condition> : axis
Summary: Axis along which boundary conditions are to be enforced
Type: string
Default: “all”
Scope: Cello

The axis parameter restricts the boundary conditions to the face orthogonal to the specified axis. axis must be “x” , “y” , “z” or “all”. The axis parameter may be used in conjunction with the face parameter, or by itself.

Parameter: Boundary : <condition> : face
Summary: Face along which boundary conditions are to be enforced
Type: string
Default: “all”
Scope: Cello

The face parameter can restrict the boundary conditions to be applied only to the upper or lower faces. face orthogonal to the given face. face must be “upper” , “lower” or “all”. The face parameter may be used in conjunction with the axis parameter, or by itself.

Parameter: Boundary : <condition> : mask
Summary: Subregion in which boundary conditions are to be enforced
Type: logical-expr
Default: none
Scope: Cello

The mask parameter specifies the subregion of the boundary on which to apply the boundary conditions. The logical expression may be a function of x, y, z, and t, and boundary conditions are restricted to where (and when) it evaluates to true:

Boundary {
   ...
   OUT {
      type = "outflow";
      mask = (x >= 4.0) ||
             (y >= 1.0 && (x >= 0.744017 + 11.547* t));
   }
}

Parameter: Boundary : <condition> : value
Summary: Value for inflow boundary conditions
Type: float
Type: float-expr
Type: list ( float-expr [, logical-expr, float-expr [, … ] ] )
Default: []
Scope: Cello

For inflow type boundary conditions, there are 2 ways to specify field values. In both cases, the parameter(s) are assigned “value-expressions”, which may be of type float, float-expr, or a list of alternating float-expr and logical-expr types. Both float-expr and logical-expr may be functions of x, y, z, and t. When a list is specified, the logical-expr is treated as a mask, similar to an ‘if-then-else’ clause.

The two approaches include:

Under the historic approach, Boundary:<condition>:value is a parameter that is directly assigned a “value-expression”. This “value-expression” specifies the value enforced by this boundary for all fields in the field_list parameter.
Boundary {
   ...
   VELOCITY_Y {
      type = "inflow";
      field_list = "velocity_y";
      value = [ -8.25*0.5,
                 ((x <= 0.166667) && (y <= 0.0) ) ||
                  (x <= 0.0) ||
                  ((x < 0.744017 + 11.547*t) && (y >= 1.0)),
                 0.0
              ];
   }
}
Under the second approach, Boundary:<condition>:value is a parameter-subgroup. Within the parameter-subgroup, “value-expressions” are assigned to parameters that are named after the fields that the “value-expressions” apply to. Under this approach, it is an error for the field_list parameter to be specified. This approach bears a lot of similarities to the way values are specified in the “value” problem initializer.
Boundary {
   ...
   x_upstream {
      type = "inflow";
      axis = "x";
      face = "lower";
      value {
         density    = [ 0.1, (y <= 0.5), 0.1 * (y - 0.5) ];
         velocity_x = 10.0;
         velocity_y = 0.0;
         velocity_z = 0.0;
         total_energy = 75.0;
      }
   }
}

Parameter: Boundary : <condition> : field_list
Summary: List of fields to apply boundary conditions to
Type: list ( string )
Default: []
Scope: Cello

The field_list parameter is used to restrict boundary conditions to the specified fields. An empty list, which is the default, is used to specify all fields.

Domain

Domain parameters specify the lower and upper extents of the computational domain, using the lower and upper parameters.

Parameter: Domain : lower
Summary: Lower domain extent
Type: list ( float )
Default: [0.0, 0.0, 0.0]
Scope: Cello

Lower extent of the computational domain, [x_min], [ x_min, y_min], or [ x_min, y_min, z_min].

Parameter: Domain : upper
Summary: Upper domain extent
Type: list ( float )
Default: [1.0, 1.0, 1.0]
Scope: Cello

Upper extent of the computational domain, [x_max], [ x_max, y_max], or [ x_max, y_max, z_max].

Field

Fields and their properties are defined using the Field parameter group. All fields must be explicitly defined using the list Field parameter, and must match the names expected by the respective Methods. Properties include the number of ghost zones, precision, and whether a field is centered or lies on some face, edge, or corner. Some performance-related parameters are available as well, including alignment in memory, and memory padding between fields.

Parameter: Field : list
Summary: List of fields
Type: list ( string )
Default: []
Scope: Cello

All fields must be explicitly listed in the list parameter. Field names depend on the Method(s) used; e.g., PPM uses “density”, “velocity_x”, “velocity_y”, “total_energy”, and “internal_energy”.

Parameter: Field : gamma
Summary: Adiabatic exponent
Type: float
Default: 5.0 / 3.0
Scope: Enzo

gamma specifies the ratio of specific heats for the ideal gas used by the hydrodynamics solvers.

Warning

This parameter is deprecated and will be removed in a future version. Going forward, pass this value to Physics:fluid_props:eos:gamma.

Parameter: Field : alignment
Summary: Force field data on each block to start on alignment bytes
Type: integer
Default: 8
Scope: Cello

Depending on the computer architecture, variables can be accessed from memory faster if they have at least 4-byte or 8-byte alignment. This parameter forces each field block array to have an address evenly divisible by the specified number of bytes.

Parameter: Field : <field> : centering
Summary: Specify the position of the given field variable within the computational cell.
Type: list ( logical )
Default: [ true, true, true ]
Scope: Cello

By default, variables are centered within a computational cell. Some methods expect some variable, e.g. velocity components, to be positioned on a cell face. The effect of this parameter is to increase the dimension of the field block by one along each axis with a value of “false”. Numerical method implementations like PPML that assume (NX,NY,NZ) sized blocks even for offset variables, as opposed to e.g. (NX+1,NY,NZ), should still define the variable as centered.

Parameter: Field : <field> : group_list
Summary: Specify a list of groups that the Field belongs to
Type: list ( string )
Default: [ ]
Scope: Cello

Different Fields may belong to any number of different “groups”. For example, Enzo uses “color fields”, which Enzo-E implements as defining color fields to belong to the group “color”.

Parameter: Field : ghost_depth
Summary: Field ghost zone depths
Type: [ integer | list ( integer ) ]
Default: [ 0, 0, 0 ]
Scope: Cello

The default storage patch / block ghost zone depths [gx, gy, gz] along each axis for fields. If an integer, then the same ghost zone depth is used for each axis. Currently this value needs to be 4 for PPM when AMR is used.

Parameter: Field : padding
Summary: Add padding of the specified number of bytes between fields on each block.
Type: integer
Default: 0
Scope: Cello

If block sizes are large and a power of two, and if the computer’s cache has low associativity, performance can suffer due to cache thrashing. This can be avoided by introducing padding between fields. A value of twice the cache line width is recommended. Since field blocks are usually small, this should not usually be an issue.

Parameter: Field : precision
Summary: Default field precision
Type: string
Default: “default”
Scope: Cello

Default precision for all fields. Supported precisions include “single” (32-bit) and “double” (64-bit). “quadruple” is accepted, but not implemented by most numerical methods (e.g. PPM). “default” is for compatibility with Enzo, and corresponds to either “single” or “double” depending on the CELLO_PREC configuration flag setting. This precision parameter must not conflict with the CELLO_PREC setting.

Parameter: Field : prolong
Summary: Type of prolongation (interpolation)
Type: string
Default: “linear”
Scope: Cello

For adaptive mesh refinement, field values may need to be transferred from coarser to finer blocks, either from coarse neighbor blocks in the refresh phase, or to fine child blocks during refinement in the adapt phase. Valid values include “linear” ; other values accepted but not implemented include “enzo” and “MC1” :e:` ; which are unfinished implementations of Enzo’s` “InterpolationMethod” functionality.

Parameter: Field : restrict
Summary: Type of restriction (coarsening)
Type: string
Default: “linear”
Scope: Cello

For adaptive mesh refinement, field values may need to be transferred from finer to coarser blocks, either from fine neighbor blocks in the refresh phase, or to the parent block during coarsening in the adapt phase. Valid values include “linear” ; ;other values accepted but not implemented include “enzo”.

Parameter: Field : history
Summary: How many generations of “old” fields to maintain
Type: integer
Default: 0
Scope: Cello

Many problems may require field values from the previous timestep, e.g. for flux-correction, updating particles, etc. Cello supports this by allowing one or more generations of all fields to be stored and maintained. The default is 0, though 1 may be fairly common, and even more generations are supported if needed.

Group

The Group parameter group is used to differentiate between different types of Field’s and Particles. For example, field groups may include “color” and “temporary”, and particle groups may include “dark_matter” and “star”.

Group {

   list = ["color", "temporary"];

   color {
      field_list = ["species_HI", "species_HII" ];
   }

   temporary {
      field_list = ["pressure", "temperature"];
   }

}

Field and Particle groups can analogously be defined in the respective Field and Particle parameter groups:

Field {

   list = ["density", "velocity_x", "species_HI"];

   species_HI {

      group_list = ["temporary"];

   }

}

Groups allow Cello applications to differentiate between these different types of fields and particles using the Grouping class (see src/Cello/data_Grouping.?pp).

Parameter: Group : list
Summary: List of groups
Type: list ( string )
Default: []
Scope: Cello

This parameter defines all groups.

Parameter: Group : <group> : field_list
Summary: List of fields belonging to the group
Type: list ( string )
Default: []
Scope: Cello

This parameter is used to assign fields to a given group.

Parameter: Group : <group> : particle_list
Summary: List of particle types belonging to the group
Type: list ( string )
Default: []
Scope: Cello

This parameter is used to assign particle groups to a given group.

Initial

The Initial group is used to specify initial conditions. cycle specifies the initial cycle number (usually 0), list specifies a list of initial conditions, which may include "value" for initializing fields directly, or other problem-specific initial condition generators.

Parameter: Initial : list
Summary: Sequence of initializers to apply.
Type: list ( string )
Default: none
Scope: Cello

This parameter specifies the list of initializers to apply. Each initializer in the list is applied in the order specified. Not all initializers are meant to be used alongside other initializers. Possible initializers include:

“accretion_test” Setup a test problem with a sink particle.
“bb_test” Initialize a “BB Test” problem, following the setup described in Federrath et al 2010, ApJ, 713, 269.
“cloud” Initialize a spherical cloud embedded in a hot wind.
“collapse” Initialize a spherical collapse test.
“grackle_test” Initialize a grackle chemistry and cooling test.
“implosion_2d” Initialize an “implosion” test problem.
“inclined_wave” Initialize an inclined wave test problem.
“merge_sinks_test” Initialise sink particles with masses, positions, and velocities read from a text file specified in the parameter file.
“pm” Initialize “dark” matter particles in either a regular uniform array with one particle per cell, or randomly following the “density” field distribution.
“ppml_test” Initialize fields for the PPML solver for a high-pressure sphere in an anisotropic magnetic field.
“sedov” Sets up sedov blast problems.
“shock_tube” Initialize an axis-aligned shock tube test problem
“shu_collapse” Initialize a Shu Collapse problem, following the setup described in Federrath et al 2010, ApJ, 713, 269.
“soup” Similar to the “sedov” problem, but with letters instead of spheres.
“trace” Initialize “trace” tracer particles in either a regular uniform array with one particle per cell, or randomly following the “density” field distribution.
“turbulence” Initialize fields for driving turbulence, including “driving_[xyz]” fields.
“value” Initialize fields using expressions directly from the parameter file.
“vlct_bfield” Initialize the cell-centered magnetic fields for use by the VL + CT method. For more details, see vlct_bfield

Parameters specific to individual initializers are specified in subgroups.

Parameter: Initial : cycle
Summary: Initial cycle number
Type: list ( integer )
Default: 0
Scope: Cello

Initial value for the cycle number.

Parameter: Initial : time
Summary: Initial time
Type: float
Default: 0.0
Scope: Cello

Initial time in code units.

Parameter: Initial : restart
Summary: Set to true to restart from a checkpoint directory created by the “check” method
Type: bool
Default: false
Scope: Cello

Restart the simulation to continue a previous run from a saved checkpoint. If true, the restart directory must be specified using the “restart_dir” parameter.

Parameter: Initial : restart_dir
Summary: Directory containing restart files from a checkpoint created using the “check” method
Type: string
Default: none
Scope: Cello

When restarting a simulation from a “check” checkpoint directory, this parameter must specify the path to that directory.

value

Parameter: Initial : value : <field>
Summary: Initialize field values
Type: list ( float-expr, [ logical-expr, float-expr, [ … ] ] )
Default: []
Scope: Cello

This initialization approach allows initializing field values directly. The first element of the list must be a float expression, and may include arithmetic operators, variables “x”, “y”, “z”, and most functions in the POSIX math library /include/math.h. The second optional list element is a logical expression, and serves as a “mask” of the domain. The third float expression parameter is required if a mask is supplied, and serves as the “else” case. Multiple such mask-value pairs may be used. For example:

Initial {

   list = ["value"];

   value {
      density = [ sin ( x + y ), x - y < 0.0, 1.0 ];
   }
}

is read as “Set the density field equal to sin ( x + y ) wherever x - y < 0.0 , otherwise set to 1.0 “.

accretion_test

The accretion_test Initial subgroup is used to initialize an accretion test problem. In particular, it initializes a single sink particle with a given initial mass, position, and velocity, in a background medium with constant density and pressure, and (possibly) an initial velocity field with constant magnitude, directed towards the sink particle’s initial position. Running this test problem requires the use of the “mhd_vlct”, “pm_update”, “merge_sinks”, and “accretion” methods. One can then test the accretion method by checking whether mass and momentum are conserved in this problem.

This initializer requires periodic boundary conditions, and three spatial dimensions.

Note: sink particles must have a "mass" attribute if this initializer is used.

Parameter: Initial : accretion : sink_mass
Summary: The initial mass of the sink particle.
Type: float
Default: 0.0
Scope: Enzo

The initial mass of the sink particle

Parameter: Initial : accretion : sink_position
Summary: The initial position of the sink particle.
Type: list ( float )
Default: [0.0,0.0,0.0]
Scope: Enzo

The initial (3D) position of the sink particle

Parameter: Initial : accretion : sink_velocity
Summary: The initial velocity of the sink particle.
Type: list ( float )
Default: [0.0,0.0,0.0]
Scope: Enzo

The initial (3D) velocity of the sink particle

Parameter: Initial : accretion : gas_density
Summary: The initial uniform density of the gas.
Type: float
Default: 1.0e-6
Scope: Enzo

The initial uniform density of the gas.

Parameter: Initial : accretion : gas_pressure
Summary: The initial uniform pressure of the gas.
Type: float
Default: 1.0e-6
Scope: Enzo

The initial uniform pressure of the gas.

Parameter: Initial : accretion : gas_radial_velocity
Summary: The (inwards) radial velocity of the gas, with respect to the initial sink particle position.
Type: float
Default: 0.0
Scope: Enzo

The gas velocity in every cell with have magnitude equal to the value of this parameter, directed towards the initial sink particle position.

bb_test

The bb_test Initial subgroup is used to initialize a “BB Test” problem, as described in Federrath et al 2010, ApJ, 713, 269. In particular, it initializes an isothermal sphere of gas with, with the gas having a constant (small) “external density” outside of the truncation radius. Within the truncation radius, the gas density has the following form:

\(\rho(\phi) = \rho_0 (1 + A \cos(2 \phi)),\)

where \(\rho\) is the gas density, \(\phi\) is the azimuthal angle in the spherical polar coordinate system, \(\rho_0\) is the mean density and \(A\) is the (small) fluctuation amplitude. The gas rotates around the z-axis as a solid-body, with an optional additional uniform “drift velocity”.

Running this test problem requires the use of the "pm_deposit", "gravity", "mhd_vlct", "sink_maker", and "pm_update" methods.

This initializer requires periodic boundary conditions, three spatial dimensions, and that the gas adiabatic index ("Field:gamma") is between 1.0 and 1.000001.

The following fields are required, and must be specified in the input parameter file: "density", "density_total", "density_particle", "density_particle_accumulate", "density_gas", "particle_mass", "potential", "potential_temp", "potential_copy", "total_energy", "pressure", "acceleration_x", "acceleration_y", "acceleration_z", "velocity_x", "velocity_y", "velocity_z", "X", "X_copy", "B", "B_copy", "density_source", "density_source_accumulate", "mom_dens_x_source", "mom_dens_x_source_accumulate", "mom_dens_y_source", "mom_dens_y_source_accumulate", "mom_dens_z_source", and "mom_dens_z_source_accumulate".

Sink particles must have the following attributes: "mass", "x", "y", "z", "vx", "vy", "vz", and "is_copy". These must all be of type "default", except for "is_copy", which should be of type "int64".

Sink particles must be in the "is_gravitating" particle group.

Parameter: Initial : bb_test : center
Summary: The coordinates of the center of the sphere.
Type: list (float)
Default: [0.0,0.0,0.0]
Scope: Enzo

The coordinates of the center of the sphere.

Parameter: Initial : bb_test : drift_velocity
Summary: The initial additional uniform velocity of the gas.
Type: list (float)
Default: [0.0,0.0,0.0]
Scope: Enzo

The initial additional uniform velocity of the gas. Inside the truncation radius, the initial gas velocity will be determined by solid body rotation, plus this additional velocity. Outside the truncation radius, the gas velocity is just this velocity.

Parameter: Initial : bb_test : truncation_radius
Summary: The truncation radius of the sphere.
Type: float
Default: 1.0
Scope: Enzo

The truncation radius of the isothermal sphere. Within this radius, the gas density is determined by the azimuthal angle; outside of this radius, it is equal to “external_density”.

Parameter: Initial : bb_test : nominal_sound_speed
Summary: The nominal uniform sound speed of the gas.
Type: float
Default: 1.0
Scope: Enzo

Nominal uniform sound speed of the gas used to initialise the total specific energy. In practice the actual sound speed will be different since the adiabatic index is not exactly 1.

Parameter: Initial : bb_test : fluctuation_amplitude
Summary: The amplitude of the density fluctuation which determines the initial gas density.
Type: float
Default: 0.0
Scope: Enzo

Within the truncation radius, the gas density has the following form:

\(\rho(\phi) = \rho_0 (1 + A \cos(2 \phi)),\)

where \(\rho\) is the gas density, \(\phi\) is the azimuthal angle in the spherical polar coordinate system, \(\rho_0\) is the mean density and \(A\) is the fluctuation amplitude.

Parameter: Initial : bb_test : external_density
Summary: The gas density outside of the truncation radius.
Type: float
Default: 1.0e-6
Scope: Enzo

The gas density outside of the truncation radius. Should be set to something much smaller than the mean gas density inside the truncation radius.

Parameter: Initial : bb_test : mean_density
Summary: The mean gas density inside the truncation radius.
Type: float
Default: 1.0e-6
Scope: Enzo

The mean gas density inside the truncation radius.

Parameter: Initial : bb_test : angular_rotation_velocity
Summary: The angular rotation velocity of gas inside the truncation radius in radians per second.
Type: float
Default: 0.0
Scope: Enzo

Inside the truncation radius, the gas rotates as a solid body around the z-axis. This parameter determines the angular rotation velocity in units of radians per second.

cloud

The cloud Initial subgroup is used to setup a Spherical cloud embedded in a hot wind. The cloud and wind are assumed to be in pressure equilibrium with one another.

The presence of (or lack thereof) the “bfield_x”, “bfield_y”, and “bfield_z” fields indicate whether the setup is purely hydrodynamic or involves magnetic fields. Presently, only uniform magnetic fields are supported if they are constant across the entire domain. The values of the magnetic fields are specified in one of 2 ways:

If the uniform_bfield parameter is passed a list of 3 floats, the first, second, and third entries are used to initilize the x, y, and z components of a uniform magnetic field. If the “bfieldi_x”, “bfieldi_y”, and “bfieldi_z” face-centered fields are defined, then they will be correctly initialized for use with the VL+CT integrator.
(Deprecated) If the uniform_bfield parameter is not specified (or is passed a list containing 0 entries), then the cell-centered magnetic fields are assumed to have been initialized by another Initial subgroup (e.g. value) prior to the call of this subgroup.

The initial density of a cell entirely enclosed by the cloud is the spatial average taken over that cell of \(\rho_{\rm cl} (1 + \delta (\vec{x}))\), where \(\delta (\vec{x})\) is a spatially varying perturbation term that we will return to momentarily. Outside of the cloud, we initialize the density to \(\rho_{\rm w}\).

We use subsampling near the edge of cloud to estimate the fraction of the cell’s volume occupied by the cloud, \(f_{V}\). In more detail, we initialize the density of these cells to \(f_{V} \rho_{\rm inside-avg} + (1 - f_{\rm V})\rho_{\rm w}\), where \(\rho_{\rm inside-avg}\) is the average of \(\rho_{\rm cl} (1 + \delta (\vec{x}))\) taken over all subcells that lie within the cloud.

Now, we consider the definition of the perturbation term that can be used to break symmetries in the cloud’s initial density distribution. This is a sum of \(N\) planar waves or: \(\delta (\vec{x}) = A \sum_{i=1}^{N} \cos \left(\frac{2 \pi}{\lambda_{i}} \hat{e}_i \cdot \vec{x} + \phi_i\right)\), where

\(N\) is set by perturb_Nwaves
\(A\) is set by perturb_amplitude
for each \(i\) we draw a random unit vector \(\hat{e}_i\), as well as random values for \(\lambda_{i}\) and \(\phi_i\) from \([\lambda_{\rm min}, \lambda_{\rm max}]\) and \([0,\pi)\). \(\lambda_{\rm min}\) and \(\lambda_{\rm max}\) are set by the parameters perturb_min_lambda and perturb_max_lambda. As an aside, \(\phi_i\) doesn’t need to sample values within the interval \([\pi, 2\pi)\) since \(\hat{e}_i\) samples all directions.

The random values are all drawn from uniform distributions using a PRNG seeded by the value of perturb_seed.

Note

The randomly drawn values should be portable across different machines. But, this has not been rigorously tested.

Parameter: Initial : cloud : subsample_n
Summary: Determines the subsampling resolution
Type: integer
Default: 0
Scope: Enzo

Subsampling is used to initialize the fields in regions of overlap between the cloud and the wind. For cells in this region, the fraction of the volume enclosed by the cloud is estimated by subdividing a cell into \(2^n\) subcells along each axis (a value of 0, corresponds to no subsampling. The average density of the cells in this region are volume weighted and the average velocities are mass weighted. The total energy in a cell is currently computed by assuming constant internal energy density throughout the grid and using the average velocities and densities (and, if applicable, the magnetic fields).

Parameter: Initial : cloud : cloud_radius
Summary: Initial radius of the spherical cloud
Type: float
Default: none
Scope: Enzo

This must be a positive value.

Parameter: Initial : cloud : cloud_center_x
Summary: x coordinate of the cloud center
Type: float
Default: 0.0
Scope: Enzo

Parameter: Initial : cloud : cloud_center_y
Summary: y coordinate of the cloud center
Type: float
Default: 0.0
Scope: Enzo

Parameter: Initial : cloud : cloud_center_z
Summary: z coordinate of the cloud center
Type: float
Default: 0.0
Scope: Enzo

Parameter: Initial : cloud : cloud_density
Summary: initial mass density of the cloud
Type: float
Default: none
Scope: Enzo

This must be a positive value.

Parameter: Initial : cloud : metal_mass_frac
Summary: initial fraction of the mass density contributed by metals
Type: float
Default: 0.0
Scope: Enzo

If the ` `”metal_density_frac”`` field exists and is registered as a member of the ` `”colour”`` group, then the field is initialized by multiplying this value by the "density" field (this is done everywhere, regardless of proximity to the cloud center). Under these circumstances, this must have a positive value.

Parameter: Initial : cloud : uniform_bfield
Summary: initial uniform magnetic field values
Type: list ( float )
Default: [ ]
Scope: Enzo

If specified, provides the values of the components of the initial magnetic field that are uniform throughout the entire domain. When employed this MUST have 3 entries. This will also initialize the face-centered fields magnetic fields (in addition to the cell-centered fields) if the appropriate fields have been defined. When this is not specified (i.e., when this has a list of 0 entries), the magnetic fields are assumed to have been pre-initialized by a separate problem initializer prior to the execution of the cloud initializer.

Parameter: Initial : cloud : wind_density
Summary: initial mass density of the wind
Type: float
Default: none
Scope: Enzo

This must be a positive value.

Parameter: Initial : cloud : wind_velocity
Summary: initial velocity of the wind along the x-axis
Type: float
Default: 0.0
Scope: Enzo

Parameter: Initial : cloud : wind_total_energy
Summary: initial specific total energy of the wind
Type: float
Default: none
Scope: Enzo

This must be a positive value.

Parameter: Initial : cloud : wind_internal_energy
Summary: initial specific internal energy of the wind
Type: float
Default: 0
Scope: Enzo

If the "internal_energy" field is defined, then this must be a positive value. In this case, the value is also used to help initialize the "total_energy" field for cells that overlap with the cloud. However, if the "internal_energy" field is not defined, then this must not have a specified value (i.e. it must have a value of 0).

Parameter: Initial : cloud : perturb_seed
Summary: Seeds the perturbations to cloud density
Type: integer
Default: 0
Scope: Enzo

This must hold a value representable by a 32-bit unsigned integer. It is meaningless unless perturb_Nwaves and perturb_amplitude are positive.

Parameter: Initial : cloud : perturb_Nwaves
Summary: Number of planar waves to use in perturbation machinery
Type: integer
Default: 0
Scope: Enzo

This should be zero or larger.

Parameter: Initial : cloud : perturb_amplitude
Summary: Planar wave amplitude to use in perturbation machinery
Type: float
Default: 0.0
Scope: Enzo

This must be a non-negative value

Parameter: Initial : cloud : perturb_min_lambda
Summary: Lower bound on wavelengths used in perturbation machinery
Type: float
Default: none
Scope: Enzo

This must be a non-negative value and must be less than perturb_max_lambda. It is meaningless unless perturb_Nwaves and perturb_amplitude are positive.

Parameter: Initial : cloud : perturb_max_lambda
Summary: Upper bound on wavelengths used in perturbation machinery
Type: float
Default: none
Scope: Enzo

This must be a non-negative value and must exceed perturb_min_lambda. It is meaningless unless perturb_Nwaves and perturb_amplitude are positive.

Parameter: Initial : cloud : wind_total_energy
Summary: initial specific total energy of the wind
Type: float
Default: none
Scope: Enzo

This must be a positive value.

inclined_wave

The inclined_wave Initial subgroup is used to setup a HD, MHD, or Jeans wave at an angle inclined to the simulation domain for testing HD/MHD integrators. If applicable, magnetic fields fields are set to zero when a HD wave is initialized.

The initialization procedure was adopted from Gardiner & Stone (2008) . Specifically, a coordinate system “x0”, “x1”, “x2” is defined and the wave is initialized to travel along “x0”. The transformation between “x”, “y”, “z” and “x0”, “x1”, “x2”, is determined by the values of the alpha and beta parameters. They are explicitly related by

\[\begin{split}x &= x_0\cos\alpha\cos\beta - x_1\sin\beta - x_2\sin \alpha \cos \beta \\ y &= x_0\cos\alpha\sin\beta + x_1\cos\beta - x_2\sin \alpha \sin \beta \\ z &= x_0\sin\alpha + x_2 \cos\alpha\end{split}\]

As in that paper, non-zero magnetic fields are initialized using the vector potential to ensure that they are divergence-free.

Parameter: Initial : inclined_wave : alpha
Summary: Angle used to help determine wave inclination
Type: float
Default: 0
Scope: Enzo

The angle is assumed to have units of radians.

Parameter: Initial : inclined_wave : beta
Summary: Angle used to help determine wave inclination
Type: float
Default: 0
Scope: Enzo

The angle is assumed to have units of radians.

Parameter: Initial : inclined_wave : wave_type
Summary: Specifies the type of wave to initialize.
Type: string
Default: alfven
Scope: Enzo

This value specifies the type of wave to initialize. We have provided more details about each option down below. Note, when using an MHD solver with a non-MHD wave, the mangetic fields are uniformly initialized to zero.

Hydro Waves

The values used to initialize hydrodynamical linear waves are taken from the columns of the matrix given in equation B3 of Stone et al. (2008) . Valid hydrodynamical waves include:

"sound" A linear sound wave.

"hd_entropy" A linear HD entropy wave with perturbations in v0 (velocity along the “x0”-axis).

"hd_transv_entropy_v1" A linear HD entropy wave with perturbations in velocity component v1 (transverse to the direction of bulk motion).

"hd_transv_entropy_v2" A linear HD entropy wave with perturbations in velocity component v2 (transverse to the direction of bulk motion).

MHD Waves

Each of the valid MHD waves are described in Gardiner & Stone (2008) . Valid MHD wave types include:

"alfven" A linear Alfven wave with perturbations to the magnetic field along the “x2”-axis.

"circ_alfven" A traveling circularly polarized Alfven wave.

"mhd_entropy" A linear MHD entropy wave.

"fast" A linear fast magnetosonic wave.

"slow" A linear slow magnetosonic wave.

Jeans Wave

To initialize a Jeans wave, set this parameter to "jeans". We use equations consistent with what Athena and (earlier versions of) Athena++ use. In detail, we use:

\[\begin{split}\rho &= \rho_{\rm bkg} \left( 1 + A \sin\left(\frac{2\pi}{\lambda} x_0 \right) \right) \\ \rho v_0 &= \rho_{\rm bkg} \frac{\sqrt{|\omega^2|}}{2\pi / \lambda} A \begin{cases} 0 & \omega^2 > 0 \\ \cos\left(\frac{2\pi}{\lambda} x_0 \right) & \omega^2 < 0 \\ \end{cases} \\ v_1 &= 0 \\ v_2 &= 0 \\ \rho E &= \frac{P_{\rm bkg}}{\gamma - 1} + \gamma A \sin\left(\frac{2\pi}{\lambda} x_0\right) \\\end{split}\]

in which:

\(E\) specifies the specific internal energy

\(\gamma\) is the adiabatic index.

\(A\) is the amplitude, specified by Initial:inclined_wave:amplitude and \(\lambda\) is the wavelength, specified by Initial:inclined_wave:lambda

\(\rho_{\rm bkg}=1\) and \(P_{\rm bkg}=1/\gamma\) in the appropriate code units

\(\omega^2=(2\pi c_{s,{\rm bkg}}/ \lambda)^2 (1 - (\lambda/\lambda_J)^2)\) is the dispersion relation. In this equation, \(c_{s,{\rm bkg}}^2=\gamma P_{\rm bkg}/\rho_{\rm bkg}\) and \(\lambda_J = c_{s,{\rm bkg}} \sqrt{\pi / (G \rho_{\rm bkg})}\). Note that the value of \(G\) is directly set by Method:gravity:grav_const.

Parameter: Initial : inclined_wave : amplitude
Summary: Sets the amplitudes of the waves.
Type: float
Default: 1.e-6
Scope: Enzo

This must be a positive value. This has no effect for the circularly polarized Alfven wave (for that case, amplitude is fixed at 0.1).

Parameter: Initial : inclined_wave : lambda
Summary: The wavelength of the wave.
Type: float
Default: 1.
Scope: Enzo

This must be a positive value.

Parameter: Initial : inclined_wave : positive_vel
Summary: Sets the sign of the wave speed.
Type: logical
Default: true
Scope: Enzo

Do not specify this parameter when initializing a circularly polarized Alfven wave or a Jeans wave. This is ignored for linear HD entropy waves when Initial:inclined_wave:parallel_vel is specified.

Parameter: Initial : inclined_wave : parallel_vel
Summary: optionally sets the background velocity for HD waves
Type: float
Default: none
Scope: Enzo

This can be used to specify a background velocity along v0 for HD linear waves. At present, this parameter should only be specified for the hydrodynamic waves.

merge_sinks_test

The merge_sinks_test Initial subgroup is used to read and initialise particle data from a text file. It is designed to be run with a small number of particles, in order to check conservation of mass and momentum (and potentially other quantities) when running with the “merge_sinks” method. The data are assumed to be arranged into seven columns, corresponding to mass, the x,y,z coordinates and the x,y,z-components of velocity, respectively. Each row corresponds to one sink particle.

Note: sink particles must have a "mass" attribute if this initializer is used.

Parameter: Initial : merge_sinks_test : particle_data_filename
Summary: Name of the file to read from.
Type: string
Default: none
Scope: Enzo

Must point to a valid text file, with data arranged in seven columns seperated by blank space

music

The music Initial subgroup is used to read block data from HDF5 files generated by MUSIC initial conditions generator. Parameters are used to specify the HDF5 files to read from, the names of the HDF5 datasets, what type of data the datasets contain ("field" or "particle"), field or particle names, and particle attributes. Additionally, a coords parameter is used to specify the axis ordering used. The music group has its own list parameter, one for each field or particle type and attribute.

The following example reads the "density" field from "GridDensity" file, and the "dark" particle "position_x" attributes from the "ParticleDisplacements_x" file:

Initial {

  list = ["music"];
  music {

     file_list = ["FD","PX"];
     FD {
       type      = "field";
       name      = "density";
       coords    = ".zyx";
       file      = "GridDensity";
       dataset   = "GridDensity";
     }
     PX {
       type      = "particle";
       name      = "dark";
       coords    = ".zyx";
       attribute = "position_x";
       file      = "ParticleDisplacements_x";
       dataset   = "ParticleDisplacements_x";
     }
  }
}

Parameter: Initial : music : list
Summary: Name of the HDF5 to read from
Type: string
Default: none
Scope: Enzo

List of file identifiers, one for each field or particle type+attribute.

Parameter: Initial : music : <file> : type
Summary: Type of data to read in
Type: string
Default: none
Scope: Enzo

Type of data to read in, either “field” or “particle”.

Parameter: Initial : music : <file> : file
Summary: Name of the HDF5 file to read from
Type: string
Default: none
Scope: Enzo

Name of the HDF5 file to read from.

Parameter: Initial : music : <file> : dataset
Summary: Name of the dataset to read from the the HDF5 file
Type: string
Default: none
Scope: Enzo

Name of the dataset to read from the the HDF5 file.

Parameter: Initial : music : <file> : name
Summary: Name of the field or particle type
Type: string
Default: none
Scope: Enzo

Name of the field or particle type.

Parameter: Initial : music : <file> : attribute
Summary: Name of the particle attribute to initialize
Type: string
Default: none
Scope: Enzo

Name of the particle attribute to initialize..

Parameter: Initial : music : <file> : coords
Summary: Ordering of axes in the HDF5 file
Type: string
Default: “zyx”
Scope: Enzo

String defining the axis ordering of ‘x’, ‘y’, and ‘z’ in the HDF5 file. For MUSIC initial conditions, which may have 4D datasets, “tzyx” can be used, where “t” is ignored and can be any character other than ‘x’, ‘y’, or ‘z’.

sedov

Parameter: Initial : sedov : array
Summary: Size of array of Sedov blasts
Type: list ( integer )
Default: [ 1, 1, 1 ]
Scope: Enzo

This parameter defines the size of the array of Sedov blast waves. The default is a single blast.

Parameter: Initial : sedov : radius_relative
Summary: Initial radius of the Sedov blast
Type: float
Default: 0.1
Scope: Enzo
Todo: write

Parameter: Initial : sedov : pressure_in
Summary: Pressure inside the Sedov blast
Type: float
Default: 1.0
Scope: Enzo
Todo: write

Parameter: Initial : sedov : pressure_out
Summary: Pressure outside the Sedov blast
Type: float
Default: 1.0e-5
Scope: Enzo
Todo: write

Parameter: Initial : sedov : density
Summary: Density for the Sedov blast array problem
Type: float
Default: 1.0
Scope: Enzo
Todo: write

shock_tube

The shock_tube Initial subgroup is used to setup axis-aligned shock tube test problems.

Generically, a shock tube get’s set up to evolve along an axis given by the value of aligned_ax. The discontinuity is always placed at 0.5 along that axis (typically the domain should extend from 0.0 to 1.0).

Parameter: Initial : shock_tube : setup_name
Summary: Specifies the name of the shock tube problem to setup.
Type: string
Default: none
Scope: Enzo

Valid shock tube problems include:

"rj2a" An MHD shock tube problem illustrated in Figure 2a of Ryu & Jones (1995) . The initialization assumes that the adiabatic index is 5/3.

"sod" The hydrodynamical Sod shock tube test problem. The canonical adiabatic is 1.4 (although this is not required).

Parameter: Initial : shock_tube : aligned_ax
Summary: Specify the axis along which the shock tube evolves along.
Type: string
Default: x
Scope: Enzo

Allowed values are "x" , "y" , or "z" .

Parameter: Initial : shock_tube : axis_velocity
Summary: Value to add to velocity component along aligned_ax
Type: float
Default: 0.
Scope: Enzo

This value is added throughout the entire domain.

Parameter: Initial : shock_tube : transverse_velocity
Summary: Value to add to a velocity component perpendicular to aligned_ax
Type: float
Default: 0.
Scope: Enzo

This value is added throughout the entire domain. If aligned_ax is "x" , "y" , or "z" , then this value is added to the "velocity_y" , "velocity_z" , or "velocity_z" field.

Parameter: Initial : shock_tube : flip_initialize
Summary: Whether to mirror the initial condition across the discontinuity
Type: logical
Default: false
Scope: Enzo

When this is "true" the entire setup is mirrored across the discontinuity. Basically the left and right states are swapped AND all components of the magnetic field and velocity (including contributions from axis_velocity and transverse_velocity) are multiplied by -1.

shu_collapse

The shu_collapse Initial subgroup is used to initialize a Shu Collapse problem, as described in Federrath et al 2010, ApJ, 713, 269. In particular, it initializes a gravitationally unstable isothermal sphere of gas with an inverse-square density profile, with an optional uniform “drift velocity”, and an optional sink particle at the center of the domain.

Running this test problem requires the use of the "pm_deposit", "gravity", "mhd_vlct", "sink_maker", and "pm_update" methods.

This initializer requires periodic boundary conditions, three spatial dimensions, and that the gas adiabatic index ("Field:gamma") is between 1.0 and 1.000001.

The following fields are required, and must be specified in the input parameter file: "density", "density_total", "density_particle", "density_particle_accumulate", "density_gas", "particle_mass", "potential", "potential_temp", "potential_copy", "total_energy", "pressure", "acceleration_x", "acceleration_y", "acceleration_z", "velocity_x", "velocity_y", "velocity_z", "X", "X_copy", "B", "B_copy", "density_source", "density_source_accumulate", "mom_dens_x_source", "mom_dens_x_source_accumulate", "mom_dens_y_source", "mom_dens_y_source_accumulate", "mom_dens_z_source", and "mom_dens_z_source_accumulate".

Sink particles must have the following attributes: "mass", "x", "y", "z", "vx", "vy", "vz", and "is_copy". These must all be of type "default", except for "is_copy", which should be of type "int64".

Sink particles must be in the "is_gravitating" particle group.

Parameter: Initial : shu_collapse : center
Summary: The coordinates of the center of the collapse.
Type: list (float)
Default: [0.0,0.0,0.0]
Scope: Enzo

The coordinates of the center of the sphere.

Parameter: Initial : shu_collapse : drift_velocity
Summary: The initial uniform velocity of the gas.
Type: list (float)
Default: [0.0,0.0,0.0]
Scope: Enzo

The initial uniform velocity of the gas.

Parameter: Initial : shu_collapse : truncation_radius
Summary: The truncation radius of the isothermal sphere.
Type: float
Default: 1.0
Scope: Enzo

The truncation radius of the isothermal sphere. Within this radius, the gas has an inverse square density profile; outside of this radius, the gas density is determined by “external_density”. Value must be at most a quarter of the domain width..

Parameter: Initial : shu_collapse : nominal_sound_speed
Summary: The nominal uniform sound speed of the gas.
Type: float
Default: 1.0
Scope: Enzo

Nominal uniform sound speed of the gas used to initialise the total specific energy. In practice the actual sound speed will be different since the adiabatic index is not exactly 1.

Parameter: Initial : shu_collapse : instability_parameter
Summary: The instability parameter which determines the gas density profile.
Type: float
Default: 2.1
Scope: Enzo

Instability parameter - sphere is gravitationally unstable if this is greater than 2.0. Determines density profile according to \(\rho(r) = \frac{A c_s^2}{4 \pi G r^2}\), where \(rho\) is the gas density, r is the distance from the center of the sphere, \(A\) is the instability parameter, \(c_s\) is the nominal sound speed, and \(G\) is the gravitational constant.

Parameter: Initial : shu_collapse : external_density
Summary: The gas density outside of the truncation radius.
Type: float
Default: 1.0e-6
Scope: Enzo

The gas density outside of the truncation radius. Should be set to something much smaller than the gas density just inside the truncation radius.

Parameter: Initial : shu_collapse : central_sink_exists
Summary: Controls whether a sink particle is placed at the center in the initial conditions.
Type: logical
Default: false
Scope: Enzo

If true, a sink particle is initialised with position at the center of the sphere, and velocity equal to “drift_velocity”. Its mass is determined by “central_sink_mass”.

Parameter: Initial : shu_collapse : central_sink_mass
Summary: The mass of the central sink particle, if it exists.
Type: float
Default: 0.0
Scope: Enzo

If “central_sink_exists” is true, this determines the mass of the central sink particle. If false, this parameter is ignored.

turbulence

Parameter: Initial : turbulence : density
Summary: Initial density for turbulence initialization and method
Type: float
Default: 1.0
Scope: Enzo

Initial density for initializing the turbulence problem.

Parameter: Initial : turbulence : pressure
Summary: Initial pressure for turbulence initialization and method
Type: float
Default: 0.0
Scope: Enzo

Initial pressure for initializing the turbulence problem. Default is 0.0, meaning it is not used. Either pressure or temperature should be defined, but not both.

Parameter: Initial : turbulence : temperature
Summary: Initial temperature for turbulence initialization and method
Type: float
Default: 0.0
Scope: Enzo

Initial temperature for initializing the turbulence problem. Default is 0.0, meaning it is not used. Either pressure or temperature should be defined, but not both.

vlct_bfield

This is used to compute the cell-centered magnetic field for the VL + CT MHD method. This initializer can be utilized in 2 ways:

Components of the vector potential ("Ax", "Ay", "Az") can be specified as parameters of the subgroup (functions can be specified for each component in the same way as functions are specified for the value subgroup. The initializer operates in this mode as long as the values for one of the components of the vector potential is specified (any unspecified components are assumed to be zero everywhere). In this mode, both the cell-centered and face-centered magnetic field values get specified.

Initialize the cell-centered values of the magnetic fields after after another Initial subgroup (e.g. the value subgroup) has already to specified the face-centered magnetic fields ("bfieldi_x", "bfieldi_y", "bfieldi_z"). The cell-centered value is just the average of the corresponding face-centered component. The initializer operates in this mode if none of the components of the vector potential have specified values. (To properly use this mode, specify "vlct_bfield" in Initial:list after the name of the initializer that sets up the face-centered values.

In both modes, the option to update partially initialized "total_energy" fields with the specific magnetic energy computed from the newly computed cell-centered bfields and pre-initialized "density" fields.

It might be nice to eventually generalize this initializer to be able to initialize cell-centered B-fields from vector potentials for MHD integrators that don’t require face-centered B-fields

Parameter: Initial : vlct_bfield : update_etot
Summary: update total energy with the initialized magnetic fields
Type: logical
Default: false
Scope: Enzo

If true, then the calculated cell-centered magnetic fields are used to update the specific total energy. This requires that the "total_energy" field has already been partially initialized (it just doesn’t include the specific magnetic energy), and that the "density" field has been initialized.

Parameter: Initial : vlct_bfield : Ax
Summary: Expression for the x-component of the magnetic vector potential
Type: list ( float-expr, [ logical-expr, float-expr, [ … ] ] )
Default: []
Scope: Enzo

This parameter allows for the direct specification of the x-component of the magnetic vector potential (which will be used to compute magnetic fields). The arguements for this parameter follow the same sets of rules as the parameters of Initial:value. If this parameter is not specified, but the values of the other components of the magnetic vector potential are, then this component is assumed to be zero everywhere.

Parameter: Initial : vlct_bfield : Ay
Summary: Expression for the y-component of the magnetic vector potential
Type: list ( float-expr, [ logical-expr, float-expr, [ … ] ] )
Default: []
Scope: Enzo

This parameter allows for the direct specification of the y-component of the magnetic vector potential (which will be used to compute magnetic fields). The arguements for this parameter follow the same sets of rules as the parameters of Initial:value. If this parameter is not specified, but the values of the other components of the magnetic vector potential are, then this component is assumed to be zero everywhere.

Parameter: Initial : vlct_bfield : Az
Summary: Expression for the z-component of the magnetic vector potential
Type: list ( float-expr, [ logical-expr, float-expr, [ … ] ] )
Default: []
Scope: Enzo

This parameter allows for the direct specification of the z-component of the magnetic vector potential (which will be used to compute magnetic fields). The arguements for this parameter follow the same sets of rules as the parameters of Initial:value. If this parameter is not specified, but the values of the other components of the magnetic vector potential are, then this component is assumed to be zero everywhere.

Memory

Parameters in the Memory group are used to define the behavior of Cello’s dynamic memory allocation and deallocation.

Parameter: Memory : active
Summary: Whether to track memory usage
Type: logical
Default: true
Scope: Cello

This parameter is used to turn on or off Cello’s build-in memory tracking. By default it is on, meaning it tracks the number and size of memory allocations, including the current number of bytes allocated, the maximum over the simulation, and the maximum over the current cycle. Cello implements this by overloading C’s new, new[], delete, and delete[] operators. This can be problematic on some systems, e.g. if an external library also redefines these operators, in which case this parameter should be set to false. This can be turned off completely by setting “memory” OFF (default value) as a cmake option.

Mesh

Parameter: Mesh : root_blocks
Summary: Number of Blocks used to tile the coarsest refinement level
Type: list ( integer )
Default: [ 1, 1, 1 ]
Scope: Cello

This parameter specifies the number of Blocks along each axis in the mesh “array”. The product must not be smaller than the number of processors used.

Parameter: Mesh : root_rank
Summary: Physical dimensionality of the problem
Type: integer
Default: 0
Scope: Cello

Number of physical dimensions in the problem, 1, 2, or 3.

Parameter: Mesh : root_size
Summary: Coarsest Patch size
Type: list ( integer )
Default: [ 1, 1, 1 ]
Scope: Cello

This parameter specifies the total size of the root-level mesh. For example, [400, 400] specifies a two dimensional root-level discretization of 400 x 400 zones, excluding ghost zones.

Method

Parameter: Method : list
Summary: Sequence of numerical methods to apply.
Type: list ( string )
Default: none
Scope: Cello

This parameter specifies the list of numerical methods to use, and is analagous to “EvolveLevel” routine in ENZO. Each method in the list is applied in the order specified. Possible methods include:

“comoving_expansion” adds comoving expansion terms to the physical variables.

“cosmology” for writing redshift to monitor output.

“flux_correct” for performing flux corrections when using AMR.

“grackle” for heating and cooling methods in the Enzo Grackle library

“gravity” solves for the gravitational potential given gas and particle density fields.

“heat” for the forward-Euler heat-equation solver, which is used primarily for demonstrating how new Methods are implemented in Enzo-E

“pm_deposit” deposits “dark” particle density into “density_particle” field using CIC for “gravity” method.

“pm_update” moves cosmological “dark” particles based on positions, velocities, and accelerations. This will be phased out in favor of a more general “move_particles” method.

“ppm” for Enzo-E’s PPM hydrodynamics method. This may be phased out in favor of using a more general “hydro” method instead, with a specific hydro solver specified.

“ppml” for the PPML ideal MHD solver. This may be phased out in favor of using a more general “mhd” method instead, with a specific mhd solver specified.

“mhd_vlct” for the VL + CT (van Leer + Constrained Transport) MHD solver.

“trace” for moving tracer particles. This will be phased out in favor of a more general “move_particles” method.

“turbulence” computes random forcing for turbulence simulations.

Parameters specific to individual methods are specified in subgroups, e.g.:

Method {
   list = ["ppm"];
   ppm {
      diffusion   = true;
      flattening  = 3;
      steepening  = true;
      dual_energy = false;
   }
}

There are a subset of parameters that can be specified for all methods. For example, a schedule subgroup can be defined for any method object (to dictate when the method is executed).

For more detailed documentation on Methods, see Enzo-E Methods

Parameter: Method : courant
Summary: Global Courant safety factor
Type: float
Default: 1.0
Scope: Cello

The global Courant safety factor is a multiplication factor for the time step applied on top of any Field or Particle specific Courant safety factors.

accretion

Parameter: Method : accretion : accretion_radius_cells
Summary: The radius of the spherical accretion zone around each sink particle, in units of the minimum cell width.
Type: float
Default: 4.0
Scope: Enzo

The accretion radius (i.e., the radius of the spherical accretion zone) in units of the minimum cell width (i.e., if the cell width along all the x, y, and z-axes are hx, hy, and hz, then the minimum cell width is the minimum of hx, hy, and hz),, at the highest refinement level. Its value must be less than one fewer than the minimum ghost depth for “flux” accretion, and less than the minimum ghost depth for other flavors of accretion. The ghost depth is 4 (along all axes) by default.

Parameter: Method : accretion : flavor
Summary: The flavor of accretion used.
Type: string
Default: “”
Scope: Enzo

The flavor of accretion used, which can be either “threshold”, “bondi_hoyle”, “flux”, or “dummy”. If this parameter is not set in the parameter file, or if some other string is provided, then Enzo-E will exit with an error message.

Parameter: Method : accretion : physical_density_threshold_cgs
Summary: The value of the accretion (physical) density threshold in cgs units.
Type: float
Default: 1.0e-24
Scope: Enzo

The value of the (physical) density threshold in cgs units. The density in each cell in the accretion zone cannot go below this value during the accretion process. The value of this parameter in code density units must be greater than or equal to the value of the density floor imposed by the hydro method (either “ppm” or “mhd_vlct”. In cosmological simulations, the density unit is the mean matter density of the universe which decreases with time, which means that the value of a density quantity expressed in these units will increase with time, while the density floor is fixed in comoving units. The consequence is that is is sufficient for the density threshold to be above the density floor at the start of the simulation to guarantee that it will be above the floor at all subsequent times.

Parameter: Method : accretion : max_mass_fraction
Summary: The maximum fraction of mass which can be accreted from a cell in one timestep.
Type: float
Default: 0.25
Scope: Enzo

This parameter specifies the maximum fraction of mass which can be accreted from a cell in one timestep. This value of this parameter must be between 0 and 1.

check

The "check" method is used for writing HDF5 data files used by Cello for restart. The "check" method can also be used for data dumps, though currently all data (all fields and all particles on all blocks) are written to disk. This method should typically be called with a schedule.

Warning 1: Currently requires the "order_morton" method to be called beforehand, with a matching schedule.

Warning 2: If a file or directory corresponding to a requested checkpoint dump already exists, no data will be written. This is to avoid over-writing checkpoint files, but may not necessarily be what is expected. This behavior may be revised in the future.

Parameter: Method : check : dir
Summary: Directory in which to write the checkpoint files
Type: list ( string )
Default: “”
Scope: Enzo

This parameter specifies the subdirectory for the output file. The first element is the file name, which may contain printf-style formatting fields. Subsequent values correspond to variables for the formatting fields, which may include “cycle”, “time”, “count” (a counter incremented each time output is performed), “proc” (the process rank), and “flipflop” (alternating 0 and 1).

Note warning 2 above: if the directory pre-exists, no data will be written!

Parameter: Method : check : num_files
Summary: The number of HDF5 files in which to store restart data
Type: integer
Default: 1
Scope: Enzo

This parameter specifies the number of HDF5 files to use for writing checkpoint data. Since an ordering is used, files will be close to the same size. For large runs, using a value close to the number of compute nodes is generally a reasonable value. Note that parallel HDF5 is not (currently) used, so the only parallelism available is from writing to multiple files. Do not use the default of 1 for large runs!

Parameter: Method : check : ordering
Summary: Block-ordering used for determining block-to-file mapping
Type: string
Default: “order_morton”
Scope: Enzo

This parameter defines the method used for ordering blocks. Currently, the default “order_morton” is the only allowed value.

Parameter: Method : check : include_ghosts
Summary: Whether to include ghost zones in checkpoint files
Type: logical
Default: false
Scope: Enzo

This parameter specifies whether to include ghost zones when writing field data to HDF5 files. While this should likely be left as false to save disk storage (e.g. a factor of about 3.375 when 16³ blocks are used), earlier versions of Enzo-E always included ghost zones, so if the original behavior is required this should be set to true.

Parameter: Method : check : monitor_iter
Summary: How often to write progress updates
Type: integer
Default: 0
Scope: Enzo

This is a debugging parameter, used to periodically write progress updates to stdout. The value indicates how often an update gets written, with 0 meaning no output, and k>0 meaning output every time k blocks get written. This can produce a lot of output for large problems and k=1.

feedback

Method:feedback parameters.

Parameter: Method : feedback : supernovae
Summary: Whether to turn on supernova feedback in EnzoMethodFeedbackSTARSS
Type: logical
Default: true
Scope: Enzo

Whether to turn on supernova feedback in EnzoMethodFeedbackSTARSS

Parameter: Method : feedback : unrestricted_sn
Summary: Whether to turn on supernova feedback in EnzoMethodFeedbackSTARSS
Type: logical
Default: true
Scope: Enzo

Allow for > 1 supernova event per star particle in a timestep.

Parameter: Method : feedback : stellar_winds
Summary: Whether to turn on stellar winds in EnzoMethodFeedbackSTARSS
Type: logical
Default: true
Scope: Enzo

Whether to turn on stellar wind feedback in EnzoMethodFeedbackSTARSS

Parameter: Method : feedback : radiation
Summary: Whether to turn on radiation in EnzoMethodFeedbackSTARSS
Type: logical
Default: true
Scope: Enzo

Whether to turn on ionizing radiation in EnzoMethodFeedbackSTARSS. If true, updates the “luminosity” attribute of “star” particles using piecewise rates taken from Appendix A of Hopkins et al. (2018).

Parameter: Method : feedback : analytic_SNR_shell_mass
Summary: Calculates supernova remnant shell mass via analytic formulae
Type: logical
Default: true
Scope: Enzo

Calculates supernova remnant shell mass via analytic formulae

Parameter: Method : feedback : fade_SNR
Summary: Allow coupling to fading phase of SNe in EnzoMethodFeedbackSTARSS
Type: logical
Default: true
Scope: Enzo

Allow coupling to fading phase of SNe in EnzoMethodFeedbackSTARSS if cell width is greater than fading radius.

Parameter: Method : feedback : NEvents
Summary: Manually set off supernovae in test problems
Type: integer
Default: -1
Scope: Enzo

If -1, will probabilistically model supernova. If “NEvents” > 0, will set off N-supernovae per particle, (1 per timestep for each particle). If NEvents = 0, no supernovae will go off. Mostly for testing purposes.

flux_correct

Parameter: Method : flux_correct : group
Summary: Name of group of fields to apply flux correction to
Type: string
Default: “conserved”
Scope: Cello

Flux correction must be applied to conserved fields in AMR simulations to maintain conserved quantities across mesh resolution jumps. This parameter selects the group of fields to which the “flux_correct” method will be applied.

Fields that store a conserved quantity divided by density (e.g. "total_energy", "velocity_x") have special handling. Such fields must be included in both the group specified by this parameter AND the "make_field_conservative" group. Flux corrections are applied to an element of such fields according to the following procedure:

The element is multiplied by the corresponding element of the "density" field (before the flux corrections are applied to the "density" field).

Flux corrections are applied to the product from step 1.

Finally, the element in the original field is assigned the value computed in step 2 divided by the corresponding element from the "density" field (after flux corrections are applied to the "density" field).

An error will be raised if these special fields are detected, and the "density" field is not included in the group specified by this parameter.

Parameter: Method : flux_correct : min_digits
Summary: Number of digits expected to be conserved by fields in tests
Type: list
Default: []
Scope: Cello

Specifies the minimum number of digits that are expected to be conserved by fields. This is used for testing purposes (the simulation will check at each timestep whether this expectation has been met). Entries of this list should alternate between the name of fields (a string) and the expected number of conserved digits for that field (a float).

The example provided below indicates that the "density" field and the product of the "density" & "velocity_x" fields are expected to be conserved to 7.1 and 4.9 digits, respectively:

Method {
   flux_correct {
      min_digits = ["density", 7.1,
                    "velocity_x", 4.9];
   }
}

Group {
   list = [ "conserved", "make_field_conservative" ];
   conserved {
      field_list = [ "density", "velocity_x"];
   }
   make_field_conservative {
      field_list = [ "velocity_x"];
   }
}

For the sake of backwards compatibility, this parameter can be assigned a single float (that is not in a list). In this case, the value is assumed to be the expected minimum number of digits conserved by the "density" field. (Support for this type of parameter may be removed in the future)

grackle

“Grackle is a chemistry and radiative cooling library for astrophysical simulations. It is a generalized and updated version of the chemistry network of the Enzo simulation code.”

While most of the parameters come directly from Grackle, there are a few notable exceptions. These generally affect how Enzo-E uses Grackle and don’t have direct counterparts listed on the Grackle parameters section of the Grackle website. These parameters include:

Parameter: Method : grackle : courant
Summary: Courant safety factor
Type: float
Default: 1.0
Scope: Enzo

The method-specific courant safety factor. This is meaningless unless use_cooling_timestep has been set to true. In that case, the timestep associated with the Grackle method is this value mutliplied by the minimum timestep.

Parameter: Method : grackle : use_cooling_timestep
Summary: Whether to limit the timestep by the minimum cooling time
Type: logical
Default: false
Scope: Enzo

By default, usage of Grackle does not limit the timestep. When this parameter is set to true, the timestep is limited by the product of the minimum cooling time and Method:grackle:courant.

Parameter: Method : grackle : radiation_redshift
Summary: redshift of the UV background in non-cosmological simulations
Type: float
Default: -1.0
Scope: Enzo

In non-cosmological simulations, this parameter is used to specify the redshift of the UV background. The default value, -1.0, is used to indicate that this parameter is unset.

When this parameter has a value other than the default value in a cosmological simulation, the program will abort with an error message.
When this parameter has a default value in a non-cosmological simulation, the radiation redshift is set to 0.0, internally.

All of the other allowed parameters are used to directly configure the grackle parameters stored in Grackle’s configuration object, which are each listed on the Grackle parameters section of the Grackle website. In general, to configure a given parameter on that page, <grackle-param>, just assign your desired value to Method:grackle:<grackle-param>. The primary exceptions to this guideline are for the following grackle parameters:

use_grackle: when the grackle method is in use, this is always set to 1.

Gamma: this grackle parameter is instead initialized by Physics:fluid_props:eos:gamma

grackle_data_field: this grackle parameter is initialized with the value of Method:grackle:data_file

If you choose not to specify a value for a given grackle parameter, the default value is selected by the Grackle library.

For brevity (and to avoid having out-of-date documentation), we omit descriptions for the vast majority of recognized parameters that are directly used to initialize a corresponding grackle parameter. With that said, we make exceptions for a small handful of these parameters (primarily in cases where a parameter’s value may necessitate the existence of a field) and provide descriptions for them down below:

Parameter: Method : grackle : data_file
Summary: Path to the data file containing the metal cooling and UV background tables.
Type: string
Default: “”
Scope: Enzo

Path to the data file containing the metal cooling and UV background tables. This parameter is directly used to initialize Grackle’s grackle_data_file parameter. The only reason this isn’t called Method:grackle:grackle_data_file is for the sake of maintaining backwards compatability.

Parameter: Method : grackle : primordial_chemistry
Summary: Flag to control which primordial chemistry network is used
Type: integer
Default: 0
Scope: Enzo

Flag to control which primordial chemistry network is used (this directly corresponds to Grackle’s primordial_chemistry parameter).

0: no chemistry network. Radiative cooling for primordial species is solved by interpolating from lookup tables calculated with Cloudy. A simplified set of functions are available (though not required) for use in this mode. For more information, see Pure Tabulated Mode.

1: 6-species atomic H and He. Active species: H, H⁺, He, He⁺, ⁺⁺, e^-.

2: 9-species network including atomic species above and species for molecular hydrogen formation. This network includes formation from the H^- and H₂⁺ channels, three-body formation ( H + H + H and H + H + H²), H² rotational transitions, chemical heating, and collision-induced emission (optional). Active species: above + H^-, H², H₂⁺.

3: 12-species network include all above plus HD rotation cooling. Active species: above plus D, D⁺, HD.

Note: In order to make use of the non-equilibrium chemistry network (primordial_chemistry options 1-3), you must add and advect baryon fields for each of the species used by that particular option.

Parameter: Method : grackle : metal_cooling
Summary: Flag to enable metal cooling using the Cloudy tables
Type: logical
Default: false
Scope: Enzo

Flag to enable metal cooling using the Cloudy tables. If enabled, the cooling table to be used must be specified within the table specified by the Method:grackle:data_file parameter.

Note: In order to use the metal cooling, you must add and advect a metal density field.

gravity

Parameter: Method : gravity : solver
Summary: Name of the linear solver to use
Type: string
Default: “unknown”
Scope: Enzo

Identifier for the linear solver to use, which must be included in the “Solver:list” parameter.

Parameter: Method : gravity : order
Summary: Order of accuracy discretization to use for the discrete Laplacian
Type: integer
Default: 4
Scope: Enzo

Second, fourth, and sixth order discretizations of the Laplacian are available; valid values are 2, 4, or 6.

Parameter: Method : gravity : accumulate
Summary: Whether to add one layer of ghost zones when refreshing particle density
Type: logical
Default: true
Scope: Enzo

This should be true for all runs with particles, since particle mass deposited in the “density_particle” field may bleed into the first layer of ghost zones. This parameter ensures that that mass will be included in “density_total”.

Parameter: Method : gravity : dt_max
Summary: The maximum timestep returned by EnzoMethodGravity::timestep
Type: float
Default: 1.0e10
Scope: Enzo

The timestep returned by EnzoMethodGravity::timestep (when called on a block) is calculated as follows. First, the geometric mean of the cell-widths in all dimensions is found, which we call the “mean cell width”. Next, the quantity “epsilon” is calculated, as the mean cell width divided by the square of dt_max. Then, the maximum acceleration magnitude across all cells in the block is found, which we call “a_mag_max”. We then calculate the mean cell width divided by the sum of a_mag_max and epsilon. The timestep is then the square root of this quantity. This means that if all the accelerations are zero (such as at the first time step), the timestep is equal to dt_max. Defining the timestep in this way also means that the value of the timestep is independent of how the acceleration vectors are oriented relative to the mesh.

Parameter: Method : gravity : grav_const
Summary: Gravitational constant
Type: float
Default: none
Scope: Enzo

Warning

This parameter is deprecated and will be removed in the future. The user should use Physics:gravity:grav_const_codeU instead. These 2 parameters have identical behavior when using the "gravity" method, but the new parameter influences other gravity-related calculations such as (but NOT limited to)

calculation of acceleration from a static potential

enforcement of minimum pressure support

star formation

certain initial conditions

heat

Parameter: Method : heat : alpha
Summary: Parameter for the forward euler heat equation solver
Type: float
Default: 1.0
Scope: Enzo

Thermal diffusivity parameter for the heat equation.

merge_sinks

Parameter: Method : merge_sinks : merging_radius_cells
Summary: The distance within which sink particles merge with each other, in units of the minimum cell width
Type: float
Default: 8.0
Scope: Enzo

The distance within which sink particles merge with each other, in units of the minimum cell width, i.e., the minimum of the cell widths in all 3 dimensions, at the highest level of refinement.

mhd_vlct

Method:mhd_vlct parameters are used to initialize parameters for Enzo-E’s VL (+ CT) (magneto)hydrodynamic integrator.

The Method:mhd_vlct:mhd_choice determines whether the method is used as a pure hydrodynamic integrator or a MHD integrator that uses constrained transport.

Parameter: Method : mhd_vlct : mhd_choice
Summary: Denotes handling of bfields (or lack thereof)
Type: string
Default: none
Scope: Enzo

Denotes how the integrator handles magentic fields. This must be specified. Valid choices include:

"no_bfield" The integrator acts as a pure hydrodynamical integrator; magnetic fields are ignored entirely.

"constrained_transport" Magnetic fields are evolved using constrained transport. The primary representation of the magnetic fields are stored in face-centered cello fields and cell-centered cello-fields are used to store a secondary representation.

This may be updated to include additional options in the future. For more details see "mhd_vlct" method

For debugging purposes, there is technically one last choice, "unsafe_constant_uniform". This is NOT meant for science runs. When this option is selected, the magnetic field is treated as a cell-centered conserved quantity and the magnetic fluxes computed in the Riemann solver are directly added to to the magnetic fields (magnetic field values are only stored in cell-centered Cello fields). Outside of very specific cases, this will NOT enforce the divergence-free constrain of the magnetic fields to grow. To use this option, you need to explicitly comment out an error in "enzo_EnzoMethodMHDVlct.cpp".

Parameter: Method : mhd_vlct : courant
Summary: Courant safety factor
Type: float
Default: 1.0
Scope: Enzo

The method-specific courant safety factor. The method’s minimum timestep is the minimum value of the following expression (which is computed for all cells):

\[C \times \min \left( \frac{\Delta x}{c_f + |v_x|} + \frac{\Delta y}{c_f + |v_y|} + \frac{\Delta z}{c_f + |v_z|} \right)\]

in which:

\(C\) is the courant factor

\(c_f\) is the local fast magnetosonic speed (it reduces to the local sound speed in the absence of magnetic fields)

\(v_x,\ v_y,\ v_z\) are the velocity components

\(\Delta x,\ \Delta y,\ \Delta z\) are cell widths

A value of 0.5 or smaller is generally recommended.

Warning

The way that parsing of the courant safety factor is currently handled, the default value is fixed to 1.0 for all values (which is too large for this method). Some near-term modifications are planned that will resolve this issue.

Parameter: Method : mhd_vlct : time_scheme
Summary: name of the time-integration scheme to use
Type: string
Default: vl
Scope: Enzo

Name of the time integration scheme to use. The recommended choice is "vl", which corresponds to the default 2-stage predictor-corrector scheme. This should generally be used with a courant factor satisfying \(C \leq 0.5\).

At present, the only other option is "euler", which just updates the MHD fields in a single-stage. It is ONLY INTENDED FOR TESTING PURPOSES and at the time of writing this documentation, it has not been rigorously tested. When using this choice, make sure to pass "nn" to the reconstruct_method parameter. This scheme should generally be compatible with courant factors satisfying \(C \leq 1\).

In the future, we may add additional options to this parameter to support higher order Runge-Kutta integration schemes.

Parameter: Method : mhd_vlct : riemann_solver
Summary: name of the Riemann solver to use
Type: string
Default: hlld
Scope: Enzo

Name of the Riemann solver to use. For a list of options, see riemann solvers

Parameter: Method : mhd_vlct : reconstruct_method
Summary: name of the reconstruction method
Type: string
Default: plm
Scope: Enzo

Name of the interpolation method used to reconstruct face-centered primitives for computing the fluxes. For a list of options, see reconstruction

Note

When time_scheme is "vl", this has no effect on the predictor stage (aka the half-timestep); it only affects the reconstruction method in the second stage. The predictor stage MUST use nearest-neighbor reconstruction.

Parameter: Method : mhd_vlct : theta_limiter
Summary: controls the dissipation of certain slope limiters.
Type: float
Default: 1.5
Scope: Enzo

Modifies the disipation of the slope limiter of the "plm"/"plm_enzo" piecewise linear reconstruction algorithm. For more details, see reconstruction

Parameter: Method : mhd_vlct : half_dt_reconstruct_method
Summary: name of the reconstruction method to use for the full timestep
Type: string
Default: nn
Scope: Enzo

Name of the interpolation method used to reconstruct face-centered primitives for the first half timestep. "nn" is recommended for this method (problems arise if "plm" or "plm_athena" are used). For a list of options, see reconstruction

Warning

This parameter is deprecated and will be removed in a future version. It only carried meaning while using the original predictor-corrector time integration scheme.

Furthermore, this parameter only conveyed the illusion of choice. In reality, the integrator ONLY worked when this was set to "nn". For that reason, this parameter is not replaced.

Parameter: Method : mhd_vlct : full_dt_reconstruct_method
Summary: name of the reconstruction method to use for the full timestep
Type: string
Default: plm
Scope: Enzo

Name of the interpolation method used to reconstruct face-centered primitives for the full timestep. For a list of options, see reconstruction

Warning

This parameter is deprecated and will be removed in a future version. The reconstruct_method parameter is a direct replacement.

Deprecated mhd_vlct parameters

The following parameters have all been deprecated and will be removed in a future version of Enzo-E. Going forwards, the corresponding parameters in Physics:fluid_props should be used instead.

Parameter: Method : mhd_vlct : dual_energy
Summary: Whether to use dual-energy formalism
Type: logical
Default: false
Scope: Enzo

Whether to use the dual-energy formalism.

Parameter: Method : mhd_vlct : dual_energy_eta
Summary: Dual energy parameter eta
Type: float
Default: 0.001
Scope: Enzo

Dual-energy formalism parameter.

Parameter: Method : mhd_vlct : density_floor
Summary: Lower limit on density
Type: float
Default: none
Scope: Enzo

Density floor, which must exceed 0. This is applied during reconstruction and quantity updates.

Parameter: Method : mhd_vlct : pressure_floor
Summary: Lower limit on thermal pressure
Type: float
Default: none
Scope: Enzo

Thermal pressure floor, which must exceed 0. This is applied during reconstruction and quantity updates.

m1_closure

Method:m1_closure parameters are used to initialize parameters for Enzo-E’s multigroup M1 Closure radiative transfer solver.

Parameter: Method : m1_closure : N_groups
Summary: The number of groups to define
Type: integer
Default: 1
Scope: Enzo

This parameter specifies the number of energy groups to use for radiative transfer. The transport equation will be solved separately for each group. N_groups must be >= 1.

Parameter: Method : m1_closure : energy_lower
Summary: Lower bin edges of groups in eV
Type: list ( float )
Default: range(1.0, 100.0, 100.0/N_groups)
Scope: Enzo

This parameter specifies the lower bounds for energy groups in eV. Bins are not required to be contiguous. Lower bounds are inclusive.

Parameter: Method : m1_closure : energy_upper
Summary: Upper bin edges of groups in eV
Type: list ( float )
Default: range(100.0/N_groups, 100.0 + 100.0/N_groups, 100.0/N_groups)
Scope: Enzo

This parameter specifies the lower bounds for energy groups in eV. Bins are not required to be contiguous. Upper bounds are non-inclusive.

Parameter: Method : m1_closure : energy_mean
Summary: Group mean energy in eV
Type: list ( float )
Default: 0.5 * (energy_lower[i] + energy_upper[i])
Scope: Enzo

This parameter specifies the group mean energies in eV.

Parameter: Method : m1_closure : clight_frac
Summary: Speed-of-light fraction
Type: float
Default: 1.0
Scope: Enzo

Speed of light fraction to use for radiative transfer.

Parameter: Method : m1_closure : photon_escape_fraction
Summary: Escape fraction of photons from gas around star particles
Type: float
Default: 1.0
Scope: Enzo

Calculated photon densities for star particle radiation are multiplied by this value before being deposited onto the mesh.

Parameter: Method : m1_closure : courant
Summary: Courant number for radiative transfer
Type: float
Default: 1.0
Scope: Enzo

The radiation timestep is calculated as dt = courant * dx/(3*clight_frac*C).

Parameter: Method : m1_closure : cross_section_calculator
Summary: Choose calculator for group-mean cross-sections
Type: string
Default: “vernier”
Scope: Enzo

Specifies which group-mean photoionization cross section to use. Options include:

"vernier" Calculates the group-mean cross section using fits from `Vernier et al. (1996) <https://ui.adsabs.harvard.edu/abs/1996ApJ…465..487V/abstract>. The midpoint energy is used for each group (e.g. energy = 0.5 * (E_lower + E_upper) ).`

"vernier_average" Same as `”vernier”, with the added step of averaging the cross section over all star particles in the simulation, weighted by mass * luminosity, where luminosity in this case is converted to units of photons/s.`

"custom" Specify cross sections explicitly in the parameter file using the sigmaN and sigmaE parameters.

Parameter: Method : m1_closure : flux_function
Summary: Choose flux function for radiative transfer
Type: string
Default: “GLF”
Scope: Enzo

Specifies which flux function to use for converting cell-centered fluxes to face-centered fluxes in the transport step. For the following functions, \(\mathcal{F}\) and \(\mathcal{U}\) are vectors of unknowns defined such that \(\frac{\partial \mathcal{U}}{\partial t} + \nabla \mathcal{F}\left(\mathcal{U}\right).\)

"GLF" \(\mathcal{F}_{i+1/2}=\frac{1}{2}\left(\mathcal{F}_i+\mathcal{F}_{i+1}\right) + \frac{c}{2}\left(\mathcal{U}_{i+1}+\mathcal{U}_i\right)\)

"HLL" \(\mathcal{F}_{i+1/2}=\frac{\lambda^+\mathcal{F}_i-\lambda^-\mathcal{F}_{i+1} + \lambda^+\lambda^-\left(\mathcal{U}_{i+1}+\mathcal{U}_i\right)}{\lambda^+-\lambda^-}\), where \(\lambda^+\) and \(\lambda^-\) are eigenvalues of the Jacobian \(\frac{\partial \mathcal{F}}{\partial \mathcal{U}}\). Requires path to eigenvalue text file using the :p:`hll_file parameter.

Broadly speaking, “GLF” is more diffusive than “HLL”, but is better at handling radiation from isotropic sources. On the other hand, “HLL” is better for simulating beams of radiation and shadows. See` Rosdahl et al. (2013) for a more detailed comparison.

Parameter: Method : m1_closure : hll_file
Summary: Path to text file containing table of eigenvalues
Type: string
Default: “hll_evals.list”
Scope: Enzo

Path to text file containing table of eigenvalues. A table with eiganvalues calculated by Gonzalez, Audut, & Huynh (2007) is provided in the input/RadiativeTransfer directory.

Parameter: Method : m1_closure : min_photon_density
Summary: Minimum photon density in CGS units
Type: float
Default: 0.0
Scope: Enzo

Minimum photon density in units of \(\mathrm{cm}^{-3}\).

Parameter: Method : m1_closure : particle_luminosity
Summary: User-specified luminosity for star particles in erg/s
Type: float
Default: -1.0
Scope: Enzo

If particle_luminosity >= 0.0, all star particles will be given the emission rate specified using this parameter. Otherwise, the “luminosity” particle attribute will be checked unless radiation_spectrum equals "blackbody" .

Parameter: Method : m1_closure : radiation_spectrum
Summary: Type of radiation spectrum for star particle
Type: string
Default: “custom”
Scope: Enzo

Options include:

"blackbody" Calculates emission rate into each radiation group by integrating over a Planck function

"custom" Specify SED explicitly in the parameter file using the SED parameter

Parameter: Method : m1_closure : attenuation
Summary: Whether to attenuate radiation
Type: bool
Default: true
Scope: Enzo

Whether to include attenuation in the radiative transport equation. Requires color fields to be defined for six-species chemistry (HI, HII, HeI, HeII, HeIII, and \(e^-\).) If no density fields are defined, the attenuation calculation will be skipped by default.

Parameter: Method : m1_closure : thermochemistry
Summary: Whether to include thermochemistry
Type: bool
Default: true
Scope: Enzo

Whether to include thermochemistry. If thermochemistry == true, photoionization and heating rates are calculated and stored in the following fields: “RT_HI_ionization_rate”, “RT_HeI_ionization_rate”, “RT_HeII_ionization_rate”, and “RT_heating_rate”. The actual updates to species fields and the solving of the energy equation are handled by Grackle. As such, this method must be run in tandem with Grackle using Method:grackle:with_radiative_transfer = 1.

Parameter: Method : m1_closure : recombination_radiation
Summary: Whether to include recombination radiation
Type: bool
Default: “false”
Scope: Enzo

Whether to source photons from recombination radiation. Ignoring recombination radiation is known as the on-the-spot approximation. This is valid in gas that is optically thick to ionizing radiation.

Parameter: Method : m1_closure : lyman_werner_background
Summary: Whether to include a Lyman-Werner background
Type: bool
Default: “false”
Scope: Enzo

Whether to include an H2-photodissociating Lyman-Werner background. Requires radiation group 0 to be defined corresponding to energies in the Lyman-Werner band (11.18-13.6 eV). A constant intensity can be specified using the LWB_J21 parameter. If LWB_J21 is not set, the intensity will be calculated using the redshift-dependent polynomial fit defined in Equation 16 of Wise et al. (2012).

Parameter: Method : m1_closure : LWB_J21
Summary: Intensity of the LW background in units of 1e-21 erg s^-1 cm^-2 Hz^-1 sr^-1
Type: float
Default: -1.0
Scope: Enzo

Intensity of the LW background in units of 1e-21 erg s^-1 cm^-2 Hz^-1 sr^-1.

Parameter: Method : m1_closure : H2_photodissociation
Summary: Whether to include H2 photodissociation from LW radiation
Type: bool
Default: “false”
Scope: Enzo

Whether to include an H2 photodissociation from Lyman-Werner radiation. If true, H2 photodissication rates are calculated and stored in a field called “RT_H2_dissociation_rate”. Requires radiation group 0 to be defined corresponding to energies in the Lyman-Werner band (11.18-13.6 eV).

Parameter: Method : m1_closure : SED
Summary: User-specified SED for radiating point sources
Type: list ( float )
Default: Flat spectrum, where each group is given an emission rate of 1.0/N_groups
Scope: Enzo

User-specified SED for radiating point sources. This is a list, where each entry corresponds to an energy fraction to inject into each group every timestep. For example, if SED = [0.1, 0.6, 0.3], the emitted radiation will be split into three groups such that L1 = 0.1*L, L2 = 0.6*L, and L = 0.3*L, where L is the total luminosity of the particle.

Parameter: Method : m1_closure : sigmaE
Summary: User-specified group-mean cross sections in cm^2, averaged by energy
Type: list ( float )
Default: 0.0
Scope: Enzo

User-specified group-mean cross sections, averaged by energy. Requires cross_section_calculator to be set to “custom”. If this parameter is set, sigmaN must also be set. This list has length N_groups * 3 ( N_groups * 4 if H2_photodissociation is true), where the number 3 (or 4) represents the number of chemical species (HI, HeI, HeII, and optionally H2I). For example, a simulation could use three radiation groups with energy_mean = [21.62, 30.0, 60.0]. In this case, setting sigmaE = [1.78e-18,0.0,0.0, 7.03e-19,5.36e-18,0.0, 9.19e-20,1.37e-18,1.22e-18] would produce the same cross sections as the fits from Vernier et al. (1996) <https://ui.adsabs.harvard.edu/abs/1996ApJ…465..487V/abstract>_.

Parameter: Method : m1_closure : sigmaN
Summary: User-specified group-mean cross sections in cm^2, averaged by photon density
Type: list ( float )
Default: 0.0
Scope: Enzo

User-specified group-mean cross sections, averaged by photon number. Requires cross_section_calculator to be set to “custom”. If this parameter is set, sigmaE must also be set. This list has length N_groups * 3 ( N_groups * 4 if H2_photodissociation is true), where the number 3 (or 4) represents the number of chemical species (HI, HeI, HeII, and optionally H2I). For example, a simulation could use three radiation groups with energy_mean = [21.62, 30.0, 60.0]. In this case, setting sigmaE = [1.78e-18,0.0,0.0, 7.03e-19,5.36e-18,0.0, 9.19e-20,1.37e-18,1.22e-18] would produce the same cross sections as the fits from Vernier et al. (1996) <https://ui.adsabs.harvard.edu/abs/1996ApJ…465..487V/abstract>_.

Parameter: Method : m1_closure : temperature_blackbody
Summary: User-specified blackbody temperature for radiating point sources
Type: float
Default: 0.0
Scope: Enzo

User-specified blackbody temperature for radiating point sources. Requires radiation_spectrum to be set to "blackbody".

null

Parameter: Method : null : dt
Summary: Set the time step for the “null” Method
Type: float
Default: max (float)
Scope: Enzo

Sets the time step for the null Method. This is typically used for testing the AMR meshing infrastructure without having to use any specific method. It can also be used to add an additional maximal time step value for other methods.

pm_deposit

Parameter: Method : pm_deposit : alpha
Summary: Compute the total gravitating density field at time t + alpha*dt
Type: float
Default: 0.5
Scope: Enzo

Sets the factor defining at what time to deposit mass into the density_total field. The default is 0.5, meaning density_total is computed at t + 0.5*dt.

ppm

Method:ppm parameters are used to initialize parameters for Enzo-E’s PPM hydrodynamics method.

Parameter: Method : ppm : courant
Summary: Courant safety factor
Type: float
Default: 1.0
Scope: Enzo

The method-specific courant safety factor. The method’s minimum timestep is the minimum value of the following expression (which is computed for all cells):

\[C \times \left( \frac{c_s + |v_x|}{a\, \Delta x} + \frac{c_s + |v_y|}{a\, \Delta y} + \frac{c_s + |v_z|}{a\, \Delta z} \right)^{-1}\]

in which:

\(C\) is the courant factor

\(a\) is the cosmological scale factor

\(c_s\) is the local sound speed

\(v_x,\ v_y,\ v_z\) are the velocity components

\(\Delta x,\ \Delta y,\ \Delta z\) are cell widths

A value of 0.8 or smaller is generally recommended.

Warning

The way that parsing of the courant safety factor is currently handled, the default value is fixed to 1.0 for all values (which is too large for this method). Some near-term modifications are planned that will resolve this issue.

Parameter: Method : ppm : diffusion
Summary: PPM diffusion parameter
Type: logical
Default: false
Scope: Enzo

PPM diffusion parameter.

Parameter: Method : ppm : flattening
Summary: PPM flattening parameter
Type: integer
Default: 3
Scope: Enzo

PPM flattening parameter.

Parameter: Method : ppm : minimum_pressure_support_parameter
Summary: Enzo’s MinimumPressureSupportParameter
Type: integer
Default: 100
Scope: Enzo

Enzo’s MinimumPressureSupportParameter parameter. This is meaningless unless use_minimum_pressure_support is set to true.

Parameter: Method : ppm : pressure_free
Summary: Pressure-free flag
Type: logical
Default: false
Scope: Enzo

Pressure-free flag.

Parameter: Method : ppm : steepening
Summary: PPM steepening parameter
Type: logical
Default: false
Scope: Enzo

PPM steepening parameter.

Parameter: Method : ppm : use_minimum_pressure_support
Summary: Minimum pressure support
Type: logical
Default: false
Scope: Enzo

Enzo’s UseMinimumPressureSupport parameter.

When radiative cooling is turned on, and objects are allowed to collapse to very small sizes so that their Jeans length is no longer resolved, they may undergo artificial fragmentation and angular momentum non-conservation. This parameter can be used to turn on a very simple fudge described in Machacek, Bryan & Abel (2001) in order to alleviate this problem.

When using minimum-pressure support, a floor is applied to the specific internal energy (or equivalently, temperature) to blocks with a refinement level equivalent to Adapt:max_level. A floor is applied in order to satisfy the inequality: \(\lambda_J \geq \sqrt{K}\, \Delta x\), where:

\(\lambda_J = c_s \sqrt{\pi / (G \rho)}\) is the Jeans-length

\(K\) encodes the value assigned to minimum_pressure_support_parameter

\(\Delta x\) encodes the cell-width.

In other words, the minimum pressure-support ensures that the Jeans length is larger than the cell-width by a factor that is at least the square-root of minimum_pressure_support_parameter.

Deprecated ppm parameters

The following parameters have all been deprecated and will be removed in a future version of Enzo-E. Going forwards, the corresponding parameters in Physics:fluid_props should be used instead.

Parameter: Method : ppm : density_floor
Summary: Lower limit on density
Type: float
Default: 1.0e-6
Scope: Enzo

Density floor, which replaces Enzo’s “tiny_number”.

Parameter: Method : ppm : dual_energy
Summary: Whether to use dual-energy formalism
Type: logical
Default: false
Scope: Enzo

Whether to use the dual-energy formalism.

Parameter: Method : ppm : dual_energy_eta_1
Summary: Dual energy parameter eta 1
Type: float
Default: 0.001
Scope: Enzo

First dual-energy formalism parameter.

Parameter: Method : ppm : dual_energy_eta_2
Summary: Dual energy parameter eta 2
Type: float
Default: 0.1
Scope: Enzo

Second dual-energy formalism parameter.

Parameter: Method : ppm : mol_weight
Summary: Enzo’s Mu parameter
Type: float
Default: 0.6
Scope: Enzo

Enzo’s Mu molecular weight parameter.

Parameter: Method : ppm : number_density_floor
Summary: Lower limit on number density
Type: float
Default: 1.0e-6
Scope: Enzo

Number density floor, which replaces Enzo’s “tiny_number”.

Parameter: Method : ppm : pressure_floor
Summary: Lower limit on pressure
Type: float
Default: 1.0e-6
Scope: Enzo

Pressure floor, which replaces Enzo’s “tiny_number”.

Parameter: Method : ppm : temperature_floor
Summary: Lower limit on temperature
Type: float
Default: 1.0e-6
Scope: Enzo

Temperature floor, which replaces Enzo’s “tiny_number”.

sink_maker

Parameter: Method : sink_maker : jeans_length_resolution_cells
Summary: Determines how many cell widths are required to resolve the local Jeans length for a cell not to form a sink.
Type: float
Default: 4.0
Scope: Enzo

If the local Jeans length in a cell is less than this quantity multiplied by the maximum cell width, then the cell is a candidate for forming a sink. The maximum cell width is maximum value out of hx, hy, and hz, where hx, hy, and hz are the cell widths across the x-, y- and z-axes, respectively.

Parameter: Method : sink_maker : physical_density_threshold_cgs
Summary: The minimum physical density required for a cell to form a sink particle in cgs units.
Type: float
Default: 1.0e-24
Scope: Enzo

The value of the physical density threshold in cgs units. The density in a cell must be greater than the density threshold to be able to form a sink. The density in a cell after sink formation will be no less than the density threshold. The value of the density threshold in code units must be greater than or equal to the value of the density floor imposed by the hydro method.

Parameter: Method : sink_maker : max_mass_fraction
Summary: The maximum fraction of a cell’s gas mass which can be turned into a sink particle in one timestep.
Type: float
Default: 0.25
Scope: Enzo

The mass of a newly-formed sink is bounded above by this parameter multiplied by the cell density multiplied by the cell volume. The value of this parameter must be between 0 and 1.

Parameter: Method : sink_maker : min_sink_mass_solar
Summary: The minimum mass of a newly-formed sink particle, in solar mass units.
Type: float
Default: 0.0
Scope: Enzo

The minimum mass of a newly-formed sink particle, in solar mass units. If there is not enough gas mass in a cell to form a sink with at least this mass, no sink is formed.

Parameter: Method : sink_maker : check_density_maximum
Summary: Determines whether a cell is required to be a local density maximum in order to form a sink particle.
Type: logical
Default: true
Scope: Enzo

If true, then a cell will only form a sink particle if its density is larger than the density in all 26 neighboring cells.

Parameter: Method : sink_maker : max_offset_cell_fraction
Summary: Controls the size of the random displacement of a sink particle’s initial position relative to the center of the cell
Type: float
Default: 0.0
Scope: Enzo

When a cell creates a sink particle, the x/y/z coordinate of its initial position will be the x/y/z coordinate of the center of the cell, plus a random value generated from a uniform distribution on the interval [-A,A], where A is equal to this parameter multiplied by the cell width along the x/y/z axis.

Parameter: Method : sink_maker : offset_seed_shift
Summary: Seed used to generate the random displacement of a sink particle’s initial position relative to the center of the cell
Type: integer
Default: 0
Scope: Enzo

When computing the random offset for the initial position of a sink particle, we compute an unsigned 64 bit integer value from the cycle number, the block index, and the cell index, and then add on this value to give the seed for the random number generator.

star_maker

Method:star_maker parameters.

Parameter: Method : star_maker : flavor
Summary: Which star_maker method to use
Type: string
Default: STARSS
Scope: Enzo

Options: “STARSS”, “stochastic”

Parameter: Method : star_maker : use_density_threshold
Summary: Use number density threshold for star formation
Type: logical
Default: false
Scope: Enzo

Flag to enable number density threshold for star formation.

Parameter: Method : star_maker : number_density_threshold
Summary: Use number density threshold for star formation
Type: logical
Default: false
Scope: Enzo

Set number density threshold for star formation in units of cm^-3. Requires “use_density_threshold”=true.

Parameter: Method : star_maker : use_overdensity_threshold
Summary: Use overdensity threshold
Type: logical
Default: false
Scope: Enzo

Flag to enable overdensity threshold for star formation. Currently only valid for cosmology simulations.

Parameter: Method : star_maker : overdensity_threshold
Summary: Use overdensity threshold for star formation
Type: float
Default: 0.0
Scope: Enzo

Set overdensity threshold for star formation. Requires “use_overdensity_threshold”=true.

Parameter: Method : star_maker : use_velocity_divergence
Summary: Use converging flow criterion for star formation
Type: logical
Default: false
Scope: Enzo

Flag to check whether div(V) < 0

Parameter: Method : star_maker : use_cooling_time
Summary: Check if cooling_time < dynamical_time for star formation
Type: logical
Default: false
Scope: Enzo

Flag to check if cooling_time < dynamical_time

Parameter: Method : star_maker : use_temperature_threshold
Summary: Use temperature threshold for star formation
Type: logical
Default: false
Scope: Enzo

Flag to enable temperature threshold check for star formation

Parameter: Method : star_maker : temperature_threshold
Summary: Temperature threshold for star formation
Type: float
Default: 1e4
Scope: Enzo

Set temperature threshold required for star formation. Requires “use_temperature_threshold”=true.

Parameter: Method : star_maker : use_self_gravitating
Summary: Use FIRE2 virial parameter criterion for star formation
Type: logical
Default: false
Scope: Enzo

Checks that alpha < 1, where alpha is the virial parameter calculated using the FIRE-2 prescription. See Appendix C of Hopkins et al. (2018).

Parameter: Method : star_maker : use_altAlpha
Summary: Use alternate virial parameter criterion for star formation
Type: logical
Default: false
Scope: Enzo

Checks that alpha < 1, where alpha is the virial parameter calculated as “potential/total_energy”. Currently only accessed by EnzoMethodStarMakerSTARSS.

Parameter: Method : star_maker : use_h2_self_shielding
Summary: Use H2 self-shielding criterion for star formation
Type: logical
Default: false
Scope: Enzo

Checks that f_shield < 0, where f_shield is the H2 self-shielded fraction calculated using fits from Krumholz & Gnedin (2011).

Parameter: Method : star_maker : use_jeans_mass
Summary: Use Jeans mass criterion for star formation
Type: logical
Default: false
Scope: Enzo

Checks that cell_mass > max(jeans_mass, 1000 Msun) in a cell.

Parameter: Method : star_maker : critical_metallicity
Summary: Metallicity threshold for star formation
Type: float
Default: 0.0
Scope: Enzo

Set metallicity threshold required for star formation

Parameter: Method : star_maker : maximum_mass_fraction
Summary: Max fraction of gas in a cell that can be converted into a star particle per formation event.
Type: float
Default: 0.05
Scope: Enzo

Max fraction of gas in a cell that can be converted into a star particle per formation event.

Parameter: Method : star_maker : min_level
Summary: Minimum AMR level required for star formation.
Type: integer
Default: 0
Scope: Enzo

Set minimum AMR level required for star formation.

Parameter: Method : star_maker : minimum_star_mass
Summary: Minimum star particle mass
Type: float
Default: 0.0
Scope: Enzo

Set minimum star particle mass.

Parameter: Method : star_maker : maximum_star_mass
Summary: Maximum star particle mass
Type: float
Default: -1.0
Scope: Enzo

Set maximum star particle mass. For no limit, set “maximum_star_mass” < 0.

Parameter: Method : star_maker : turn_off_probability
Summary: Turn off probablistic elements of EnzoMethodStarMakerSTARSS.
Type: logical
Default: false
Scope: Enzo

Turn off probablistic elements of EnzoMethodStarMakerSTARSS. Mostly meant for debugging.

turbulence

Parameter: Method : turbulence : edot
Summary: Initial value for edot for turbulence Method
Type: float
Default: -1.0
Scope: Enzo
Todo: write

Parameter: Method : turbulence : mach_number
Summary: Value for Mach number in turbulence problem
Type: float
Default: 0.0
Scope: Enzo
Todo: write

Monitor

Output

Output parameters are used to specify what types of disk output to perform and on what schedule.

Parameter: Output : list
Summary: List of output file sets
Type: list ( string )
Default: []
Scope: Cello

List of active file sets, each of which has its own associated Output : <file_set> : parameters. Any file set parameters associated with a file set not in the list parameter are ignored.

Parameter: Output : <file_set> : axis
Summary: Axis of projections for image output
Type: string
Default: none
Scope: Cello
Assumes: <file_set> is of type “image”

For the “image” output type, the axis along which to project the data for 3D problems. Values are “x”, “y”, :e:`or “z”. See the associated type parameter.

Parameter: Output : <file_set> : schedule
Summary: Output schedule for the given file set
Type: subgroup
Default: none
Scope: Cello

See the schedule subgroup for parameters used to define when to perform output for the given file set.

Parameter: Output : <file_set> : colormap
Summary: Color map for image output
Type: list ( float | string )
Default: [“black”, “white”]
Scope: Cello
Assumes: <file_set> is of type “image”

For the “image” output type, this parameter defines the colormap as a list of RGB values, such that the minimum field value is assigned the first color in the list, the maximum the last, and linear interpolated color values in between. If image_min or image_max parameters are defined, those are used instead for the respective min and max field values. The list must contain at least two colors, and the default is “black” and “white”.

RGB values are specified in one of several ways. The original (and depreciated) way is as a triad of floating point numbers between 0.0 and 1.0, such that 1.0, 0.0, 0.0 represents red, 0.5, 0.5, 0.5 represents gray, etc. Another preferred way is named colors, e.g. “black” , “white” , “azure”, etc. Any CSS3 extended color name should be accepted (lower-case). See CSS3 Extended Color list for a list of accepted color names. Also accepted are color specifications of the form #rrggbb, e.g. “#000000” for black, “#ffffff” for white, etc. (case independent).

RGB values in a given colormap can mix-and-match color representations; for example, [“black”, 0.5, 0.5, 0.5, “#Abacab”] is a valid colormap.

Parameter: Output : <file_set> : field_list
Summary: List of fields to output
Type: list ( string )
Default: []
Scope: Cello

List of fields for this output file set. For “image” field types, the field list must contain exactly one field.

Parameter: Output : <file_set> : particle_list
Summary: List of particle types to output
Type: list ( string )
Default: []
Scope: Cello

List of particles types for this output file set..

Parameter: Output : <file_set> : name
Summary: File names
Type: list ( string )
Default: “”
Scope: Cello
Assumes: <file_set> is not of type “restart”

This parameter specifies the names of files in the corresponding file_group. The first element is the file name, which may contain printf-style formatting fields. Subsequent values correspond to variables for the formatting fields, which may include “cycle”, “time”, “count” (a counter incremented each time output is performed), “proc” (the process rank), and “flipflop” (alternating 0 and 1, which can be useful for checkpoint directories). The file name should include an appropriate extension, e.g. “.png” for “image” output, and “.h5” or “.h5” for “data” output. Example: [“projection-%04d.png”, “cycle”].

Parameter: Output : <file_set> : dir
Summary: Name of the subdirectory for the output file
Type: list ( string )
Default: “”
Scope: Cello

This parameter specifies the subdirectory for the output file. The first element is the file name, which may contain printf-style formatting fields. Subsequent values correspond to variables for the formatting fields, which may include “cycle”, “time”, “count” (a counter incremented each time output is performed), “proc” (the process rank), and “flipflop” (alternating 0 and 1, which can be useful for checkpoint directories). Example: [“Checkpoint-%d”, “flipflop”].

This parameter is required for file groups of type “checkpoint”. While optional for other file types, the behavior is different for groups of type “data”. In that case, two extra files are output: <DIR>.file_list, which contains a list of all data files output, and <DIR>.block_list, which contains a list of all names of Blocks and the corresponding data file containing each Block.

Parameter: Output : <file_set> : stride_write
Summary: Subset of processors to perform write
Type: integer
Default: 1
Scope: Cello
Assumes: <file_set> is of type “data”
Status: DEPRECIATED

This parameter allows for a strict subset of physical processors to output data, which is especially helpful for large process counts to reduce the load on parallel file systems. This parameter is depreciated, since the “output” method is preferered for writing data output.

Parameter: Output : <file_set> : stride_wait
Summary: Stride for sequencing processor data writes
Type: integer
Default: 1
Scope: Cello
Assumes: <file_set> is of type “data”
Status: DEPRECIATED

This parameter allows for processes to write sequentially to prevent too many processes overloading the file system. A good starting point would be the number of processes in a shared memory node, in which case at most one process per node will be writing at any point in time. This parameter is depreciated, since the “output” method is preferered for writing data output.

Parameter: Output : <file_set> : type
Summary: Type of output files
Type: string
Default: “unknown”
Scope: Cello

The type of files to output in this output file set. Supported types include “image” (PNG file of 2D fields, or projection of 3D fields) and “data”. For “image” files, see the associated colormap and axis parameters.

Parameter: Output : <file_set> : image_min
Summary: Data value associated with the first color in the colormap
Type: float
Default: 0.0
Scope: Cello
Assumes: <file_set> is of type “image”

This parameter specifies the Field value associated with the first color in the file set’s colormap.

Parameter: Output : <file_set> : image_max
Summary: Data value associated with the last color in the colormap
Type: float
Default: 0.0
Scope: Cello
Assumes: <file_set> is of type “image”

This parameter specifies the Field value associated with the last color in the file set’s colormap.

Parameter: Output : <file_set> : image_lower
Summary: Lower bound on domain to be output in image
Type: list ( float )
Default: [min ( float ), min ( float ), min ( float )]
Scope: Cello
Assumes: <file_set> is of type “image”

This parameter specifies the lower limit of the domain to include in the image. This can be used for imaging “slices” of 3D data, or zeroing in on interesting region of the domain.

Parameter: Output : <file_set> : image_upper
Summary: Upper bound on domain to be output in image
Type: list ( float )
Default: [max ( float ), max ( float ), max ( float )]
Scope: Cello
Assumes: <file_set> is of type “image”

This parameter specifies the upper limit of the domain to include in the image. This can be used for imaging “slices” of 3D data, or zeroing in on interesting region of the domain.

Parameter: Output : <file_set> : image_ghost
Summary: Whether to include ghost zones in the image
Type: logical
Default: false
Scope: Cello
Assumes: <file_set> is of type “image”

Setting the image_ghost to true will include ghost zone values in the image output. This is typically used only when debugging. The default is false.

Parameter: Output : <file_set> : image_reduce_type
Summary: How to handle 3D field data orthogonal to the image
Type: string
Default: “sum”
Scope: Cello
Assumes: <file_set> is of type “image”

When images are generated for 3D problems, multiple data values will be associated with each pixel in the image. This parameter defines how to handle these multiple values, including “sum”, “min”, “max”, and, “avg”. For field data the default of “sum” is appropriate, though for images of meshes “max” should be used.

Parameter: Output : <file_set> : image_face_rank
Summary: Whether to include neighbor markers in the mesh image output
Type: integer
Default: 3
Scope: Cello
Assumes: <file_set> is of type “image”

This parameter is primarily used for debugging. Internally, each node in the mesh keeps track of the mesh level of its neighbors. This parameter includes a marker on each face colored according to the neighbor’s level. The value of this parameter specifies the lower limit on the face “rank” (0 for corners, 1 for edges, 2 for faces). The default of 3 means no markers are displayed.

Parameter: Output : <file_set> : image_size
Summary: Set the size of the image
Type: list ( integer )
Default: [0,0]
Scope: Cello
Assumes: <file_set> is of type “image”

Specify the size of the output image. By default it is sized to be one pixel per field value at the finest mesh level. This is useful to keep images from being to big for large problems, or too small for small problems (e.g. for mesh images which could otherwise be too small).

Parameter: Output : <file_set> : image_log
Summary: Whether to output the log of the data
Type: logical
Default: false
Scope: Cello
Assumes: <file_set> is of type “image”

If true, then the natural logarithm of the field value is used for mapping values to the colormap, otherwise use the original field value.

Parameter: Output : <file_set> : image_type
Summary: Type of image to write
Type: string
Default: “data”
Scope: Cello
Assumes: <file_set> is of type “image”

This parameter is used to control whether field values are used to generate the image, whether it’s an image of the mesh structure, or a combination of both. Valid values are “data”, “mesh”, or “data+mesh”.

Parameter: Output : <file_set> : image_block_size
Summary: Number of pixels for fine-level blocks in a mesh image
Type: integer
Default: 1
Scope: Cello
Assumes: <file_set> is of type “image”
Status: DEPRECIATED

For images of meshes, this parameter defines how many pixels wide each finest-level block is in the image. This parameter and the image_size parameter should not both be set.

Parameter: Output : <file_set> : image_mesh_color
Summary: How to color blocks in a mesh image
Type: string
Default: “level”
Scope: Cello
Assumes: <file_set> is of type “image”

By default, blocks in mesh images are colored according to the level of the block. In addition to “level”, other possible ways to assign colors to blocks include “process” and “age”.

Particle

Cello supports any number of particle types–e.g. “dark” for dark matter particles, or “trace” for tracer particles. Each particle type in turn may have any number of attributes–e.g. “x” or “position_x” for position, “vx” or “velocity_x” for velocity, “mass”, “id”, etc. Attributes can have any basic floating-point or integer type.

All particle types must have at least attributes for position, defined using the position parameter. This allows Cello to know whether particles have moved off of a Block, and if so to relocate them to the correct new block.

Particle positions may be defined as integer types instead of floating-point. When a particle position attribute is defined as an integer, then the coordinate value is defined relative to the enclosed Block instead of a global coordinate system. This can be useful both to reduce memory usage, and to simultaneously improve accuracy–it avoids possible catastrophic cancellation errors that are especially large in “deep” Blocks in an AMR hierarchy whose position is far from 0. When positions are defined as integers, 0 is defined to be the center of the block, and [ -min-int / 2 , max-int / 2) are the bounds of the Block, where min-int is the minimum value of the signed integer of the corresponding size. Integer types allowed include “int8”, “int16”, “int32”, and “int64”. Two byte integers “int16” should be sufficient for most simulations: it has a range of [ -16384, 16384 ) within the particle’s containing Block, and ranges [-32768, -16384) and [16384, 32768) on either side of the associated Block.

Particles are allocated and operated on in “batches”. The batch_size parameter defines how many particles are in a batch. By operating on particles in batches, the frequency of memory operations is greatly reduced, and functions operating on particle attributes can be more efficient due to reduced overhead. It should also simplify writing particle methods to be executed on accelerators, such as NVIDIA or AMD GPU’s.

Just as with fields, particle types can be assigned to groups.

Parameter: Particle : list
Summary: List of particle types
Type: list ( string )
Default: []
Scope: Cello

Cello allows arbitrary parameter types (dark matter particles, tracer particles, star particles, etc.), each with arbitrary attributes (position, velocity, etc.). The list parameter defines which types of particles to use.

Particle {

    list = ["dark", "trace"];

}

Parameter: Particle : batch_size
Summary: Number of particles in a “batch” of particles
Type: integer
Default: 1024
Scope: Cello

Particles are allocated and operated on in batches. The number of particles in a batch is set using the batch_size parameter. The default batch size is 1024.

Parameter: Particle : particle_type : attributes
Summary: List of attribute names and data types
Type: list ( string )
Default: none
Scope: Cello

Each particle type can have multiple attributes of varying types, which are defined by the attributes parameter. The attributes parameter is a list of strings, alternating between the name of the parameter, and its type. Names may include “position_x”, “velocity_z”, “mass”, “id”, etc. Types may include “single”, “double”, “quadruple”, “int8”, “int16”, “int32”, or “int64”. Ordering of attributes in memory is as in the attributes parameter.

Parameter {

    list = ["trace", "dark"];

        trace {

            attributes = ["id", "int64",
                          "x",  "single",
                          "y",  "single",
                          "z",  "single"];
         }

         dark {

             attributes = ["id",         "int64",
                           "mass",       "double",
                           "velocity_x", "single",
                           "velocity_y", "single",
                           "velocity_z", "single",
                           "position_x", "int16",
                           "position_y", "int16",
                           "position_z", "int16"];
       }
  }

Note that when attributes of multiple sizes are included in the same parameter type, it can be helpful to order the attributes so that larger-sized attributes are listed first, followed by smaller-sized attributes. This can help prevent allocating more memory than necessary, since attributes may be padded with unused bytes for correct memory alignment.

Parameter: Particle : particle_type : interleaved
Summary: Format of output files
Type: logical
Default: false
Scope: Cello

Particle attributes within a batch of particles may be stored in memory either particle-by-particle, or “interleaved” (attribute-by-attribute). If a_i,j represents the jth attribute of particle i, then with interleaved = false, attributes would be stored as a_0,0 … a_m,0, a_0,1 … a_m,1 … a_0,n … a_m,n. If, however, interleaved = true, then attributes would be stored as a_0,0 … a_0,n, a_1,0 … a_1,n … a_m,0 … a_m,n. Non-interleaved particle attributes have array accesses of stride 1 and minimal storage overhead, but may not utilize cache well. Interleaved particle attributes may have improved cache utilization, but will have stride > 1, and may require memory padding for correct alignment of attributes in memory. The default is false.

Parameter: Particle : particle_type : group_list
Summary: Specify a list of groups that the Particle type belongs to
Type: list ( string )
Default: [ ]
Scope: Cello

Different Particle types may belong to any number of different “groups”, which allows simulation code to loop over multiple related particle types.

Particle {
    list = ["trace","dark","star"];

    dark { group_list = ["is_gravitating"]; }
    star { group_list = ["is_gravitating"]; }
}

This example can be rewritten as follows, which is completely equivalent:

Particle
    list = ["trace","dark","star"];
}

Group {
    list = ["is_gravitating"];
    is_gravitating {
       particle_list = ["dark","star"];
    }
}

Parameter: Particle : particle_type : position
Summary: Format of output files
Type: string
Default: “”
Scope: Cello

Cello needs to know which particle attributes represent position, so that it can determine when particles migrate out of a Block and need to be moved to a neighboring Block. This is done using the position parameter:

Particle {

   list = ["trace"];

   trace {

      attributes = ["id",
                    "x","single",
                 "y","single",
                 "z","single"];

      position = ["x","y","z"];
   }
}

Parameter: Particle : particle_type : velocity
Summary: Format of output files
Type: string
Default: “”
Scope: Cello

Enzo may need to know which particle attributes represent velocity, for example for kick() or drift() operations. This is done using the velocity parameter, whose usage is analogous to the position parameter. While specifying position is required, specifying velocity is optional.

Particle {

   list = ["dark"];

   trace {

      attributes = [ "x","single",   "y","single",   "z","single",
                    "vx","single",  "vy","single",  "vz","single",
                 "mass","single"];

      velocity = ["vx","vy","vz"];
   }
}

Parameter: Particle : mass_is_mass
Summary: Flag for whether particle masses should be handled as a quantity with dimensions of mass.
Type: any
Default: none
Scope: Cello

This parameter is not used by Enzo-E, but is rather used by yt to indicate whether particle “mass” should be treated as a quantity with dimensions of mass. If this parameter is absent, then “mass” is treated as a quantity with dimensions of density, which has a value equal to the true mass divided by the root level cell volume. The value of this parameter is not used: yt only checks whether this parameter is present, however, it must have some value which can be read in by yt. It is recommended to set the velue to be “true”.

Performance

Parameter: Performance : warnings
Summary: Whether to output performance-related warnings
Type: logical
Default: true
Scope: Cello

If calls to the Performance API are incorrect, e.g. if stop_region() is called on a region that has not been started, then this parameter specifies whether or not to display warning messages

Parameter: Performance : papi : counters
Summary: List of PAPI counters
Type: list ( string )
Default: []
Scope: Cello

List of PAPI hardware performance counters to trace, e.g. ‘counters = [“PAPI_FP_OPS”, “PAPI_L3_TCA”];’. For a list of available counters, use the PAPI “papi_avail” utility.

Physics

Parameter: Physics : list
Summary: List of physics-sets
Type: list ( string )
Default: []
Scope: Cello

Specifies list of physics-sets, each of which has its own associated: Physics : <physics-set> : parameters. Any parameters associated with a physics-set subgroup that is not in this list parameter are ignored. Allowed values include:

“cosmology” specifies cosmological constants.

“fluid_props” specifies parameters related to gas properties.

“gravity” specifies parameters related to gravity.

cosmology

Parameter: Physics : cosmology : comoving_box_size
Summary: Enzo’s CosmologyComovingBoxSize parameter
Type: float
Default: 64.0
Scope: Enzo

Enzo’s CosmologyComovingBoxSize parameter.

Parameter: Physics : cosmology : hubble_constant_now
Summary: Hubble constant for Z=0
Type: float
Default: 0.701
Scope: Enzo

Hubble constant for Z=0.

Parameter: Physics : cosmology : initial_redshift
Summary: Enzo’s CosmologyInitialRedshift parameter.
Type: float
Default: 20.0
Scope: Enzo

Enzo’s CosmologyInitialRedshift parameter.

Parameter: Physics : cosmology : max_expansion_rate
Summary: Maximum expansion rate
Type: float
Default: 0.01
Scope: Enzo

Maximum expansion rate.

Parameter: Physics : cosmology : omega_lamda_now
Summary: Omega lambda for Z=0
Type: float
Default: 0.721
Scope: Enzo

Omega lamda for Z=0.

Parameter: Physics : cosmology : omega_matter_now
Summary: Omega matter for Z=0
Type: float
Default: 0.279
Scope: Enzo

Omega matter for Z=0.

fluid_props

Physics:fluid_props parameters are used to specify general fluid properties for the gas. The majority of these parameters are further divided into the following 3 subgroups: dual_energy, floors, eos.

An example configuration is described below:

Physics {
   list = ["fluid_props"];
   fluid_props {

      dual_energy { type = "disabled"; }

      eos {
         gamma = 1.4;
      }

      floors {
         density  = 1e-10;
         pressure = 1e-10;
      }

      mol_weight = 0.6;
   }
}

Parameter: Physics : fluid_props : mol_weight
Summary: Specifies the gas’s nominal mean molecular weight
Type: float
Default: 0.6
Scope: Enzo

Specifies the gas’s nominal mean molecular weight. This is used in operations like computing the temperature field. When the "grackle" method is in use, this parameter may not be used.

dual_energy

Physics:fluid_props:dual_energy parameters specify details about the dual-energy formalism (or the lack thereof). Significantly more detail about the different variants are provided in dual-energy formalism.

Parameter: Physics : fluid_props : dual_energy : type
Summary: specifies formulation of dual-energy formalism (if any)
Type: string
Default: disabled
Scope: Enzo

Specifies the formulation of the dual-energy formalism that the simulation uses (if any). Valid choices include:

"disabled" The dual-energy formalism is not used. This is the default option.

"bryan95" Enables the formulation of the dual-energy formalism that is described in Bryan et al (1995)

"modern" Enables the formulation of the dual-energy formalism that is described in Overview

Parameter: Physics : fluid_props : dual_energy : eta
Summary: eta parameter(s) for the dual-energy formalism
Type: list ( float )
Default: []
Scope: Enzo

Specifies parameters used in the dual energy formalism. It expects a different number of parameters based on the value of Physics:fluid_props:dual_energy:type. The expectations are summarized below:

"disabled": This should always be an empty list.

"bryan95": The list should always contain two entries corresponding to [eta_1, eta_2]. An empty list (the default value) is treated as though it has the value [0.001, 0.1].

modern": The list should always one entry corresponding to [eta]. An empty list (the default value) is treated as though it has the value [0.001].

eos

Physics:fluid_props:dual_energy parameters specify details about the (caloric) equation of state. At this time, this only supports an ideal gas. But, in the future this will support alternative equations of state (like an isothermal equation of state).

See Compatability with hydro/mhd solvers for further discussion about how the equation of state is handled when Method:grackle:primordial_chemistry exceeds 1 (under these conditions Grackle models a spatially varying adiabatic index).

Parameter: Physics : fluid_props : eos : gamma
Summary: Adiabatic exponent
Type: float
Default: 5.0 / 3.0
Scope: Enzo

gamma specifies the ratio of specific heats for the ideal gas used by the hydrodynamics solvers. This is used in a number other places like the "grackle" method, and various problem-initializers.

floors

Physics:fluid_props:floors parameters specify the floors that should be applied to different fluid quantities. Valid parameter values must be positive. Different methods selectively apply these floors. For more details, see Floors.

Parameter: Physics : fluid_props : floors : density
Summary: Lower limit on density field
Type: float
Default: none
Scope: Enzo

Floor to be applied to the mass density field.

Parameter: Physics : fluid_props : floors : pressure
Summary: Lower limit on thermal pressure
Type: float
Default: none
Scope: Enzo

Thermal pressure floor.

Parameter: Physics : fluid_props : floors : temperature
Summary: Lower limit on temperature
Type: float
Default: none
Scope: Enzo

Temperature floor, which must exceed 0. Note that this is specified with units of Kelvin (since the `”temperature”`` field is always measured in Kelvin in Enzo-E)`

Parameter: Physics : fluid_props : floors : metallicity
Summary: Minimum metallicity in solar units
Type: float
Default: 0.0
Scope: Enzo

Minimum metallicity in solar units. This parameter is multiplied by the enzo_constants::metallicity_solar constant and the local value of the "density" field to give the local floor for the "metal_density" field

gravity

Parameter: Physics : gravity : grav_const_codeU
Summary: The gravitational constant in code units
Type: float
Default: none
Scope: Enzo

When this parameter is not specified, the gravitational constant is automatically taken to be the real-world reference value \(G\approx 6.67\times 10^{-8}\, {\rm cm}^3\, {\rm g}^{-1} {\rm s}^{-2}\) (the actual value used within the codebase is not quoted here in case we ever update it). In this case, the conversion between cgs units and code-units are handled internally.

Note

In most cases, users should not need to specify this parameter at all (so that the appropriate default value is used). This parameter mostly exists to help simplify some test problems in non-cosmological simulations.

Users are NOT allowed to specify this parameter in cosmological simulations. This is because cosmological code-units are defined such that \(4\pi G\bar{\rho}\) has the value 1.0, where \(\bar{\rho}\) is the mean physical matter density of the universe.

At the time of writing this documentation, users can force the usage of the default value by assigning this parameter a non-positive value. However this is an implementation-detail that may change in the future (if it does change, an error will be raised).

schedule

“schedule” is a parameter subgroup that defines when to do something, such as perform output, apply a method, or to apply the dynamic load balancer. Schedules can be specified as either

a list of values

an interval of values specified using some subset of start, schedule:stop, and step.

The associated variable, set using var, can be “cycle”, “time”, or “seconds”. Here “time” refers to simulation time, and “seconds” to wall-clock time. At each cycle, all schedules are checked to see if the cycle number, simulation time or wall-clock seconds match the list or interval of values. If there is a match, the associated output or is performed; otherwise, it is skipped.

Note that when simulation “time” is specified, then the simulation’s time step may be reduced so that the corresponding output occurs exactly at the specified time.

Output {


   list = ["check", "dump", "image"];

   check {

      # **** write a checkpoint every 100.0 seconds ****

      schedule {
         var = "seconds";
         start = 100.0;
         step =  100.0;
      }
       ...
   }

   dump {

      # **** perform a data dump every 50 cycles until cycle 1000 ****

      schedule {
         var = "cycle";
         step =   50;
         stop = 1000;
       }
        ...
   }

   image {

      # **** write an image at times t = 1.0,  2.0, and 5.0 ****

      schedule {
         var = "time";
         list = [1.0, 2.0, 5.0];
       }
        ...
   }
}

Parameter: schedule : var
Summary: Variable associated with scheduling for the given file set
Type: string
Default: “none”
Scope: Cello

The var parameter specifies what value is checked at each cycle, which may be “cycle”, “time”, or “seconds” Here “time” refers to simulation time, and “seconds” to wall-clock time. Note that when simulation “time” is specified, the simulation’s time step may be reduced such that the corresponding output occurs exactly at the specified time.

Parameter: schedule : list
Summary: List of scheduled values for the specified variable
Type: [ list ( integer ) | list ( float ) ]
Default: []
Scope: Cello

This parameter specifies a list of values to check against for output with respect to cycle, time, or seconds. If the var parameter associated with the schedule is “cycle”, then value must be a list of integers; otherwise, value must be a list of float’s The default is an empty list.

Parameter: schedule : start
Summary: Starting value for scheduled interval
Type: [ integer | float ]
Default: 0 | 0.0
Scope: Cello
Todo: write

Parameter: schedule : stop
Summary: Last value for scheduled interval
Type: [ integer | float ]
Default: max (integer) | max (double)
Scope: Cello
Todo: write

Parameter: schedule : step
Summary: Stepping increment for interval
Type: [ integer | float ]
Default: 1 | 1.0
Scope: Cello
Todo: write

Solver

Parameter: Solver : solver : iter_max
Summary: Iteration limit for the CG solver
Type: int
Default: 100
Scope: Enzo

Maximum number of CG iterations to take.

Parameter: Solver : solver : res_tol
Summary: Residual norm reduction tolerance for the CG solver
Type: float
Default: 1e-6
Scope: Enzo

Stopping tolerance on the 2-norm of the residual relative to the initial residual, i.e. CG is defined to have converged when ||R_i ||₂ / ||R_0 ||₂ < res_tol.

Parameter: Solver : solver : grav_const
Summary: Gravitational constant
Type: float
Default: 6.67384e-8
Scope: Enzo

Gravitational constant used in place of G. The default is G in cgs units.

Parameter: Solver : solver : diag_precon
Summary: Whether to apply diagonal preconditioning
Type: logical
Default: false
Scope: Enzo

Whether to diagonally precondition the linear system A*X = B in EnzoSolverGravityCg by 1.0 / (h^2).

Parameter: Solver : solver : monitor_iter
Summary: How often to display progress
Type: integer
Default: 1
Scope: Enzo

The current iteration, and minimum, current, and maximum relative residuals, are displayed every monitor_iter iterations. If monitor_iter is 0, then only the first and last iteration are displayed.

Stopping

Parameter: Stopping : cycle
Summary: Stopping cycle
Type: integer
Default: max ( integer )
Scope: Cello

Stopping cycle.

Parameter: Stopping : time
Summary: Stopping time
Type: float
Default: max ( double )
Scope: Cello

Stopping time.

Parameter: Stopping : seconds
Summary: Stop after this number of seconds (wall-clock time)
Type: float
Default: max ( double )
Scope: Cello

End the calculation after this many seconds of wall-clock time.

Parameter: Stopping : interval
Summary: Stopping interval
Type: integer
Default: 1
Scope: Cello

Number of cycles between applying the stopping criteria.

Testing

Parameter: Testing : cycle_final
Summary: Enzo-E unit test parameter for expected final cycle number
Type: integer
Default: 0
Scope: Cello

Enzo-E unit test parameter for expected final cycle number.

Parameter: Testing : time_final
Summary: Enzo-E unit test parameter for expected final time
Type: float
Default: 0.0
Scope: Cello

Enzo-E unit test parameter for expected final time.

Parameter: Testing : time_tolerance
Summary: Tolerance on the absolute error between actual final time and time_final
Type: float
Default: 1.0e-6
Scope: Cello

Enzo-E unit test parameter for tolerance on the expected final time.

Units

Parameter: Units : length
Summary: Units scaling factor for length
Type: double
Default: 1.0
Scope: Cello

Units scaling factor for length.

Parameter: Units : mass
Summary: Units scaling factor for mass
Type: double
Default: 1.0
Scope: Cello

Units scaling factor for mass. Only one of mass and density Units parameters can be initialized to ≠ 0.

Parameter: Units : time
Summary: Units scaling factor for time
Type: double
Default: 1.0
Scope: Cello

Units scaling factor for time.

Parameter: Units : density
Summary: Units scaling factor for density
Type: double
Default: 1.0
Scope: Cello

Units scaling factor for density. Only one of mass and density Units parameters can be initialized to ≠ 0.