NekRSStandaloneProblem

This class performs all activities related to solving NekRS as a MOOSE application. This class differs from the NekRSProblem class because this class does not couple NekRS to another MOOSE application. Instead, this class simply allows standalone NekRS simulations to be run using the Cardinal executable, which allows uncoupled NekRS simulations to take advantage of a number of features available in Cardinal, such as:

Postprocessors to query the solution, evaluate heat balances and pressure drops, or evaluate solution convergence
UserObjects to project the NekRS solution onto other discretization schemes, such as a subchannel discretization, or onto other MOOSE applications, such as for providing closures
Automatic conversion of nondimensional NekRS solutions into dimensional form

In other words, this class allows NekRS input files to be run through Cardinal without any modifications.

This class must be used in conjunction with two other classes in Cardinal:

NekRSMesh, which builds a mirror of the NekRS mesh in a MOOSE format so that all the usual Transfers understand how to send data into/out of NekRS. The settings on NekRSMesh also determine which coupling type (listed above) is used.
NekTimeStepper, which allows NekRS to control its own time stepping.

Therefore, we recommend first reading the documentation for the above classes before proceeding here.

The smallest possible MOOSE-wrapped input file that can be used to run NekRS standalone cases is shown below. This input file in particular runs the channel example that ships with the NekRS repository.

In this input file, casename is the prefix describing the NekRS input files, i.e. this parameter would be casename = channel if the NekRS input files are channel.re2, channel.par, channel.udf, and channel.oudf.

Listing 1: Smallest possible input file for running a standalone NekRS simulation within Cardinal

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'channel'
  output = 'pressure velocity'
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

In other words, you can either run the channel NekRS example with the standalone NekRS executable (which does not bring any advantages of Cardinal),


nrsmpi channel 8

or through the Cardinal executable (which brings many useful postprocessing features),


mpiexec -np 8 cardinal-opt -i nek.i

Both will run the NekRS case in exactly the same fashion using exactly the same NekRS input files. All that is needed to wrap NekRS in MOOSE is a thin input file like that shown in Listing 1. The remainder of this page highlights a few potential use cases for running standalone NekRS cases through Cardinal.

Outputting the NekRS Solution

This class enables extracting a number of fields from the NekRS solution onto the NekRSMesh mesh mirror in addition to any fields that are already interpolated onto the mesh mirror for purposes of multiphysics coupling to another MOOSE application. This feature can be used for:

Quick visualization of the NekRS solution without needing to rely on NekRS's custom output format
Postprocessing the NekRS solution using MOOSE's systems
Providing one-way coupling to other MOOSE applications, such as for transporting scalars based on NekRS's velocity solution or for projecting NekRS turbulent viscosity closure terms onto another MOOSE application's mesh

This output feature is used by specifying the fields to be output with the output parameter. Available output fields include:

pressure (which creates a MOOSE variable named P)
velocity (which creates MOOSE variables named vel_x, vel_y, and vel_z)
temperature (which creates a MOOSE variable named temp)
scalar01 (which creates a MOOSE variable named scalar01)
scalar02 (which creates a MOOSE variable named scalar02)
scalar03 (which creates a MOOSE variable named scalar03)

For NekRS simulations that are coupled to MOOSE, the temperature will already be output because it is used as part of the physics transfers.

When outputting data, the NekRS solution fields are interpolated from the GLL points onto the NekRSMesh, which will be either a first or second order representation of the NekRS mesh. This interpolation is performed using Vandermonde matrices. Therefore, the output solution is generally not an exact representation of NekRS's solution, for which the NekRS field files are still required to visualize fully. Because the MOOSE framework supports many different output formats, this is a convenient manner by which to obtain a representation of the NekRS solution in Exodus, VTK, CSV, and other formats.

If volume = true is specified on the NekRSMesh, the output solutions are represented over a volume mesh mirror. Otherwise, if volume = false, the solution is shown only on the boundaries specified with the boundary parameter.

For example, if you would like to extract the NekRS solution on an Exodus mesh, simply specify the output parameter with the desired fields. The following input sections will interpolate the NekRS pressure, velocity, and temperature for the lowMach NekRS example onto a second order representation of the NekRS mesh.

[Mesh]
  type = NekRSMesh
  volume = true
  order = SECOND
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'lowMach'
  output = 'pressure velocity temperature'

  # We omit the non-dimensional settings here in order to just extract the
  # non-dimensional solution as-is, without dimensionalizing it.
[]

Then, the output format specified in the [Output] block will be used. Here, the NekRS solution is projected onto an Exodus mesh.

[Outputs]
  exodus = true
[]

For instance, Figure 1 shows the pressure from the NekRS field files (left) and interpolated onto a second-order mesh mirror (right). Because this particular example runs NekRS in a higher order than can be represented on a second-order mesh mirror, the interpolated pressure is clearly not an exact representation of the NekRS solution - only an interpolated version of the NekRS solution.

Figure 1: Pressure from the NekRS field files (left) and after interpolation onto a second order mesh mirror (right).

Postprocessing the NekRS Solution

An advantage of running NekRS cases through Cardinal is the ability to leverage a wide set of MOOSE postprocessors to both monitor the solution as the solve progresses and to easily perform common postprocessing steps. The example below runs the ktauChannel NekRS example through Cardinal. The max_T postprocessor computes the maximum temperature by directly querying the NekRS solution; many other available postprocessors of this type are available in Cardinal and described on the source documentation page.

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'channel'
  output = 'pressure velocity temperature'
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

[Postprocessors]
  [max_T]
    type = NekVolumeExtremeValue
    field = temperature
  []
  [T_at_point]
    type = PointValue
    variable = temp
    point = '4.0 -0.5 0.0'
  []
  [pct_change]
    type = PercentChangePostprocessor
    postprocessor = max_T
  []
[]

The max_T postprocessor is a special, Nek-specific postprocessor available in Cardinal that directly queries the underlying data structures in NekRS. However, when specifying fields to output from the NekRS solution with the output parameter (described in more detail in Outputting the NekRS Solution ), any of the much wider set of MOOSE postprocessors can also be used. For instance, a PointValue postprocessor is used to extract the value of temperature at a specific point in space, and a PercentChangePostprocessor is used to evaluate the percent change in the maximum temperature between two successive time steps such as for assessing convergence. A few examples of other postprocessors that may be of use to NekRS simulations include:

ElementL2Error, which computes the L $var element = document.getElementById("moose-equation-e27ca1f9-3db4-4ff9-8944-ac1f578fcb21");katex.render("^2", element, {displayMode:false,throwOnError:false});$ norm of a variable relative to a provided function, useful for solution verification
FindValueOnLine, which finds the point at which a specified value of a variable occurs, which might be used for evaluating a boundary layer thickness
LinearCombinationPostprocessor, which can be used to combine postprocessors together in a general expression $var element = document.getElementById("moose-equation-ffec0e99-df5e-4d51-a336-9d0c0c63085e");katex.render("a_0p_0+a_1p_1+\\cdots+b", element, {displayMode:false,throwOnError:false});$ , where $var element = document.getElementById("moose-equation-5050553f-1bb2-42fe-8952-e51b4b4ec24f");katex.render("a_i", element, {displayMode:false,throwOnError:false});$ are coefficients, $var element = document.getElementById("moose-equation-9d01186c-4c42-4a56-9157-bd3850285b51");katex.render("p_i", element, {displayMode:false,throwOnError:false});$ are postprocessors, and $var element = document.getElementById("moose-equation-b87d6c08-f644-4fd7-bd83-7f4b0cc6fadc");katex.render("b", element, {displayMode:false,throwOnError:false});$ is a constant additive factor. This can be used to compute the temperature rise in a domain by subtracting a postprocessor that computes the inlet temperature from a postprocessor that computes the outlet temperature.
TimeExtremeValue, which provides the maximum/minimum value of a variable over the course of an entire simulation, such as for evaluating peak stress in an oscillating system

Please consult the MOOSE documentation for a full list of available postprocessors.

In addition to the postprocessor system, a wide set of userobjects and auxiliary kernels may be applied to the NekRS solution once it is output to the MOOSE mesh. For instance, a LayeredAverage userobject can be used to compute an average of a MOOSE variable in a number of layers. Here, this userobject is applied to average the pressure in four layers in the $var element = document.getElementById("moose-equation-64f5f063-0835-4bcb-b8ea-a9146bc563cc");katex.render("x", element, {displayMode:false,throwOnError:false});$ direction (the direction parallel to the wall). The results of this userobject are then visualized with a SpatialUserObjectAux to place the results in the layered_p auxiliary variable.

[UserObjects]
  [layered_average]
    type = LayeredAverage
    direction = x
    variable = P
    num_layers = 4
  []
[]

[AuxVariables]
  [layered_p]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [layered_p]
    type = SpatialUserObjectAux
    variable = layered_p
    user_object = layered_average
  []
[]

These two examples of postprocessor and userobject usage only scratch the surface of the capabilities of the MOOSE framework - please consult the MOOSE documentation to learn about further capabilities.

Outputting the Scratch Array

This class (and all other NekRS wrappings in Cardinal) allows you to write slots in the nrs->usrwrk scratch space array to NekRS field files. This can be useful for viewing the data sent from MOOSE to NekRS (for problem classes that involve multiphysics), as well as to visualize custom user usage of nrs->usrwrk, such as for fetching a wall distance computation from the Nek5000 backend. To write the scratch space to a field file, set usrwrk_output to an array with each "slot" in the nrs->usrwrk array that you want to write. Then, specify a filename prefix to use to name each field file.

In the example below, the first two "slots" in the nrs->usrwrk array will be written to field files on the same interval that NekRS writes its usual field files. These files will be named aaabrick0.f00001, etc. and cccbrick0.f00001, etc. Based on limitations in how NekRS writes its files, the fields written to these files will all be named temperature when visualized.

[Problem]
  type = NekRSStandaloneProblem
  casename = 'brick'
  usrwrk_output = '0 1'
  usrwrk_output_prefix = 'aaa ccc'
[]

Input Parameters

casenameCase name for the NekRS input files; this is in .par, .udf, .oudf, and .re2.
C++ Type:std::string
Controllable:No
Description:Case name for the NekRS input files; this is in .par, .udf, .oudf, and .re2.

Required Parameters

Cp_01Heat capacity parameter value for non-dimensional solution
Default:1
C++ Type:double
Controllable:No
Description:Heat capacity parameter value for non-dimensional solution
L_ref1Reference length scale value for non-dimensional solution
Default:1
C++ Type:double
Controllable:No
Description:Reference length scale value for non-dimensional solution
T_ref0Reference temperature value for non-dimensional solution
Default:0
C++ Type:double
Controllable:No
Description:Reference temperature value for non-dimensional solution
U_ref1Reference velocity value for non-dimensional solution
Default:1
C++ Type:double
Controllable:No
Description:Reference velocity value for non-dimensional solution
constant_interval1Constant interval (in units of number of time steps) with which to synchronize the NekRS solution
Default:1
C++ Type:unsigned int
Controllable:No
Description:Constant interval (in units of number of time steps) with which to synchronize the NekRS solution
dT_ref1Reference temperature range value for non-dimensional solution
Default:1
C++ Type:double
Controllable:No
Description:Reference temperature range value for non-dimensional solution
disable_fld_file_outputFalseWhether to turn off all NekRS field file output writing (for the usual field file output - this does not affect writing the usrwrk with 'usrwrk_output')
Default:False
C++ Type:bool
Controllable:No
Description:Whether to turn off all NekRS field file output writing (for the usual field file output - this does not affect writing the usrwrk with 'usrwrk_output')
first_reserved_usrwrk_slot0Slice (zero-indexed) in nrs->usrwrk where Cardinal will begin reading/writing data; this can be used to shift the usrwrk slots reserved by Cardinal, so that you can use earlier slices for custom purposes
Default:0
C++ Type:unsigned int
Controllable:No
Description:Slice (zero-indexed) in nrs->usrwrk where Cardinal will begin reading/writing data; this can be used to shift the usrwrk slots reserved by Cardinal, so that you can use earlier slices for custom purposes
minimize_transfers_inFalseWhether to only synchronize nekRS for the direction TO_EXTERNAL_APP on multiapp synchronization steps
Default:False
C++ Type:bool
Controllable:No
Description:Whether to only synchronize nekRS for the direction TO_EXTERNAL_APP on multiapp synchronization steps
minimize_transfers_outFalseWhether to only synchronize nekRS for the direction FROM_EXTERNAL_APP on multiapp synchronization steps
Default:False
C++ Type:bool
Controllable:No
Description:Whether to only synchronize nekRS for the direction FROM_EXTERNAL_APP on multiapp synchronization steps
n_usrwrk_slots7Number of slots to allocate in nrs->usrwrk to hold fields either related to coupling (which will be populated by Cardinal), or other custom usages, such as a distance-to-wall calculation
Default:7
C++ Type:unsigned int
Controllable:No
Description:Number of slots to allocate in nrs->usrwrk to hold fields either related to coupling (which will be populated by Cardinal), or other custom usages, such as a distance-to-wall calculation
nondimensionalFalseWhether NekRS is solved in non-dimensional form
Default:False
C++ Type:bool
Controllable:No
Description:Whether NekRS is solved in non-dimensional form
outputField(s) to output from NekRS onto the mesh mirror
C++ Type:MultiMooseEnum
Options:temperature, pressure, velocity, scalar01, scalar02, scalar03
Controllable:No
Description:Field(s) to output from NekRS onto the mesh mirror
regard_general_exceptions_as_errorsFalseIf we catch an exception during residual/Jacobian evaluaton for which we don't have specific handling, immediately error instead of allowing the time step to be cut
Default:False
C++ Type:bool
Controllable:No
Description:If we catch an exception during residual/Jacobian evaluaton for which we don't have specific handling, immediately error instead of allowing the time step to be cut
rho_01Density parameter value for non-dimensional solution
Default:1
C++ Type:double
Controllable:No
Description:Density parameter value for non-dimensional solution
skip_final_field_fileFalseBy default, we write a NekRS field file on the last time step; set this to true to disable
Default:False
C++ Type:bool
Controllable:No
Description:By default, we write a NekRS field file on the last time step; set this to true to disable
solveTrueWhether or not to actually solve the Nonlinear system. This is handy in the case that all you want to do is execute AuxKernels, Transfers, etc. without actually solving anything
Default:True
C++ Type:bool
Controllable:Yes
Description:Whether or not to actually solve the Nonlinear system. This is handy in the case that all you want to do is execute AuxKernels, Transfers, etc. without actually solving anything
synchronization_intervalconstantWhen to synchronize the NekRS solution with the mesh mirror. By default, the NekRS solution is mapped to/receives data from the mesh mirror for every time step.
Default:constant
C++ Type:MooseEnum
Options:constant, parent_app
Controllable:No
Description:When to synchronize the NekRS solution with the mesh mirror. By default, the NekRS solution is mapped to/receives data from the mesh mirror for every time step.
usrwrk_outputUsrwrk slot(s) to output to NekRS field files; this can be used for viewing the quantities passed from MOOSE to NekRS after interpolation to the CFD mesh. Can also be used for any slots in usrwrk that are written by the user, but unused for coupling.
C++ Type:std::vector<unsigned int>
Controllable:No
Description:Usrwrk slot(s) to output to NekRS field files; this can be used for viewing the quantities passed from MOOSE to NekRS after interpolation to the CFD mesh. Can also be used for any slots in usrwrk that are written by the user, but unused for coupling.
usrwrk_output_prefixString prefix to use for naming the field file(s); only the first three characters are used in the name based on limitations in NekRS
C++ Type:std::vector<std::string>
Controllable:No
Description:String prefix to use for naming the field file(s); only the first three characters are used in the name based on limitations in NekRS
write_fld_filesFalseWhether to write NekRS field file output from Cardinal. If true, this will disable any output writing by NekRS itself, and instead produce output files with names a01...a99pin, b01...b99pin, etc.
Default:False
C++ Type:bool
Controllable:No
Description:Whether to write NekRS field file output from Cardinal. If true, this will disable any output writing by NekRS itself, and instead produce output files with names a01...a99pin, b01...b99pin, etc.

Optional Parameters

allow_initial_conditions_with_restartFalseTrue to allow the user to specify initial conditions when restarting. Initial conditions can override any restarted field
Default:False
C++ Type:bool
Controllable:No
Description:True to allow the user to specify initial conditions when restarting. Initial conditions can override any restarted field
restart_file_baseFile base name used for restart (e.g. / or /LATEST to grab the latest file available)
C++ Type:FileNameNoExtension
Controllable:No
Description:File base name used for restart (e.g. / or /LATEST to grab the latest file available)

Restart Parameters

control_tagsAdds user-defined labels for accessing object parameters via control logic.
C++ Type:std::vector<std::string>
Controllable:No
Description:Adds user-defined labels for accessing object parameters via control logic.
default_ghostingFalseWhether or not to use libMesh's default amount of algebraic and geometric ghosting
Default:False
C++ Type:bool
Controllable:No
Description:Whether or not to use libMesh's default amount of algebraic and geometric ghosting
enableTrueSet the enabled status of the MooseObject.
Default:True
C++ Type:bool
Controllable:No
Description:Set the enabled status of the MooseObject.

Advanced Parameters

kernel_coverage_block_listList of subdomains for kernel coverage check. The meaning of this list is controlled by the parameter 'kernel_coverage_check' (whether this is the list of subdomains to be checked, not to be checked or not taken into account).
C++ Type:std::vector<SubdomainName>
Controllable:No
Description:List of subdomains for kernel coverage check. The meaning of this list is controlled by the parameter 'kernel_coverage_check' (whether this is the list of subdomains to be checked, not to be checked or not taken into account).
material_coverage_block_listList of subdomains for material coverage check. The meaning of this list is controlled by the parameter 'material_coverage_check' (whether this is the list of subdomains to be checked, not to be checked or not taken into account).
C++ Type:std::vector<SubdomainName>
Controllable:No
Description:List of subdomains for material coverage check. The meaning of this list is controlled by the parameter 'material_coverage_check' (whether this is the list of subdomains to be checked, not to be checked or not taken into account).
material_coverage_checkTRUEControls, if and how a material subdomain coverage check is performed. With 'TRUE' or 'ON' all subdomains are checked (the default). Setting 'FALSE' or 'OFF' will disable the check for all subdomains. To exclude a predefined set of subdomains 'SKIP_LIST' is to be used, while the subdomains to skip are to be defined in the parameter 'material_coverage_block_list'. To limit the check to a list of subdomains, 'ONLY_LIST' is to be used (again, using the parameter 'material_coverage_block_list').
Default:TRUE
C++ Type:MooseEnum
Options:FALSE, TRUE, OFF, ON, SKIP_LIST, ONLY_LIST
Controllable:No
Description:Controls, if and how a material subdomain coverage check is performed. With 'TRUE' or 'ON' all subdomains are checked (the default). Setting 'FALSE' or 'OFF' will disable the check for all subdomains. To exclude a predefined set of subdomains 'SKIP_LIST' is to be used, while the subdomains to skip are to be defined in the parameter 'material_coverage_block_list'. To limit the check to a list of subdomains, 'ONLY_LIST' is to be used (again, using the parameter 'material_coverage_block_list').

Simulation Checks Parameters

parallel_barrier_messagingFalseDisplays messaging from parallel barrier notifications when executing or transferring to/from Multiapps (default: false)
Default:False
C++ Type:bool
Controllable:No
Description:Displays messaging from parallel barrier notifications when executing or transferring to/from Multiapps (default: false)
verbose_multiappsFalseSet to True to enable verbose screen printing related to MultiApps
Default:False
C++ Type:bool
Controllable:No
Description:Set to True to enable verbose screen printing related to MultiApps
verbose_setupfalseSet to 'true' to have the problem report on any object created. Set to 'extra' to also display all parameters.
Default:false
C++ Type:MooseEnum
Options:false, true, extra
Controllable:No
Description:Set to 'true' to have the problem report on any object created. Set to 'extra' to also display all parameters.

Verbosity Parameters

Input Files

(tutorials/subchannel/nek.i)
(tutorials/standalone/nek.i)
(test/tests/userobjects/subchannel_layered/1d.i)
(test/tests/userobjects/nek_scalar_value/nek_standalone.i)
(test/tests/userobjects/radial_layered/1d.i)
(test/tests/nek_errors/invalid_field/auxvar.i)
(test/tests/nek_mesh/sidesets/cube/nek_volume.i)
(tutorials/load_from_exodus/nek.i)
(test/tests/userobjects/radial_layered/2d.i)
(test/tests/nek_standalone/ktauChannel/nek.i)
(test/tests/userobjects/subchannel_layered/pin_1d.i)
(test/tests/nek_stochastic/nek_multi.i)
(test/tests/nek_stochastic/read/read.i)
(test/tests/userobjects/interval/nek.i)
(test/tests/userobjects/subchannel_layered/order_error.i)
(test/tests/nek_standalone/channel/nek.i)
(test/tests/userobjects/interval/nek_synchronization.i)
(test/tests/nek_errors/invalid_field/nonlinear.i)
(test/tests/postprocessors/nek_pressure_surface_force/nek_nondimensional.i)
(test/tests/userobjects/subchannel_layered/nek.i)
(tutorials/other_apps/cardinal_master.i)
(test/tests/nek_errors/invalid_field/nek_uo.i)
(test/tests/nek_temp/exact/exact.i)
(test/tests/nek_mesh/sidesets/pyramid/exact_volume.i)
(test/tests/postprocessors/nek_pressure_surface_force/nek.i)
(test/tests/nek_temp/exact/exact_volume.i)
(test/tests/userobjects/subchannel_layered/duplicate_directions.i)
(test/tests/nek_errors/invalid_field/nek_no_temp.i)
(test/tests/nek_standalone/adaptive_dt/nek_nondim.i)
(test/tests/nek_standalone/start_time/force_start.i)
(test/tests/userobjects/sideset_layered/z_bins.i)
(test/tests/userobjects/layered_layered/1d.i)
(test/tests/cht/multi_cht/nek.i)
(test/tests/nek_standalone/from_restart/nek.i)
(test/tests/userobjects/side/dimensional/nek.i)
(test/tests/nek_warnings/unused_boundary/nek.i)
(test/tests/nek_file_output/usrwrk/nek.i)
(test/tests/postprocessors/dimensionless_numbers/nondimensional/nek.i)
(test/tests/userobjects/hexagonal_gap_layered/nek.i)
(test/tests/nek_errors/invalid_scalar/nek.i)
(test/tests/userobjects/hexagonal_gap_layered/type_error.i)
(test/tests/userobjects/hexagonal_gap_layered/user_component.i)
(test/tests/userobjects/side/nondimensional/nek.i)
(test/tests/userobjects/volume/nondimensional/nek.i)
(test/tests/nek_stochastic/shift/nek.i)
(tutorials/other_apps/cardinal_sub.i)
(test/tests/nek_output/nek.i)
(test/tests/nek_file_output/avg_plugin/nek.i)
(test/tests/userobjects/subchannel_layered/wrong_type.i)
(test/tests/userobjects/sideset_layered/z_bins_by_centroid.i)
(test/tests/nek_standalone/adaptive_dt/nek.i)
(test/tests/deformation/nek_standalone/nek_boundary.i)
(test/tests/nek_standalone/conj_ht/nek.i)
(test/tests/nek_stochastic/errors/nek_standalone_error.i)
(test/tests/userobjects/hexagonal_gap_layered/normals/nek_axial.i)
(test/tests/userobjects/subchannel_layered/type_error.i)
(test/tests/nek_stochastic/quiet_init/nek_multi.i)
(test/tests/nek_mesh/sidesets/cube/exact_volume.i)
(test/tests/nek_standalone/lowMach/nek.i)
(test/tests/auxkernels/nek_spatial_bin_component_aux/invalid_field.i)
(test/tests/userobjects/layered_layered/nek.i)
(test/tests/deformation/nek_standalone/nek.i)
(test/tests/userobjects/volume/dimensional/nek.i)
(test/tests/userobjects/layered_layered/duplicate_directions.i)
(test/tests/nek_stochastic/device/nek_multi.i)
(test/tests/nek_mesh/exact/exact.i)
(test/tests/userobjects/gap/nondimensional/nek.i)
(test/tests/nek_standalone/ethier/nek.i)
(test/tests/userobjects/hexagonal_gap_layered/nek_axial.i)
(test/tests/userobjects/subchannel_layered/user_component.i)
(test/tests/nek_mesh/exact/exact_volume.i)
(test/tests/userobjects/hexagonal_gap_layered/normals/nek.i)
(test/tests/nek_errors/insufficient_scratch/standalone/nek_standalone.i)
(test/tests/userobjects/sideset_layered/side_average.i)
(test/tests/userobjects/gap/dimensional/nek.i)
(test/tests/nek_standalone/lowMach/nek_boundary.i)
(test/tests/userobjects/sideset_layered/invalid_boundary.i)
(test/tests/nek_errors/invalid_scalar/nek_uo.i)
(test/tests/userobjects/layered_layered/3d.i)
(test/tests/nek_errors/invalid_field/nek.i)

(test/tests/nek_standalone/channel/nek.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'channel'
  output = 'pressure velocity'
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  [max_Vx]
    type = NekVolumeExtremeValue
    field = velocity_x
    value_type = max
  []
  [max_Vx_output]
    type = NodalExtremeValue
    variable = vel_x
    value_type = max
  []
  [max_Vx_diff]
    type = DifferencePostprocessor
    value1 = max_Vx
    value2 = max_Vx_output
  []

  [min_Vx]
    type = NekVolumeExtremeValue
    field = velocity_x
    value_type = min
  []
  [min_Vx_output]
    type = NodalExtremeValue
    variable = vel_x
    value_type = min
  []
  [min_Vx_diff]
    type = DifferencePostprocessor
    value1 = min_Vx
    value2 = min_Vx_output
  []

  [max_Vy]
    type = NekVolumeExtremeValue
    field = velocity_y
    value_type = max
  []
  [max_Vy_output]
    type = NodalExtremeValue
    variable = vel_y
    value_type = max
  []
  [max_Vy_diff]
    type = DifferencePostprocessor
    value1 = max_Vy
    value2 = max_Vy_output
  []

  [min_Vy]
    type = NekVolumeExtremeValue
    field = velocity_y
    value_type = min
  []
  [min_Vy_output]
    type = NodalExtremeValue
    variable = vel_y
    value_type = min
  []

  [max_p]
    type = NekVolumeExtremeValue
    field = pressure
    value_type = max
  []
  [max_p_output]
    type = NodalExtremeValue
    variable = P
    value_type = max
  []
  [max_p_diff]
    type = DifferencePostprocessor
    value1 = max_p
    value2 = max_p_output
  []

  [min_p]
    type = NekVolumeExtremeValue
    field = pressure
    value_type = min
  []
  [min_p_output]
    type = NodalExtremeValue
    variable = P
    value_type = min
  []
  [min_p_diff]
    type = DifferencePostprocessor
    value1 = min_p
    value2 = min_p_output
  []

  [area]
    type = NekSideIntegral
    field = unity
    boundary = '1'
  []
  [area_output]
    type = AreaPostprocessor
    boundary = '1'
  []
  [area_diff]
    type = DifferencePostprocessor
    value1 = area
    value2 = area_output
  []

  [volume]
    type = NekVolumeIntegral
    field = unity
  []
  [volume_output]
    type = VolumePostprocessor
  []
  [volume_diff]
    type = DifferencePostprocessor
    value1 = volume
    value2 = volume_output
  []

  [max_Vx_side]
    type = NekSideExtremeValue
    field = velocity_x
    value_type = max
    boundary = '1'
  []
  [max_Vx_side_output]
    type = NodalExtremeValue
    variable = vel_x
    value_type = max
    boundary = '1'
  []
  [max_Vx_side_diff]
    type = DifferencePostprocessor
    value1 = max_Vx_side
    value2 = max_Vx_side_output
  []

  [max_Vy_side]
    type = NekSideExtremeValue
    field = velocity_y
    value_type = max
    boundary = '1'
  []
  [max_Vy_side_output]
    type = NodalExtremeValue
    variable = vel_y
    value_type = max
    boundary = '1'
  []
  [max_Vy_side_diff]
    type = DifferencePostprocessor
    value1 = max_Vy_side
    value2 = max_Vy_side_output
  []

  [min_Vx_side]
    type = NekSideExtremeValue
    field = velocity_x
    value_type = min
    boundary = '1'
  []
  [min_Vx_side_output]
    type = NodalExtremeValue
    variable = vel_x
    value_type = min
    boundary = '1'
  []
  [min_Vx_side_diff]
    type = DifferencePostprocessor
    value1 = min_Vx_side
    value2 = min_Vx_side_output
  []

  [min_Vy_side]
    type = NekSideExtremeValue
    field = velocity_y
    value_type = min
    boundary = '1'
  []
  [min_Vy_side_output]
    type = NodalExtremeValue
    variable = vel_y
    value_type = min
    boundary = '1'
  []
  [min_Vy_side_diff]
    type = DifferencePostprocessor
    value1 = min_Vy_side
    value2 = min_Vy_side_output
  []

  [max_p_side]
    type = NekSideExtremeValue
    field = pressure
    value_type = max
    boundary = '1'
  []
  [max_p_side_output]
    type = NodalExtremeValue
    variable = P
    value_type = max
    boundary = '1'
  []
  [min_p_side_diff]
    type = DifferencePostprocessor
    value1 = min_p_side
    value2 = min_p_side_output
  []

  [min_p_side]
    type = NekSideExtremeValue
    field = pressure
    value_type = min
    boundary = '1'
  []
  [min_p_side_output]
    type = NodalExtremeValue
    variable = P
    value_type = min
    boundary = '1'
  []
  [max_p_side_diff]
    type = DifferencePostprocessor
    value1 = max_p_side
    value2 = max_p_side_output
  []

  [avg_p]
    type = NekVolumeAverage
    field = pressure
  []
  [avg_p_output]
    type = ElementAverageValue
    variable = P
  []
  [avg_p_diff]
    type = DifferencePostprocessor
    value1 = avg_p
    value2 = avg_p_output
  []

  [avg_Vx]
    type = NekVolumeAverage
    field = velocity_x
  []
  [avg_Vx_output]
    type = ElementAverageValue
    variable = vel_x
  []
  [avg_Vx_diff]
    type = DifferencePostprocessor
    value1 = avg_Vx
    value2 = avg_Vx_output
  []

  [avg_Vy]
    type = NekVolumeAverage
    field = velocity_y
  []
  [avg_Vy_output]
    type = ElementAverageValue
    variable = vel_y
  []
  [avg_Vy_diff]
    type = DifferencePostprocessor
    value1 = avg_Vy
    value2 = avg_Vy_output
  []

  [avg_Vx_side]
    type = NekSideAverage
    field = velocity_x
    boundary = '1'
  []
  [avg_Vx_side_output]
    type = SideAverageValue
    variable = vel_x
    boundary = '1'
  []
  [avg_Vx_side_diff]
    type = DifferencePostprocessor
    value1 = avg_Vx_side
    value2 = avg_Vx_side_output
  []

  [avg_Vy_side]
    type = NekSideAverage
    field = velocity_y
    boundary = '1'
  []
  [avg_Vy_side_output]
    type = SideAverageValue
    variable = vel_y
    boundary = '1'
  []
  [avg_Vy_side_diff]
    type = DifferencePostprocessor
    value1 = avg_Vy_side
    value2 = avg_Vy_side_output
  []

  [avg_p_side]
    type = NekSideAverage
    field = pressure
    boundary = '1'
  []
  [avg_p_side_output]
    type = SideAverageValue
    variable = P
    boundary = '1'
  []
  [avg_p_side_diff]
    type = DifferencePostprocessor
    value1 = avg_p_side
    value2 = avg_p_side_output
  []
[]

[Outputs]
  csv = true
  exodus = true
  execute_on = 'final'

  hide = 'max_Vx_output min_Vx_output max_Vy_output min_Vy_output max_p_output min_p_output area_output volume_output max_Vx_side max_Vx_side_output max_Vy_side max_Vy_side_output max_p_side max_p_side_output min_Vx_side min_Vx_side_output min_Vy_side min_Vy_side_output min_p_side min_p_side_output avg_p avg_p_output avg_Vx avg_Vx_output avg_Vy avg_Vy_output avg_Vx_side avg_Vx_side_output avg_Vy_side avg_Vy_side_output avg_p_side avg_p_side_output max_Vx max_Vy max_p min_Vx min_Vy min_p area'
[]

(test/tests/nek_standalone/lowMach/nek.i)

[Mesh]
  type = NekRSMesh
  volume = true
  order = SECOND
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'lowMach'
  output = 'pressure velocity temperature'

  # We omit the non-dimensional settings here in order to just extract the
  # non-dimensional solution as-is, without dimensionalizing it.
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  # All the following postprocessors are applying operations both (a) directly to the NekRS
  # solution arrays, and (b) to the variables extracted with the 'outputs = ...' syntax.
  # Rather than check the actual values of these postprocessors (which might change if the
  # NekRS development team changes the nature of their CI tests), we can just check that
  # the difference between the Nek-style postprocessors from the MOOSE-style postprocessors
  # (acting on the extract solution) are nearly zero. We only check the absolute value of
  # the min/max volume values for Vx, temperature, and pressure because those values are printed to
  # the screen and offer quick confirmation of any changes that are due to changes in NekRS itself.

  [max_Vx]
    type = NekVolumeExtremeValue
    field = velocity_x
    value_type = max
  []
  [max_Vx_output]
    type = NodalExtremeValue
    variable = vel_x
    value_type = max
  []
  [max_Vx_diff]
    type = DifferencePostprocessor
    value1 = max_Vx
    value2 = max_Vx_output
  []

  [min_Vx]
    type = NekVolumeExtremeValue
    field = velocity_x
    value_type = min
  []
  [min_Vx_output]
    type = NodalExtremeValue
    variable = vel_x
    value_type = min
  []
  [min_Vx_diff]
    type = DifferencePostprocessor
    value1 = min_Vx
    value2 = min_Vx_output
  []

  [max_p]
    type = NekVolumeExtremeValue
    field = pressure
    value_type = max
  []
  [max_p_output]
    type = NodalExtremeValue
    variable = P
    value_type = max
  []
  [max_p_diff]
    type = DifferencePostprocessor
    value1 = max_p
    value2 = max_p_output
  []

  [min_p]
    type = NekVolumeExtremeValue
    field = pressure
    value_type = min
  []
  [min_p_output]
    type = NodalExtremeValue
    variable = P
    value_type = min
  []
  [min_p_diff]
    type = DifferencePostprocessor
    value1 = min_p
    value2 = min_p_output
  []

  [max_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = max
  []
  [max_T_output]
    type = NodalExtremeValue
    variable = temp
    value_type = max
  []
  [max_T_diff]
    type = DifferencePostprocessor
    value1 = max_T
    value2 = max_T_output
  []

  [min_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = min
  []
  [min_T_output]
    type = NodalExtremeValue
    variable = temp
    value_type = min
  []
  [min_T_diff]
    type = DifferencePostprocessor
    value1 = min_T
    value2 = min_T_output
  []

  [area]
    type = NekSideIntegral
    field = unity
    boundary = '1'
  []
  [area_output]
    type = AreaPostprocessor
    boundary = '1'
  []
  [area_diff]
    type = DifferencePostprocessor
    value1 = area
    value2 = area_output
  []

  [volume]
    type = NekVolumeIntegral
    field = unity
  []
  [volume_output]
    type = VolumePostprocessor
  []
  [volume_diff]
    type = DifferencePostprocessor
    value1 = volume
    value2 = volume_output
  []

  [max_T_side]
    type = NekSideExtremeValue
    field = temperature
    value_type = max
    boundary = '1'
  []
  [max_T_side_output]
    type = NodalExtremeValue
    variable = temp
    value_type = max
    boundary = '1'
  []
  [max_T_side_diff]
    type = DifferencePostprocessor
    value1 = max_T_side
    value2 = max_T_side_output
  []

  [min_T_side]
    type = NekSideExtremeValue
    field = temperature
    value_type = min
    boundary = '1'
  []
  [min_T_side_output]
    type = NodalExtremeValue
    variable = temp
    value_type = min
    boundary = '1'
  []
  [min_T_side_diff]
    type = DifferencePostprocessor
    value1 = min_T_side
    value2 = min_T_side_output
  []

  [max_Vx_side]
    type = NekSideExtremeValue
    field = velocity_x
    value_type = max
    boundary = '1'
  []
  [max_Vx_side_output]
    type = NodalExtremeValue
    variable = vel_x
    value_type = max
    boundary = '1'
  []
  [max_Vx_side_diff]
    type = DifferencePostprocessor
    value1 = max_Vx_side
    value2 = max_Vx_side_output
  []

  [min_Vx_side]
    type = NekSideExtremeValue
    field = velocity_x
    value_type = min
    boundary = '1'
  []
  [min_Vx_side_output]
    type = NodalExtremeValue
    variable = vel_x
    value_type = min
    boundary = '1'
  []
  [min_Vx_side_diff]
    type = DifferencePostprocessor
    value1 = min_Vx_side
    value2 = min_Vx_side_output
  []

  [max_p_side]
    type = NekSideExtremeValue
    field = pressure
    value_type = max
    boundary = '1'
  []
  [max_p_side_output]
    type = NodalExtremeValue
    variable = P
    value_type = max
    boundary = '1'
  []
  [min_p_side_diff]
    type = DifferencePostprocessor
    value1 = min_p_side
    value2 = min_p_side_output
  []

  [min_p_side]
    type = NekSideExtremeValue
    field = pressure
    value_type = min
    boundary = '1'
  []
  [min_p_side_output]
    type = NodalExtremeValue
    variable = P
    value_type = min
    boundary = '1'
  []
  [max_p_side_diff]
    type = DifferencePostprocessor
    value1 = max_p_side
    value2 = max_p_side_output
  []

  [avg_T]
    type = NekVolumeAverage
    field = temperature
  []
  [avg_T_output]
    type = ElementAverageValue
    variable = temp
  []
  [avg_T_diff]
    type = DifferencePostprocessor
    value1 = avg_T
    value2 = avg_T_output
  []

  [avg_Vx]
    type = NekVolumeAverage
    field = velocity_x
  []
  [avg_Vx_output]
    type = ElementAverageValue
    variable = vel_x
  []
  [avg_Vx_diff]
    type = DifferencePostprocessor
    value1 = avg_Vx
    value2 = avg_Vx_output
  []

  [avg_T_side]
    type = NekSideAverage
    field = temperature
    boundary = '1'
  []
  [avg_T_side_output]
    type = SideAverageValue
    variable = temp
    boundary = '1'
  []
  [avg_T_side_diff]
    type = DifferencePostprocessor
    value1 = avg_T_side
    value2 = avg_T_side_output
  []

  [avg_Vx_side]
    type = NekSideAverage
    field = velocity_x
    boundary = '1'
  []
  [avg_Vx_side_output]
    type = SideAverageValue
    variable = vel_x
    boundary = '1'
  []
  [avg_Vx_side_diff]
    type = DifferencePostprocessor
    value1 = avg_Vx_side
    value2 = avg_Vx_side_output
  []

  [avg_p_side]
    type = NekSideAverage
    field = pressure
    boundary = '1'
  []
  [avg_p_side_output]
    type = SideAverageValue
    variable = P
    boundary = '1'
  []
  [avg_p_side_diff]
    type = DifferencePostprocessor
    value1 = avg_p_side
    value2 = avg_p_side_output
  []
[]

[Outputs]
  csv = true
  exodus = true
  execute_on = 'final'

  hide = 'max_Vx_output min_Vx_output max_p_output min_p_output area_output volume_output max_Vx_side max_Vx_side_output max_p_side max_p_side_output min_Vx_side min_Vx_side_output min_p_side min_p_side_output avg_Vx avg_Vx_output avg_Vx_side avg_Vx_side_output avg_p_side avg_p_side_output max_T_output min_T_output max_T_side max_T_side_output min_T_side min_T_side_output avg_T avg_T_output avg_T_side avg_T_side_output'
[]

(test/tests/nek_standalone/ktauChannel/nek.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'channel'
  output = 'pressure velocity temperature'
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

[Postprocessors]
  [max_T]
    type = NekVolumeExtremeValue
    field = temperature
  []
  [T_at_point]
    type = PointValue
    variable = temp
    point = '4.0 -0.5 0.0'
  []
  [pct_change]
    type = PercentChangePostprocessor
    postprocessor = max_T
  []
[]

[UserObjects]
  [layered_average]
    type = LayeredAverage
    direction = x
    variable = P
    num_layers = 4
  []
[]

[AuxVariables]
  [layered_p]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [layered_p]
    type = SpatialUserObjectAux
    variable = layered_p
    user_object = layered_average
  []
[]

(test/tests/nek_standalone/ktauChannel/nek.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'channel'
  output = 'pressure velocity temperature'
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

[Postprocessors]
  [max_T]
    type = NekVolumeExtremeValue
    field = temperature
  []
  [T_at_point]
    type = PointValue
    variable = temp
    point = '4.0 -0.5 0.0'
  []
  [pct_change]
    type = PercentChangePostprocessor
    postprocessor = max_T
  []
[]

[UserObjects]
  [layered_average]
    type = LayeredAverage
    direction = x
    variable = P
    num_layers = 4
  []
[]

[AuxVariables]
  [layered_p]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [layered_p]
    type = SpatialUserObjectAux
    variable = layered_p
    user_object = layered_average
  []
[]

(test/tests/nek_file_output/usrwrk/nek.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'brick'
  usrwrk_output = '0 1'
  usrwrk_output_prefix = 'aaa ccc'
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

(tutorials/subchannel/nek.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'sfr_7pin'
  output = 'temperature velocity'
[]

[UserObjects]
  [subchannel_binning]
    type = HexagonalSubchannelBin
    bundle_pitch = 0.02583914354890463
    pin_pitch = 0.0089656996
    pin_diameter = 7.646e-3
    n_rings = 2
  []
  [subchannel_gap_binning]
    type = HexagonalSubchannelGapBin
    bundle_pitch = 0.02583914354890463
    pin_pitch = 0.0089656996
    pin_diameter = 7.646e-3
    n_rings = 2
  []
  [axial_binning]
    type = LayeredBin
    direction = z
    num_layers = 7
  []
  [average_T]
    type = NekBinnedVolumeAverage
    bins = 'subchannel_binning axial_binning'
    field = temperature
    map_space_by_qp = true
  []
  [average_T_gaps]
    type = NekBinnedPlaneAverage
    bins = 'subchannel_gap_binning axial_binning'
    field = temperature
    map_space_by_qp = true
    gap_thickness = ${fparse 0.05 * 7.646e-3}
  []
  [avg_gap_velocity]
    type = NekBinnedPlaneAverage
    bins = 'subchannel_gap_binning axial_binning'
    field = velocity_component
    velocity_component = normal
    map_space_by_qp = true
    gap_thickness = ${fparse 0.05 * 7.646e-3}
  []
[]

[AuxVariables]
  # These are just for visualizing the average velocity component with Glyphs in paraview;
  # the result of the 'avg_gap_velocity' user object will be represented as a vector "uo_" with 3 components
  [uo_x]
    family = MONOMIAL
    order = CONSTANT
  []
  [uo_y]
    family = MONOMIAL
    order = CONSTANT
  []
  [uo_z]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [uo_x]
    type = NekSpatialBinComponentAux
    variable = uo_x
    user_object = avg_gap_velocity
    component = 0
  []
  [uo_y]
    type = NekSpatialBinComponentAux
    variable = uo_y
    user_object = avg_gap_velocity
    component = 1
  []
  [uo_z]
    type = NekSpatialBinComponentAux
    variable = uo_z
    user_object = avg_gap_velocity
    component = 2
  []
[]

[MultiApps]
  [subchannel]
    type = TransientMultiApp
    input_files = 'subchannel.i'
    execute_on = timestep_end
    sub_cycling = true
  []
  [subchannel_gap]
    type = TransientMultiApp
    input_files = 'subchannel_gap.i'
    execute_on = timestep_end
    sub_cycling = true
  []
[]

[Transfers]
  [uo_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = average_T
    to_multi_app = subchannel
    variable = average_T
  []
  [uo_to_sub2]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = average_T_gaps
    to_multi_app = subchannel_gap
    variable = average_T
  []
  [uo1_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = avg_gap_velocity
    to_multi_app = subchannel_gap
    variable = avg_gap_velocity
  []
  [uox_to_sub]
    type = MultiAppGeneralFieldNearestLocationTransfer
    to_multi_app = subchannel_gap
    source_variable = uo_x
    variable = uo_x
  []
  [uoy_to_sub]
    type = MultiAppGeneralFieldNearestLocationTransfer
    to_multi_app = subchannel_gap
    source_variable = uo_y
    variable = uo_y
  []
[]

[VectorPostprocessors]
  [avg_T]
    type = SpatialUserObjectVectorPostprocessor
    userobject = average_T
  []
  [avg_T_gaps]
    type = SpatialUserObjectVectorPostprocessor
    userobject = average_T_gaps
  []
  [avg_v_gaps]
    type = SpatialUserObjectVectorPostprocessor
    userobject = avg_gap_velocity
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  csv = true
[]

(tutorials/standalone/nek.i)

[Mesh]
  type = NekRSMesh
  volume = true
  order = SECOND
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'turbPipe'
  output = 'pressure velocity'
[]

[Postprocessors]
  [outlet_p]
    type = NekSideAverage
    boundary = '2'
    field = pressure
  []
  [inlet_p]
    type = NekSideAverage
    boundary = '1'
    field = pressure
  []
  [mdot]
    type = NekMassFluxWeightedSideIntegral
    boundary = '1'
    field = unity
  []

  # subtracts the two pressure postprocessors
  [dP]
    type = DifferencePostprocessor
    value1 = outlet_p
    value2 = inlet_p
  []
[]

[UserObjects]
  [axial_bins]
    type = LayeredBin
    direction = z
    num_layers = 20
  []
  [radial_bins]
    type = RadialBin
    vertical_axis = z
    rmax = 0.5
    nr = 12
    growth_r = 0.9
  []
  [volume_averages]
    type = NekBinnedVolumeAverage
    bins = 'radial_bins axial_bins'
    field = velocity_z
    map_space_by_qp = true
  []
[]

[AuxVariables]
  [volume_averages]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [volume_averages]
    type = SpatialUserObjectAux
    variable = volume_averages
    user_object = volume_averages
  []
[]

[MultiApps]
  [sub]
    type = TransientMultiApp
    input_files = sub.i
    execute_on = timestep_end
  []
[]

[Transfers]
  [uo_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    to_multi_app = sub
    source_user_object = volume_averages
    variable = avg_velocity
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
  csv = true

  # this hides these values from the screen for neater output
  hide = 'outlet_p inlet_p'
[]

(test/tests/userobjects/subchannel_layered/1d.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'sfr_7pin'
  output = 'temperature'
[]

[AuxVariables]
  [uo]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [uo]
    type = SpatialUserObjectAux
    variable = uo
    user_object = vol_avg
  []
[]

[UserObjects]
  [subchannel_binning]
    type = HexagonalSubchannelBin
    bundle_pitch = 0.02583914354890463
    pin_pitch = 0.0089656996
    pin_diameter = 7.646e-3
    n_rings = 2
  []
  [vol_avg]
    type = NekBinnedVolumeAverage
    bins = 'subchannel_binning'
    field = temperature
  []
[]

[VectorPostprocessors]
  # from_uo gives exactly the same results as manually specifying the points in 'manually_provided',
  # but without the headache of figuring out what all the centroids of the subchannels are
  [from_uo]
    type = SpatialUserObjectVectorPostprocessor
    userobject = vol_avg
  []
  [manually_provided]
    type = SpatialUserObjectVectorPostprocessor
    userobject = vol_avg
    points = '         0  0.00517635        0
             -0.00448285  0.00258817        0
             -0.00448285 -0.00258817        0
                       0 -0.00517635        0
              0.00448285 -0.00258817        0
              0.00448285  0.00258817        0
                       0  0.010342          0
             -0.00895648  0.00517102        0
             -0.00895648 -0.00517102        0
                       0 -0.010342          0
              0.00895648 -0.00517102        0
              0.00895648  0.00517102        0
              0.00634302  0.0109864         0
             -0.00634302  0.0109864         0
             -0.01268600  0                 0
             -0.00634302 -0.0109864         0
              0.00634302 -0.0109864         0
              0.01268600  0                 0'
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
  csv = true
  execute_on = 'final'
[]

(test/tests/userobjects/nek_scalar_value/nek_standalone.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'pyramid'
  n_usrwrk_slots = 1
[]

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[UserObjects]
  [scalar1]
    type = NekScalarValue
  []
  [scalar2]
    type = NekScalarValue
  []
[]

[Controls]
  [func_control]
    type = RealFunctionControl
    parameter = 'UserObjects/scalar1/value'
    function = 'val'
    execute_on = 'timestep_begin'
  []
  [func_control2]
    type = RealFunctionControl
    parameter = 'UserObjects/scalar2/value'
    function = 'val2'
    execute_on = 'timestep_begin'
  []
[]

[Functions]
  [val]
    type = ParsedFunction
    expression = 'if (t > 1, 200.0, 100.0)'
  []
  [val2]
    type = ParsedFunction
    expression = 'if (t > 1, 400.0, 300.0)'
  []
[]

[Postprocessors]
  [avg_t_5]
    type = NekSideAverage
    field = temperature
    boundary = '5'
  []
  [avg_t_6]
    type = NekSideAverage
    field = temperature
    boundary = '6'
  []
[]

[Outputs]
  exodus = true
  csv = true
[]

(test/tests/userobjects/radial_layered/1d.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'cylinder'
  output = 'pressure'

  nondimensional = true
  L_ref = 5.0
  U_ref = 1.0
  rho_0 = 834.5
  Cp_0 = 1228.0
  T_ref = 573.0
  dT_ref = 10.0
[]

[Mesh]
  type = NekRSMesh
  volume = true
  scaling = 5.0
[]

[AuxVariables]
  [uo]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [uo]
    type = SpatialUserObjectAux
    variable = uo
    user_object = vol_integral
  []
[]

[UserObjects]
  [r_bins]
    type = RadialBin
    vertical_axis = z
    nr = 5
    rmin = 0.0
    rmax = 1.0
  []
  [vol_integral]
    type = NekBinnedVolumeIntegral
    bins = 'r_bins'
    field = pressure
  []
[]

[VectorPostprocessors]
  # from_uo gives exactly the same results as manually specifying the points in 'manually_provided'
  [from_uo]
    type = SpatialUserObjectVectorPostprocessor
    userobject = vol_integral
  []
  [manually_provided]
    type = SpatialUserObjectVectorPostprocessor
    userobject = vol_integral
    points = '0.1 0.0 0.0
              0.3 0.0 0.0
              0.5 0.0 0.0
              0.7 0.0 0.0
              0.9 0.0 0.0'
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  csv = true
  exodus = true
  execute_on = 'final'
[]

(test/tests/nek_errors/invalid_field/auxvar.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'pyramid'
  output = 'temperature'
[]

[Mesh]
  type = NekRSMesh
  volume = true
[]

[AuxVariables]
  [temp]
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

(test/tests/nek_mesh/sidesets/cube/nek_volume.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'cube'
[]

[Mesh]
  type = NekRSMesh
  order = SECOND
  volume = true
  boundary = '1 2 3 4 5 6'
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  csv = true
[]

[Postprocessors]
  [area_side1_nek]
    type = NekSideIntegral
    field = unity
    boundary = '1'
  []
  [area_side1_moose]
    type = AreaPostprocessor
    boundary = '1'
  []
  [area_side2_nek]
    type = NekSideIntegral
    field = unity
    boundary = '2'
  []
  [area_side2_moose]
    type = AreaPostprocessor
    boundary = '2'
  []
  [area_side3_nek]
    type = NekSideIntegral
    field = unity
    boundary = '3'
  []
  [area_side3_moose]
    type = AreaPostprocessor
    boundary = '3'
  []
  [area_side4_nek]
    type = NekSideIntegral
    field = unity
    boundary = '4'
  []
  [area_side4_moose]
    type = AreaPostprocessor
    boundary = '4'
  []
  [area_side5_nek]
    type = NekSideIntegral
    field = unity
    boundary = '5'
  []
  [area_side5_moose]
    type = AreaPostprocessor
    boundary = '5'
  []
  [area_side6_nek]
    type = NekSideIntegral
    field = unity
    boundary = '6'
  []
  [area_side6_moose]
    type = AreaPostprocessor
    boundary = '6'
  []
[]

(tutorials/load_from_exodus/nek.i)

[Mesh]
  type = NekRSMesh
  volume = true
  order = SECOND
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'ethier'
  output = 'temperature'
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

(test/tests/userobjects/radial_layered/2d.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'cylinder'
  output = 'pressure'

  nondimensional = true
  L_ref = 5.0
  U_ref = 1.0
  rho_0 = 834.5
  Cp_0 = 1228.0
  T_ref = 573.0
  dT_ref = 10.0
[]

[Mesh]
  type = NekRSMesh
  volume = true
  scaling = 5.0
[]

[AuxVariables]
  [uo]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [uo]
    type = SpatialUserObjectAux
    variable = uo
    user_object = vol_integral
  []
[]

[UserObjects]
  [r_bins]
    type = RadialBin
    vertical_axis = z
    nr = 5
    rmin = 0.0
    rmax = 1.0
  []
  [z_bins]
    type = LayeredBin
    direction = z
    num_layers = 5
  []
  [vol_integral]
    type = NekBinnedVolumeIntegral
    bins = 'r_bins z_bins'
    field = pressure
  []
[]

[VectorPostprocessors]
  # from_uo gives exactly the same results as manually specifying the points in 'manually_provided'
  [from_uo]
    type = SpatialUserObjectVectorPostprocessor
    userobject = vol_integral
  []
  [manually_provided]
    type = SpatialUserObjectVectorPostprocessor
    userobject = vol_integral
    points = '0.1 0.0 -2.0
              0.1 0.0 -1.0
              0.1 0.0  0.0
              0.1 0.0  1.0
              0.1 0.0  2.0

              0.3 0.0 -2.0
              0.3 0.0 -1.0
              0.3 0.0  0.0
              0.3 0.0  1.0
              0.3 0.0  2.0

              0.5 0.0 -2.0
              0.5 0.0 -1.0
              0.5 0.0  0.0
              0.5 0.0  1.0
              0.5 0.0  2.0

              0.7 0.0 -2.0
              0.7 0.0 -1.0
              0.7 0.0  0.0
              0.7 0.0  1.0
              0.7 0.0  2.0

              0.9 0.0 -2.0
              0.9 0.0 -1.0
              0.9 0.0  0.0
              0.9 0.0  1.0
              0.9 0.0  2.0'
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  csv = true
  exodus = true
  execute_on = 'final'
[]

(test/tests/nek_standalone/ktauChannel/nek.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'channel'
  output = 'pressure velocity temperature'
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

[Postprocessors]
  [max_T]
    type = NekVolumeExtremeValue
    field = temperature
  []
  [T_at_point]
    type = PointValue
    variable = temp
    point = '4.0 -0.5 0.0'
  []
  [pct_change]
    type = PercentChangePostprocessor
    postprocessor = max_T
  []
[]

[UserObjects]
  [layered_average]
    type = LayeredAverage
    direction = x
    variable = P
    num_layers = 4
  []
[]

[AuxVariables]
  [layered_p]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [layered_p]
    type = SpatialUserObjectAux
    variable = layered_p
    user_object = layered_average
  []
[]

(test/tests/userobjects/subchannel_layered/pin_1d.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'sfr_7pin'
  output = 'temperature'
[]

[AuxVariables]
  [uo]
  []
[]

[AuxKernels]
  [uo]
    type = SpatialUserObjectAux
    variable = uo
    user_object = side_avg
    boundary = '1'
  []
[]

[UserObjects]
  [subchannel_binning]
    type = HexagonalSubchannelBin
    bundle_pitch = 0.02583914354890463
    pin_pitch = 0.0089656996
    pin_diameter = 7.646e-3
    n_rings = 2
    pin_centered_bins = true
  []
  [side_avg]
    type = NekBinnedSideAverage
    bins = 'subchannel_binning'
    field = temperature
    boundary = '1'

    # for the peripheral region, we wont actually hit anything in this zone because we evaluate
    # the user object on the pin surfaces
    check_zero_contributions = false
  []
[]

[VectorPostprocessors]
  # from_uo gives exactly the same results as manually specifying the points in 'manually_provided',
  # but without the headache of figuring out what all the centroids of the pins are
  [from_uo]
    type = SpatialUserObjectVectorPostprocessor
    userobject = side_avg
  []
  [manually_provided]
    type = SpatialUserObjectVectorPostprocessor
    userobject = side_avg
    points = ' 0.0        0.0       0.0
               0.0044828  0.0077645 0.0
              -0.0044828  0.0077645 0.0
              -0.0089656  0.0       0.0
              -0.0044828 -0.0077645 0.0
               0.0044828 -0.0077645 0.0
               0.0089656  0.0       0.0
               1.0        0.0       0.0' # last point is just any point outside the pin area
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
  csv = true
  execute_on = 'final'
[]

(test/tests/nek_stochastic/nek_multi.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'ethier'
  n_usrwrk_slots = 2

  output = 'scalar02'
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[UserObjects]
  [scalar1]
    type = NekScalarValue
  []
[]

[Controls]
  [stochastic]
    type = SamplerReceiver
  []
[]

[Postprocessors]
  [s1]
    type = NekScalarValuePostprocessor
    userobject = scalar1
  []

  # we use the stochastic value to set the scalar (in the .udf files). Here,
  # we are checking that the value of the scalar everywhere is equation to the 's1' postprocessor
  [max_scalar]
    type = ElementExtremeValue
    variable = scalar02
    value_type = max
  []
  [min_scalar]
    type = ElementExtremeValue
    variable = scalar02
    value_type = min
  []
[]

[Outputs]
  csv = true
[]

(test/tests/nek_stochastic/read/read.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'read'
  output = 'scalar02'
[]

[Executioner]
  type = Transient
  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  [max_scalar]
    type = ElementExtremeValue
    variable = scalar02
    value_type = max
  []
  [min_scalar]
    type = ElementExtremeValue
    variable = scalar02
    value_type = min
  []
[]

[Outputs]
  csv = true
[]

(test/tests/userobjects/interval/nek.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'brick'

  nondimensional = true
  L_ref = 2.0
  U_ref = 1.0
  rho_0 = 834.5
  Cp_0 = 1228.0
  T_ref = 573.0
  dT_ref = 10.0
[]

[Mesh]
  type = NekRSMesh
  volume = true
  scaling = 2.0
[]

[UserObjects]
  [x_bins]
    type = LayeredBin
    direction = x
    num_layers = 3
  []
  [avg_v]
    type = NekBinnedVolumeAverage
    bins = 'x_bins'
    field = velocity_z
    interval = 3
  []
[]

[VectorPostprocessors]
  [v]
    type = SpatialUserObjectVectorPostprocessor
    userobject = avg_v
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  csv = true
  interval = 3
[]

(test/tests/userobjects/subchannel_layered/order_error.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'sfr_7pin'
  output = 'temperature'
[]

[UserObjects]
  [vol_avg]
    type = NekBinnedVolumeAverage
    bins = 'subchannel_binning'
    field = temperature
  []
  [subchannel_binning]
    type = HexagonalSubchannelBin
    bundle_pitch = 0.02583914354890463
    pin_pitch = 0.0089656996
    pin_diameter = 7.646e-3
    n_rings = 2
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

(test/tests/nek_standalone/channel/nek.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'channel'
  output = 'pressure velocity'
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  [max_Vx]
    type = NekVolumeExtremeValue
    field = velocity_x
    value_type = max
  []
  [max_Vx_output]
    type = NodalExtremeValue
    variable = vel_x
    value_type = max
  []
  [max_Vx_diff]
    type = DifferencePostprocessor
    value1 = max_Vx
    value2 = max_Vx_output
  []

  [min_Vx]
    type = NekVolumeExtremeValue
    field = velocity_x
    value_type = min
  []
  [min_Vx_output]
    type = NodalExtremeValue
    variable = vel_x
    value_type = min
  []
  [min_Vx_diff]
    type = DifferencePostprocessor
    value1 = min_Vx
    value2 = min_Vx_output
  []

  [max_Vy]
    type = NekVolumeExtremeValue
    field = velocity_y
    value_type = max
  []
  [max_Vy_output]
    type = NodalExtremeValue
    variable = vel_y
    value_type = max
  []
  [max_Vy_diff]
    type = DifferencePostprocessor
    value1 = max_Vy
    value2 = max_Vy_output
  []

  [min_Vy]
    type = NekVolumeExtremeValue
    field = velocity_y
    value_type = min
  []
  [min_Vy_output]
    type = NodalExtremeValue
    variable = vel_y
    value_type = min
  []

  [max_p]
    type = NekVolumeExtremeValue
    field = pressure
    value_type = max
  []
  [max_p_output]
    type = NodalExtremeValue
    variable = P
    value_type = max
  []
  [max_p_diff]
    type = DifferencePostprocessor
    value1 = max_p
    value2 = max_p_output
  []

  [min_p]
    type = NekVolumeExtremeValue
    field = pressure
    value_type = min
  []
  [min_p_output]
    type = NodalExtremeValue
    variable = P
    value_type = min
  []
  [min_p_diff]
    type = DifferencePostprocessor
    value1 = min_p
    value2 = min_p_output
  []

  [area]
    type = NekSideIntegral
    field = unity
    boundary = '1'
  []
  [area_output]
    type = AreaPostprocessor
    boundary = '1'
  []
  [area_diff]
    type = DifferencePostprocessor
    value1 = area
    value2 = area_output
  []

  [volume]
    type = NekVolumeIntegral
    field = unity
  []
  [volume_output]
    type = VolumePostprocessor
  []
  [volume_diff]
    type = DifferencePostprocessor
    value1 = volume
    value2 = volume_output
  []

  [max_Vx_side]
    type = NekSideExtremeValue
    field = velocity_x
    value_type = max
    boundary = '1'
  []
  [max_Vx_side_output]
    type = NodalExtremeValue
    variable = vel_x
    value_type = max
    boundary = '1'
  []
  [max_Vx_side_diff]
    type = DifferencePostprocessor
    value1 = max_Vx_side
    value2 = max_Vx_side_output
  []

  [max_Vy_side]
    type = NekSideExtremeValue
    field = velocity_y
    value_type = max
    boundary = '1'
  []
  [max_Vy_side_output]
    type = NodalExtremeValue
    variable = vel_y
    value_type = max
    boundary = '1'
  []
  [max_Vy_side_diff]
    type = DifferencePostprocessor
    value1 = max_Vy_side
    value2 = max_Vy_side_output
  []

  [min_Vx_side]
    type = NekSideExtremeValue
    field = velocity_x
    value_type = min
    boundary = '1'
  []
  [min_Vx_side_output]
    type = NodalExtremeValue
    variable = vel_x
    value_type = min
    boundary = '1'
  []
  [min_Vx_side_diff]
    type = DifferencePostprocessor
    value1 = min_Vx_side
    value2 = min_Vx_side_output
  []

  [min_Vy_side]
    type = NekSideExtremeValue
    field = velocity_y
    value_type = min
    boundary = '1'
  []
  [min_Vy_side_output]
    type = NodalExtremeValue
    variable = vel_y
    value_type = min
    boundary = '1'
  []
  [min_Vy_side_diff]
    type = DifferencePostprocessor
    value1 = min_Vy_side
    value2 = min_Vy_side_output
  []

  [max_p_side]
    type = NekSideExtremeValue
    field = pressure
    value_type = max
    boundary = '1'
  []
  [max_p_side_output]
    type = NodalExtremeValue
    variable = P
    value_type = max
    boundary = '1'
  []
  [min_p_side_diff]
    type = DifferencePostprocessor
    value1 = min_p_side
    value2 = min_p_side_output
  []

  [min_p_side]
    type = NekSideExtremeValue
    field = pressure
    value_type = min
    boundary = '1'
  []
  [min_p_side_output]
    type = NodalExtremeValue
    variable = P
    value_type = min
    boundary = '1'
  []
  [max_p_side_diff]
    type = DifferencePostprocessor
    value1 = max_p_side
    value2 = max_p_side_output
  []

  [avg_p]
    type = NekVolumeAverage
    field = pressure
  []
  [avg_p_output]
    type = ElementAverageValue
    variable = P
  []
  [avg_p_diff]
    type = DifferencePostprocessor
    value1 = avg_p
    value2 = avg_p_output
  []

  [avg_Vx]
    type = NekVolumeAverage
    field = velocity_x
  []
  [avg_Vx_output]
    type = ElementAverageValue
    variable = vel_x
  []
  [avg_Vx_diff]
    type = DifferencePostprocessor
    value1 = avg_Vx
    value2 = avg_Vx_output
  []

  [avg_Vy]
    type = NekVolumeAverage
    field = velocity_y
  []
  [avg_Vy_output]
    type = ElementAverageValue
    variable = vel_y
  []
  [avg_Vy_diff]
    type = DifferencePostprocessor
    value1 = avg_Vy
    value2 = avg_Vy_output
  []

  [avg_Vx_side]
    type = NekSideAverage
    field = velocity_x
    boundary = '1'
  []
  [avg_Vx_side_output]
    type = SideAverageValue
    variable = vel_x
    boundary = '1'
  []
  [avg_Vx_side_diff]
    type = DifferencePostprocessor
    value1 = avg_Vx_side
    value2 = avg_Vx_side_output
  []

  [avg_Vy_side]
    type = NekSideAverage
    field = velocity_y
    boundary = '1'
  []
  [avg_Vy_side_output]
    type = SideAverageValue
    variable = vel_y
    boundary = '1'
  []
  [avg_Vy_side_diff]
    type = DifferencePostprocessor
    value1 = avg_Vy_side
    value2 = avg_Vy_side_output
  []

  [avg_p_side]
    type = NekSideAverage
    field = pressure
    boundary = '1'
  []
  [avg_p_side_output]
    type = SideAverageValue
    variable = P
    boundary = '1'
  []
  [avg_p_side_diff]
    type = DifferencePostprocessor
    value1 = avg_p_side
    value2 = avg_p_side_output
  []
[]

[Outputs]
  csv = true
  exodus = true
  execute_on = 'final'

  hide = 'max_Vx_output min_Vx_output max_Vy_output min_Vy_output max_p_output min_p_output area_output volume_output max_Vx_side max_Vx_side_output max_Vy_side max_Vy_side_output max_p_side max_p_side_output min_Vx_side min_Vx_side_output min_Vy_side min_Vy_side_output min_p_side min_p_side_output avg_p avg_p_output avg_Vx avg_Vx_output avg_Vy avg_Vy_output avg_Vx_side avg_Vx_side_output avg_Vy_side avg_Vy_side_output avg_p_side avg_p_side_output max_Vx max_Vy max_p min_Vx min_Vy min_p area'
[]

(test/tests/userobjects/interval/nek_synchronization.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'brick'
  output = 'velocity'

  nondimensional = true
  L_ref = 2.0
  U_ref = 1.0
  rho_0 = 834.5
  Cp_0 = 1228.0
  T_ref = 573.0
  dT_ref = 10.0

  synchronization_interval = constant
  constant_interval = 3
[]

[Mesh]
  type = NekRSMesh
  volume = true
  scaling = 2.0
[]

[Postprocessors]
  [vz_in]
    type = SideAverageValue
    variable = 'vel_z'
    boundary = '1'
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  csv = true
[]

(test/tests/nek_errors/invalid_field/nonlinear.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'pyramid'
  output = 'temperature'
[]

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Variables]
  [temp]
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

(test/tests/postprocessors/nek_pressure_surface_force/nek_nondimensional.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'brick'
  output = 'pressure'

  nondimensional = true
  L_ref = 0.5
  U_ref = 0.9
  rho_0 = 0.8
[]

[Mesh]
  type = NekRSMesh
  volume = true
  scaling = 0.5
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  csv = true
[]

[Postprocessors]
  [pressure_x]
    type = NekPressureSurfaceForce
    boundary = '1 2 3 4 5 6'
    direction = '1 0 0'
    mesh = 'fluid'
  []
  [pressure_y]
    type = NekPressureSurfaceForce
    boundary = '1 2 3 4 5 6'
    direction = '0 1 0'
    mesh = 'fluid'
  []
  [pressure_z]
    type = NekPressureSurfaceForce
    boundary = '1 2 3 4 5 6'
    direction = '0 0 1'
    mesh = 'fluid'
  []

  # These are added to compare by hand
  [pressure_x_3]
    type = SideIntegralVariablePostprocessor
    variable = P
    boundary = '3'
  []
  [pressure_x_4]
    type = SideIntegralVariablePostprocessor
    variable = P
    boundary = '4'
  []
  [pressure_x_comp]
    type = DifferencePostprocessor
    value1 = pressure_x_3
    value2 = pressure_x_4
  []
  [pressure_y_1]
    type = SideIntegralVariablePostprocessor
    variable = P
    boundary = '1'
  []
  [pressure_y_2]
    type = SideIntegralVariablePostprocessor
    variable = P
    boundary = '2'
  []
  [pressure_y_comp]
    type = DifferencePostprocessor
    value1 = pressure_y_1
    value2 = pressure_y_2
  []
  [pressure_z_6]
    type = SideIntegralVariablePostprocessor
    variable = P
    boundary = '6'
  []
  [pressure_z_5]
    type = SideIntegralVariablePostprocessor
    variable = P
    boundary = '5'
  []
  [pressure_z_comp]
    type = DifferencePostprocessor
    value1 = pressure_z_6
    value2 = pressure_z_5
  []
[]

(test/tests/userobjects/subchannel_layered/nek.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'sfr_7pin'
  output = 'temperature'
[]

[AuxVariables]
  [subchannel_bins]
    family = MONOMIAL
    order = CONSTANT
  []
  [axial_bins]
    family = MONOMIAL
    order = CONSTANT
  []
  [total_volume]
    family = MONOMIAL
    order = CONSTANT
  []
  [total_average_T]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [bins1]
    type = SpatialUserObjectAux
    variable = subchannel_bins
    user_object = subchannel_binning
  []
  [bins2]
    type = SpatialUserObjectAux
    variable = axial_bins
    user_object = axial_binning
  []
  [total_volume]
    type = SpatialUserObjectAux
    variable = total_volume
    user_object = reference_vol_integral
    execute_on = 'INITIAL TIMESTEP_END'
  []
  [total_average_T]
    type = SpatialUserObjectAux
    variable = total_average_T
    user_object = reference_T_avg
    execute_on = 'INITIAL TIMESTEP_END'
  []
[]

[UserObjects]
  [subchannel_binning]
    type = HexagonalSubchannelBin
    bundle_pitch = 0.02583914354890463
    pin_pitch = 0.0089656996
    pin_diameter = 7.646e-3
    n_rings = 2
  []
  [axial_binning]
    type = LayeredBin
    direction = z
    num_layers = 6
  []
  [vol_avg]
    type = NekBinnedVolumeAverage
    bins = 'subchannel_binning axial_binning'
    field = temperature
  []
  [vol_integral]
    type = NekBinnedVolumeIntegral
    bins = 'subchannel_binning axial_binning'
    field = unity
  []

  [one_bin]
    type = LayeredBin
    direction = z
    num_layers = 1
  []
  [reference_vol_integral]
    type = NekBinnedVolumeIntegral
    bins = 'one_bin'
    field = unity
  []
  [reference_T_avg]
    type = NekBinnedVolumeAverage
    bins = 'one_bin'
    field = temperature
  []
[]

[MultiApps]
  [subchannel]
    type = TransientMultiApp
    input_files = 'subchannel.i'
    execute_on = timestep_end
  []
[]

[Transfers]
  [uo1_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = vol_avg
    to_multi_app = subchannel
    variable = vol_avg
  []
  [uo2_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = vol_integral
    to_multi_app = subchannel
    variable = vol_integral
  []
[]

[Postprocessors]
  # we compare the integral (with a single bin) with an already-verified postprocessor
  # to make sure the actual internals of the binned volume integral are done correctly
  [volume_ref] # should match the value in 'total_volume' (computed with 1 bin)
    type = NekVolumeIntegral
    field = unity
  []
  [avg_T_ref] # should match the value in 'total_average_T' (computed with 1 bin)
    type = NekVolumeAverage
    field = temperature
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
  hide = 'temp'
[]

(tutorials/other_apps/cardinal_master.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'turbPipe'
[]

[MultiApps]
  [sub]
    type = TransientMultiApp
    app_type = ChickadeeApp
    input_files = chickadee_sub.i
    execute_on = timestep_end

    # change this for wherever you have Chickadee located
    library_path = '/home/anovak/Chickadee/lib'
  []
[]

[Transfers]
  # fill this out with whatever data transfers you want to/from Chickadee
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

(test/tests/nek_errors/invalid_field/nek_uo.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'pyramid'
[]

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[UserObjects]
  [subchannel_binning]
    type = HexagonalSubchannelBin
    bundle_pitch = 10
    pin_pitch = 1
    pin_diameter = 1
    n_rings = 1
  []
  [vol_avg]
    type = NekBinnedVolumeAverage
    bins = 'subchannel_binning'
    field = temperature
  []
[]

(test/tests/nek_temp/exact/exact.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'brick'
  output = 'temperature'
[]

[Mesh]
  type = NekRSMesh
  exact = true
  boundary = '1'
[]

[AuxVariables]
  [analytic]
  []
  [error_temp]
    order = CONSTANT
    family = MONOMIAL
  []
  [difference]
  []
[]

[ICs]
  [analytic]
    type = FunctionIC
    variable = analytic
    function = analytic
  []
[]

[AuxKernels]
  [error_temp]
    type = ElementL2ErrorFunctionAux
    variable = error_temp
    coupled_variable = temp
    function = analytic
  []
  [difference]
    type = ParsedAux
    variable = difference
    coupled_variables = 'analytic temp'
    expression = 'temp-analytic'
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Functions]
  [analytic]
    type = ParsedFunction
    expression = 'exp(x)+sin(y)+x*y*z'
  []
[]

[Postprocessors]
  [l2_error_in_nek_temp]
    type = ElementL2Error
    variable = temp
    function = analytic
  []
  [max_diff]
    type = NodalExtremeValue
    variable = difference
    value_type = max
  []
  [min_diff]
    type = NodalExtremeValue
    variable = difference
    value_type = min
  []
[]

[Outputs]
  exodus = true
  execute_on = 'final'
  hide = 'difference error_temp analytic'
[]

(test/tests/nek_mesh/sidesets/pyramid/exact_volume.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'pyramid'
[]

[Mesh]
  type = NekRSMesh
  volume = true
  exact = true
  boundary = '1 2 3 4 5 6 7 8'
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  csv = true
  file_base = 'nek_volume_out'
[]

[Postprocessors]
  [area_side1_nek]
    type = NekSideIntegral
    field = unity
    boundary = '1'
  []
  [area_side1_moose]
    type = AreaPostprocessor
    boundary = '1'
  []
  [area_side2_nek]
    type = NekSideIntegral
    field = unity
    boundary = '2'
  []
  [area_side2_moose]
    type = AreaPostprocessor
    boundary = '2'
  []
  [area_side3_nek]
    type = NekSideIntegral
    field = unity
    boundary = '3'
  []
  [area_side3_moose]
    type = AreaPostprocessor
    boundary = '3'
  []
  [area_side4_nek]
    type = NekSideIntegral
    field = unity
    boundary = '4'
  []
  [area_side4_moose]
    type = AreaPostprocessor
    boundary = '4'
  []
  [area_side5_nek]
    type = NekSideIntegral
    field = unity
    boundary = '5'
  []
  [area_side5_moose]
    type = AreaPostprocessor
    boundary = '5'
  []
  [area_side6_nek]
    type = NekSideIntegral
    field = unity
    boundary = '6'
  []
  [area_side6_moose]
    type = AreaPostprocessor
    boundary = '6'
  []
  [area_side7_nek]
    type = NekSideIntegral
    field = unity
    boundary = '7'
  []
  [area_side7_moose]
    type = AreaPostprocessor
    boundary = '7'
  []
  [area_side8_nek]
    type = NekSideIntegral
    field = unity
    boundary = '8'
  []
  [area_side8_moose]
    type = AreaPostprocessor
    boundary = '8'
  []
[]

(test/tests/postprocessors/nek_pressure_surface_force/nek.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'brick'
  output = 'pressure'
[]

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  csv = true
[]

[Postprocessors]
  [pressure_x]
    type = NekPressureSurfaceForce
    boundary = '1 2 3 4 5 6'
    direction = '1 0 0'
    mesh = 'fluid'
  []
  [pressure_y]
    type = NekPressureSurfaceForce
    boundary = '1 2 3 4 5 6'
    direction = '0 1 0'
    mesh = 'fluid'
  []
  [pressure_z]
    type = NekPressureSurfaceForce
    boundary = '1 2 3 4 5 6'
    direction = '0 0 1'
    mesh = 'fluid'
  []

  # These are added to compare by hand
  [pressure_x_3]
    type = SideIntegralVariablePostprocessor
    variable = P
    boundary = '3'
  []
  [pressure_x_4]
    type = SideIntegralVariablePostprocessor
    variable = P
    boundary = '4'
  []
  [pressure_x_comp]
    type = DifferencePostprocessor
    value1 = pressure_x_3
    value2 = pressure_x_4
  []
  [pressure_y_1]
    type = SideIntegralVariablePostprocessor
    variable = P
    boundary = '1'
  []
  [pressure_y_2]
    type = SideIntegralVariablePostprocessor
    variable = P
    boundary = '2'
  []
  [pressure_y_comp]
    type = DifferencePostprocessor
    value1 = pressure_y_1
    value2 = pressure_y_2
  []
  [pressure_z_6]
    type = SideIntegralVariablePostprocessor
    variable = P
    boundary = '6'
  []
  [pressure_z_5]
    type = SideIntegralVariablePostprocessor
    variable = P
    boundary = '5'
  []
  [pressure_z_comp]
    type = DifferencePostprocessor
    value1 = pressure_z_6
    value2 = pressure_z_5
  []
[]

(test/tests/nek_temp/exact/exact_volume.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'brick'
  output = 'temperature'
[]

[Mesh]
  type = NekRSMesh
  exact = true
  volume = true
[]

[AuxVariables]
  [analytic]
  []
  [error_temp]
    order = CONSTANT
    family = MONOMIAL
  []
  [difference]
  []
[]

[ICs]
  [analytic]
    type = FunctionIC
    variable = analytic
    function = analytic
  []
[]

[AuxKernels]
  [error_temp]
    type = ElementL2ErrorFunctionAux
    variable = error_temp
    coupled_variable = temp
    function = analytic
  []
  [difference]
    type = ParsedAux
    variable = difference
    coupled_variables = 'analytic temp'
    expression = 'temp-analytic'
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Functions]
  [analytic]
    type = ParsedFunction
    expression = 'exp(x)+sin(y)+x*y*z'
  []
[]

[Postprocessors]
  [l2_error_in_nek_temp]
    type = ElementL2Error
    variable = temp
    function = analytic
  []
  [max_diff]
    type = NodalExtremeValue
    variable = difference
    value_type = max
  []
  [min_diff]
    type = NodalExtremeValue
    variable = difference
    value_type = min
  []
[]

[Outputs]
  exodus = true
  execute_on = 'final'
  hide = 'difference error_temp analytic'
[]

(test/tests/userobjects/subchannel_layered/duplicate_directions.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'sfr_7pin'
[]

[UserObjects]
  [subchannel_binning]
    type = HexagonalSubchannelBin
    bundle_pitch = 0.02583914354890463
    pin_pitch = 0.0089656996
    pin_diameter = 7.646e-3
    n_rings = 2
  []
  [axial_binning]
    type = LayeredBin
    direction = z
    num_layers = 6
  []
  [x_bins]
    type = LayeredBin
    direction = x
    num_layers = 3
  []

  # should error due to duplicate bins
  [vol_avg]
    type = NekBinnedVolumeAverage
    bins = 'subchannel_binning axial_binning x_bins'
    field = temperature
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

(test/tests/nek_errors/invalid_field/nek_no_temp.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'pyramid'
  output = 'temperature'
[]

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

(test/tests/nek_standalone/adaptive_dt/nek_nondim.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'pyramid'

  nondimensional = true
  U_ref = 0.1
  L_ref = 1.0
  rho_0 = 1.0
  Cp_0 = 1.0
[]

[Mesh]
  type = NekRSMesh
  scaling = 1.0
  volume = true
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  [out]
    type = CSV
  []
[]

[Postprocessors]
  [time]
    type = TimePostprocessor
    execute_on = 'initial timestep_begin'
  []
[]

(test/tests/nek_standalone/start_time/force_start.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'pyramid'
[]

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Executioner]
  type = Transient
  start_time = 1.0

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  [out]
    type = CSV
  []
[]

[Postprocessors]
  [time]
    type = TimePostprocessor
    execute_on = 'initial timestep_begin'
  []
[]

(test/tests/userobjects/sideset_layered/z_bins.i)

[GlobalParams]
  check_boundary_restricted = false
  map_space_by_qp = true
[]

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'sfr_7pin'
  output = 'temperature'
[]

[AuxVariables]
  [uo1_bin1]
    family = MONOMIAL
    order = CONSTANT
  []
  [uo1_bin3]
    family = MONOMIAL
    order = CONSTANT
  []
  [uo2_bin1]
    family = MONOMIAL
    order = CONSTANT
  []
  [uo2_bin3]
    family = MONOMIAL
    order = CONSTANT
  []
  [uo_1_2_bin3]
    family = MONOMIAL
    order = CONSTANT
  []
  [T1_bin1]
    family = MONOMIAL
    order = CONSTANT
  []
  [T1_bin3]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [T1_bin1]
    type = SpatialUserObjectAux
    variable = T1_bin1
    user_object = T1_bin1
    boundary = '1'
  []
  [T1_bin3]
    type = SpatialUserObjectAux
    variable = T1_bin3
    user_object = T1_bin3
    boundary = '1'
  []
  [uo1_bin1]
    type = SpatialUserObjectAux
    variable = uo1_bin1
    user_object = side1_bin1
    boundary = '1'
  []
  [uo2_bin1]
    type = SpatialUserObjectAux
    variable = uo2_bin1
    user_object = side2_bin1
    boundary = '2'
  []
  [uo1_bin3]
    type = SpatialUserObjectAux
    variable = uo1_bin3
    user_object = side1_bin3
    boundary = '1'
  []
  [uo2_bin3]
    type = SpatialUserObjectAux
    variable = uo2_bin3
    user_object = side2_bin3
    boundary = '2'
  []
  [uo_1_2_bin3]
    type = SpatialUserObjectAux
    variable = uo_1_2_bin3
    user_object = side_1_2_bin3
    boundary = '1 2'
  []
[]

[UserObjects]
  [z1]
    type = LayeredBin
    direction = z
    num_layers = 1
  []
  [side1_bin1]
    type = NekBinnedSideIntegral
    bins = 'z1'
    field = unity
    boundary = '1'
  []
  [side2_bin1]
    type = NekBinnedSideIntegral
    bins = 'z1'
    field = unity
    boundary = '2'
  []
  [side_1_2_bin1] # should equal the sum of side1_bin1 and side1_bin2
    type = NekBinnedSideIntegral
    bins = 'z1'
    field = unity
    boundary = '1 2'
  []
  [T1_bin1]
    type = NekBinnedSideIntegral
    bins = 'z1'
    field = temperature
    boundary = '1'
  []

  [z3]
    type = LayeredBin
    direction = z
    num_layers = 3
  []
  [side1_bin3]
    type = NekBinnedSideIntegral
    bins = 'z3'
    field = unity
    boundary = '1'
  []
  [side2_bin3]
    type = NekBinnedSideIntegral
    bins = 'z3'
    field = unity
    boundary = '2'
  []
  [side_1_2_bin3] # should equal the sum of side1_bin3 and side2_bin3
    type = NekBinnedSideIntegral
    bins = 'z3'
    field = unity
    boundary = '1 2'
  []
  [T1_bin3]
    type = NekBinnedSideIntegral
    bins = 'z3'
    field = temperature
    boundary = '1'
  []
[]

[Postprocessors]
  [area1] # should match the value of the side1_bin1 user object
    type = NekSideIntegral
    field = unity
    boundary = '1'
  []
  [area_divided1] # should match the value of the side1_bin3 user object
    type = LinearCombinationPostprocessor
    pp_names = 'area1'
    pp_coefs = '${fparse 1.0 / 3.0}'
  []
  [area2] # should match the value of the side2_bin1 user object
    type = NekSideIntegral
    field = unity
    boundary = '2'
  []
  [area_divided2] # should match the value of the side2_bin3 user object
    type = LinearCombinationPostprocessor
    pp_names = 'area2'
    pp_coefs = '${fparse 1.0 / 3.0}'
  []
  [T1] # should match the value of the T1_bin1 user object
    type = NekSideIntegral
    field = temperature
    boundary = '1'
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  execute_on = 'final'
  exodus = true

  # removed from output to get a smaller gold file
  hide = 'temp'
[]

(test/tests/userobjects/layered_layered/1d.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'brick'
  output = 'pressure'

  nondimensional = true
  L_ref = 2.0
  U_ref = 1.0
  rho_0 = 834.5
  Cp_0 = 1228.0
  T_ref = 573.0
  dT_ref = 10.0
[]

[Mesh]
  type = NekRSMesh
  volume = true
  scaling = 2.0
[]

[AuxVariables]
  [uo]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [uo]
    type = SpatialUserObjectAux
    variable = uo
    user_object = vol_integral
  []
[]

[UserObjects]
  [x_bins]
    type = LayeredBin
    direction = x
    num_layers = 3
  []
  [x_bins_gaps]
    type = LayeredGapBin
    direction = x
    num_layers = 3
  []
  [vol_integral]
    type = NekBinnedVolumeIntegral
    bins = 'x_bins'
    field = pressure
  []
  [face_avg]
    type = NekBinnedPlaneAverage
    bins = 'x_bins_gaps'
    gap_thickness = 0.1
    map_space_by_qp = true
    field = pressure
  []
[]

[VectorPostprocessors]
  # from_uo gives exactly the same results as manually specifying the points in 'manually_provided'
  [from_uo]
    type = SpatialUserObjectVectorPostprocessor
    userobject = vol_integral
  []
  [manually_provided]
    type = SpatialUserObjectVectorPostprocessor
    userobject = vol_integral
    points = '-0.66666667 0.0 0.0
               0.0        0.0 0.0
               0.66666667 0.0 0.0'
  []
  [from_uo_gap]
    type = SpatialUserObjectVectorPostprocessor
    userobject = face_avg
  []
  [manually_provided_gap]
    type = SpatialUserObjectVectorPostprocessor
    userobject = face_avg
    points = '-1.0     0.0 0.0
              -0.33333 0.0 0.0
               0.33333 0.0 0.0
               1.0     0.0 0.0'
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  csv = true
  exodus = true
  execute_on = 'final'
[]

(test/tests/cht/multi_cht/nek.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'conj_ht'
  output = 'temperature pressure scalar01'
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  [volume_nek_fluid]
    type = NekVolumeIntegral
    field = unity
    mesh = fluid
  []
  [volume_nek_solid]
    type = NekVolumeIntegral
    field = unity
    mesh = solid
  []
  [volume_nek_all]
    type = NekVolumeIntegral
    field = unity
    mesh = all
  []
  [volume_moose_fluid]
    type = VolumePostprocessor
    block = '0'
  []
  [volume_moose_solid]
    type = VolumePostprocessor
    block = '1'
  []
  [volume_moose_all]
    type = VolumePostprocessor
  []

  [int_T_nek_fluid]
    type = NekVolumeIntegral
    field = temperature
    mesh = fluid
  []
  [int_T_nek_solid]
    type = NekVolumeIntegral
    field = temperature
    mesh = solid
  []
  [int_T_nek_all]
    type = NekVolumeIntegral
    field = temperature
    mesh = all
  []
  [int_T_moose_fluid]
    type = ElementIntegralVariablePostprocessor
    variable = temp
    block = '0'
  []
  [int_T_moose_solid]
    type = ElementIntegralVariablePostprocessor
    variable = temp
    block = '1'
  []
  [int_T_moose_all]
    type = ElementIntegralVariablePostprocessor
    variable = temp
  []

  [int_p_nek_fluid]
    type = NekVolumeIntegral
    field = pressure
    mesh = fluid
  []
  [int_p_nek_solid]
    type = NekVolumeIntegral
    field = pressure
    mesh = solid
  []
  [int_p_nek_all]
    type = NekVolumeIntegral
    field = pressure
    mesh = all
  []
  [int_p_moose_fluid]
    type = ElementIntegralVariablePostprocessor
    variable =P
    block = '0'
  []
  [int_p_moose_solid]
    type = ElementIntegralVariablePostprocessor
    variable = P
    block = '1'
  []
  [int_p_moose_all]
    type = ElementIntegralVariablePostprocessor
    variable = P
  []

  [volume_avg_nek_fluid]
    type = NekVolumeAverage
    field = unity
    mesh = fluid
  []
  [volume_avg_nek_solid]
    type = NekVolumeAverage
    field = unity
    mesh = solid
  []
  [volume_avg_nek_all]
    type = NekVolumeAverage
    field = unity
    mesh = all
  []

  [avg_T_nek_fluid]
    type = NekVolumeAverage
    field = temperature
    mesh = fluid
  []
  [avg_T_nek_solid]
    type = NekVolumeAverage
    field = temperature
    mesh = solid
  []
  [avg_T_nek_all]
    type = NekVolumeAverage
    field = temperature
    mesh = all
  []
  [avg_T_moose_fluid]
    type = ElementAverageValue
    variable = temp
    block = '0'
  []
  [avg_T_moose_solid]
    type = ElementAverageValue
    variable = temp
    block = '1'
  []
  [avg_T_moose_all]
    type = ElementAverageValue
    variable = temp
  []

  [avg_p_nek_fluid]
    type = NekVolumeAverage
    field = pressure
    mesh = fluid
  []
  [avg_p_nek_solid]
    type = NekVolumeAverage
    field = pressure
    mesh = solid
  []
  [avg_p_nek_all]
    type = NekVolumeAverage
    field = pressure
    mesh = all
  []
  [avg_p_moose_fluid]
    type = ElementAverageValue
    variable = P
    block = '0'
  []
  [avg_p_moose_solid]
    type = ElementAverageValue
    variable = P
    block = '1'
  []
  [avg_p_moose_all]
    type = ElementAverageValue
    variable = P
  []

  [max_T_nek_fluid]
    type = NekVolumeExtremeValue
    field = temperature
    mesh = fluid
  []
  [max_T_nek_solid]
    type = NekVolumeExtremeValue
    field = temperature
    mesh = solid
  []
  [max_T_nek_all]
    type = NekVolumeExtremeValue
    field = temperature
    mesh = all
  []
  [max_T_moose_fluid]
    type = NodalExtremeValue
    variable = temp
    block = '0'
  []
  [max_T_moose_solid]
    type = NodalExtremeValue
    variable = temp
    block = '1'
  []
  [max_T_moose_all]
    type = NodalExtremeValue
    variable = temp
  []

  [min_T_nek_fluid]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = min
    mesh = fluid
  []
  [min_T_nek_solid]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = min
    mesh = solid
  []
  [min_T_nek_all]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = min
    mesh = all
  []
  [min_T_moose_fluid]
    type = NodalExtremeValue
    variable = temp
    value_type = min
    block = '0'
  []
  [min_T_moose_solid]
    type = NodalExtremeValue
    variable = temp
    value_type = min
    block = '1'
  []
  [min_T_moose_all]
    type = NodalExtremeValue
    variable = temp
    value_type = min
  []

  # we include these to show that the extrema postprocessors do properly fetch the true max/min
  # when the max/min is in either the solid or the fluid domain
  [min_q_nek_fluid]
    type = NekVolumeExtremeValue
    field = scalar01
    value_type = min
    mesh = fluid
  []
  [min_q_nek_solid]
    type = NekVolumeExtremeValue
    field = scalar01
    value_type = min
    mesh = solid
  []
  [min_q_nek_all]
    type = NekVolumeExtremeValue
    field = scalar01
    value_type = min
    mesh = all
  []
  [min_q_moose_fluid]
    type = NodalExtremeValue
    variable = scalar01
    value_type = min
    block = '0'
  []
  [min_q_moose_solid]
    type = NodalExtremeValue
    variable = scalar01
    value_type = min
    block = '1'
  []
  [min_q_moose_all]
    type = NodalExtremeValue
    variable = scalar01
    value_type = min
  []
[]

[Outputs]
  csv = true
  exodus = true
[]

(test/tests/nek_standalone/from_restart/nek.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'pyramid'
[]

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  [out]
    type = CSV
    execute_on = 'final'
  []
[]

[Postprocessors]
  [temp_average]
    type = NekVolumeAverage
    field = temperature
  []
  [velocity_average]
    type = NekVolumeAverage
    field = velocity
  []
  [x_velocity_average]
    type = NekVolumeAverage
    field = velocity_x
  []
  [y_velocity_average]
    type = NekVolumeAverage
    field = velocity_y
  []
  [z_velocity_average]
    type = NekVolumeAverage
    field = velocity_z
  []
[]

(test/tests/userobjects/side/dimensional/nek.i)

[GlobalParams]
  check_boundary_restricted = false
[]

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'sfr_7pin'
  output = 'temperature pressure velocity'
[]

[AuxVariables]
  [avg_T]
    family = MONOMIAL
    order = CONSTANT
  []
  [avg_p]
    family = MONOMIAL
    order = CONSTANT
  []
  [avg_v]
    family = MONOMIAL
    order = CONSTANT
  []
  [integral_T]
    family = MONOMIAL
    order = CONSTANT
  []
  [integral_p]
    family = MONOMIAL
    order = CONSTANT
  []
  [integral_v]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [avg_T]
    type = SpatialUserObjectAux
    variable = avg_T
    user_object = avg_T
    boundary = '2'
  []
  [avg_p]
    type = SpatialUserObjectAux
    variable = avg_p
    user_object = avg_p
    boundary = '2'
  []
  [avg_v]
    type = SpatialUserObjectAux
    variable = avg_v
    user_object = avg_v
    boundary = '2'
  []
  [integral_T]
    type = SpatialUserObjectAux
    variable = integral_T
    user_object = integral_T
    boundary = '2'
  []
  [integral_p]
    type = SpatialUserObjectAux
    variable = integral_p
    user_object = integral_p
    boundary = '2'
  []
  [integral_v]
    type = SpatialUserObjectAux
    variable = integral_v
    user_object = integral_v
    boundary = '2'
  []
[]

[UserObjects]
  [x]
    type = LayeredBin
    direction = x
    num_layers = 2
  []
  [y]
    type = LayeredBin
    direction = y
    num_layers = 2
  []
  [z]
    type = LayeredBin
    direction = z
    num_layers = 3
  []
  [avg_T]
    type = NekBinnedSideAverage
    bins = 'x y z'
    field = temperature
    boundary = '2'
  []
  [avg_p]
    type = NekBinnedSideAverage
    bins = 'x y z'
    field = pressure
    boundary = '2'
  []
  [avg_v]
    type = NekBinnedSideAverage
    bins = 'x y z'
    field = velocity
    boundary = '2'
  []
  [integral_T]
    type = NekBinnedSideIntegral
    bins = 'x y z'
    field = temperature
    boundary = '2'
  []
  [integral_p]
    type = NekBinnedSideIntegral
    bins = 'x y z'
    field = pressure
    boundary = '2'
  []
  [integral_v]
    type = NekBinnedSideIntegral
    bins = 'x y z'
    field = velocity
    boundary = '2'
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
  file_base = nek_dim
[]

(test/tests/nek_warnings/unused_boundary/nek.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'pyramid'
[]

[Mesh]
  type = NekRSMesh
  volume = true
  boundary = '1 2 3 4 5 6 7 8'
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

(test/tests/nek_file_output/usrwrk/nek.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'brick'
  usrwrk_output = '0 1'
  usrwrk_output_prefix = 'aaa ccc'
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

(test/tests/postprocessors/dimensionless_numbers/nondimensional/nek.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'brick'

  nondimensional = true
  L_ref = 0.25
  U_ref = 0.001
  rho_0 = 834.5
  Cp_0 = 1228.0
  T_ref = 573.0
  dT_ref = 10.0
[]

[Mesh]
  type = NekRSMesh
  boundary = '3'
  scaling = 0.25
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  [out]
    type = CSV
    execute_on = 'final'
  []
[]

[Postprocessors]
  [Pe]
    type = PecletNumber
    boundary = '1'
  []
  [Re]
    type = ReynoldsNumber
    boundary = '1'
  []
  [area]
    type = NekSideIntegral
    field = unity
    boundary = '1'
  []
  [mdot]
    type = NekMassFluxWeightedSideIntegral
    field = unity
    boundary = '1'
  []
  [inlet_v]
    type = NekSideAverage
    field = velocity
    boundary = '1'
  []
[]

(test/tests/userobjects/hexagonal_gap_layered/nek.i)

gap_thickness = ${fparse 0.05 * 7.646e-3}

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'sfr_7pin'
  output = 'temperature'
[]

[AuxVariables]
  [gap_bins]
    family = MONOMIAL
    order = CONSTANT
  []
  [avg_temp]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [gap_bins]
    type = SpatialUserObjectAux
    variable = gap_bins
    user_object = subchannel_binning
  []
  [avg_temp]
    type = SpatialUserObjectAux
    variable = avg_temp
    user_object = gap_avg
  []
[]

[UserObjects]
  [subchannel_binning]
    type = HexagonalSubchannelGapBin
    bundle_pitch = 0.02583914354890463
    pin_pitch = 0.0089656996
    pin_diameter = 7.646e-3
    n_rings = 2
  []
  [axial_binning]
    type = LayeredBin
    direction = z
    num_layers = 6
  []
  [gap_avg]
    type = NekBinnedPlaneAverage
    bins = 'subchannel_binning axial_binning'
    field = temperature
    gap_thickness = ${gap_thickness}
    map_space_by_qp = true
  []
  [gap_area]
    type = NekBinnedPlaneIntegral
    bins = 'subchannel_binning axial_binning'
    field = unity
    gap_thickness = ${gap_thickness}
    map_space_by_qp = true
  []
[]

[MultiApps]
  [subchannel]
    type = TransientMultiApp
    input_files = 'subchannel.i'
    execute_on = timestep_end
  []
[]

[Transfers]
  [uo1_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = gap_avg
    to_multi_app = subchannel
    variable = gap_avg
  []
  [uo2_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = gap_area
    to_multi_app = subchannel
    variable = gap_area
  []
  [temp_to_sub]
    type = MultiAppGeneralFieldNearestLocationTransfer
    to_multi_app = subchannel
    variable = temp
    source_variable = temp
    search_value_conflicts = false
  []
[]

[VectorPostprocessors]
  [avg_temp]
    type = SpatialUserObjectVectorPostprocessor
    userobject = gap_avg
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
  csv = true
[]

(test/tests/nek_errors/invalid_scalar/nek.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'pyramid'
[]

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  [max_S]
    type = NekVolumeExtremeValue
  []
[]

(test/tests/userobjects/hexagonal_gap_layered/type_error.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'sfr_7pin'
  output = 'temperature'
[]

[AuxVariables]
  [axial_bins]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [bins2]
    type = SpatialUserObjectAux
    variable = axial_bins
    user_object = axial_binning
  []
[]

[UserObjects]
  [axial_binning]
    type = LayeredBin
    direction = z
    num_layers = 6
  []
  [vol_avg]
    type = NekBinnedPlaneIntegral
    bins = 'axial_binning'
    field = unity
    gap_thickness = 0.01
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

(test/tests/userobjects/hexagonal_gap_layered/user_component.i)

gap_thickness = ${fparse 0.05 * 7.646e-3}

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'sfr_7pin'
  output = 'velocity'
[]

[AuxVariables]
  [velocity_component]
  []

  # These are just for visualizing the average velocity component with Glyphs in paraview;
  # the result of the 'vol_avg' user object will be represented as a vector "uo_" with 3 components
  [uo_x]
    family = MONOMIAL
    order = CONSTANT
  []
  [uo_y]
    family = MONOMIAL
    order = CONSTANT
  []
  [uo_z]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [velocity_component] # actual velocity component computed directly from interpolated nekRS velocity fields
    type = ParsedAux
    variable = velocity_component
    expression = '(0.1*vel_x+0.2*vel_y+0.3*vel_z)/sqrt(0.1*0.1+0.2*0.2+0.3*0.3)'
    coupled_variables = 'vel_x vel_y vel_z'
    execute_on = 'timestep_end nonlinear linear'
  []
  [uo_x]
    type = NekSpatialBinComponentAux
    variable = uo_x
    user_object = avg_velocity_component
    component = 0
  []
  [uo_y]
    type = NekSpatialBinComponentAux
    variable = uo_y
    user_object = avg_velocity_component
    component = 1
  []
  [uo_z]
    type = NekSpatialBinComponentAux
    variable = uo_z
    user_object = avg_velocity_component
    component = 2
  []
[]

[UserObjects]
  [subchannel_binning]
    type = HexagonalSubchannelGapBin
    bundle_pitch = 0.02583914354890463
    pin_pitch = 0.0089656996
    pin_diameter = 7.646e-3
    n_rings = 2
  []
  [axial_binning]
    type = LayeredBin
    direction = z
    num_layers = 6
  []
  [avg_velocity_component]
    type = NekBinnedPlaneAverage
    bins = 'subchannel_binning axial_binning'
    field = velocity_component
    velocity_component = user
    velocity_direction = '0.1 0.2 0.3'
    gap_thickness = ${gap_thickness}
    map_space_by_qp = true
  []
[]

[MultiApps]
  [subchannel]
    type = TransientMultiApp
    input_files = 'subchannel_b.i'
    execute_on = timestep_end
  []
[]

[Transfers]
  [uo1_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = avg_velocity_component
    to_multi_app = subchannel
    variable = avg_velocity_component
  []
  [uox_to_sub]
    type = MultiAppGeneralFieldNearestLocationTransfer
    to_multi_app = subchannel
    source_variable = uo_x
    variable = uo_x
    search_value_conflicts = false
  []
  [uoy_to_sub]
    type = MultiAppGeneralFieldNearestLocationTransfer
    to_multi_app = subchannel
    source_variable = uo_y
    variable = uo_y
    search_value_conflicts = false
  []
  [uoz_to_sub]
    type = MultiAppGeneralFieldNearestLocationTransfer
    to_multi_app = subchannel
    source_variable = uo_z
    variable = uo_z
    search_value_conflicts = false
  []
  [actual_velocity_component]
    type = MultiAppGeneralFieldNearestLocationTransfer
    to_multi_app = subchannel
    source_variable = velocity_component
    variable = velocity_component
    search_value_conflicts = false
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

(test/tests/userobjects/side/nondimensional/nek.i)

[GlobalParams]
  check_boundary_restricted = false
[]

[Mesh]
  type = NekRSMesh
  volume = true
  scaling = 7.646e-3
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'sfr_7pin'
  output = 'temperature pressure velocity'

  nondimensional = true
  L_ref = 7.646e-3
  T_ref = 100.0
  dT_ref = 50.0
  U_ref = 2.0
  rho_0 = 834.5
  Cp_0 = 1228.0
[]

[AuxVariables]
  [avg_T]
    family = MONOMIAL
    order = CONSTANT
  []
  [avg_p]
    family = MONOMIAL
    order = CONSTANT
  []
  [avg_v]
    family = MONOMIAL
    order = CONSTANT
  []
  [integral_T]
    family = MONOMIAL
    order = CONSTANT
  []
  [integral_p]
    family = MONOMIAL
    order = CONSTANT
  []
  [integral_v]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [avg_T]
    type = SpatialUserObjectAux
    variable = avg_T
    user_object = avg_T
    boundary = '2'
  []
  [avg_p]
    type = SpatialUserObjectAux
    variable = avg_p
    user_object = avg_p
    boundary = '2'
  []
  [avg_v]
    type = SpatialUserObjectAux
    variable = avg_v
    user_object = avg_v
    boundary = '2'
  []
  [integral_T]
    type = SpatialUserObjectAux
    variable = integral_T
    user_object = integral_T
    boundary = '2'
  []
  [integral_p]
    type = SpatialUserObjectAux
    variable = integral_p
    user_object = integral_p
    boundary = '2'
  []
  [integral_v]
    type = SpatialUserObjectAux
    variable = integral_v
    user_object = integral_v
    boundary = '2'
  []
[]

[UserObjects]
  [x]
    type = LayeredBin
    direction = x
    num_layers = 2
  []
  [y]
    type = LayeredBin
    direction = y
    num_layers = 2
  []
  [z]
    type = LayeredBin
    direction = z
    num_layers = 3
  []
  [avg_T]
    type = NekBinnedSideAverage
    bins = 'x y z'
    field = temperature
    boundary = '2'
  []
  [avg_p]
    type = NekBinnedSideAverage
    bins = 'x y z'
    field = pressure
    boundary = '2'
  []
  [avg_v]
    type = NekBinnedSideAverage
    bins = 'x y z'
    field = velocity
    boundary = '2'
  []
  [integral_T]
    type = NekBinnedSideIntegral
    bins = 'x y z'
    field = temperature
    boundary = '2'
  []
  [integral_p]
    type = NekBinnedSideIntegral
    bins = 'x y z'
    field = pressure
    boundary = '2'
  []
  [integral_v]
    type = NekBinnedSideIntegral
    bins = 'x y z'
    field = velocity
    boundary = '2'
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

(test/tests/userobjects/volume/nondimensional/nek.i)

[Mesh]
  type = NekRSMesh
  volume = true
  scaling = 7.646e-3
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'sfr_7pin'
  output = 'temperature pressure velocity'

  nondimensional = true
  L_ref = 7.646e-3
  T_ref = 100.0
  dT_ref = 50.0
  U_ref = 2.0
  rho_0 = 834.5
  Cp_0 = 1228.0
[]

[AuxVariables]
  [avg_T]
    family = MONOMIAL
    order = CONSTANT
  []
  [avg_p]
    family = MONOMIAL
    order = CONSTANT
  []
  [avg_v]
    family = MONOMIAL
    order = CONSTANT
  []
  [integral_T]
    family = MONOMIAL
    order = CONSTANT
  []
  [integral_p]
    family = MONOMIAL
    order = CONSTANT
  []
  [integral_v]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [avg_T]
    type = SpatialUserObjectAux
    variable = avg_T
    user_object = avg_T
  []
  [avg_p]
    type = SpatialUserObjectAux
    variable = avg_p
    user_object = avg_p
  []
  [avg_v]
    type = SpatialUserObjectAux
    variable = avg_v
    user_object = avg_v
  []
  [integral_T]
    type = SpatialUserObjectAux
    variable = integral_T
    user_object = integral_T
  []
  [integral_p]
    type = SpatialUserObjectAux
    variable = integral_p
    user_object = integral_p
  []
  [integral_v]
    type = SpatialUserObjectAux
    variable = integral_v
    user_object = integral_v
  []
[]

[UserObjects]
  [subchannel_binning]
    type = HexagonalSubchannelBin
    bundle_pitch = 0.02583914354890463
    pin_pitch = 0.0089656996
    pin_diameter = 7.646e-3
    n_rings = 2
  []
  [axial_binning]
    type = LayeredBin
    direction = z
    num_layers = 6
  []
  [avg_T]
    type = NekBinnedVolumeAverage
    bins = 'subchannel_binning axial_binning'
    field = temperature
  []
  [avg_p]
    type = NekBinnedVolumeAverage
    bins = 'subchannel_binning axial_binning'
    field = pressure
  []
  [avg_v]
    type = NekBinnedVolumeAverage
    bins = 'subchannel_binning axial_binning'
    field = velocity
  []
  [integral_T]
    type = NekBinnedVolumeIntegral
    bins = 'subchannel_binning axial_binning'
    field = temperature
  []
  [integral_p]
    type = NekBinnedVolumeIntegral
    bins = 'subchannel_binning axial_binning'
    field = pressure
  []
  [integral_v]
    type = NekBinnedVolumeIntegral
    bins = 'subchannel_binning axial_binning'
    field = velocity
  []
[]

[MultiApps]
  [subchannel]
    type = TransientMultiApp
    input_files = 'subchannel.i'
    execute_on = timestep_end
  []
[]

[Transfers]
  [uo1_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = avg_T
    to_multi_app = subchannel
    variable = avg_T
  []
  [uo2_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = avg_p
    to_multi_app = subchannel
    variable = avg_p
  []
  [uo3_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = avg_v
    to_multi_app = subchannel
    variable = avg_v
  []
  [uo4_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = integral_T
    to_multi_app = subchannel
    variable = integral_T
  []
  [uo5_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = integral_p
    to_multi_app = subchannel
    variable = integral_p
  []
  [uo6_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = integral_v
    to_multi_app = subchannel
    variable = integral_v
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

(test/tests/nek_stochastic/shift/nek.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'brick'
  n_usrwrk_slots = 3

  output = 'scalar01 scalar02 scalar03'
  first_reserved_usrwrk_slot = 1
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[UserObjects]
  [scalar2]
    type = NekScalarValue
    value = 2.5
  []
  [scalar3]
    type = NekScalarValue
    value = 3.5
  []
[]

[Postprocessors]
  [s2]
    type = NekScalarValuePostprocessor
    userobject = scalar2
  []
  [s3]
    type = NekScalarValuePostprocessor
    userobject = scalar3
  []

  [max_scalar1]
    type = NodalExtremeValue
    variable = scalar01
    value_type = max
  []
  [min_scalar1]
    type = NodalExtremeValue
    variable = scalar01
    value_type = min
  []
  [max_scalar2]
    type = NodalExtremeValue
    variable = scalar02
    value_type = max
  []
  [min_scalar2]
    type = NodalExtremeValue
    variable = scalar02
    value_type = min
  []
  [max_scalar3]
    type = NodalExtremeValue
    variable = scalar03
    value_type = max
  []
  [min_scalar3]
    type = NodalExtremeValue
    variable = scalar03
    value_type = min
  []
[]

[Outputs]
  csv = true
[]

(tutorials/other_apps/cardinal_sub.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'turbPipe'
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

(test/tests/nek_output/nek.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'pyramid'
  output = 'scalar01 scalar02 scalar03'
[]

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Functions]
  [s01]
    type = ParsedFunction
    expression = 'sin(x)'
  []
  [s02]
    type = ParsedFunction
    expression = 'y+1'
  []
  [s03]
    type = ParsedFunction
    expression = 'exp(x*y*z)'
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []

  [Quadrature]
    type = GAUSS_LOBATTO
    order = FIRST
  []
[]

[Postprocessors]
  [s01_error]
    type = ElementL1Error
     variable = scalar01
     function = s01
  []
  [s02_error]
    type = ElementL1Error
     variable = scalar02
     function = s02
  []
  [s03_error]
    type = ElementL1Error
     variable = scalar03
     function = s03
  []
[]

[Outputs]
  exodus = true
  csv = true
[]

(test/tests/nek_file_output/avg_plugin/nek.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'turbPipe'

  # We omit the non-dimensional settings here in order to just extract the
  # non-dimensional solution as-is, without dimensionalizing it.
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

(test/tests/userobjects/subchannel_layered/wrong_type.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'sfr_7pin'
  output = 'temperature'
[]

[UserObjects]
  [subchannel_binning]
    type = HexagonalSubchannelGapBin
    bundle_pitch = 0.02583914354890463
    pin_pitch = 0.0089656996
    pin_diameter = 7.646e-3
    n_rings = 2
  []
  [axial_binning]
    type = LayeredBin
    direction = z
    num_layers = 6
  []
  [vol_avg]
    type = NekBinnedVolumeAverage
    bins = 'subchannel_binning axial_binning'
    field = temperature
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

(test/tests/userobjects/sideset_layered/z_bins_by_centroid.i)

[GlobalParams]
  check_boundary_restricted = false
  map_space_by_qp = false
[]

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'sfr_7pin'
  output = 'temperature'
[]

[AuxVariables]
  [T1_bin3]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [T1_bin3]
    type = SpatialUserObjectAux
    variable = T1_bin3
    user_object = T1_bin3
    boundary = '1'
  []
[]

[UserObjects]
  [z3]
    type = LayeredBin
    direction = z
    num_layers = 3
  []
  [T1_bin3]
    type = NekBinnedSideIntegral
    bins = 'z3'
    field = temperature
    boundary = '1'
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[VectorPostprocessors]
  [T]
    type = SpatialUserObjectVectorPostprocessor
    userobject = T1_bin3
  []
[]

[Outputs]
  exodus = true

  # remove from output to get smaller gold file
  hide = 'temp'
[]

(test/tests/nek_standalone/adaptive_dt/nek.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'pyramid'
[]

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  [out]
    type = CSV
  []
[]

[Postprocessors]
  [time]
    type = TimePostprocessor
    execute_on = 'initial timestep_begin'
  []
[]

(test/tests/deformation/nek_standalone/nek_boundary.i)

[Mesh]
  type = NekRSMesh
  boundary = '1 2 3'
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'mv_cyl'
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  [volume]
    type = NekVolumeIntegral
    field = unity
  []
  [area]
    type = NekSideIntegral
    field = unity
    boundary = '1 2 3'
  []

  # these will not reflect the changing mesh, because we do not copy displacements
  # from NekRS to MOOSE
  [area_moose]
    type = VolumePostprocessor
  []
[]

[Outputs]
  csv = true
  execute_on = 'final'
[]

(test/tests/nek_standalone/conj_ht/nek.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'conj_ht'
  output = 'temperature'
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
 [Area_BC3_flow]
   type = NekSideIntegral
   boundary = '3'
   field = unity
   mesh = 'fluid'
 []
 [Area_BC3_all]
   type = NekSideIntegral
   boundary = '3'
   field = unity
   mesh = 'all'
 []
 [SideAverage_T_BC3_flow]
   type = NekSideAverage
   boundary = '3'
   field = temperature
   mesh = 'fluid'
 []
 [SideAverage_T_BC3_all]
   type = NekSideAverage
   boundary = '3'
   field = temperature
   mesh = 'all'
 []
 [HeatFluxIntegral_BC3_flow]
   type = NekHeatFluxIntegral
   boundary = '3'
   mesh = 'fluid'
 []
 [HeatFluxIntegral_BC3_all]
   type = NekHeatFluxIntegral
   boundary = '3'
   mesh = 'all'
 []
 [MassFlowRate_BC1_flow]
   type = NekMassFluxWeightedSideIntegral
   boundary = '1'
   field = unity
   mesh = 'fluid'
 []
 [MassFlowRate_BC1_all]
   type = NekMassFluxWeightedSideIntegral
   boundary = '1'
   field = unity
   mesh = 'all'
 []
 [MflowAvgTemp_BC2_flow]
   type = NekMassFluxWeightedSideAverage
   boundary = '2'
   field = temperature
   mesh = 'fluid'
 []
 [MflowAvgTemp_BC2_all]
   type = NekMassFluxWeightedSideAverage
   boundary = '2'
   field = temperature
   mesh = 'all'
 []
 [Reynolds_BC1_flow]
   type = ReynoldsNumber
   boundary = '1'
   L_ref = 0.5
   mesh = 'fluid'
 []
 [Reynolds_BC1_all]
   type = ReynoldsNumber
   boundary = '1'
   L_ref = 0.5
   mesh = 'all'
 []
 [Peclet_BC1_flow]
   type = PecletNumber
   boundary = '1'
   L_ref = 0.5
   mesh = 'fluid'
 []
 [Peclet_BC1_all]
   type = PecletNumber
   boundary = '1'
   L_ref = 0.5
   mesh = 'all'
 []
#
# Volume post processors
#
 [Vol_flow]
   type = NekVolumeIntegral
   field = unity
   mesh = 'fluid'
 []
 [Vol_all]
   type = NekVolumeIntegral
   field = unity
   mesh = 'all'
 []
 [maxVol_T_flow]
   type = NekVolumeExtremeValue
   field = temperature
   value_type = max
   mesh = 'fluid'
 []
 [maxVol_T_all]
   type = NekVolumeExtremeValue
   field = temperature
   value_type = max
   mesh = 'all'
 []
 [avgVol_T_flow]
   type = NekVolumeAverage
   field = temperature
   mesh = 'fluid'
 []
 [avgVol_T_all]
   type = NekVolumeAverage
   field = temperature
   mesh = 'all'
 []
[]

[Outputs]
  csv = true
  exodus = true
  execute_on = final
[]

(test/tests/nek_stochastic/errors/nek_standalone_error.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'ethier'
  output = 'temperature'
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[UserObjects]
  [scalar1]
    type = NekScalarValue
    usrwrk_slot = 0
  []
[]

(test/tests/userobjects/hexagonal_gap_layered/normals/nek_axial.i)

gap_thickness = ${fparse 0.05 * 7.646e-3}

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'sfr_7pin'
  output = 'velocity'
[]

[AuxVariables]
  # These are just for visualizing the average velocity component with Glyphs in paraview;
  # the result of the 'vol_avg' user object will be represented as a vector "uo_" with 3 components
  [uo_x]
    family = MONOMIAL
    order = CONSTANT
  []
  [uo_y]
    family = MONOMIAL
    order = CONSTANT
  []
  [uo_z]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [uo_x]
    type = NekSpatialBinComponentAux
    variable = uo_x
    user_object = avg_velocity_component
    component = 0
  []
  [uo_y]
    type = NekSpatialBinComponentAux
    variable = uo_y
    user_object = avg_velocity_component
    component = 1
  []
  [uo_z]
    type = NekSpatialBinComponentAux
    variable = uo_z
    user_object = avg_velocity_component
    component = 2
  []
[]

[UserObjects]
  [subchannel_binning]
    type = HexagonalSubchannelBin
    bundle_pitch = 0.02583914354890463
    pin_pitch = 0.0089656996
    pin_diameter = 7.646e-3
    n_rings = 2
  []
  [axial_binning]
    type = LayeredGapBin
    direction = z
    num_layers = 6
  []
  [avg_velocity_component]
    type = NekBinnedPlaneAverage
    bins = 'subchannel_binning axial_binning'
    field = velocity_component
    velocity_component = normal
    gap_thickness = ${gap_thickness}
    map_space_by_qp = true
  []
[]

[MultiApps]
  [subchannel]
    type = TransientMultiApp
    input_files = 'subchannel_axial.i'
    execute_on = timestep_end
  []
[]

[Transfers]
  [uox_to_sub]
    type = MultiAppGeneralFieldNearestLocationTransfer
    to_multi_app = subchannel
    source_variable = uo_x
    variable = uo_x
    search_value_conflicts = false
  []
  [uoy_to_sub]
    type = MultiAppGeneralFieldNearestLocationTransfer
    to_multi_app = subchannel
    source_variable = uo_y
    variable = uo_y
    search_value_conflicts = false
  []
  [uoz_to_sub]
    type = MultiAppGeneralFieldNearestLocationTransfer
    to_multi_app = subchannel
    source_variable = uo_z
    variable = uo_z
    search_value_conflicts = false
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

(test/tests/userobjects/subchannel_layered/type_error.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'sfr_7pin'
  output = 'temperature'
[]

[UserObjects]
  [dummy]
    type = NearestNodeNumberUO
    point = '0.0 0.0 0.1'
  []
  [vol_avg]
    type = NekBinnedVolumeAverage
    bins = 'dummy'
    field = temperature
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

(test/tests/nek_stochastic/quiet_init/nek_multi.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'ethier'
  n_usrwrk_slots = 2

  output = 'scalar02'
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[UserObjects]
  [scalar1]
    type = NekScalarValue
  []
[]

[Controls]
  [stochastic]
    type = SamplerReceiver
  []
[]

[Postprocessors]
  [s1]
    type = NekScalarValuePostprocessor
    userobject = scalar1
  []

  # we use the stochastic value to set the scalar (in the .udf files). Here,
  # we are checking that the value of the scalar everywhere is equation to the 's1' postprocessor
  [max_scalar]
    type = ElementExtremeValue
    variable = scalar02
    value_type = max
  []
  [min_scalar]
    type = ElementExtremeValue
    variable = scalar02
    value_type = min
  []
[]

[Outputs]
  csv = true
[]

(test/tests/nek_mesh/sidesets/cube/exact_volume.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'cube'
[]

[Mesh]
  type = NekRSMesh
  volume = true
  exact = true
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  file_base = 'nek_volume_out'
  csv = true
[]

[Postprocessors]
  [area_side1_nek]
    type = NekSideIntegral
    field = unity
    boundary = '1'
  []
  [area_side1_moose]
    type = AreaPostprocessor
    boundary = '1'
  []
  [area_side2_nek]
    type = NekSideIntegral
    field = unity
    boundary = '2'
  []
  [area_side2_moose]
    type = AreaPostprocessor
    boundary = '2'
  []
  [area_side3_nek]
    type = NekSideIntegral
    field = unity
    boundary = '3'
  []
  [area_side3_moose]
    type = AreaPostprocessor
    boundary = '3'
  []
  [area_side4_nek]
    type = NekSideIntegral
    field = unity
    boundary = '4'
  []
  [area_side4_moose]
    type = AreaPostprocessor
    boundary = '4'
  []
  [area_side5_nek]
    type = NekSideIntegral
    field = unity
    boundary = '5'
  []
  [area_side5_moose]
    type = AreaPostprocessor
    boundary = '5'
  []
  [area_side6_nek]
    type = NekSideIntegral
    field = unity
    boundary = '6'
  []
  [area_side6_moose]
    type = AreaPostprocessor
    boundary = '6'
  []
[]

(test/tests/nek_standalone/lowMach/nek.i)

[Mesh]
  type = NekRSMesh
  volume = true
  order = SECOND
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'lowMach'
  output = 'pressure velocity temperature'

  # We omit the non-dimensional settings here in order to just extract the
  # non-dimensional solution as-is, without dimensionalizing it.
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  # All the following postprocessors are applying operations both (a) directly to the NekRS
  # solution arrays, and (b) to the variables extracted with the 'outputs = ...' syntax.
  # Rather than check the actual values of these postprocessors (which might change if the
  # NekRS development team changes the nature of their CI tests), we can just check that
  # the difference between the Nek-style postprocessors from the MOOSE-style postprocessors
  # (acting on the extract solution) are nearly zero. We only check the absolute value of
  # the min/max volume values for Vx, temperature, and pressure because those values are printed to
  # the screen and offer quick confirmation of any changes that are due to changes in NekRS itself.

  [max_Vx]
    type = NekVolumeExtremeValue
    field = velocity_x
    value_type = max
  []
  [max_Vx_output]
    type = NodalExtremeValue
    variable = vel_x
    value_type = max
  []
  [max_Vx_diff]
    type = DifferencePostprocessor
    value1 = max_Vx
    value2 = max_Vx_output
  []

  [min_Vx]
    type = NekVolumeExtremeValue
    field = velocity_x
    value_type = min
  []
  [min_Vx_output]
    type = NodalExtremeValue
    variable = vel_x
    value_type = min
  []
  [min_Vx_diff]
    type = DifferencePostprocessor
    value1 = min_Vx
    value2 = min_Vx_output
  []

  [max_p]
    type = NekVolumeExtremeValue
    field = pressure
    value_type = max
  []
  [max_p_output]
    type = NodalExtremeValue
    variable = P
    value_type = max
  []
  [max_p_diff]
    type = DifferencePostprocessor
    value1 = max_p
    value2 = max_p_output
  []

  [min_p]
    type = NekVolumeExtremeValue
    field = pressure
    value_type = min
  []
  [min_p_output]
    type = NodalExtremeValue
    variable = P
    value_type = min
  []
  [min_p_diff]
    type = DifferencePostprocessor
    value1 = min_p
    value2 = min_p_output
  []

  [max_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = max
  []
  [max_T_output]
    type = NodalExtremeValue
    variable = temp
    value_type = max
  []
  [max_T_diff]
    type = DifferencePostprocessor
    value1 = max_T
    value2 = max_T_output
  []

  [min_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = min
  []
  [min_T_output]
    type = NodalExtremeValue
    variable = temp
    value_type = min
  []
  [min_T_diff]
    type = DifferencePostprocessor
    value1 = min_T
    value2 = min_T_output
  []

  [area]
    type = NekSideIntegral
    field = unity
    boundary = '1'
  []
  [area_output]
    type = AreaPostprocessor
    boundary = '1'
  []
  [area_diff]
    type = DifferencePostprocessor
    value1 = area
    value2 = area_output
  []

  [volume]
    type = NekVolumeIntegral
    field = unity
  []
  [volume_output]
    type = VolumePostprocessor
  []
  [volume_diff]
    type = DifferencePostprocessor
    value1 = volume
    value2 = volume_output
  []

  [max_T_side]
    type = NekSideExtremeValue
    field = temperature
    value_type = max
    boundary = '1'
  []
  [max_T_side_output]
    type = NodalExtremeValue
    variable = temp
    value_type = max
    boundary = '1'
  []
  [max_T_side_diff]
    type = DifferencePostprocessor
    value1 = max_T_side
    value2 = max_T_side_output
  []

  [min_T_side]
    type = NekSideExtremeValue
    field = temperature
    value_type = min
    boundary = '1'
  []
  [min_T_side_output]
    type = NodalExtremeValue
    variable = temp
    value_type = min
    boundary = '1'
  []
  [min_T_side_diff]
    type = DifferencePostprocessor
    value1 = min_T_side
    value2 = min_T_side_output
  []

  [max_Vx_side]
    type = NekSideExtremeValue
    field = velocity_x
    value_type = max
    boundary = '1'
  []
  [max_Vx_side_output]
    type = NodalExtremeValue
    variable = vel_x
    value_type = max
    boundary = '1'
  []
  [max_Vx_side_diff]
    type = DifferencePostprocessor
    value1 = max_Vx_side
    value2 = max_Vx_side_output
  []

  [min_Vx_side]
    type = NekSideExtremeValue
    field = velocity_x
    value_type = min
    boundary = '1'
  []
  [min_Vx_side_output]
    type = NodalExtremeValue
    variable = vel_x
    value_type = min
    boundary = '1'
  []
  [min_Vx_side_diff]
    type = DifferencePostprocessor
    value1 = min_Vx_side
    value2 = min_Vx_side_output
  []

  [max_p_side]
    type = NekSideExtremeValue
    field = pressure
    value_type = max
    boundary = '1'
  []
  [max_p_side_output]
    type = NodalExtremeValue
    variable = P
    value_type = max
    boundary = '1'
  []
  [min_p_side_diff]
    type = DifferencePostprocessor
    value1 = min_p_side
    value2 = min_p_side_output
  []

  [min_p_side]
    type = NekSideExtremeValue
    field = pressure
    value_type = min
    boundary = '1'
  []
  [min_p_side_output]
    type = NodalExtremeValue
    variable = P
    value_type = min
    boundary = '1'
  []
  [max_p_side_diff]
    type = DifferencePostprocessor
    value1 = max_p_side
    value2 = max_p_side_output
  []

  [avg_T]
    type = NekVolumeAverage
    field = temperature
  []
  [avg_T_output]
    type = ElementAverageValue
    variable = temp
  []
  [avg_T_diff]
    type = DifferencePostprocessor
    value1 = avg_T
    value2 = avg_T_output
  []

  [avg_Vx]
    type = NekVolumeAverage
    field = velocity_x
  []
  [avg_Vx_output]
    type = ElementAverageValue
    variable = vel_x
  []
  [avg_Vx_diff]
    type = DifferencePostprocessor
    value1 = avg_Vx
    value2 = avg_Vx_output
  []

  [avg_T_side]
    type = NekSideAverage
    field = temperature
    boundary = '1'
  []
  [avg_T_side_output]
    type = SideAverageValue
    variable = temp
    boundary = '1'
  []
  [avg_T_side_diff]
    type = DifferencePostprocessor
    value1 = avg_T_side
    value2 = avg_T_side_output
  []

  [avg_Vx_side]
    type = NekSideAverage
    field = velocity_x
    boundary = '1'
  []
  [avg_Vx_side_output]
    type = SideAverageValue
    variable = vel_x
    boundary = '1'
  []
  [avg_Vx_side_diff]
    type = DifferencePostprocessor
    value1 = avg_Vx_side
    value2 = avg_Vx_side_output
  []

  [avg_p_side]
    type = NekSideAverage
    field = pressure
    boundary = '1'
  []
  [avg_p_side_output]
    type = SideAverageValue
    variable = P
    boundary = '1'
  []
  [avg_p_side_diff]
    type = DifferencePostprocessor
    value1 = avg_p_side
    value2 = avg_p_side_output
  []
[]

[Outputs]
  csv = true
  exodus = true
  execute_on = 'final'

  hide = 'max_Vx_output min_Vx_output max_p_output min_p_output area_output volume_output max_Vx_side max_Vx_side_output max_p_side max_p_side_output min_Vx_side min_Vx_side_output min_p_side min_p_side_output avg_Vx avg_Vx_output avg_Vx_side avg_Vx_side_output avg_p_side avg_p_side_output max_T_output min_T_output max_T_side max_T_side_output min_T_side min_T_side_output avg_T avg_T_output avg_T_side avg_T_side_output'
[]

(test/tests/auxkernels/nek_spatial_bin_component_aux/invalid_field.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'brick'
  output = 'pressure'
[]

[Mesh]
  type = NekRSMesh
  volume = true
[]

[AuxVariables]
  [uo]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [uo]
    type = NekSpatialBinComponentAux
    variable = uo
    user_object = vol_integral
    component = 0
  []
[]

[UserObjects]
  [x_bins]
    type = LayeredBin
    direction = x
    num_layers = 3
  []
  [vol_integral]
    type = NekBinnedVolumeIntegral
    bins = 'x_bins'
    field = pressure
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

(test/tests/userobjects/layered_layered/nek.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'brick'
  output = 'pressure'

  nondimensional = true
  L_ref = 2.0
  U_ref = 1.0
  rho_0 = 834.5
  Cp_0 = 1228.0
  T_ref = 573.0
  dT_ref = 10.0
[]

[Mesh]
  type = NekRSMesh
  volume = true
  scaling = 2.0
[]

[AuxVariables]
  [bin_volumes]
    family = MONOMIAL
    order = CONSTANT
  []
  [avg_p]
    family = MONOMIAL
    order = CONSTANT
  []
  [total_volume]
    family = MONOMIAL
    order = CONSTANT
  []
  [total_average_p]
    family = MONOMIAL
    order = CONSTANT
  []

  # just for visualization of the binning
  [x_bins]
    family = MONOMIAL
    order = CONSTANT
  []
  [y_bins]
    family = MONOMIAL
    order = CONSTANT
  []
  [z_bins]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  # just for visualization of the binning
  [x_bins]
    type = SpatialUserObjectAux
    variable = x_bins
    user_object = x_bins
    execute_on = INITIAL
  []
  [y_bins]
    type = SpatialUserObjectAux
    variable = y_bins
    user_object = y_bins
    execute_on = INITIAL
  []
  [z_bins]
    type = SpatialUserObjectAux
    variable = z_bins
    user_object = z_bins
    execute_on = INITIAL
  []

  [bin_volumes]
    type = SpatialUserObjectAux
    variable = bin_volumes
    user_object = vol_integral
    execute_on = 'INITIAL TIMESTEP_END'
  []
  [avg_p]
    type = SpatialUserObjectAux
    variable = avg_p
    user_object = avg_p
    execute_on = 'INITIAL TIMESTEP_END'
  []
  [total_volume]
    type = SpatialUserObjectAux
    variable = total_volume
    user_object = reference_vol_integral
    execute_on = 'INITIAL TIMESTEP_END'
  []
  [total_average_p]
    type = SpatialUserObjectAux
    variable = total_average_p
    user_object = reference_pressure_avg
    execute_on = 'INITIAL TIMESTEP_END'
  []
[]

[UserObjects]
  [x_bins]
    type = LayeredBin
    direction = x
    num_layers = 3
  []
  [y_bins]
    type = LayeredBin
    direction = y
    num_layers = 3
  []
  [z_bins]
    type = LayeredBin
    direction = z
    num_layers = 12
  []
  [vol_integral]
    type = NekBinnedVolumeIntegral
    bins = 'x_bins y_bins z_bins'
    field = unity
  []
  [avg_p]
    type = NekBinnedVolumeAverage
    bins = 'x_bins y_bins z_bins'
    field = pressure
  []

  [one_bin]
    type = LayeredBin
    direction = z
    num_layers = 1
  []
  [reference_vol_integral]
    type = NekBinnedVolumeIntegral
    bins = 'one_bin'
    field = unity
  []
  [reference_pressure_avg]
    type = NekBinnedVolumeAverage
    bins = 'one_bin'
    field = pressure
  []
[]

[Postprocessors]
  # we compare the integral (with a single bin) with an already-verified postprocessor
  # to make sure the actual internals of the binned volume integral are done correctly
  [volume_ref] # should match the value in 'total_volume' (computed with 1 bin)
    type = NekVolumeIntegral
    field = unity
  []
  [avg_p_ref] # should match the value in 'total_average_p' (computed with 1 bin)
    type = NekVolumeAverage
    field = pressure
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

(test/tests/deformation/nek_standalone/nek.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'mv_cyl'
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  [volume]
    type = NekVolumeIntegral
    field = unity
  []
  [area]
    type = NekSideIntegral
    field = unity
    boundary = '1 2 3'
  []

  # these will not reflect the changing mesh, because we do not copy displacements
  # from NekRS to MOOSE
  [volume_moose]
    type = VolumePostprocessor
  []
  [area_moose]
    type = AreaPostprocessor
    boundary = '1 2 3'
  []
[]

[Outputs]
  csv = true
  execute_on = 'final'
[]

(test/tests/userobjects/volume/dimensional/nek.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'sfr_7pin'
  output = 'temperature pressure velocity'
[]

[AuxVariables]
  [avg_T]
    family = MONOMIAL
    order = CONSTANT
  []
  [avg_p]
    family = MONOMIAL
    order = CONSTANT
  []
  [avg_v]
    family = MONOMIAL
    order = CONSTANT
  []
  [integral_T]
    family = MONOMIAL
    order = CONSTANT
  []
  [integral_p]
    family = MONOMIAL
    order = CONSTANT
  []
  [integral_v]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [avg_T]
    type = SpatialUserObjectAux
    variable = avg_T
    user_object = avg_T
  []
  [avg_p]
    type = SpatialUserObjectAux
    variable = avg_p
    user_object = avg_p
  []
  [avg_v]
    type = SpatialUserObjectAux
    variable = avg_v
    user_object = avg_v
  []
  [integral_T]
    type = SpatialUserObjectAux
    variable = integral_T
    user_object = integral_T
  []
  [integral_p]
    type = SpatialUserObjectAux
    variable = integral_p
    user_object = integral_p
  []
  [integral_v]
    type = SpatialUserObjectAux
    variable = integral_v
    user_object = integral_v
  []
[]

[UserObjects]
  [subchannel_binning]
    type = HexagonalSubchannelBin
    bundle_pitch = 0.02583914354890463
    pin_pitch = 0.0089656996
    pin_diameter = 7.646e-3
    n_rings = 2
  []
  [axial_binning]
    type = LayeredBin
    direction = z
    num_layers = 6
  []
  [avg_T]
    type = NekBinnedVolumeAverage
    bins = 'subchannel_binning axial_binning'
    field = temperature
  []
  [avg_p]
    type = NekBinnedVolumeAverage
    bins = 'subchannel_binning axial_binning'
    field = pressure
  []
  [avg_v]
    type = NekBinnedVolumeAverage
    bins = 'subchannel_binning axial_binning'
    field = velocity
  []
  [integral_T]
    type = NekBinnedVolumeIntegral
    bins = 'subchannel_binning axial_binning'
    field = temperature
  []
  [integral_p]
    type = NekBinnedVolumeIntegral
    bins = 'subchannel_binning axial_binning'
    field = pressure
  []
  [integral_v]
    type = NekBinnedVolumeIntegral
    bins = 'subchannel_binning axial_binning'
    field = velocity
  []
[]

[MultiApps]
  [subchannel]
    type = TransientMultiApp
    input_files = 'subchannel.i'
    execute_on = timestep_end
  []
[]

[Transfers]
  [uo1_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = avg_T
    to_multi_app = subchannel
    variable = avg_T
  []
  [uo2_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = avg_p
    to_multi_app = subchannel
    variable = avg_p
  []
  [uo3_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = avg_v
    to_multi_app = subchannel
    variable = avg_v
  []
  [uo4_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = integral_T
    to_multi_app = subchannel
    variable = integral_T
  []
  [uo5_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = integral_p
    to_multi_app = subchannel
    variable = integral_p
  []
  [uo6_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = integral_v
    to_multi_app = subchannel
    variable = integral_v
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
  file_base = nek_dim
[]

(test/tests/userobjects/layered_layered/duplicate_directions.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'brick'
  output = 'pressure'

  nondimensional = true
  L_ref = 2.0
  U_ref = 1.0
  rho_0 = 834.5
  Cp_0 = 1228.0
  T_ref = 573.0
  dT_ref = 10.0
[]

[Mesh]
  type = NekRSMesh
  volume = true
  scaling = 2.0
[]

[UserObjects]
  [x_bins]
    type = LayeredBin
    direction = x
    num_layers = 3
  []
  [y_bins]
    type = LayeredBin
    direction = y
    num_layers = 3
  []
  [x_bins2]
    type = LayeredBin
    direction = x
    num_layers = 12
  []

  # should error because weve specified two x-direction bins
  [vol_integral]
    type = NekBinnedVolumeIntegral
    bins = 'x_bins y_bins x_bins2'
    field = unity
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

(test/tests/nek_stochastic/device/nek_multi.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'pyramid'
  n_usrwrk_slots = 1
  output = 'temperature'
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[UserObjects]
  [scalar1]
    type = NekScalarValue
  []
[]

[Controls]
  [stochastic]
    type = SamplerReceiver
  []
[]

[Postprocessors]
  [s1]
    type = NekScalarValuePostprocessor
    userobject = scalar1
  []

  # we use the stochastic value to set the boundary condition on temperature on sideset 1;
  # we are checking that the value of the temperature on sideset 1 indeed matches that value
  [max_on_side]
    type = NekSideExtremeValue
    field = temperature
    boundary = '1'
    value_type = max
  []
  [min_on_side]
    type = NekSideExtremeValue
    field = temperature
    boundary = '1'
    value_type = min
  []
[]

[Outputs]
  csv = true
[]

(test/tests/userobjects/gap/nondimensional/nek.i)

[Mesh]
  type = NekRSMesh
  volume = true
  scaling = 7.646e-3
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'sfr_7pin'
  output = 'temperature pressure velocity'

  nondimensional = true
  L_ref = 7.646e-3
  T_ref = 100.0
  dT_ref = 50.0
  U_ref = 2.0
  rho_0 = 834.5
  Cp_0 = 1228.0
[]

[AuxVariables]
  [avg_T]
    family = MONOMIAL
    order = CONSTANT
  []
  [avg_p]
    family = MONOMIAL
    order = CONSTANT
  []
  [avg_v]
    family = MONOMIAL
    order = CONSTANT
  []
  [integral_T]
    family = MONOMIAL
    order = CONSTANT
  []
  [integral_p]
    family = MONOMIAL
    order = CONSTANT
  []
  [integral_v]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [avg_T]
    type = SpatialUserObjectAux
    variable = avg_T
    user_object = avg_T
  []
  [avg_p]
    type = SpatialUserObjectAux
    variable = avg_p
    user_object = avg_p
  []
  [avg_v]
    type = SpatialUserObjectAux
    variable = avg_v
    user_object = avg_v
  []
  [integral_T]
    type = SpatialUserObjectAux
    variable = integral_T
    user_object = integral_T
  []
  [integral_p]
    type = SpatialUserObjectAux
    variable = integral_p
    user_object = integral_p
  []
  [integral_v]
    type = SpatialUserObjectAux
    variable = integral_v
    user_object = integral_v
  []
[]

[UserObjects]
  [subchannel_binning]
    type = HexagonalSubchannelBin
    bundle_pitch = 0.02583914354890463
    pin_pitch = 0.0089656996
    pin_diameter = 7.646e-3
    n_rings = 2
  []
  [axial_binning]
    type = LayeredBin
    direction = z
    num_layers = 6
  []
  [avg_T]
    type = NekBinnedVolumeAverage
    bins = 'subchannel_binning axial_binning'
    field = temperature
  []
  [avg_p]
    type = NekBinnedVolumeAverage
    bins = 'subchannel_binning axial_binning'
    field = pressure
  []
  [avg_v]
    type = NekBinnedVolumeAverage
    bins = 'subchannel_binning axial_binning'
    field = velocity
  []
  [integral_T]
    type = NekBinnedVolumeIntegral
    bins = 'subchannel_binning axial_binning'
    field = temperature
  []
  [integral_p]
    type = NekBinnedVolumeIntegral
    bins = 'subchannel_binning axial_binning'
    field = pressure
  []
  [integral_v]
    type = NekBinnedVolumeIntegral
    bins = 'subchannel_binning axial_binning'
    field = velocity
  []
[]

[MultiApps]
  [subchannel]
    type = TransientMultiApp
    input_files = 'subchannel.i'
    execute_on = timestep_end
  []
[]

[Transfers]
  [uo1_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = avg_T
    to_multi_app = subchannel
    variable = avg_T
  []
  [uo2_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = avg_p
    to_multi_app = subchannel
    variable = avg_p
  []
  [uo3_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = avg_v
    to_multi_app = subchannel
    variable = avg_v
  []
  [uo4_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = integral_T
    to_multi_app = subchannel
    variable = integral_T
  []
  [uo5_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = integral_p
    to_multi_app = subchannel
    variable = integral_p
  []
  [uo6_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = integral_v
    to_multi_app = subchannel
    variable = integral_v
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

(test/tests/nek_standalone/ethier/nek.i)

[Mesh]
  type = NekRSMesh
  volume = true
  order = SECOND
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'ethier'
  output = 'pressure velocity temperature'

  # We omit the non-dimensional settings here in order to just extract the
  # non-dimensional solution as-is, without dimensionalizing it.
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  [heat_flux]
    type = NekHeatFluxIntegral
    boundary = '1'
  []

  # These postprocessors are just used to verify correct extraction of the
  # NekRS solution, because we can directly compare against the values printed
  # to stdout by NekRS
  [max_Vx]
    type = NodalExtremeValue
    variable = vel_x
    value_type = max
  []
  [min_Vx]
    type = NodalExtremeValue
    variable = vel_x
    value_type = min
  []
  [max_Vy]
    type = NodalExtremeValue
    variable = vel_y
    value_type = max
  []
  [min_Vy]
    type = NodalExtremeValue
    variable = vel_y
    value_type = min
  []
  [max_Vz]
    type = NodalExtremeValue
    variable = vel_z
    value_type = max
  []
  [min_Vz]
    type = NodalExtremeValue
    variable = vel_z
    value_type = min
  []
  [max_p]
    type = NodalExtremeValue
    variable = P
    value_type = max
  []
  [min_p]
    type = NodalExtremeValue
    variable = P
    value_type = min
  []
  [max_T]
    type = NodalExtremeValue
    variable = temp
    value_type = max
  []
  [min_T]
    type = NodalExtremeValue
    variable = temp
    value_type = min
  []
[]

[Outputs]
  csv = true
  exodus = true
  execute_on = 'final'
[]

(test/tests/userobjects/hexagonal_gap_layered/nek_axial.i)

gap_thickness = ${fparse 0.1 * 7.646e-3}

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'sfr_7pin'
  output = 'pressure'
[]

[AuxVariables]
  [gap_bins]
    family = MONOMIAL
    order = CONSTANT
  []
  [avg_p]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [gap_bins]
    type = SpatialUserObjectAux
    variable = gap_bins
    user_object = subchannel_binning
  []
  [avg_p]
    type = SpatialUserObjectAux
    variable = avg_p
    user_object = gap_avg
  []
[]

[UserObjects]
  [subchannel_binning]
    type = HexagonalSubchannelBin
    bundle_pitch = 0.02583914354890463
    pin_pitch = 0.0089656996
    pin_diameter = 7.646e-3
    n_rings = 2
  []
  [axial_binning]
    type = LayeredGapBin
    direction = z
    num_layers = 6
  []
  [gap_avg]
    type = NekBinnedPlaneAverage
    bins = 'subchannel_binning axial_binning'
    field = pressure
    gap_thickness = ${gap_thickness}
    map_space_by_qp = true
  []
  [gap_area]
    type = NekBinnedPlaneIntegral
    bins = 'subchannel_binning axial_binning'
    field = unity
    gap_thickness = ${gap_thickness}
    map_space_by_qp = true
  []
[]

[MultiApps]
  [subchannel]
    type = TransientMultiApp
    input_files = 'subchannel_axial.i'
    execute_on = timestep_end
  []
[]

[Transfers]
  [uo1_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = gap_avg
    to_multi_app = subchannel
    variable = gap_avg
  []
  [uo2_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = gap_area
    to_multi_app = subchannel
    variable = gap_area
  []
  [temp_to_sub]
    type = MultiAppGeneralFieldNearestLocationTransfer
    to_multi_app = subchannel
    variable = P
    source_variable = P
    search_value_conflicts = false
  []
[]

[VectorPostprocessors]
  [avg_p]
    type = SpatialUserObjectVectorPostprocessor
    userobject = gap_avg
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
  csv = true
[]

(test/tests/userobjects/subchannel_layered/user_component.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'sfr_7pin'
  output = 'velocity'
[]

[AuxVariables]
  [velocity_component]
  []

  # These are just for visualizing the average velocity component with Glyphs in paraview;
  # the result of the 'vol_avg' user object will be represented as a vector "uo_" with 3 components
  [uo_x]
    family = MONOMIAL
    order = CONSTANT
  []
  [uo_y]
    family = MONOMIAL
    order = CONSTANT
  []
  [uo_z]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [velocity_component] # actual velocity component computed directly from interpolated nekRS velocity fields
    type = ParsedAux
    variable = velocity_component
    expression = '(0.1*vel_x-0.2*vel_y+0.3*vel_z)/sqrt(0.1*0.1+0.2*0.2+0.3*0.3)'
    coupled_variables = 'vel_x vel_y vel_z'
    execute_on = 'timestep_end nonlinear linear'
  []
  [uo_x]
    type = NekSpatialBinComponentAux
    variable = uo_x
    user_object = vol_avg
    component = 0
  []
  [uo_y]
    type = NekSpatialBinComponentAux
    variable = uo_y
    user_object = vol_avg
    component = 1
  []
  [uo_z]
    type = NekSpatialBinComponentAux
    variable = uo_z
    user_object = vol_avg
    component = 2
  []
[]

[UserObjects]
  [subchannel_binning]
    type = HexagonalSubchannelBin
    bundle_pitch = 0.02583914354890463
    pin_pitch = 0.0089656996
    pin_diameter = 7.646e-3
    n_rings = 2
  []
  [axial_binning]
    type = LayeredBin
    direction = z
    num_layers = 6
  []
  [vol_avg]
    type = NekBinnedVolumeAverage
    bins = 'subchannel_binning axial_binning'
    field = velocity_component
    velocity_component = user
    velocity_direction = '0.1 -0.2 0.3'
  []
[]

[MultiApps]
  [subchannel]
    type = TransientMultiApp
    input_files = 'subchannel_b.i'
    execute_on = timestep_end
  []
[]

[Transfers]
  [uo1_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = vol_avg
    to_multi_app = subchannel
    variable = vol_avg
  []
  [uox_to_sub]
    type = MultiAppGeneralFieldNearestLocationTransfer
    source_variable = uo_x
    to_multi_app = subchannel
    variable = uo_x
    search_value_conflicts = false
  []
  [uoy_to_sub]
    type = MultiAppGeneralFieldNearestLocationTransfer
    source_variable = uo_y
    to_multi_app = subchannel
    variable = uo_y
    search_value_conflicts = false
  []
  [uoz_to_sub]
    type = MultiAppGeneralFieldNearestLocationTransfer
    source_variable = uo_z
    to_multi_app = subchannel
    variable = uo_z
    search_value_conflicts = false
  []
  [analytic_to_sub]
    type = MultiAppGeneralFieldNearestLocationTransfer
    source_variable = velocity_component
    to_multi_app = subchannel
    variable = velocity_component
    search_value_conflicts = false
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true

  # unhide and turn the number of time steps in the .par file to greater than 1 in order to see this
  # match the user object
  hide = 'velocity_component'
[]

(test/tests/userobjects/hexagonal_gap_layered/normals/nek.i)

gap_thickness = ${fparse 0.05 * 7.646e-3}

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'sfr_7pin'
  output = 'velocity'
[]

[AuxVariables]
  # These are just for visualizing the average velocity component with Glyphs in paraview;
  # the result of the 'vol_avg' user object will be represented as a vector "uo_" with 3 components
  [uo_x]
    family = MONOMIAL
    order = CONSTANT
  []
  [uo_y]
    family = MONOMIAL
    order = CONSTANT
  []
  [uo_z]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [uo_x]
    type = NekSpatialBinComponentAux
    variable = uo_x
    user_object = avg_velocity_component
    component = 0
  []
  [uo_y]
    type = NekSpatialBinComponentAux
    variable = uo_y
    user_object = avg_velocity_component
    component = 1
  []
  [uo_z]
    type = NekSpatialBinComponentAux
    variable = uo_z
    user_object = avg_velocity_component
    component = 2
  []
[]

[UserObjects]
  [subchannel_binning]
    type = HexagonalSubchannelGapBin
    bundle_pitch = 0.02583914354890463
    pin_pitch = 0.0089656996
    pin_diameter = 7.646e-3
    n_rings = 2
  []
  [axial_binning]
    type = LayeredBin
    direction = z
    num_layers = 6
  []
  [avg_velocity_component]
    type = NekBinnedPlaneAverage
    bins = 'subchannel_binning'
    field = velocity_component
    velocity_component = normal
    gap_thickness = ${gap_thickness}
    map_space_by_qp = true
  []
[]

[MultiApps]
  [subchannel]
    type = TransientMultiApp
    input_files = 'subchannel.i'
    execute_on = timestep_end
  []
[]

[Transfers]
  [uo1_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = avg_velocity_component
    to_multi_app = subchannel
    variable = avg_velocity_component
  []
  [uox_to_sub]
    type = MultiAppGeneralFieldNearestLocationTransfer
    to_multi_app = subchannel
    source_variable = uo_x
    variable = uo_x
    search_value_conflicts = false
  []
  [uoy_to_sub]
    type = MultiAppGeneralFieldNearestLocationTransfer
    to_multi_app = subchannel
    source_variable = uo_y
    variable = uo_y
    search_value_conflicts = false
  []
  [uoz_to_sub]
    type = MultiAppGeneralFieldNearestLocationTransfer
    to_multi_app = subchannel
    source_variable = uo_z
    variable = uo_z
    search_value_conflicts = false
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

(test/tests/nek_errors/insufficient_scratch/standalone/nek_standalone.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'brick'
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

(test/tests/userobjects/sideset_layered/side_average.i)

[GlobalParams]
  map_space_by_qp = true
  check_boundary_restricted = false
[]

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'sfr_7pin'
  output = 'temperature'
[]

[AuxVariables]
  [avg_T_duct_wall]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [avg_T_duct_wall]
    type = SpatialUserObjectAux
    variable = avg_T_duct_wall
    user_object = avg_T_duct_wall
    boundary = '2'
  []
[]

[UserObjects]
  [x]
    type = LayeredBin
    direction = x
    num_layers = 2
  []
  [y]
    type = LayeredBin
    direction = y
    num_layers = 2
  []
  [z]
    type = LayeredBin
    direction = z
    num_layers = 3
  []
  [avg_T_duct_wall]
    type = NekBinnedSideAverage
    bins = 'x y z'
    field = temperature
    boundary = '2'
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[VectorPostprocessors]
  [temp_duct]
    type = SpatialUserObjectVectorPostprocessor
    userobject = avg_T_duct_wall
  []
[]

[Outputs]
  csv = true
  exodus = true
[]

(test/tests/userobjects/gap/dimensional/nek.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'sfr_7pin'
  output = 'temperature pressure velocity'
[]

[AuxVariables]
  [area]
    family = MONOMIAL
    order = CONSTANT
  []
  [avg_T]
    family = MONOMIAL
    order = CONSTANT
  []
  [avg_p]
    family = MONOMIAL
    order = CONSTANT
  []
  [avg_v]
    family = MONOMIAL
    order = CONSTANT
  []
  [integral_T]
    family = MONOMIAL
    order = CONSTANT
  []
  [integral_p]
    family = MONOMIAL
    order = CONSTANT
  []
  [integral_v]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [area]
    type = SpatialUserObjectAux
    variable = area
    user_object = area
  []
  [avg_T]
    type = SpatialUserObjectAux
    variable = avg_T
    user_object = avg_T
  []
  [avg_p]
    type = SpatialUserObjectAux
    variable = avg_p
    user_object = avg_p
  []
  [avg_v]
    type = SpatialUserObjectAux
    variable = avg_v
    user_object = avg_v
  []
  [integral_T]
    type = SpatialUserObjectAux
    variable = integral_T
    user_object = integral_T
  []
  [integral_p]
    type = SpatialUserObjectAux
    variable = integral_p
    user_object = integral_p
  []
  [integral_v]
    type = SpatialUserObjectAux
    variable = integral_v
    user_object = integral_v
  []
[]

[UserObjects]
  [subchannel_binning]
    type = HexagonalSubchannelBin
    bundle_pitch = 0.02583914354890463
    pin_pitch = 0.0089656996
    pin_diameter = 7.646e-3
    n_rings = 2
  []
  [axial_binning]
    type = LayeredBin
    direction = z
    num_layers = 6
  []
  [area]
    type = NekBinnedVolumeIntegral
    bins = 'subchannel_binning axial_binning'
    field = unity
  []
  [avg_T]
    type = NekBinnedVolumeAverage
    bins = 'subchannel_binning axial_binning'
    field = temperature
  []
  [avg_p]
    type = NekBinnedVolumeAverage
    bins = 'subchannel_binning axial_binning'
    field = pressure
  []
  [avg_v]
    type = NekBinnedVolumeAverage
    bins = 'subchannel_binning axial_binning'
    field = velocity
  []
  [integral_T]
    type = NekBinnedVolumeIntegral
    bins = 'subchannel_binning axial_binning'
    field = temperature
  []
  [integral_p]
    type = NekBinnedVolumeIntegral
    bins = 'subchannel_binning axial_binning'
    field = pressure
  []
  [integral_v]
    type = NekBinnedVolumeIntegral
    bins = 'subchannel_binning axial_binning'
    field = velocity
  []
[]

[MultiApps]
  [subchannel]
    type = TransientMultiApp
    input_files = 'subchannel.i'
    execute_on = timestep_end
  []
[]

[Transfers]
  [uo1_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = avg_T
    to_multi_app = subchannel
    variable = avg_T
  []
  [uo2_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = avg_p
    to_multi_app = subchannel
    variable = avg_p
  []
  [uo3_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = avg_v
    to_multi_app = subchannel
    variable = avg_v
  []
  [uo4_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = integral_T
    to_multi_app = subchannel
    variable = integral_T
  []
  [uo5_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = integral_p
    to_multi_app = subchannel
    variable = integral_p
  []
  [uo6_to_sub]
    type = MultiAppGeneralFieldUserObjectTransfer
    source_user_object = integral_v
    to_multi_app = subchannel
    variable = integral_v
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
  file_base = nek_dim
[]

(test/tests/nek_standalone/lowMach/nek_boundary.i)

[Mesh]
  type = NekRSMesh
  boundary = '1'
  order = SECOND
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'lowMach'
  output = 'pressure velocity temperature'

  # We omit the non-dimensional settings here in order to just extract the
  # non-dimensional solution as-is, without dimensionalizing it.
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  [max_T_side]
    type = NekSideExtremeValue
    field = temperature
    value_type = max
    boundary = '1'
  []
  [max_T_side_output]
    type = NodalExtremeValue
    variable = temp
    value_type = max
  []
  [max_T_side_diff]
    type = DifferencePostprocessor
    value1 = max_T_side
    value2 = max_T_side_output
  []

  [min_T_side]
    type = NekSideExtremeValue
    field = temperature
    value_type = min
    boundary = '1'
  []
  [min_T_side_output]
    type = NodalExtremeValue
    variable = temp
    value_type = min
  []
  [min_T_side_diff]
    type = DifferencePostprocessor
    value1 = min_T_side
    value2 = min_T_side_output
  []

  [max_Vx_side]
    type = NekSideExtremeValue
    field = velocity_x
    value_type = max
    boundary = '1'
  []
  [max_Vx_side_output]
    type = NodalExtremeValue
    variable = vel_x
    value_type = max
  []
  [max_Vx_side_diff]
    type = DifferencePostprocessor
    value1 = max_Vx_side
    value2 = max_Vx_side_output
  []

  [min_Vx_side]
    type = NekSideExtremeValue
    field = velocity_x
    value_type = min
    boundary = '1'
  []
  [min_Vx_side_output]
    type = NodalExtremeValue
    variable = vel_x
    value_type = min
  []
  [min_Vx_side_diff]
    type = DifferencePostprocessor
    value1 = min_Vx_side
    value2 = min_Vx_side_output
  []

  [max_p_side]
    type = NekSideExtremeValue
    field = pressure
    value_type = max
    boundary = '1'
  []
  [max_p_side_output]
    type = NodalExtremeValue
    variable = P
    value_type = max
  []
  [min_p_side_diff]
    type = DifferencePostprocessor
    value1 = min_p_side
    value2 = min_p_side_output
  []

  [min_p_side]
    type = NekSideExtremeValue
    field = pressure
    value_type = min
    boundary = '1'
  []
  [min_p_side_output]
    type = NodalExtremeValue
    variable = P
    value_type = min
  []
  [max_p_side_diff]
    type = DifferencePostprocessor
    value1 = max_p_side
    value2 = max_p_side_output
  []

  [avg_T_side]
    type = NekSideAverage
    field = temperature
    boundary = '1'
  []
  [avg_T_side_output]
    type = ElementAverageValue
    variable = temp
  []
  [avg_T_side_diff]
    type = DifferencePostprocessor
    value1 = avg_T_side
    value2 = avg_T_side_output
  []

  [avg_Vx_side]
    type = NekSideAverage
    field = velocity_x
    boundary = '1'
  []
  [avg_Vx_side_output]
    type = ElementAverageValue
    variable = vel_x
  []
  [avg_Vx_side_diff]
    type = DifferencePostprocessor
    value1 = avg_Vx_side
    value2 = avg_Vx_side_output
  []

  [avg_p_side]
    type = NekSideAverage
    field = pressure
    boundary = '1'
  []
  [avg_p_side_output]
    type = ElementAverageValue
    variable = P
  []
  [avg_p_side_diff]
    type = DifferencePostprocessor
    value1 = avg_p_side
    value2 = avg_p_side_output
  []
[]

[Outputs]
  csv = true
  exodus = true
  execute_on = 'final'

  hide = 'max_Vx_side max_Vx_side_output max_p_side max_p_side_output min_Vx_side min_Vx_side_output min_p_side min_p_side_output avg_Vx_side avg_Vx_side_output avg_p_side avg_p_side_output max_T_side max_T_side_output min_T_side min_T_side_output avg_T_side avg_T_side_output'
[]

(test/tests/userobjects/sideset_layered/invalid_boundary.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSStandaloneProblem
  casename = 'sfr_7pin'
  output = 'temperature'
[]

[UserObjects]
  [x]
    type = LayeredBin
    direction = x
    num_layers = 3
  []
  [vol_avg]
    type = NekBinnedSideIntegral
    bins = 'x'
    field = temperature
    boundary = '5'
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

(test/tests/nek_errors/invalid_scalar/nek_uo.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'pyramid'
[]

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[UserObjects]
  [subchannel_binning]
    type = HexagonalSubchannelBin
    bundle_pitch = 10
    pin_pitch = 1
    pin_diameter = 1
    n_rings = 1
  []
  [vol_avg]
    type = NekBinnedVolumeAverage
    bins = 'subchannel_binning'
  []
[]

(test/tests/userobjects/layered_layered/3d.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'brick'
  output = 'pressure'

  nondimensional = true
  L_ref = 2.0
  U_ref = 1.0
  rho_0 = 834.5
  Cp_0 = 1228.0
  T_ref = 573.0
  dT_ref = 10.0
[]

[Mesh]
  type = NekRSMesh
  volume = true
  scaling = 2.0
[]

[AuxVariables]
  [uo]
    family = MONOMIAL
    order = CONSTANT
  []
[]

[AuxKernels]
  [uo]
    type = SpatialUserObjectAux
    variable = uo
    user_object = vol_integral
  []
[]

[UserObjects]
  [x_bins]
    type = LayeredBin
    direction = x
    num_layers = 3
  []
  [y_bins]
    type = LayeredBin
    direction = y
    num_layers = 3
  []
  [z_bins]
    type = LayeredBin
    direction = z
    num_layers = 4
  []
  [vol_integral]
    type = NekBinnedVolumeIntegral
    bins = 'x_bins y_bins z_bins'
    field = pressure
  []
[]

[VectorPostprocessors]
  # from_uo gives exactly the same results as manually specifying the points in 'manually_provided'
  [from_uo]
    type = SpatialUserObjectVectorPostprocessor
    userobject = vol_integral
  []
  [manually_provided]
    type = SpatialUserObjectVectorPostprocessor
    userobject = vol_integral
    points = '-0.66666667 -0.66666667 -3.0
              -0.66666667 -0.66666667 -1.0
              -0.66666667 -0.66666667  1.0
              -0.66666667 -0.66666667  3.0

              -0.66666667 0.0         -3.0
              -0.66666667 0.0         -1.0
              -0.66666667 0.0          1.0
              -0.66666667 0.0          3.0

              -0.66666667 0.66666667 -3.0
              -0.66666667 0.66666667 -1.0
              -0.66666667 0.66666667  1.0
              -0.66666667 0.66666667  3.0

               0.0       -0.66666667 -3.0
               0.0       -0.66666667 -1.0
               0.0       -0.66666667  1.0
               0.0       -0.66666667  3.0

               0.0        0.0        -3.0
               0.0        0.0        -1.0
               0.0        0.0         1.0
               0.0        0.0         3.0

               0.0        0.66666667 -3.0
               0.0        0.66666667 -1.0
               0.0        0.66666667  1.0
               0.0        0.66666667  3.0

               0.66666667 -0.66666667 -3.0
               0.66666667 -0.66666667 -1.0
               0.66666667 -0.66666667  1.0
               0.66666667 -0.66666667  3.0

               0.66666667 0.0         -3.0
               0.66666667 0.0         -1.0
               0.66666667 0.0          1.0
               0.66666667 0.0          3.0

               0.66666667 0.66666667 -3.0
               0.66666667 0.66666667 -1.0
               0.66666667 0.66666667  1.0
               0.66666667 0.66666667  3.0'
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  csv = true
  exodus = true
  execute_on = 'final'
[]

(test/tests/nek_errors/invalid_field/nek.i)

[Problem]
  type = NekRSStandaloneProblem
  casename = 'pyramid'
[]

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  [max_T]
    type = NekVolumeExtremeValue
    field = temperature
  []
[]

Outputting the NekRS Solution
Postprocessing the NekRS Solution
Outputting the Scratch Array
Input Parameters
Input Files