NekBoundaryFlux

Description

NekBoundaryFlux is a FieldTransfer that sends a boundary flux between NekRS and MOOSE. First, this object creates an AuxVariable using the name of the object; this variable will hold the flux which NekRS reads (for direction = to_nek) or will be written by NekRS (for direction = from_nek).

Flux Normalization

The internal NekRS mesh is based on the spectral element method (with Guass-Lobatto quadrature), whereas a coupled MOOSE applcation which wants to write/use a boundary flux will likely be using a different quadrature rule. In order to ensure perfect conservation of the flux as it is exchanged between NekRS and MOOSE, a Receiver postprocessor is automatically added with name taken as <name of the object>_integral. For direction = to_nek, this postprocessor should be populated by a parent/sub application with the total integrated flux in the originating MOOSE application. For direction = from_nek, this postprocessor will be filled by the total integrated flux computed internally in NekRS.

Flux Normalization

By default, NekBoundaryFlux will lump all "receiving" sidesets in NekRS together for the purpose of flux normalization. For example, suppose we are coupling NekRS to MOOSE heat conduction through two boundaries. Suppose MOOSE heat conduction predicts the following heat flux integrals on each of these boundaries:

MOOSE boundary 1: 100.0 W
MOOSE boundary 2: 200.0 W

When this data gets mapped to NekRS's spectral element mesh, we need to renormalize to ensure that we conserve power. This renormalization is necessary because the NekRS mesh can be entirely different from the MOOSE mesh, and integrating a nodal field on the origin mesh from MOOSE (say, a 1-st order Lagrange interpolation) will give a different integral value than integrating the interpolated nodal values on the receiving NekRS mesh (say, a 7-th order Lagrange interpolation of GLL points). By default, NekBoundaryFlux lumps all receiving sidesets in the NekRS model together for the sake of normalization. For example, suppose that once received on the NekRS mesh and integrated, that the received flux has values of:

NekRS boundary 1: 102.0 W
NekRS boundary 2: 199.0 W

By default, this class will renormalize the NekRS flux in order to match the total MOOSE flux (of 300.0 W) to give:

NekRS boundary 1: $var element = document.getElementById("moose-equation-9e070655-59ae-4873-846c-8288604e106e");katex.render("102.0 * \\frac{100.0 + 200.0}{102.0 + 199.0}\\equiv 101.66", element, {displayMode:false,throwOnError:false});$
NekRS boundary 2: $var element = document.getElementById("moose-equation-c9671578-bc0d-4c3b-8945-d62761fa7e32");katex.render("199.0 * \\frac{100.0 + 200.0}{102.0 + 199.0}\\equiv 198.34", element, {displayMode:false,throwOnError:false});$

The total power entering the flux is preserved, but not the distribution among the sidesets. This is usually a very small error and is an acceptable approximation for many analyses. However, we do also support an option where the heat flux on each sideset is preserved with the conserve_flux_by_sideset option. When setting this parameter to true, the heat flux on each NekRS sideset will instead be evaluated as:

NekRS boundary 1: $var element = document.getElementById("moose-equation-cd0df551-da68-47f9-94a0-1cca8ddb8e20");katex.render("102.0 * \\frac{100.0}{102.0}\\equiv 100.0", element, {displayMode:false,throwOnError:false});$
NekRS boundary 2: $var element = document.getElementById("moose-equation-9585c8e9-08b2-463c-ab33-da9d4f2436c9");katex.render("199.0 * \\frac{200.0}{199.0}\\equiv 200.0", element, {displayMode:false,throwOnError:false});$

This option requires using a vector postprocessor (we typically recommend the VectorOfPostprocessors object) to send indiviudal boundary flux values into your NekRS-wrapped case. This more advanced option cannot be used if:

Your sidesets in the coupled MOOSE App are not individually specified. For instance, if your heat conduction solver has one sideset that maps to two NekRS sidesets, there's no natural way to figure out what the heat flux is in those sub-sidesets to send a correct value to NekRS.
Any nodes are shared among the NekRS sidesets, such as a node on a corner between two sidesets. When we renormalize the NekRS flux, nodes that are present on more than one sideset will get renormalized multiple times, so there is no guarantee that we can enforce the total flux.

What are the Fluxes?

There are a few different heat fluxes involved when coupling NekRS via Conjugate Heat Transfer (CHT) to MOOSE. When you run a CHT calculation, for each time step you will see something like the following printed to the screen:

Sending heat flux to NekRS boundary 1
Normalizing total NekRS flux of 78.8581 to the conserved MOOSE value of 78.6508

Here, the "total NekRS flux of ..." is the integral of nrs->usrwrk over the high-order NekRS spectral element mesh. Conversely, the "conserved MOOSE value of ..." is the total heat flux that MOOSE is setting in NekRS (read from the <name_of_object>_integral postprocessor that this object creates. These two numbers will be different unless all of the following are true:

The NekRS and MOOSE meshes are identical
The NekRS polynomial order matches the MOOSE polynomial order, and for the same polynomial order the nodes are the same. Because NekRS is a spectral element method and MOOSE uses the finite element method, this criteria can only occur if NekRS and MOOSE are either 1st or 2nd order (because the node placement for 1st or 2nd order elements is the same for spectral and finite elements).
The quadrature rule used to integrate in MOOSE is the GLL quadrature

Any differences between the "total NekRS flux" and the "conserved MOOSE value" will simply arise due to differences in the integration of a field over their respective meshes, and is not anything of concern - in fact, Cardinal is specifically designed to renormalized so that conservation is maintained. However, you may see large differences if the geometry is curved, since the NekRS high-order mesh will capture the curvature and result in very different area integrals. We always recommend doing a sanity check on the flux sent from MOOSE to NekRS via the MOOSE output files.

You can also monitor the heat flux in NekRS by computing $var element = document.getElementById("moose-equation-c5d97a39-f425-443d-bfec-68464e1c75cc");katex.render("-k\\nabla T\\cdot\\hat{n}", element, {displayMode:false,throwOnError:false});$ using a NekHeatFluxIntegral postprocessor. In general, the quantity computed by this postprocessor will not match the heat flux set by MOOSE because both the finite and spectral element methods solve weak forms where Neumann boundary conditions are only weakly imposed. That is, we set the heat flux but only enforce it by driving the entire nonlinear residual to a small-enough number, so heat flux boundary conditions are never perfectly observed like Dirichlet boundary conditions are.

Example Input File Syntax

As an example, the example below couples NekRS to MOOSE via CHT. A coupled MOOSE application sends a heat flux variable and a postprocessor representing the total flux integral into a NekRS-wrapped case. The NekBoundaryFlux object creates automatically an auxiliary variable named avg_flux and a postprocessor by the name of flux_integral (the default postprocessor name would have been avg_flux_integral but you can also specify a custom name if desired as shown here). The NekBoundaryFlux object then handles writing this heat flux into usrwrk slot 0.

[Problem<<<{"href": "../../syntax/Problem/index.html"}>>>]
  type = NekRSProblem
  casename<<<{"description": "Case name for the NekRS input files; this is <case> in <case>.par, <case>.udf, <case>.oudf, and <case>.re2."}>>> = 'onepebble2'
  n_usrwrk_slots<<<{"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"}>>> = 1

  [FieldTransfers<<<{"href": "../../syntax/Problem/FieldTransfers/index.html"}>>>]
    [avg_flux]
      type = NekBoundaryFlux<<<{"description": "Reads/writes boundary flux data between NekRS and MOOSE."}>>>
      direction<<<{"description": "Direction in which to send data"}>>> = to_nek
      postprocessor_to_conserve<<<{"description": "Name of the postprocessor/vectorpostprocessor containing the integral(s) used to ensure conservation; defaults to the name of the object plus '_integral'"}>>> = flux_integral
      usrwrk_slot<<<{"description": "When 'direction = to_nek', the slot(s) in the usrwrk array to write the incoming data; provide one entry for each quantity being passed"}>>> = 0
    []
    [temp]
      type = NekFieldVariable<<<{"description": "Reads/writes volumetric field data between NekRS and MOOSE."}>>>
      field<<<{"description": "NekRS field variable to read/write; defaults to the name of the object"}>>> = temperature
      direction<<<{"description": "Direction in which to send data"}>>> = from_nek
    []
  []
[]

Then, all that is required to actually _apply_ this heat flux to the NekRS model is to use it in the scalarNeumannConditions boundary condition. Below, bc->usrwrk is the same as nrs->o_usrwrk, or the scratch space on the device; this function applies the heat flux computed by MOOSE to the flux boundaries.

void scalarNeumannConditions(bcData *bc)
{
  // note: when running with Cardinal, Cardinal will allocate the usrwrk
  // array. If running with NekRS standalone (e.g. nrsmpi), you need to
  // replace the usrwrk with some other value or allocate it youself from
  // the udf and populate it with values.
  bc->flux = bc->usrwrk[bc->idM];
}

Input Parameters

directionDirection in which to send data
C++ Type:MooseEnum
Options:to_nek, from_nek
Controllable:No
Description:Direction in which to send data

Required Parameters

conserve_flux_by_sidesetFalseWhether to conserve the flux by individual sideset (as opposed to lumping all sidesets together). Setting this option to true requires syntax changes in the input file to use vector postprocessors, and places restrictions on how the sidesets are set up.
Default:False
C++ Type:bool
Controllable:No
Description:Whether to conserve the flux by individual sideset (as opposed to lumping all sidesets together). Setting this option to true requires syntax changes in the input file to use vector postprocessors, and places restrictions on how the sidesets are set up.
initial_flux_integral0Initial value to use for the 'postprocessor_to_conserve'; this initial value will be overridden once the coupled app executes its transfer of the boundary flux term integral into the 'postprocessor_to_conserve'. You may want to use this parameter if NekRS runs first, or if you are running NekRS in isolation but still want to apply a boundary flux term via Cardinal. Remember that this parameter is only used to normalize the flux, so you will need to populate an initial shape if you want to see this parameter take effect.
Default:0
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:Initial value to use for the 'postprocessor_to_conserve'; this initial value will be overridden once the coupled app executes its transfer of the boundary flux term integral into the 'postprocessor_to_conserve'. You may want to use this parameter if NekRS runs first, or if you are running NekRS in isolation but still want to apply a boundary flux term via Cardinal. Remember that this parameter is only used to normalize the flux, so you will need to populate an initial shape if you want to see this parameter take effect.
normalization_abs_tol1e-08Absolute tolerance for checking if conservation is maintained during transfer
Default:1e-08
C++ Type:double
Unit:(no unit assumed)
Range:normalization_abs_tol > 0
Controllable:No
Description:Absolute tolerance for checking if conservation is maintained during transfer
normalization_rel_tol1e-05Relative tolerance for checking if conservation is maintained during transfer
Default:1e-05
C++ Type:double
Unit:(no unit assumed)
Range:normalization_rel_tol > 0
Controllable:No
Description:Relative tolerance for checking if conservation is maintained during transfer
postprocessor_to_conserveName of the postprocessor/vectorpostprocessor containing the integral(s) used to ensure conservation; defaults to the name of the object plus '_integral'
C++ Type:std::string
Controllable:No
Description:Name of the postprocessor/vectorpostprocessor containing the integral(s) used to ensure conservation; defaults to the name of the object plus '_integral'
usrwrk_slotWhen 'direction = to_nek', the slot(s) in the usrwrk array to write the incoming data; provide one entry for each quantity being passed
C++ Type:std::vector<unsigned int>
Controllable:No
Description:When 'direction = to_nek', the slot(s) in the usrwrk array to write the incoming data; provide one entry for each quantity being passed

Optional 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:No
Description:Set the enabled status of the MooseObject.

Advanced Parameters

Input Files

(tutorials/fhr_reflector/cht/nek.i)
(tutorials/pincell_multiphysics/nek.i)
(test/tests/conduction/reverse_cht/nek.i)
(test/tests/cht/nondimensional/nek.i)
(test/tests/conduction/zero_flux/mismatch_nek.i)
(test/tests/nek_errors/usrwrk_transfers/scalar.i)
(tutorials/pebble_67/nek.i)
(test/tests/nek_errors/no_temp_var/nek.i)
(test/tests/conduction/zero_flux/nek.i)
(test/tests/cht/pebble/shift/nek.i)
(test/tests/cht/nondimensional/nek_exact.i)
(tutorials/sfr_7pin/nek.i)
(tutorials/nek_stochastic/nek.i)
(test/tests/multiple_nek_apps/two_channels/nek.i)
(test/tests/conduction/boundary_and_volume/prism/nek.i)
(test/tests/transfers/nek_flux/nek.i)
(test/tests/nek_errors/usrwrk_transfers/wrong_problem.i)
(test/tests/conduction/nonidentical_interface/cylinders/nek.i)
(test/tests/auxkernels/heat_transfer_coefficient/nek.i)
(test/tests/cht/sfr_pincell/nek_vpp.i)
(test/tests/cht/pincell_p_v/nek.i)
(tutorials/sfr_7pin/nek_vpp.i)
(test/tests/conduction/zero_flux/nek_vpp.i)
(tutorials/pebble_cht/nek.i)
(tutorials/sfr_7pin/nek_fluxflux.i)
(test/tests/conduction/zero_flux/nek_disjoint.i)
(test/tests/nek_errors/usrwrk_transfers/nek.i)
(tutorials/gas_compact_cht/nek.i)
(test/tests/cht/sfr_pincell/nek.i)
(test/tests/nek_errors/no_temp_solve/nek.i)
(test/tests/nek_errors/usrwrk_transfers/flux.i)
(tutorials/fhr_reflector/conduction/nek.i)
(tutorials/gas_compact_multiphysics/nek.i)
(test/tests/conduction/identical_interface/cube/nek.i)
(test/tests/cht/pebble/nek.i)
(test/tests/conduction/identical_interface/pyramid/nek.i)
(test/tests/conduction/nonidentical_interface/cylinders/nek_mini.i)
(test/tests/cht/sfr_pincell/nek_isolated.i)
(test/tests/nek_errors/invalid_settings/nek_bc.i)
(test/tests/postprocessors/nek_point_value/usrwrk_units.i)
(test/tests/transfers/nek_source/flux.i)
(test/tests/conduction/nonidentical_interface/cylinders/nek_exact.i)
(test/tests/conduction/boundary_and_volume/prism/nek_exact.i)

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

[Mesh]
  type = NekRSMesh
  boundary = '1'

  # nekRS solves with a length scale of meters, but nek_master.i is currently solving
  # in terms of centimeters. Therefore, just for the sake of data transfers, we need to
  # scale NekRSMesh to centimeters.
  scaling = 100.0
[]

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

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

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

[Postprocessors]
  # This is the heat flux in the nekRS solution, i.e. it is not an integral
  # of nrs->usrwrk, instead this is directly an integral of k*grad(T)*hat(n).
  # So this should closely match 'flux_integral'
  [flux_in_nek]
    type = NekHeatFluxIntegral
    boundary = '1'
  []

  [max_nek_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = max
  []
  [min_nek_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = min
  []
[]

(test/tests/cht/pebble/onepebble2.oudf)

// Boundary conditions
void velocityDirichletConditions(bcData *bc)
{
  bc->u = 0.0;
  bc->v = 0.0;
  bc->w = 0.17;
}

void scalarDirichletConditions(bcData *bc)
{
  bc->s = 573.0;
}

void scalarNeumannConditions(bcData *bc)
{
  // note: when running with Cardinal, Cardinal will allocate the usrwrk
  // array. If running with NekRS standalone (e.g. nrsmpi), you need to
  // replace the usrwrk with some other value or allocate it youself from
  // the udf and populate it with values.
  bc->flux = bc->usrwrk[bc->idM];
}

(tutorials/fhr_reflector/cht/nek.i)

fluid_solid_interface = '1 2 7'

[Mesh]
  type = NekRSMesh
  boundary = ${fluid_solid_interface}
  scaling = 0.006
[]

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

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

  [Dimensionalize]
    U = 0.0575
    T = 923.15
    dT = 10.0
    L = 0.006
    rho = 1962.13
    Cp = 2416.0
  []
[]

[Executioner]
  type = Transient
  timestep_tolerance = 1e-9

  [./TimeStepper]
    type = NekTimeStepper
  [../]
[]

[Outputs]
  exodus = true
[]

[Postprocessors]
  [boundary_flux]
    type = NekHeatFluxIntegral
    boundary = ${fluid_solid_interface}
  []
  [max_nek_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = max
  []
  [min_nek_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = min
  []
  [pressure_in]
    type = NekSideAverage
    field = pressure
    boundary = '5'
  []
  [mdot_in]
    type = NekMassFluxWeightedSideIntegral
    field = unity
    boundary = '5'
  []
  [mdot_out]
    type = NekMassFluxWeightedSideIntegral
    field = unity
    boundary = '6'
  []
[]

(tutorials/pincell_multiphysics/nek.i)

inlet_T  = 573.0           # inlet temperature
power = 250                # total power (W)
Re = 500.0                 # Reynolds number

pin_diameter = 0.97e-2     # pin outer diameter
pin_pitch = 1.28e-2        # pin pitch

mu = 8.8e-5                # fluid dynamic viscosity
rho = 723.6                # fluid density
Cp = 5512.0                # fluid isobaric specific heat capacity

flow_area = ${fparse pin_pitch * pin_pitch - pi * pin_diameter * pin_diameter / 4.0}
wetted_perimeter = ${fparse pi * pin_diameter}
hydraulic_diameter = ${fparse 4.0 * flow_area / wetted_perimeter}

U_ref = ${fparse Re * mu / rho / hydraulic_diameter}
mdot = ${fparse rho * U_ref * flow_area}
dT = ${fparse power / mdot / Cp}

[Mesh]
  type = NekRSMesh
  boundary = '1'
  scaling = ${hydraulic_diameter}
  volume = true
[]

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

  [Dimensionalize]
    L = ${hydraulic_diameter}
    T = ${inlet_T}
    U = ${U_ref}
    dT = ${dT}
    rho = ${rho}
    Cp = ${Cp}
  []

  [FieldTransfers]
    [flux]
      type = NekBoundaryFlux
      direction = to_nek
      usrwrk_slot = 0
    []
    [temperature]
      type = NekFieldVariable
      direction = from_nek
    []
  []

  synchronization_interval = parent_app
[]

[Postprocessors]
  [outlet_T]
    type = NekMassFluxWeightedSideAverage
    field = temperature
    boundary = '3'
  []
  [max_T]
    type = NekVolumeExtremeValue
    field = temperature
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
  interval = 10
[]

(test/tests/conduction/reverse_cht/nek.i)

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

  [FieldTransfers]
    [flux]
      type = NekBoundaryFlux
      direction = from_nek
    []
    [temperature]
      type = NekFieldVariable
      direction = to_nek
      usrwrk_slot = 1
    []
  []
[]

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

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  [interface_T]
    type = NekSideAverage
    field = temperature
    boundary = '4'
  []
[]

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

  # 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'

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

(test/tests/conduction/zero_flux/mismatch_nek.i)

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

  [FieldTransfers]
    [avg_flux]
      type = NekBoundaryFlux
      usrwrk_slot = 0
      direction = to_nek
      conserve_flux_by_sideset = true
      postprocessor_to_conserve = flux_integral
    []
  []
[]

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

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

(test/tests/nek_errors/usrwrk_transfers/scalar.i)

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

[Problem]
  type = NekRSProblem
  casename = 'brick'
  n_usrwrk_slots = 5

  [ScalarTransfers]
    [scalar]
      type = NekScalarValue
      direction = to_nek
      usrwrk_slot = '3'
    []
  []

  [FieldTransfers]
    [flux]
      type = NekBoundaryFlux
      direction = to_nek
      usrwrk_slot = '3'
    []
    [flux2]
      type = NekBoundaryFlux
      direction = to_nek
      usrwrk_slot = '4'
    []
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

(tutorials/pebble_67/nek.i)

Re = 1460.0
dp = 0.06
cylinder_diameter = ${fparse 4.4 * dp}
density = 3.645
C = 3121.0
mu = 2.93e-5
power = 2400.0
inlet_area = ${fparse pi * cylinder_diameter^2 / 4.0}

[Mesh]
  type = NekRSMesh
  boundary = 4
  scaling = ${dp}
[]

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

  [Dimensionalize]
    L = ${dp}
    U = ${fparse Re * mu / density / dp}
    T = 523.0
    dT = ${fparse power * dp / Re / inlet_area / mu / C}
    rho = ${density}
    Cp = ${C}
  []

  [FieldTransfers]
    [flux]
      type = NekBoundaryFlux
      direction = to_nek
      usrwrk_slot = 0
    []
    [temperature]
      type = NekFieldVariable
      direction = from_nek
    []
    [velocity_x]
      type = NekFieldVariable
      direction = from_nek
    []
    [velocity_y]
      type = NekFieldVariable
      direction = from_nek
    []
    [velocity_z]
      type = NekFieldVariable
      direction = from_nek
    []
  []

  synchronization_interval = parent_app
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
  interval = 100
[]

[Postprocessors]
  [max_nek_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = max
  []
  [min_nek_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = min
  []
  [average_nek_pebble_T]
    type = NekSideAverage
    boundary = '4'
    field = temperature
  []
[]

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

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

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

  [FieldTransfers]
    [flux]
      type = NekBoundaryFlux
      direction = to_nek
      usrwrk_slot = 0
    []
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

(test/tests/conduction/zero_flux/nek.i)

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

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

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

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

(test/tests/cht/pebble/shift/nek.i)

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

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

  [FieldTransfers]
    [flux]
      type = NekBoundaryFlux
      direction = to_nek
      usrwrk_slot = 1
    []
    [temp]
      type = NekFieldVariable
      field = temperature
      direction = from_nek
    []
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
  csv = true
[]

[Postprocessors]
  [flux_in_nek]
    type = NekHeatFluxIntegral
    boundary = '1'
  []
  [max_nek_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = max
  []
  [min_nek_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = min
  []
[]

(test/tests/cht/nondimensional/nek_exact.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.0950466
    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'
  exact = true

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

[Outputs]
  exodus = true
  [screen]
    type = Console
    hide = 'synchronization_in'
  []
[]

(tutorials/sfr_7pin/nek.i)

interval = 100

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

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

  [FieldTransfers]
    [heat_flux]
      type = NekBoundaryFlux
      direction = to_nek
      usrwrk_slot = 0
    []
    [temperature]
      type = NekFieldVariable
      direction = from_nek
    []
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true

  # this will only display the NekRS output every N time steps; postprocessors
  # are still computed on every step, just not output to the console
  time_step_interval = ${interval}
[]

[Postprocessors]
  [pin_flux_in_nek]
    type = NekHeatFluxIntegral
    boundary = '1'
  []
  [duct_flux_in_nek]
    type = NekHeatFluxIntegral
    boundary = '4'
  []
  [max_nek_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = max
  []
  [min_nek_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = min
  []
[]

(tutorials/nek_stochastic/nek.i)

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

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

  [FieldTransfers]
    [flux]
      type = NekBoundaryFlux
      direction = to_nek
      usrwrk_slot = 0
    []
    [temperature]
      type = NekFieldVariable
      field = temperature
      direction = from_nek
    []
  []

  [ScalarTransfers]
    [k]
      type = NekScalarValue
      direction = to_nek
      usrwrk_slot = 1
      output_postprocessor = k_from_stm
    []
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  [max_temp]
    type = NekVolumeExtremeValue
    field = temperature
  []
  [k_from_stm] # this will just print to the screen the value of k received
    type = Receiver
  []
  [expect_max_T]
    type = ParsedPostprocessor
    expression = '1000.0 / k_from_stm + 500.0'
    pp_names = k_from_stm
  []
[]

[Outputs]
  csv = true
  hide = 'flux_integral'
[]

[Controls]
  [stm]
    type = SamplerReceiver
  []
[]

(test/tests/multiple_nek_apps/two_channels/nek.i)

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

[Problem]
  type = NekRSProblem
  casename = 'pin'
  write_fld_files = true
  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
    []
  []
[]

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

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

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

  # just to make the gold files smaller
  hide = 'avg_flux flux_integral'
[]

(test/tests/conduction/boundary_and_volume/prism/nek.i)

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

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

[Mesh]
  type = NekRSMesh
  volume = true
  boundary = '2'
  order = FIRST
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  [max_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = max
  []
  [avg_T_volume]
    type = NekVolumeAverage
    field = temperature
  []
  [heat_flux]
    type = NekHeatFluxIntegral
    boundary = '2'
  []
  [nek_min_1]
    type = NekSideExtremeValue
    field = temperature
    boundary = '3'
    value_type = min
  []
  [nek_min_2]
    type = NekSideExtremeValue
    field = temperature
    boundary = '4'
    value_type = min
  []
  [nek_min_3]
    type = NekSideExtremeValue
    field = temperature
    boundary = '5'
    value_type = min
  []
  [nek_min_4]
    type = NekSideExtremeValue
    field = temperature
    boundary = '6'
    value_type = min
  []
  [nek_max_1]
    type = NekSideExtremeValue
    field = temperature
    boundary = '3'
  []
  [nek_max_2]
    type = NekSideExtremeValue
    field = temperature
    boundary = '4'
  []
  [nek_max_3]
    type = NekSideExtremeValue
    field = temperature
    boundary = '5'
  []
  [nek_max_4]
    type = NekSideExtremeValue
    field = temperature
    boundary = '6'
  []
[]

[Outputs]
  exodus = true
  time_step_interval = 30

  hide = 'flux_integral source_integral'
[]

(test/tests/transfers/nek_flux/nek.i)

dTv = 10
Tv = 5

[Problem]
  type = NekRSProblem
  casename = 'brick'

  [FieldTransfers]
    [flux]
      type = NekBoundaryFlux
      direction = from_nek
    []
  []

  [Dimensionalize]
    dT = ${dTv}
    T = ${Tv}
  []
[]

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

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []

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

[Postprocessors]
  [read_flux]
    type = ElementIntegralVariablePostprocessor
    variable = flux
  []
  [analytic_flux]
    type = ElementIntegralVariablePostprocessor
    variable = moose_flux
  []
  [max_error]
    type = ElementExtremeValue
    variable = d
  []
[]

[AuxVariables]
  [moose_flux]
  []
  [d]
  []
[]

[AuxKernels]
  [moose_flux]
    type = FunctionAux
    variable = moose_flux
    function = f
  []
  [d]
    type = ParsedAux
    variable = d
    expression = 'flux - moose_flux'
    coupled_variables = 'flux moose_flux'
  []
[]

[Functions]
  [f] # dimensionalized
    type = ParsedFunction
    expression = '2*(cos(y)+x*z) * ${dTv}'
  []
[]

[Materials]
  [k]
    type = GenericConstantMaterial
    prop_names = 'k'
    prop_values = '2'
  []
[]

[Outputs]
  csv = true
[]

(test/tests/nek_errors/usrwrk_transfers/wrong_problem.i)

[Mesh]
  [g]
    type = GeneratedMeshGenerator
    dim = 1
    nx = 5
  []
[]

[Problem]
  type = FEProblem

  [FieldTransfers]
    [flux]
      type = NekBoundaryFlux
      direction = to_nek
      usrwrk_slot = '1'
    []
  []
[]

[Executioner]
  type = Transient
[]

(test/tests/conduction/nonidentical_interface/cylinders/nek.i)

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

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

[Mesh]
  type = NekRSMesh
  order = FIRST
  boundary = '2'
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  [max_temp_nek]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = max
  []
  [min_temp_nek]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = min
  []
[]

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

(test/tests/auxkernels/heat_transfer_coefficient/nek.i)

[Problem]
  type = NekRSProblem
  casename = 'sfr_pin'
  synchronization_interval = constant
  constant_interval = 100
  n_usrwrk_slots = 1

  [FieldTransfers]
    [avg_flux]
      type = NekBoundaryFlux
      direction = to_nek
      usrwrk_slot = 0
      initial_flux_integral = 1000
    []
  []
[]

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

[UserObjects]
  [axial]
    type = LayeredBin
    num_layers = 5
    direction = z
  []
  [q]
    type = NekBinnedSideAverage
    field = usrwrk00
    bins = 'axial'
    boundary = '1'
    interval = 100
  []
  [Tw]
    type = NekBinnedSideAverage
    field = temperature
    bins = 'axial'
    boundary = '1'
    interval = 100
  []
  [Tinf]
    type = NekBinnedVolumeAverage
    field = temperature
    bins = 'axial'
    interval = 100
  []
[]

[AuxVariables]
  [h]
  []
[]

[AuxKernels]
  [h]
    type = HeatTransferCoefficientAux
    variable = h
    heat_flux = q
    wall_T = Tw
    bulk_T = Tinf
  []
[]

[ICs]
  [avg_flux]
    type = ConstantIC
    variable = avg_flux
    value = 10.0
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  # for the boundary mesh mirror, this is a boundary average integral
  [avg_h_uo]
    type = ElementAverageValue
    variable = h
  []

  [avg_wall_flux]
    type = NekSideAverage
    boundary = '1'
    field = usrwrk00
  []
  [avg_wall_T]
    type = NekSideAverage
    boundary = '1'
    field = temperature
  []
  [avg_bulk_T]
    type = NekVolumeAverage
    field = temperature
  []
  [avg_h]
    type = ParsedPostprocessor
    expression = 'avg_wall_flux/(avg_wall_T-avg_bulk_T)'
    pp_names = 'avg_wall_flux avg_wall_T avg_bulk_T'
  []
[]

[Outputs]
  csv = true
  time_step_interval = 100
  hide = 'avg_flux_integral'
[]

(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/cht/pincell_p_v/nek.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
    []
    [temp]
      type = NekFieldVariable
      field = temperature
      direction = from_nek
    []
    [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
    []
  []
[]

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

  # we dont have any volume-based coupling with NekRS, but by specifying
  # volume here, we will extract pressure and velocity on
  # a volume mesh mirror
  volume = true
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

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

(tutorials/sfr_7pin/nek_vpp.i)

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

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

  [FieldTransfers]
    [heat_flux]
      type = NekBoundaryFlux
      usrwrk_slot = 0
      direction = to_nek
      conserve_flux_by_sideset = true
    []
    [temperature]
      type = NekFieldVariable
      direction = from_nek
    []
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

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

[Postprocessors]
  [pin_flux_in_nek]
    type = NekHeatFluxIntegral
    boundary = '1'
  []
  [duct_flux_in_nek]
    type = NekHeatFluxIntegral
    boundary = '4'
  []
  [max_nek_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = max
  []
  [min_nek_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = min
  []
[]

(test/tests/conduction/zero_flux/nek_vpp.i)

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

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

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

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

(tutorials/pebble_cht/nek.i)

[Mesh]
  type = NekRSMesh

  # This is the boundary we are coupling via conjugate heat transfer to MOOSE
  boundary = '3'
[]

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

  [FieldTransfers]
    [flux]
      type = NekBoundaryFlux
      direction = to_nek
      usrwrk_slot = 0
    []
    [temp]
      type = NekFieldVariable
      direction = from_nek
      field = temperature
    []
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[UserObjects]
  [layered_bin]
    type = LayeredBin
    num_layers = 5
    direction = z
  []
  [wall_temp]
    type = NekBinnedSideAverage
    bins = 'layered_bin'
    boundary = '3'
    field = temperature
    map_space_by_qp = true
    interval = 10
  []
  [bulk_temp]
    type = NekBinnedVolumeAverage
    bins = 'layered_bin'
    field = temperature
    map_space_by_qp = true
    interval = 10
  []
[]

[VectorPostprocessors]
  [wall]
    type = SpatialUserObjectVectorPostprocessor
    userobject = wall_temp
  []
  [bulk]
    type = SpatialUserObjectVectorPostprocessor
    userobject = bulk_temp
  []
[]

[Outputs]
  exodus = true
  csv = true
  interval = 10
  hide = 'flux_integral'
[]

(tutorials/sfr_7pin/nek_fluxflux.i)

interval = 100

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

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

  [FieldTransfers]
    [heat_flux]
      type = NekBoundaryFlux
      direction = to_nek
      usrwrk_slot = 0
    []
    [temperature]
      type = NekFieldVariable
      direction = from_nek
    []
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true

  # this will only display the NekRS output every N time steps; postprocessors
  # are still computed on every step, just not output to the console
  time_step_interval = ${interval}
[]

[UserObjects]
  [axial_bin]
    type = LayeredBin
    direction = z
    num_layers = 20
  []
  [volume_bin]
    type = HexagonalSubchannelBin
    bundle_pitch = ${fparse 0.02625*1.1}
    pin_pitch = 0.00904000030292588
    pin_diameter = 8e-3
    n_rings = 2
  []
  [wall_flux]
    type = NekBinnedSideAverage
    bins = 'axial_bin volume_bin'
    boundary = '1'
    field = usrwrk00
    map_space_by_qp = true
    interval = ${interval}
    check_zero_contributions = false
  []
  [wall_temp]
    type = NekBinnedSideAverage
    bins = 'axial_bin volume_bin'
    boundary = '1'
    field = temperature
    map_space_by_qp = true
    interval = ${interval}
    check_zero_contributions = false
  []
  [bulk_temp]
    type = NekBinnedVolumeAverage
    bins = 'axial_bin volume_bin'
    field = temperature
    map_space_by_qp = true
    interval = ${interval}
    check_zero_contributions = false
  []
[]

[AuxVariables]
  [h]
  []
[]

[AuxKernels]
  [h]
    type = HeatTransferCoefficientAux
    variable = h
    wall_T = wall_temp
    bulk_T = bulk_temp
    heat_flux = wall_flux
  []
[]

[Postprocessors]
  [pin_flux_in_nek]
    type = NekHeatFluxIntegral
    boundary = '1'
  []
  [duct_flux_in_nek]
    type = NekHeatFluxIntegral
    boundary = '4'
  []
  [max_nek_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = max
  []
  [min_nek_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = min
  []
[]

(test/tests/conduction/zero_flux/nek_disjoint.i)

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

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

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

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
  csv = true
[]

[Postprocessors]
  [flux1]
    type = NekUsrWrkBoundaryIntegral
    usrwrk_slot = 0
    boundary = '1'
  []
  [flux2]
    type = NekUsrWrkBoundaryIntegral
    usrwrk_slot = 0
    boundary = '2'
  []
[]

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

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

[Problem]
  type = NekRSProblem
  casename = 'brick'
  n_usrwrk_slots = 7

  [FieldTransfers]
    [flux]
      type = NekBoundaryFlux
      direction = to_nek
      usrwrk_slot = '1'
    []
    [source]
      type = NekBoundaryFlux
      direction = to_nek
      usrwrk_slot = '2'
    []
  []

  [ScalarTransfers]
    [scalar]
      type = NekScalarValue
      direction = to_nek
      usrwrk_slot = '3'
    []
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

(tutorials/gas_compact_cht/nek.i)

!include common_input.i

[Mesh]
  type = NekRSMesh
  boundary = '3'
  volume = true
  scaling = ${channel_diameter}
[]

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

  [Dimensionalize]
    U = ${fparse mdot / (n_bundles * n_coolant_channels_per_block) / fluid_density / (pi * channel_diameter * channel_diameter / 4.0)}
    T = ${inlet_T}
    dT = ${fparse power / mdot / fluid_Cp * unit_cell_height / height}
    L = ${channel_diameter}
    rho = ${fluid_density}
    Cp = ${fluid_Cp}
  []

  [FieldTransfers]
    [flux]
      type = NekBoundaryFlux
      direction = to_nek
      usrwrk_slot = 0
    []
    [temperature]
      type = NekFieldVariable
      direction = from_nek
    []
  []

  synchronization_interval = parent_app
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
    min_dt = 1e-10
  []
[]

[Outputs]
  exodus = true

  [screen]
    type = Console
    hide = 'boundary_flux inlet_T outlet_T max_T flux_integral transfer_in'
  []

  [csv]
    file_base = 'csv/nek'
    type = CSV
  []
[]

[Postprocessors]
  [boundary_flux]
    type = NekHeatFluxIntegral
    boundary = '3'
  []
  [inlet_T]
    type = NekSideAverage
    field = temperature
    boundary = '1'
  []
  [outlet_T]
    type = NekSideAverage
    field = temperature
    boundary = '2'
  []
  [max_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = max
  []
[]

[UserObjects]
active = '' # simply comment out this line to evaluate these user objects
  [layered_bin]
    type = LayeredBin
    num_layers = ${num_layers_for_plots}
    direction = z
  []
  [wall_temp]
    type = NekBinnedSideAverage
    bins = 'layered_bin'
    boundary = '3'
    field = temperature
    map_space_by_qp = true
  []
  [bulk_temp]
    type = NekBinnedVolumeAverage
    bins = 'layered_bin'
    field = temperature
    map_space_by_qp = true
  []
[]

[VectorPostprocessors]
active = '' # simply comment out this line to evaluate these user objects
  [wall]
    type = SpatialUserObjectVectorPostprocessor
    userobject = wall_temp
  []
  [bulk]
    type = SpatialUserObjectVectorPostprocessor
    userobject = bulk_temp
  []
[]

(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 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 transfer_in'
  []
[]

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

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

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

  [FieldTransfers]
    [flux]
      type = NekBoundaryFlux
      direction = to_nek
      usrwrk_slot = 0
    []
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

(test/tests/nek_errors/usrwrk_transfers/flux.i)

[Mesh]
  type = NekRSMesh
  volume = true
[]

[Problem]
  type = NekRSProblem
  casename = 'brick'
  n_usrwrk_slots = 7

  [FieldTransfers]
    [flux]
      type = NekBoundaryFlux
      direction = to_nek
      usrwrk_slot = '1'
    []
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

(tutorials/fhr_reflector/conduction/nek.i)

fluid_solid_interface = '1 2 7'

[Mesh]
  type = NekRSMesh
  boundary = ${fluid_solid_interface}
  scaling = 0.006
[]

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

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

  [Dimensionalize]
    U = 0.0575
    T = 923.15
    dT = 10.0
    L = 0.006
    rho = 1962.13
    Cp = 2416.0
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

[Postprocessors]
  [boundary_flux]
    type = NekHeatFluxIntegral
    boundary = ${fluid_solid_interface}
  []
  [max_nek_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = max
  []
  [min_nek_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = min
  []
[]

(tutorials/gas_compact_multiphysics/nek.i)

# copy-pasta from common_input.i

channel_diameter = 0.016                 # diameter of the coolant channels (m)
height = 6.343                           # height of the full core (m)
inlet_T = 598.0                          # inlet fluid temperature (K)
power = 200e6                            # full core power (W)
mdot = 117.3                             # fluid mass flowrate (kg/s)
fluid_density = 5.5508                   # fluid density (kg/m3)
fluid_Cp = 5189.0                        # fluid isobaric specific heat (J/kg/K)
n_bundles = 12                           # number of bundles in the full core
n_coolant_channels_per_block = 108       # number of coolant channels per assembly
unit_cell_height = 1.6                   # unit cell height - arbitrarily selected

[Mesh]
  type = NekRSMesh
  boundary = '3'
  volume = true
  scaling = ${channel_diameter}
[]

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

  [Dimensionalize]
    U = ${fparse mdot / (n_bundles * n_coolant_channels_per_block) / fluid_density / (pi * channel_diameter * channel_diameter / 4.0)}
    T = ${inlet_T}
    dT = ${fparse power / mdot / fluid_Cp * unit_cell_height / height}
    L = ${channel_diameter}
    rho = ${fluid_density}
    Cp = ${fluid_Cp}
  []

  [FieldTransfers]
    [flux]
      type = NekBoundaryFlux
      direction = to_nek
      usrwrk_slot = 0
    []
    [temperature]
      type = NekFieldVariable
      direction = from_nek
    []
  []

  synchronization_interval = parent_app
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true

  [screen]
    type = Console
    hide = 'flux_integral transfer_in'
  []

  [csv]
    file_base = 'csv/nek'
    type = CSV
  []
[]

[Postprocessors]
  [inlet_T]
    type = NekSideAverage
    field = temperature
    boundary = '1'
  []
  [outlet_T]
    type = NekSideAverage
    field = temperature
    boundary = '2'
  []
  [max_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = max
  []
[]

(test/tests/conduction/identical_interface/cube/nek.i)

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

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

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

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

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

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

[Mesh]
  type = NekRSMesh
  boundary = '1'

  # nekRS solves with a length scale of meters, but nek_master.i is currently solving
  # in terms of centimeters. Therefore, just for the sake of data transfers, we need to
  # scale NekRSMesh to centimeters.
  scaling = 100.0
[]

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

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

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Outputs]
  exodus = true
[]

[Postprocessors]
  # This is the heat flux in the nekRS solution, i.e. it is not an integral
  # of nrs->usrwrk, instead this is directly an integral of k*grad(T)*hat(n).
  # So this should closely match 'flux_integral'
  [flux_in_nek]
    type = NekHeatFluxIntegral
    boundary = '1'
  []

  [max_nek_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = max
  []
  [min_nek_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = min
  []
[]

(test/tests/conduction/identical_interface/pyramid/nek.i)

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

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

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

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  [max_temp_nek]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = max
  []
  [min_temp_nek]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = min
  []
  [heat_flux]
    type = NekHeatFluxIntegral
    boundary = '2'
  []
[]

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

(test/tests/conduction/nonidentical_interface/cylinders/nek_mini.i)

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

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

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

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  [max_temp_nek]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = max
  []
  [min_temp_nek]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = min
  []
[]

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

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

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

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

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

[ICs]
  [avg_flux]
    type = ConstantIC
    variable = avg_flux
    value = 1.0
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

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

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

(test/tests/nek_errors/invalid_settings/nek_bc.i)

# The mesh file used for nekRS (brick.re2) has six sidesets numbered
# as 1, 2, 3, 4, 5, 6. In the nekRS input file (brick.par), we set
# these six boundaries to have insulated, insulated, specified flux,
# insulated, insulated, and insulated boundary conditions, respectively.
# Based on the data transfers assumed in/out from nekRS, we should throw
# an error if a flux boundary condition is not specified on the boundary
# we set for NekRSMesh, because otherwise that heat flux condition would
# never get used.

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

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

  [FieldTransfers]
    [flux]
      type = NekBoundaryFlux
      direction = to_nek
      usrwrk_slot = 0
    []
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

(test/tests/postprocessors/nek_point_value/usrwrk_units.i)

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

  [FieldTransfers]
    [avg_flux]
      type = NekBoundaryFlux
      initial_flux_integral = 1
      usrwrk_slot = 1
      direction = to_nek
    []
    [heat_source]
      type = NekVolumetricSource
      initial_source_integral = 2
      usrwrk_slot = 2
      direction = to_nek
    []
  []

  [Dimensionalize]
    L = 5.0
    U = 0.2
    T = 10.0
    dT = 200.0
    rho = 1000
    Cp = 3000
  []
[]

[Mesh]
  type = NekRSMesh
  boundary = '1'
  volume = true
  scaling = 5.0
[]

[ICs]
  [flux]
    type = FunctionIC
    variable = avg_flux
    function = f
  []
  [source]
    type = FunctionIC
    variable = heat_source
    function = s
  []
[]

[Functions]
  [f]
    type = ParsedFunction
    expression = '(100+200*x+300*y+400*z)/4e4'
  []
  [s]
    type = ParsedFunction
    expression = '(100+200*x+300*y+500*z)/2.937500e+05/1.106383e+00*2'
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  [u01]
    type = NekPointValue
    field = usrwrk01
    point = '0.25 0.3 0.27'
  []
  [u02]
    type = NekPointValue
    field = usrwrk02
    point = '0.25 0.3 0.27'
  []
  [integral_flux]
    type = SideIntegralVariablePostprocessor
    variable = avg_flux
    boundary = '1'
  []
  [integral_source]
    type = ElementIntegralVariablePostprocessor
    variable = heat_source
  []
[]

[Outputs]
  csv = true
  hide = 'avg_flux_integral heat_source_integral'
[]

(test/tests/transfers/nek_source/flux.i)

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

  [FieldTransfers]
    [src1]
      type = NekBoundaryFlux
      direction = to_nek
      usrwrk_slot = 1
      initial_flux_integral = 10
    []
    [src2]
      type = NekBoundaryFlux
      direction = to_nek
      usrwrk_slot = 0
      initial_flux_integral = 15
    []
  []
[]

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

[ICs]
  [src1]
    type = ConstantIC
    variable = src1
    value = 1
  []
  [src2]
    type = ConstantIC
    variable = src2
    value = 1
  []
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  [usrwrk1]
    type = NekUsrWrkBoundaryIntegral
    usrwrk_slot = 0
    boundary = '2'
  []
  [usrwrk2]
    type = NekUsrWrkBoundaryIntegral
    usrwrk_slot = 1
    boundary = '2'
  []
[]

[Outputs]
  csv = true
[]

(test/tests/conduction/nonidentical_interface/cylinders/nek_exact.i)

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

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

[Mesh]
  type = NekRSMesh
  order = FIRST
  exact = true
  boundary = '2'
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  [max_temp_nek]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = max
  []
  [min_temp_nek]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = min
  []
[]

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

(test/tests/conduction/boundary_and_volume/prism/nek_exact.i)

[Problem]
  type = NekRSProblem
  casename = 'pyramid_low'
  usrwrk_output = '0 1'
  usrwrk_output_prefix = 'flx src'
  n_usrwrk_slots = 2

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

[Mesh]
  type = NekRSMesh
  volume = true
  boundary = '2'
  order = FIRST
  exact = true
[]

[Executioner]
  type = Transient

  [TimeStepper]
    type = NekTimeStepper
  []
[]

[Postprocessors]
  [max_T]
    type = NekVolumeExtremeValue
    field = temperature
    value_type = max
  []
  [avg_T_volume]
    type = NekVolumeAverage
    field = temperature
  []
  [heat_flux]
    type = NekHeatFluxIntegral
    boundary = '2'
  []
  [nek_min_1]
    type = NekSideExtremeValue
    field = temperature
    boundary = '3'
    value_type = min
  []
  [nek_min_2]
    type = NekSideExtremeValue
    field = temperature
    boundary = '4'
    value_type = min
  []
  [nek_min_3]
    type = NekSideExtremeValue
    field = temperature
    boundary = '5'
    value_type = min
  []
  [nek_min_4]
    type = NekSideExtremeValue
    field = temperature
    boundary = '6'
    value_type = min
  []
  [nek_max_1]
    type = NekSideExtremeValue
    field = temperature
    boundary = '3'
  []
  [nek_max_2]
    type = NekSideExtremeValue
    field = temperature
    boundary = '4'
  []
  [nek_max_3]
    type = NekSideExtremeValue
    field = temperature
    boundary = '5'
  []
  [nek_max_4]
    type = NekSideExtremeValue
    field = temperature
    boundary = '6'
  []
[]

[Outputs]
  exodus = true
  time_step_interval = 30

  hide = 'flux_integral source_integral'
[]

Description
Flux Normalization
Example Input File Syntax
Input Parameters
Input Files