NekVolumeIntegral

Integral of a field over the NekRS volume mesh

Description

This postprocessor computes the integral of a specified field over the volume of the NekRS mesh,

$var element = document.getElementById("moose-equation-74b16bb6-62bc-4646-a142-00463a6ec292");katex.render("p=\\int_{\\Omega}(v-f)\\ d\\Omega", element, {displayMode:true,throwOnError:false});$

where $var element = document.getElementById("moose-equation-bfa5eacd-ea1d-4b9a-891f-d74e5c1517fe");katex.render("p", element, {displayMode:false,throwOnError:false});$ is the value of the postprocessor, $var element = document.getElementById("moose-equation-66b35fbc-892b-4d93-acb2-43f848a84182");katex.render("\\Omega", element, {displayMode:false,throwOnError:false});$ is the volume of the nekrs mesh, $var element = document.getElementById("moose-equation-1eb15b24-52dd-4f80-8ba6-798472e75ff0");katex.render("v", element, {displayMode:false,throwOnError:false});$ is the specified field, and $var element = document.getElementById("moose-equation-9545cf76-08ae-4672-99eb-ad4cd3d7a999");katex.render("f", element, {displayMode:false,throwOnError:false});$ is an optional function provided by the function parameter. To be clear, this postprocessor is not evaluated on the NekRSMesh mesh mirror, but instead on the mesh actually used for computation in NekRS.

The field is specified with the field parameter, which may be one of:

pressure: pressure
temperature: temperature
velocity: magnitude of velocity
velocity_x: $var element = document.getElementById("moose-equation-f157a885-f5ff-43fb-9fb7-0c07f05b7588");katex.render("x", element, {displayMode:false,throwOnError:false});$ -component of velocity
velocity_y: $var element = document.getElementById("moose-equation-486cacfc-0425-4fe8-8a4e-924d91816aa9");katex.render("y", element, {displayMode:false,throwOnError:false});$ -component of velocity
velocity_z: $var element = document.getElementById("moose-equation-74d346a1-3fd6-4ef3-bd0a-1cef32bf245f");katex.render("z", element, {displayMode:false,throwOnError:false});$ -component of velocity
velocity_x_squared: $var element = document.getElementById("moose-equation-b0668c0a-864b-49c9-af30-f6750fab1dcc");katex.render("x", element, {displayMode:false,throwOnError:false});$ -component of velocity, squared
velocity_y_squared: $var element = document.getElementById("moose-equation-415ae562-cc59-41a3-8823-d744aa549514");katex.render("y", element, {displayMode:false,throwOnError:false});$ -component of velocity, squared
velocity_z_squared: $var element = document.getElementById("moose-equation-60753509-96ab-4093-9a7e-4069a100f954");katex.render("z", element, {displayMode:false,throwOnError:false});$ -component of velocity, squared
velocity_component: velocity vector dotted against another vector
scalar01: first non-temperature passive scalar
scalar02: second non-temperature passive scalar
scalar03: third non-temperature passive scalar
unity: the value 1.0
zero: the value 0.0 (this is typically used when combining with a function shift, to only apply the operation to the function)

Setting field = unity is equivalent to computing the volume.

If running NekRS in non-dimensional form (and you have indicated the appropriate nondimensional scales with the Dimensionalize sub-block for the [Problem]) then the value of this object is shown in dimensional units.

The function, like all quantities in Cardinal input files, is given in dimensional form. If the function depends on time, that time is either the time of the start of the next timestep (if using the default of execute_on = timestep_end), or the time of the current timestep (if using execute_on = timestep_begin).

Example Input Syntax

As an example, the following code snippet will evaluate the volume and volume-integreated temperature, pressure, and velocity magnitude on the volume of the NekRS mesh.

[Postprocessors<<<{"href": "../../syntax/Postprocessors/index.html"}>>>]
  [usrwrk00]
    type = NekVolumeIntegral<<<{"description": "Integral of a field over the NekRS volume mesh", "href": "NekVolumeIntegral.html"}>>>
    field<<<{"description": "Field to apply this object to"}>>> = usrwrk00
  []
  [usrwrk01]
    type = NekVolumeIntegral<<<{"description": "Integral of a field over the NekRS volume mesh", "href": "NekVolumeIntegral.html"}>>>
    field<<<{"description": "Field to apply this object to"}>>> = usrwrk01
  []
  [usrwrk02]
    type = NekVolumeIntegral<<<{"description": "Integral of a field over the NekRS volume mesh", "href": "NekVolumeIntegral.html"}>>>
    field<<<{"description": "Field to apply this object to"}>>> = usrwrk02
  []
  [unity_int]
    type = NekVolumeIntegral<<<{"description": "Integral of a field over the NekRS volume mesh", "href": "NekVolumeIntegral.html"}>>>
    field<<<{"description": "Field to apply this object to"}>>> = unity
  []
  [unity_intf]
    type = NekVolumeIntegral<<<{"description": "Integral of a field over the NekRS volume mesh", "href": "NekVolumeIntegral.html"}>>>
    field<<<{"description": "Field to apply this object to"}>>> = unity
    function<<<{"description": "Function to shift the field by, when applying this object. For example, if 'field = temperature', using this parameter will apply this object to the new combined quantity 'temperature - f', where 'f' is this shifting function."}>>> = '3.0'
  []
  [unity_zero_field]
    # should give same value as unity_int
    type = NekVolumeIntegral<<<{"description": "Integral of a field over the NekRS volume mesh", "href": "NekVolumeIntegral.html"}>>>
    field<<<{"description": "Field to apply this object to"}>>> = zero
    function<<<{"description": "Function to shift the field by, when applying this object. For example, if 'field = temperature', using this parameter will apply this object to the new combined quantity 'temperature - f', where 'f' is this shifting function."}>>> = '-1'
  []
  [temp_int]
    type = NekVolumeIntegral<<<{"description": "Integral of a field over the NekRS volume mesh", "href": "NekVolumeIntegral.html"}>>>
    field<<<{"description": "Field to apply this object to"}>>> = temperature
  []
  [s01_int]
    type = NekVolumeIntegral<<<{"description": "Integral of a field over the NekRS volume mesh", "href": "NekVolumeIntegral.html"}>>>
    field<<<{"description": "Field to apply this object to"}>>> = scalar01
  []
  [s01_intf]
    type = NekVolumeIntegral<<<{"description": "Integral of a field over the NekRS volume mesh", "href": "NekVolumeIntegral.html"}>>>
    field<<<{"description": "Field to apply this object to"}>>> = scalar01
    function<<<{"description": "Function to shift the field by, when applying this object. For example, if 'field = temperature', using this parameter will apply this object to the new combined quantity 'temperature - f', where 'f' is this shifting function."}>>> = f
    execute_on<<<{"description": "The list of flag(s) indicating when this object should be executed. For a description of each flag, see https://mooseframework.inl.gov/source/interfaces/SetupInterface.html."}>>> = timestep_begin
  []
  [s02_int]
    type = NekVolumeIntegral<<<{"description": "Integral of a field over the NekRS volume mesh", "href": "NekVolumeIntegral.html"}>>>
    field<<<{"description": "Field to apply this object to"}>>> = scalar02
  []
  [s03_int]
    type = NekVolumeIntegral<<<{"description": "Integral of a field over the NekRS volume mesh", "href": "NekVolumeIntegral.html"}>>>
    field<<<{"description": "Field to apply this object to"}>>> = scalar03
  []
  [pressure_int]
    type = NekVolumeIntegral<<<{"description": "Integral of a field over the NekRS volume mesh", "href": "NekVolumeIntegral.html"}>>>
    field<<<{"description": "Field to apply this object to"}>>> = pressure
  []
  [velocity_int]
    type = NekVolumeIntegral<<<{"description": "Integral of a field over the NekRS volume mesh", "href": "NekVolumeIntegral.html"}>>>
    field<<<{"description": "Field to apply this object to"}>>> = velocity
  []
  [x_velocity_int]
    type = NekVolumeIntegral<<<{"description": "Integral of a field over the NekRS volume mesh", "href": "NekVolumeIntegral.html"}>>>
    field<<<{"description": "Field to apply this object to"}>>> = velocity_x
  []
  [y_velocity_int]
    type = NekVolumeIntegral<<<{"description": "Integral of a field over the NekRS volume mesh", "href": "NekVolumeIntegral.html"}>>>
    field<<<{"description": "Field to apply this object to"}>>> = velocity_y
  []
  [z_velocity_int]
    type = NekVolumeIntegral<<<{"description": "Integral of a field over the NekRS volume mesh", "href": "NekVolumeIntegral.html"}>>>
    field<<<{"description": "Field to apply this object to"}>>> = velocity_z
  []
  [x2_velocity_int]
    type = NekVolumeIntegral<<<{"description": "Integral of a field over the NekRS volume mesh", "href": "NekVolumeIntegral.html"}>>>
    field<<<{"description": "Field to apply this object to"}>>> = velocity_x_squared
  []
  [y2_velocity_int]
    type = NekVolumeIntegral<<<{"description": "Integral of a field over the NekRS volume mesh", "href": "NekVolumeIntegral.html"}>>>
    field<<<{"description": "Field to apply this object to"}>>> = velocity_y_squared
  []
  [z2_velocity_int]
    type = NekVolumeIntegral<<<{"description": "Integral of a field over the NekRS volume mesh", "href": "NekVolumeIntegral.html"}>>>
    field<<<{"description": "Field to apply this object to"}>>> = velocity_z_squared
  []
  [velocity_component]
    type = NekVolumeIntegral<<<{"description": "Integral of a field over the NekRS volume mesh", "href": "NekVolumeIntegral.html"}>>>
    field<<<{"description": "Field to apply this object to"}>>> = velocity_component
    velocity_direction<<<{"description": "Unit vector to dot with velocity, for 'field = velocity_component'. For example, velocity_direction = '1 1 0' will get the velocity dotted with (1/sqrt(2), 1/sqrt(2), 0)."}>>> = '0.1 0.2 -0.3'
  []
[]

Input Parameters

fieldField to apply this object to
C++ Type:MooseEnum
Options:velocity_x, velocity_y, velocity_z, velocity, velocity_component, velocity_x_squared, velocity_y_squared, velocity_z_squared, temperature, pressure, scalar01, scalar02, scalar03, unity, usrwrk00, usrwrk01, usrwrk02, zero
Controllable:No
Description:Field to apply this object to

Required Parameters

functionFunction to shift the field by, when applying this object. For example, if 'field = temperature', using this parameter will apply this object to the new combined quantity 'temperature - f', where 'f' is this shifting function.
C++ Type:FunctionName
Unit:(no unit assumed)
Controllable:No
Description:Function to shift the field by, when applying this object. For example, if 'field = temperature', using this parameter will apply this object to the new combined quantity 'temperature - f', where 'f' is this shifting function.
meshallNekRS mesh to compute postprocessor on
Default:all
C++ Type:MooseEnum
Options:fluid, solid, all
Controllable:No
Description:NekRS mesh to compute postprocessor on
velocity_componentuserDirection in which to evaluate velocity when 'field = velocity_component.' Options: user (you then need to specify a direction with 'velocity_direction'); normal
Default:user
C++ Type:MooseEnum
Options:normal, user
Controllable:No
Description:Direction in which to evaluate velocity when 'field = velocity_component.' Options: user (you then need to specify a direction with 'velocity_direction'); normal
velocity_directionUnit vector to dot with velocity, for 'field = velocity_component'. For example, velocity_direction = '1 1 0' will get the velocity dotted with (1/sqrt(2), 1/sqrt(2), 0).
C++ Type:libMesh::Point
Controllable:No
Description:Unit vector to dot with velocity, for 'field = velocity_component'. For example, velocity_direction = '1 1 0' will get the velocity dotted with (1/sqrt(2), 1/sqrt(2), 0).

Optional Parameters

allow_duplicate_execution_on_initialFalseIn the case where this UserObject is depended upon by an initial condition, allow it to be executed twice during the initial setup (once before the IC and again after mesh adaptivity (if applicable).
Default:False
C++ Type:bool
Controllable:No
Description:In the case where this UserObject is depended upon by an initial condition, allow it to be executed twice during the initial setup (once before the IC and again after mesh adaptivity (if applicable).
execute_onTIMESTEP_ENDThe list of flag(s) indicating when this object should be executed. For a description of each flag, see https://mooseframework.inl.gov/source/interfaces/SetupInterface.html.
Default:TIMESTEP_END
C++ Type:ExecFlagEnum
Options:XFEM_MARK, NONE, INITIAL, LINEAR, LINEAR_CONVERGENCE, NONLINEAR, NONLINEAR_CONVERGENCE, POSTCHECK, TIMESTEP_END, TIMESTEP_BEGIN, MULTIAPP_FIXED_POINT_END, MULTIAPP_FIXED_POINT_BEGIN, MULTIAPP_FIXED_POINT_CONVERGENCE, MULTISYSTEM_FIXED_POINT_ITERATION_END, FINAL, CUSTOM, TRANSFER
Controllable:No
Description:The list of flag(s) indicating when this object should be executed. For a description of each flag, see https://mooseframework.inl.gov/source/interfaces/SetupInterface.html.
execution_order_group0Execution order groups are executed in increasing order (e.g., the lowest number is executed first). Note that negative group numbers may be used to execute groups before the default (0) group. Please refer to the user object documentation for ordering of user object execution within a group.
Default:0
C++ Type:int
Controllable:No
Description:Execution order groups are executed in increasing order (e.g., the lowest number is executed first). Note that negative group numbers may be used to execute groups before the default (0) group. Please refer to the user object documentation for ordering of user object execution within a group.
force_postauxFalseForces the UserObject to be executed in POSTAUX
Default:False
C++ Type:bool
Controllable:No
Description:Forces the UserObject to be executed in POSTAUX
force_preauxFalseForces the UserObject to be executed in PREAUX
Default:False
C++ Type:bool
Controllable:No
Description:Forces the UserObject to be executed in PREAUX
force_preicFalseForces the UserObject to be executed in PREIC during initial setup
Default:False
C++ Type:bool
Controllable:No
Description:Forces the UserObject to be executed in PREIC during initial setup

Execution Scheduling 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.
enableTrueSet the enabled status of the MooseObject.
Default:True
C++ Type:bool
Controllable:Yes
Description:Set the enabled status of the MooseObject.
outputsVector of output names where you would like to restrict the output of variables(s) associated with this object
C++ Type:std::vector<OutputName>
Controllable:No
Description:Vector of output names where you would like to restrict the output of variables(s) associated with this object
use_displaced_meshFalseWhether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.
Default:False
C++ Type:bool
Controllable:No
Description:Whether or not this object should use the displaced mesh for computation. Note that in the case this is true but no displacements are provided in the Mesh block the undisplaced mesh will still be used.

Advanced Parameters

prop_getter_suffixAn optional suffix parameter that can be appended to any attempt to retrieve/get material properties. The suffix will be prepended with a '_' character.
C++ Type:MaterialPropertyName
Unit:(no unit assumed)
Controllable:No
Description:An optional suffix parameter that can be appended to any attempt to retrieve/get material properties. The suffix will be prepended with a '_' character.
use_interpolated_stateFalseFor the old and older state use projected material properties interpolated at the quadrature points. To set up projection use the ProjectedStatefulMaterialStorageAction.
Default:False
C++ Type:bool
Controllable:No
Description:For the old and older state use projected material properties interpolated at the quadrature points. To set up projection use the ProjectedStatefulMaterialStorageAction.

Material Property Retrieval Parameters

Input Files

(test/tests/userobjects/subchannel_layered/nek.i)
(test/tests/cht/sfr_pincell/nek_vpp.i)
(test/tests/deformation/nek_standalone/nek.i)
(test/tests/nek_standalone/lowMach/nek.i)
(test/tests/nek_standalone/conj_ht/nek.i)
(test/tests/cht/multi_cht/nek.i)
(test/tests/conduction/identical_volume/cube/nek.i)
(test/tests/deformation/nek_standalone/nek_boundary.i)
(test/tests/postprocessors/nek_function_norm/nek.i)
(test/tests/postprocessors/nek_volume_integral/nek_no_temp.i)
(test/tests/nek_standalone/channel/nek.i)
(test/tests/conduction/nonidentical_volume/nondimensional/nek.i)
(test/tests/postprocessors/nek_volume_integral/nondimensional.i)
(test/tests/cht/sfr_pincell/nek.i)
(test/tests/userobjects/layered_layered/nek.i)
(test/tests/cht/nondimensional/nek.i)
(test/tests/postprocessors/nek_volume_integral/nek.i)

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

[Problem]
  type = NekRSProblem
  casename = 'pyramid'
  n_usrwrk_slots = 4

  [FieldTransfers]
    [usrwrk00]
      type = NekVolumetricData
      usrwrk_slot = 0
      direction = to_nek
    []
    [usrwrk01]
      type = NekVolumetricData
      usrwrk_slot = 1
      direction = to_nek
    []
    [usrwrk02]
      type = NekVolumetricData
      usrwrk_slot = 2
      direction = to_nek
    []
  []
[]

[AuxKernels]
  [usrwrk00]
    type = FunctionAux
    variable = usrwrk00
    function = usrwrk00
    execute_on = timestep_begin
  []
  [usrwrk01]
    type = FunctionAux
    variable = usrwrk01
    function = usrwrk01
    execute_on = timestep_begin
  []
  [usrwrk02]
    type = FunctionAux
    variable = usrwrk02
    function = usrwrk02
    execute_on = timestep_begin
  []
[]

[Functions]
  [usrwrk00]
    type = ParsedFunction
    expression = 'exp(x)+1'
  []
  [usrwrk01]
    type = ParsedFunction
    expression = 'exp(y)+1'
  []
  [usrwrk02]
    type = ParsedFunction
    expression = 'exp(z)+1'
  []
[]

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

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Functions]
  [f]
    type = ParsedFunction
    expression = 'x+y+z+100*t'
  []
[]

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

[Postprocessors]
  [usrwrk00]
    type = NekVolumeIntegral
    field = usrwrk00
  []
  [usrwrk01]
    type = NekVolumeIntegral
    field = usrwrk01
  []
  [usrwrk02]
    type = NekVolumeIntegral
    field = usrwrk02
  []
  [unity_int]
    type = NekVolumeIntegral
    field = unity
  []
  [unity_intf]
    type = NekVolumeIntegral
    field = unity
    function = '3.0'
  []
  [unity_zero_field] # should give same value as unity_int
    type = NekVolumeIntegral
    field = zero
    function = '-1'
  []
  [temp_int]
    type = NekVolumeIntegral
    field = temperature
  []
  [s01_int]
    type = NekVolumeIntegral
    field = scalar01
  []
  [s01_intf]
    type = NekVolumeIntegral
    field = scalar01
    function = f
    execute_on = timestep_begin
  []
  [s02_int]
    type = NekVolumeIntegral
    field = scalar02
  []
  [s03_int]
    type = NekVolumeIntegral
    field = scalar03
  []
  [pressure_int]
    type = NekVolumeIntegral
    field = pressure
  []
  [velocity_int]
    type = NekVolumeIntegral
    field = velocity
  []
  [x_velocity_int]
    type = NekVolumeIntegral
    field = velocity_x
  []
  [y_velocity_int]
    type = NekVolumeIntegral
    field = velocity_y
  []
  [z_velocity_int]
    type = NekVolumeIntegral
    field = velocity_z
  []
  [x2_velocity_int]
    type = NekVolumeIntegral
    field = velocity_x_squared
  []
  [y2_velocity_int]
    type = NekVolumeIntegral
    field = velocity_y_squared
  []
  [z2_velocity_int]
    type = NekVolumeIntegral
    field = velocity_z_squared
  []
  [velocity_component]
    type = NekVolumeIntegral
    field = velocity_component
    velocity_direction = '0.1 0.2 -0.3'
  []
[]

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

[Mesh]
  type = NekRSMesh
  volume = true
[]

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

[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
  []
  [vol_avg]
    type = NekBinnedVolumeAverage
    bins = 'subchannel_binning axial_binning'
    field = temperature
  []
  [vol_integral]
    type = NekBinnedVolumeIntegral
    bins = 'subchannel_binning axial_binning'
    field = unity
  []
  [axial_binning]
    type = LayeredBin
    direction = z
    num_layers = 6
  []

  [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
[]

(test/tests/cht/sfr_pincell/nek_vpp.i)

[Problem]
  type = NekRSProblem
  casename = 'sfr_pin'
  n_usrwrk_slots = 1

  [FieldTransfers]
    [avg_flux]
      type = NekBoundaryFlux
      direction = to_nek
      usrwrk_slot = 0
      postprocessor_to_conserve = flux_integral
      conserve_flux_by_sideset = true
    []
    [temp]
      type = NekFieldVariable
      field = temperature
      direction = from_nek
    []
  []
[]

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

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  [nek_flux]
    type = NekHeatFluxIntegral
    boundary = '1'
  []
  [average_inlet_T]
    type = NekSideAverage
    field = temperature
    boundary = '3'
    execute_on = initial
  []
  [average_outlet_T]
    type = NekSideAverage
    field = temperature
    boundary = '4'
  []
  [dT]
    type = DifferencePostprocessor
    value1 = average_outlet_T
    value2 = average_inlet_T
  []
  [inlet_mdot]
    type = NekMassFluxWeightedSideIntegral
    field = unity
    boundary = '3'
    execute_on = initial
  []

  # postprocessors for comparing against non-dimensional version in ../nondimensional
  # --> uncomment in order to get the reference values that the nondimensional boundary coupling
  #     was verified against
  #
  # # side integral
  # [area_1]
  #   type = NekSideIntegral
  #   field = unity
  #   boundary = '1'
  # []
  # [pressure_1]
  #   type = NekSideIntegral
  #   field = pressure
  #   boundary = '1'
  # []
  # [temperature_1]
  #   type = NekSideIntegral
  #   field = temperature
  #   boundary = '1'
  # []

  # # side average
  # [avg_area_1]
  #   type = NekSideAverage
  #   field = unity
  #   boundary = '1'
  # []
  # [avg_pressure_1]
  #   type = NekSideAverage
  #   field = pressure
  #   boundary = '1'
  # []
  # [avg_temperature_1]
  #   type = NekSideAverage
  #   field = temperature
  #   boundary = '1'
  # []

  # # volume integral
  # [volume]
  #   type = NekVolumeIntegral
  #   field = unity
  # []
  # [pressure_vol]
  #   type = NekVolumeIntegral
  #   field = pressure
  # []
  # [temperature_vol]
  #   type = NekVolumeIntegral
  #   field = temperature
  # []

  # # volume average
  # [avg_volume]
  #   type = NekVolumeAverage
  #   field = unity
  # []
  # [avg_pressure_vol]
  #   type = NekVolumeAverage
  #   field = pressure
  # []
  # [avg_temperature_vol]
  #   type = NekVolumeAverage
  #   field = temperature
  # []

  # # heat flux integral
  # [nek_flux]
  #   type = NekHeatFluxIntegral
  #   boundary = '1'
  # []

  # # mass flux weighted integral
  # [inlet_mdot]
  #   type = NekMassFluxWeightedSideIntegral
  #   field = unity
  #   boundary = '3'
  #   execute_on = initial
  # []
  # [outlet_T]
  #   type = NekMassFluxWeightedSideIntegral
  #   field = temperature
  #   boundary = '4'
  # []
  # [inlet_P]
  #   type = NekMassFluxWeightedSideIntegral
  #   field = pressure
  #   boundary = '4'
  # []

  # # mass flux weighted integral
  # [inlet_mdot_avg]
  #   type = NekMassFluxWeightedSideAverage
  #   field = unity
  #   boundary = '3'
  #   execute_on = initial
  # []
  # [outlet_T_avg]
  #   type = NekMassFluxWeightedSideAverage
  #   field = temperature
  #   boundary = '4'
  # []
  # [inlet_P_avg]
  #   type = NekMassFluxWeightedSideAverage
  #   field = pressure
  #   boundary = '4'
  # []

  # # extreme value postprocessors - VOLUME
  # [max_T]
  #   type = NekVolumeExtremeValue
  #   field = temperature
  #   value_type = max
  # []
  # [min_T]
  #   type = NekVolumeExtremeValue
  #   field = temperature
  #   value_type = min
  # []
  # [max_p]
  #   type = NekVolumeExtremeValue
  #   field = pressure
  #   value_type = max
  # []
  # [min_p]
  #   type = NekVolumeExtremeValue
  #   field = pressure
  #   value_type = min
  # []
  # [max_1]
  #   type = NekVolumeExtremeValue
  #   field = unity
  #   value_type = max
  # []
  # [min_1]
  #   type = NekVolumeExtremeValue
  #   field = unity
  #   value_type = min
  # []

  # # extreme value postprocessors - SIDE
  # [max_T_out]
  #   type = NekSideExtremeValue
  #   field = temperature
  #   boundary = '4'
  #   value_type = max
  # []
  # [min_T_out]
  #   type = NekSideExtremeValue
  #   field = temperature
  #   boundary = '4'
  #   value_type = min
  # []
  # [max_p_in]
  #   type = NekSideExtremeValue
  #   field = pressure
  #   boundary = '3'
  #   value_type = max
  # []
  # [min_p_in]
  #   type = NekSideExtremeValue
  #   field = pressure
  #   boundary = '3'
  #   value_type = min
  # []
  # [max_1_in]
  #   type = NekSideExtremeValue
  #   field = unity
  #   boundary = '3'
  #   value_type = max
  # []
  # [min_1_in]
  #   type = NekSideExtremeValue
  #   field = unity
  #   boundary = '3'
  #   value_type = min
  # []
[]

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

  [screen]
    type = Console
    hide = 'average_inlet_T average_outlet_T'
  []
[]

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

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSProblem
  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/nek_standalone/lowMach/nek.i)

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

[Problem]
  type = NekRSProblem
  casename = 'lowMach'

  [FieldTransfers]
    [temp]
      type = NekFieldVariable
      direction = from_nek
      field = temperature
    []
    [P]
      type = NekFieldVariable
      direction = from_nek
      field = pressure
    []
    [vel_x]
      type = NekFieldVariable
      direction = from_nek
      field = velocity_x
    []
    [vel_y]
      type = NekFieldVariable
      direction = from_nek
      field = velocity_y
    []
    [vel_z]
      type = NekFieldVariable
      direction = from_nek
      field = velocity_z
    []
  []
[]

[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/conj_ht/nek.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSProblem
  casename = 'conj_ht'
[]

[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/cht/multi_cht/nek.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSProblem
  casename = 'conj_ht'

  [FieldTransfers]
    [temp]
      type = NekFieldVariable
      direction = from_nek
      field = temperature
    []
    [P]
      type = NekFieldVariable
      direction = from_nek
      field = pressure
    []
    [scalar01]
      type = NekFieldVariable
      direction = from_nek
    []
  []
[]

[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/conduction/identical_volume/cube/nek.i)

[Problem]
  type = NekRSProblem
  casename = 'cube'
  n_usrwrk_slots = 2

  [FieldTransfers]
    [heat_source]
      type = NekVolumetricSource
      direction = to_nek
      postprocessor_to_conserve = source_integral
      usrwrk_slot = 0
      normalization_abs_tol = 1e-7
    []
    [temp]
      type = NekFieldVariable
      field = temperature
      direction = from_nek
    []
  []
[]

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

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  [max_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = max
  []
  [avg_T_volume]
    type = NekVolumeIntegral
    field = temperature
  []
  [avg_T_back]
    type = NekSideAverage
    field = temperature
    boundary = '6'
  []
[]

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

  # for this tests purposes, we only want to check temperature. This keeps the gold file smaller
  hide = 'heat_source'
[]

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

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

[Problem]
  type = NekRSProblem
  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/postprocessors/nek_function_norm/nek.i)

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

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[AuxVariables]
  [temperature_minus_function]
  []
  [temperature]
  []
[]

[AuxKernels]
  [temperature_minus_function]
    type = FunctionAux
    variable = temperature_minus_function
    function = temperature_minus_function
  []
  [temperature]
    type = FunctionAux
    variable = temperature
    function = temperature
  []
[]

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

[Functions]
  [temperature]
    type = ParsedFunction
    expression = 'exp(x)+sin(y)+x*y*z'
  []
  [function_to_compare]
    type = ParsedFunction
    expression = 'exp(x*x)+0.7*y+0.8*z+1'
  []
  [temperature_minus_function]
    type = ParsedFunction
    expression = 'abs(temperature-function_to_compare)'
    symbol_names = 'temperature function_to_compare'
    symbol_values = 'temperature function_to_compare'
  []
[]

[Postprocessors]
  [temp_l2]
    type = NekVolumeNorm
    field = temperature
    function = function_to_compare
  []
  [temp_l2_comparison_b]
    type = NekVolumeIntegral
    field = velocity_x
  []
  [temp_l2_comparison]
    type = ParsedPostprocessor
    expression = 'sqrt(temp_l2_comparison_b)'
    pp_names = 'temp_l2_comparison_b'
  []

  [temp_l1]
    type = NekVolumeNorm
    field = temperature
    N = 1
    function = function_to_compare
  []
  [temp_l1_comparison]
    type = NekVolumeIntegral
    field = velocity_y
  []

  [temp_linf]
    type = NekVolumeNorm
    field = temperature
    N = infinity
    function = function_to_compare
  []
  [temp_linf_comparison]
    type = NodalExtremeValue
    variable = temperature_minus_function
  []

  [temp_without_function_linf]
    type = NekVolumeNorm
    field = temperature
    N = infinity
  []
  [temp_without_function_linf_comparison]
    type = NodalExtremeValue
    variable = temperature
  []
[]

(test/tests/postprocessors/nek_volume_integral/nek_no_temp.i)

[Problem]
  type = NekRSProblem
  casename = 'pyramid_no_temp'
[]

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

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

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

[Postprocessors]
  [s01_int]
    type = NekVolumeIntegral
    field = scalar01
  []
  [s02_int]
    type = NekVolumeIntegral
    field = scalar02
  []
  [s03_int]
    type = NekVolumeIntegral
    field = scalar03
  []
[]

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

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSProblem
  casename = 'channel'

  [FieldTransfers]
    [P]
      type = NekFieldVariable
      direction = from_nek
      field = pressure
    []
    [vel_x]
      type = NekFieldVariable
      direction = from_nek
      field = velocity_x
    []
    [vel_y]
      type = NekFieldVariable
      direction = from_nek
      field = velocity_y
    []
    [vel_z]
      type = NekFieldVariable
      direction = from_nek
      field = velocity_z
    []
  []
[]

[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/conduction/nonidentical_volume/nondimensional/nek.i)

[Problem]
  type = NekRSProblem
  casename = 'cylinder'
  n_usrwrk_slots = 1

  [Dimensionalize]
    T = 500.0
    dT = 50.0
    rho = 5.0
    Cp = 6.0
    L = 0.5
    U = 1.0
  []

  [FieldTransfers]
    [heat_source]
      type = NekVolumetricSource
      usrwrk_slot = 0
      direction = to_nek
      postprocessor_to_conserve = source_integral
    []
    [temp]
      type = NekFieldVariable
      field = temperature
      direction = from_nek
    []
  []
[]

[Mesh]
  type = NekRSMesh
  volume = true

  # change to SECOND to exactly match the verification case in ../cylinder; we use
  # FIRST here just to reduce the size of the gold file
  order = FIRST

  # nekRS runs in nondimensional form, so we need to adjust the mesh (in nondimensional
  # coordinates) to the dimensional form expected by MOOSE
  scaling = 0.5
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  [max_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = max
  []
  [min_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = min
  []
  [avg_T_volume]
    type = NekVolumeAverage
    field = temperature
  []
  [T_volume]
    type = NekVolumeIntegral
    field = temperature
  []
[]

[Outputs]
  exodus = true
  execute_on = 'final'

  # we can infer that these variables dont change by ensuring that 'temp' does not change,
  # since these other two variables are boundary conditions and source terms for the energy equation
  hide = 'heat_source'
[]

(test/tests/postprocessors/nek_volume_integral/nondimensional.i)

[Problem]
  type = NekRSProblem
  casename = 'pyramid'
  n_usrwrk_slots = 4

  [FieldTransfers]
    [usrwrk00]
      type = NekVolumetricData
      usrwrk_slot = 0
      direction = to_nek
    []
    [usrwrk01]
      type = NekVolumetricData
      usrwrk_slot = 1
      direction = to_nek
    []
    [usrwrk02]
      type = NekVolumetricData
      usrwrk_slot = 2
      direction = to_nek
    []
  []

  [Dimensionalize]
    L = 2.0
    U = 0.2
    T = 10.0
    dT = 100.0
    s01 = 15.0
    ds01 = 150.0
    s02 = 20.0
    ds02 = 200.0
    s03 = 30.0
    ds03 = 300.0
    rho = 1000.0
    Cp = 4000.0
  []
[]

[AuxKernels]
  [usrwrk00]
    type = FunctionAux
    variable = usrwrk00
    function = usrwrk00
    execute_on = timestep_begin
  []
  [usrwrk01]
    type = FunctionAux
    variable = usrwrk01
    function = usrwrk01
    execute_on = timestep_begin
  []
  [usrwrk02]
    type = FunctionAux
    variable = usrwrk02
    function = usrwrk02
    execute_on = timestep_begin
  []
[]

[Functions]
  [usrwrk00]
    type = ParsedFunction
    expression = 'exp(x/2)+1'
  []
  [usrwrk01]
    type = ParsedFunction
    expression = 'exp(y/2)+1'
  []
  [usrwrk02]
    type = ParsedFunction
    expression = 'exp(z/2)+1'
  []
  [f]
    type = ParsedFunction
    expression = '10.0*(x+y+z)'
  []
[]

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

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

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

[Postprocessors]
  [unity_int]
    type = NekVolumeIntegral
    field = unity
  []

  # subtracting off 3 means that this value should be -2 * unity_int
  [unity_intf]
    type = NekVolumeIntegral
    field = unity
    function = '3'
  []

  [temp_int]
    type = NekVolumeIntegral
    field = temperature
  []

  [temp_intf]
    type = NekVolumeIntegral
    field = temperature
    function = f
    execute_on = timestep_end
  []

  [u00_int]
    type = NekVolumeIntegral
    field = usrwrk00
  []
  [u01_int]
    type = NekVolumeIntegral
    field = usrwrk01
  []
  [u02_int]
    type = NekVolumeIntegral
    field = usrwrk02
  []
  [s01_int]
    type = NekVolumeIntegral
    field = scalar01
  []
  [s02_int]
    type = NekVolumeIntegral
    field = scalar02
  []
  [s03_int]
    type = NekVolumeIntegral
    field = scalar03
  []
  [pressure_int]
    type = NekVolumeIntegral
    field = pressure
  []
  [velocity_int]
    type = NekVolumeIntegral
    field = velocity
  []
  [x_velocity_int]
    type = NekVolumeIntegral
    field = velocity_x
  []
  [y_velocity_int]
    type = NekVolumeIntegral
    field = velocity_y
  []
  [z_velocity_int]
    type = NekVolumeIntegral
    field = velocity_z
  []
  [x2_velocity_int]
    type = NekVolumeIntegral
    field = velocity_x_squared
  []
  [y2_velocity_int]
    type = NekVolumeIntegral
    field = velocity_y_squared
  []
  [z2_velocity_int]
    type = NekVolumeIntegral
    field = velocity_z_squared
  []
  [velocity_component]
    type = NekVolumeIntegral
    field = velocity_component
    velocity_direction = '0.1 0.2 -0.3'
  []
[]

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

[Problem]
  type = NekRSProblem
  casename = 'sfr_pin'
  synchronization_interval = parent_app
  n_usrwrk_slots = 1

  [FieldTransfers]
    [avg_flux]
      type = NekBoundaryFlux
      direction = to_nek
      usrwrk_slot = 0
      postprocessor_to_conserve = flux_integral
    []
    [temp]
      type = NekFieldVariable
      field = temperature
      direction = from_nek
    []
  []
[]

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

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  [nek_flux]
    type = NekHeatFluxIntegral
    boundary = '1'
  []
  [average_inlet_T]
    type = NekSideAverage
    field = temperature
    boundary = '3'
    execute_on = initial
  []
  [average_outlet_T]
    type = NekSideAverage
    field = temperature
    boundary = '4'
  []
  [dT]
    type = DifferencePostprocessor
    value1 = average_outlet_T
    value2 = average_inlet_T
  []
  [inlet_mdot]
    type = NekMassFluxWeightedSideIntegral
    field = unity
    boundary = '3'
    execute_on = initial
  []

  # postprocessors for comparing against the non-dimensional version in ../nondimensional
  # --> uncomment in order to get the reference values that the nondimensional boundary coupling
  #     was verified against
  # # side integral
  # [area_1]
  #   type = NekSideIntegral
  #   field = unity
  #   boundary = '1'
  # []
  # [pressure_1]
  #   type = NekSideIntegral
  #   field = pressure
  #   boundary = '1'
  # []
  # [temperature_1]
  #   type = NekSideIntegral
  #   field = temperature
  #   boundary = '1'
  # []

  # # side average
  # [avg_area_1]
  #   type = NekSideAverage
  #   field = unity
  #   boundary = '1'
  # []
  # [avg_pressure_1]
  #   type = NekSideAverage
  #   field = pressure
  #   boundary = '1'
  # []
  # [avg_temperature_1]
  #   type = NekSideAverage
  #   field = temperature
  #   boundary = '1'
  # []

  # # volume integral
  # [volume]
  #   type = NekVolumeIntegral
  #   field = unity
  # []
  # [pressure_vol]
  #   type = NekVolumeIntegral
  #   field = pressure
  # []
  # [temperature_vol]
  #   type = NekVolumeIntegral
  #   field = temperature
  # []

  # # volume average
  # [avg_volume]
  #   type = NekVolumeAverage
  #   field = unity
  # []
  # [avg_pressure_vol]
  #   type = NekVolumeAverage
  #   field = pressure
  # []
  # [avg_temperature_vol]
  #   type = NekVolumeAverage
  #   field = temperature
  # []

  # # mass flux weighted integral
  # [outlet_T]
  #   type = NekMassFluxWeightedSideIntegral
  #   field = temperature
  #   boundary = '4'
  # []
  # [inlet_P]
  #   type = NekMassFluxWeightedSideIntegral
  #   field = pressure
  #   boundary = '4'
  # []

  # # mass flux weighted integral
  # [inlet_mdot_avg]
  #   type = NekMassFluxWeightedSideAverage
  #   field = unity
  #   boundary = '3'
  #   execute_on = initial
  # []
  # [outlet_T_avg]
  #   type = NekMassFluxWeightedSideAverage
  #   field = temperature
  #   boundary = '4'
  # []
  # [inlet_P_avg]
  #   type = NekMassFluxWeightedSideAverage
  #   field = pressure
  #   boundary = '4'
  # []

  # # extreme value postprocessors - VOLUME
  # [max_T]
  #   type = NekVolumeExtremeValue
  #   field = temperature
  #   value_type = max
  # []
  # [min_T]
  #   type = NekVolumeExtremeValue
  #   field = temperature
  #   value_type = min
  # []
  # [max_p]
  #   type = NekVolumeExtremeValue
  #   field = pressure
  #   value_type = max
  # []
  # [min_p]
  #   type = NekVolumeExtremeValue
  #   field = pressure
  #   value_type = min
  # []
  # [max_1]
  #   type = NekVolumeExtremeValue
  #   field = unity
  #   value_type = max
  # []
  # [min_1]
  #   type = NekVolumeExtremeValue
  #   field = unity
  #   value_type = min
  # []

  # # extreme value postprocessors - SIDE
  # [max_T_out]
  #   type = NekSideExtremeValue
  #   field = temperature
  #   boundary = '4'
  #   value_type = max
  # []
  # [min_T_out]
  #   type = NekSideExtremeValue
  #   field = temperature
  #   boundary = '4'
  #   value_type = min
  # []
  # [max_p_in]
  #   type = NekSideExtremeValue
  #   field = pressure
  #   boundary = '3'
  #   value_type = max
  # []
  # [min_p_in]
  #   type = NekSideExtremeValue
  #   field = pressure
  #   boundary = '3'
  #   value_type = min
  # []
  # [max_1_in]
  #   type = NekSideExtremeValue
  #   field = unity
  #   boundary = '3'
  #   value_type = max
  # []
  # [min_1_in]
  #   type = NekSideExtremeValue
  #   field = unity
  #   boundary = '3'
  #   value_type = min
  # []
[]

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

  [screen]
    type = Console
    hide = 'average_inlet_T average_outlet_T transfer_in'
  []
[]

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

[Problem]
  type = NekRSProblem
  casename = 'brick'

  [Dimensionalize]
    L = 2.0
    U = 1.0
    rho = 834.5
    Cp = 1228.0
    T = 573.0
    dT = 10.0
  []

  [FieldTransfers]
    [P]
      type = NekFieldVariable
      direction = from_nek
      field = pressure
    []
  []
[]

[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/cht/nondimensional/nek.i)

[Problem]
  type = NekRSProblem
  casename = 'sfr_pin'
  n_usrwrk_slots = 1

  # This input is run in nondimensional form to verify that all the postprocessors
  # and data transfers in/out of nekRS are properly dimensionalized.
  [Dimensionalize]
    U = 0.000950466
    T = 628.15
    dT = 50.0
    L = 0.908e-2
    rho = 834.5
    Cp = 1228.0
  []

  [FieldTransfers]
    [avg_flux]
      type = NekBoundaryFlux
      direction = to_nek
      usrwrk_slot = 0
      postprocessor_to_conserve = flux_integral
    []
    [temp]
      type = NekFieldVariable
      field = temperature
      direction = from_nek
    []
  []
[]

[Mesh]
  type = NekRSMesh
  boundary = '1'

  # nekRS runs in non-dimensional form, which means that we shrunk the mesh
  # from physical units of meters to our characteristic scale of 0.908e-2 m
  # (the pin pitch, arbitrarily chosen). That means that we must multiply
  # the nekRS mesh by 0.908e-2 to get back in units of meters that BISON is
  # running in.
  scaling = 0.908e-2
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]

  [synchronization_in]
    type = Receiver
  []

  # uncomment these to see the postprocessors used to compare against the exact mesh within this
  # same folder, as well as the dimensional case in ../sfr_pincell

  ## side integral
  #[area_1]
  #  type = NekSideIntegral
  #  field = unity
  #  boundary = '1'
  #[]
  #[pressure_1]
  #  type = NekSideIntegral
  #  field = pressure
  #  boundary = '1'
  #[]
  #[temperature_1]
  #  type = NekSideIntegral
  #  field = temperature
  #  boundary = '1'
  #[]

  ## side average
  #[avg_area_1]
  #  type = NekSideAverage
  #  field = unity
  #  boundary = '1'
  #[]
  #[avg_pressure_1]
  #  type = NekSideAverage
  #  field = pressure
  #  boundary = '1'
  #[]
  #[avg_temperature_1]
  #  type = NekSideAverage
  #  field = temperature
  #  boundary = '1'
  #[]

  ## volume integral
  #[volume]
  #  type = NekVolumeIntegral
  #  field = unity
  #[]
  #[pressure_vol]
  #  type = NekVolumeIntegral
  #  field = pressure
  #[]
  #[temperature_vol]
  #  type = NekVolumeIntegral
  #  field = temperature
  #[]

  ## volume average
  #[avg_volume]
  #  type = NekVolumeAverage
  #  field = unity
  #[]
  #[avg_pressure_vol]
  #  type = NekVolumeAverage
  #  field = pressure
  #[]
  #[avg_temperature_vol]
  #  type = NekVolumeAverage
  #  field = temperature
  #[]

  ## heat flux integral
  #[nek_flux]
  #  type = NekHeatFluxIntegral
  #  boundary = '1'
  #[]

  ## mass flux weighted integral
  #[inlet_mdot]
  #  type = NekMassFluxWeightedSideIntegral
  #  field = unity
  #  boundary = '3'
  #  execute_on = initial
  #[]
  #[outlet_T]
  #  type = NekMassFluxWeightedSideIntegral
  #  field = temperature
  #  boundary = '4'
  #[]
  #[inlet_P]
  #  type = NekMassFluxWeightedSideIntegral
  #  field = pressure
  #  boundary = '4'
  #[]

  ## mass flux weighted integral
  #[inlet_mdot_avg]
  #  type = NekMassFluxWeightedSideAverage
  #  field = unity
  #  boundary = '3'
  #  execute_on = initial
  #[]
  #[outlet_T_avg]
  #  type = NekMassFluxWeightedSideAverage
  #  field = temperature
  #  boundary = '4'
  #[]
  #[inlet_P_avg]
  #  type = NekMassFluxWeightedSideAverage
  #  field = pressure
  #  boundary = '4'
  #[]

  ## extreme value postprocessors - VOLUME
  #[max_T]
  #  type = NekVolumeExtremeValue
  #  field = temperature
  #  value_type = max
  #[]
  #[min_T]
  #  type = NekVolumeExtremeValue
  #  field = temperature
  #  value_type = min
  #[]
  #[max_p]
  #  type = NekVolumeExtremeValue
  #  field = pressure
  #  value_type = max
  #[]
  #[min_p]
  #  type = NekVolumeExtremeValue
  #  field = pressure
  #  value_type = min
  #[]
  #[max_1]
  #  type = NekVolumeExtremeValue
  #  field = unity
  #  value_type = max
  #[]
  #[min_1]
  #  type = NekVolumeExtremeValue
  #  field = unity
  #  value_type = min
  #[]

  ## extreme value postprocessors - SIDE
  #[max_T_out]
  #  type = NekSideExtremeValue
  #  field = temperature
  #  boundary = '4'
  #  value_type = max
  #[]
  #[min_T_out]
  #  type = NekSideExtremeValue
  #  field = temperature
  #  boundary = '4'
  #  value_type = min
  #[]
  #[max_p_in]
  #  type = NekSideExtremeValue
  #  field = pressure
  #  boundary = '3'
  #  value_type = max
  #[]
  #[min_p_in]
  #  type = NekSideExtremeValue
  #  field = pressure
  #  boundary = '3'
  #  value_type = min
  #[]
  #[max_1_in]
  #  type = NekSideExtremeValue
  #  field = unity
  #  boundary = '3'
  #  value_type = max
  #[]
  #[min_1_in]
  #  type = NekSideExtremeValue
  #  field = unity
  #  boundary = '3'
  #  value_type = min
  #[]
[]

[Outputs]
  exodus = true
  execute_on = 'final'
  hide = 'avg_flux'

  [screen]
    type = Console
    hide = 'synchronization_in'
  []
[]

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

[Problem]
  type = NekRSProblem
  casename = 'pyramid'
  n_usrwrk_slots = 4

  [FieldTransfers]
    [usrwrk00]
      type = NekVolumetricData
      usrwrk_slot = 0
      direction = to_nek
    []
    [usrwrk01]
      type = NekVolumetricData
      usrwrk_slot = 1
      direction = to_nek
    []
    [usrwrk02]
      type = NekVolumetricData
      usrwrk_slot = 2
      direction = to_nek
    []
  []
[]

[AuxKernels]
  [usrwrk00]
    type = FunctionAux
    variable = usrwrk00
    function = usrwrk00
    execute_on = timestep_begin
  []
  [usrwrk01]
    type = FunctionAux
    variable = usrwrk01
    function = usrwrk01
    execute_on = timestep_begin
  []
  [usrwrk02]
    type = FunctionAux
    variable = usrwrk02
    function = usrwrk02
    execute_on = timestep_begin
  []
[]

[Functions]
  [usrwrk00]
    type = ParsedFunction
    expression = 'exp(x)+1'
  []
  [usrwrk01]
    type = ParsedFunction
    expression = 'exp(y)+1'
  []
  [usrwrk02]
    type = ParsedFunction
    expression = 'exp(z)+1'
  []
[]

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

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Functions]
  [f]
    type = ParsedFunction
    expression = 'x+y+z+100*t'
  []
[]

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

[Postprocessors]
  [usrwrk00]
    type = NekVolumeIntegral
    field = usrwrk00
  []
  [usrwrk01]
    type = NekVolumeIntegral
    field = usrwrk01
  []
  [usrwrk02]
    type = NekVolumeIntegral
    field = usrwrk02
  []
  [unity_int]
    type = NekVolumeIntegral
    field = unity
  []
  [unity_intf]
    type = NekVolumeIntegral
    field = unity
    function = '3.0'
  []
  [unity_zero_field] # should give same value as unity_int
    type = NekVolumeIntegral
    field = zero
    function = '-1'
  []
  [temp_int]
    type = NekVolumeIntegral
    field = temperature
  []
  [s01_int]
    type = NekVolumeIntegral
    field = scalar01
  []
  [s01_intf]
    type = NekVolumeIntegral
    field = scalar01
    function = f
    execute_on = timestep_begin
  []
  [s02_int]
    type = NekVolumeIntegral
    field = scalar02
  []
  [s03_int]
    type = NekVolumeIntegral
    field = scalar03
  []
  [pressure_int]
    type = NekVolumeIntegral
    field = pressure
  []
  [velocity_int]
    type = NekVolumeIntegral
    field = velocity
  []
  [x_velocity_int]
    type = NekVolumeIntegral
    field = velocity_x
  []
  [y_velocity_int]
    type = NekVolumeIntegral
    field = velocity_y
  []
  [z_velocity_int]
    type = NekVolumeIntegral
    field = velocity_z
  []
  [x2_velocity_int]
    type = NekVolumeIntegral
    field = velocity_x_squared
  []
  [y2_velocity_int]
    type = NekVolumeIntegral
    field = velocity_y_squared
  []
  [z2_velocity_int]
    type = NekVolumeIntegral
    field = velocity_z_squared
  []
  [velocity_component]
    type = NekVolumeIntegral
    field = velocity_component
    velocity_direction = '0.1 0.2 -0.3'
  []
[]

Description
Example Input Syntax
Input Parameters
Input Files