Cardinal Failure Analysis Report

[invalid_uo]
  type = RunException
  input = nek_bin_aux.i
  expect_err = "This auxkernel can only be combined with NekSpatialBinUserObject-derived classes!"
  requirement = "System shall error if auxkernel is not paired with a compatible bin user object."
  capabilities = 'nekrs'
[]

[invalid_field]
  type = RunException
  input = invalid_field.i
  expect_err = "This auxkernel can only be used with a binning user object that sets 'field = velocity_component'!"
  requirement = "System shall error if auxkernel is not paired with a velocity vector bin user object."
  capabilities = 'nekrs'
[]

[duplicate_temp]
  type = RunException
  input = nek.i
  cli_args = "AuxVariables/heat_source/order=FIRST"
  expect_err = "Cardinal is trying to add an auxiliary variable named 'heat_source', but you already have a variable by this name."
  requirement = "The system shall error if the user specifies a duplicate variable with a name overlapping with special names reserved for Cardinal data transfers."
  capabilities = 'nekrs'
[]

[mismatch_length]
  type = RunException
  input = mismatch_main.i
  expect_err = "The sideset flux reporter transferred to NekRS must have a length equal to"
  requirement = "The system shall print a helpful error message if the sideset flux reporter does not have the correct length."
  capabilities = 'nekrs'
[]

[nodes_on_shared]
  type = RunException
  input = main_shared.i
  expect_err = "Flux normalization process failed!"
  requirement = "The system shall error if conserving flux on each unique sideset, but with nodes shared across multiple sidesets."
  capabilities = 'nekrs'
[]

[wrong_uo]
  type = RunException
  input = error.i
  expect_err = 'The given UserObject does not exist or it is not a OpenMCNuclideDensities object'
  requirement = 'The system shall error if the controls is not used with the proper user object'
  capabilities = 'openmc'
[]

[missing_initial]
  type = RunException
  input = sinusoidal_z.i
  expect_err = "The 'execute_on' parameter for the 'vol' postprocessor must include 'initial'!"
  cli_args = 'Postprocessors/vol/execute_on=final'
  requirement = 'The volume postprocessor must have execute_on initial'
[]

[invalid_mdot_cp]
  type = RunException
  input = sinusoidal_z.i
  cli_args = "ICs/fluid_temp/mass_flowrate=0.0"
  expect_err = "Product of mass flowrate and specific heat cannot be zero!"
  requirement = 'The system shall error if invalid parameters are provided'
[]

[missing_paired_action]
  type = RunException
  input = no_heat_source.i
  expect_err = "To use the 'BulkEnergyConservation' action syntax, you must also have a 'VolumetricHeatSource' action!"
  requirement = 'The system shall error if the pairing heat source action is missing'
[]

[invalid_id]
  type = RunException
  input = six.i
  cli_args = "Mesh/to_hex20/polygon_boundary='59' --mesh-only"
  expect_err = "Boundary '59' was not found in the mesh!"
  requirement = "The system shall error if the boundary specified for corner fitting does not exist"
[]

[duplicate_boundary]
  type = RunException
  input = six.i
  cli_args = "Mesh/to_hex20/boundary='1' Mesh/to_hex20/radius=0.1 Mesh/to_hex20/polygon_boundary='1' --mesh-only"
  expect_err = "The 'polygon_boundary' cannot also be listed in the 'boundary'!"
  requirement = "The system shall error if an invalid polygon boundary is provided"
[]

[too_big_radius]
  type = RunException
  input = six.i
  cli_args = "Mesh/to_hex20/corner_radius=0.016 --mesh-only"
  expect_err = "Specified 'corner_radius' cannot fit within the specified polygon!\nThe maximum allowable radius of curvature is: 0.015"
  requirement = "The system shall error if the radius of curvature is too big to fit inside the polygon"
[]

[corners_translate_rotate]
  type = RunException
  input = six_translate.i
  cli_args = "Mesh/to_hex20/rotation_angle=30.0 --mesh-only"
  expect_err = "Cannot specify a non-zero 'rotation_angle' when providing custom 'polygon_origins'!"
  requirement = "The system shall error if applying a rotation angle to a polygon not centered on (0, 0)"
[]

[invalid_number_of_smoothing]
  type = RunException
  input = six_with_smoothing.i
  cli_args = 'Mesh/to_hex20/polygon_layer_smoothing="1.0 1.0" --mesh-only'
  expect_err = "The length of 'polygon_layer_smoothing' must be equal to 'polygon_layers'!"
  requirement = "The system shall error if the length of smoothing adjustments does not equal the number of polygon layers"
[]

[zero_smoothing]
  type = RunException
  input = six_with_smoothing.i
  cli_args = 'Mesh/to_hex20/polygon_layer_smoothing="1.0 1.0 0.0" --mesh-only'
  expect_err = "Each entry in 'polygon_layer_smoothing' must be positive and non-zero!"
  requirement = "The system shall error if the length of smoothing adjustments are not set to valid values"
[]

[invalid_elem]
  type = RunException
  input = invalid_elem.i
  cli_args = '--mesh-only'
  expect_err = "This mesh generator can only be applied to meshes that contain QUAD9 or HEX27 elements!"
  requirement = "The system shall error if an invalid element type is used with a quad9 to quad8 converter"
[]

[multiple_sides]
  type = RunException
  input = multiple_sides.i
  cli_args = '--mesh-only'
  expect_err = "This mesh generator cannot be applied to elements that have more than one face on the circular sideset!"
  requirement = "The system shall error if attempting to move elements to a circular surface when those elements have more than one face on the circular sideset."
[]

[repeated_sides]
  type = RunException
  input = repeated_sides.i
  cli_args = '--mesh-only'
  expect_err = "This mesh generator does not support elements with the same face existing on multiple moving side sets!"
  requirement = "The system shall error if attempting to move elements to a circular surface when those elements have more than one face on the circular sidesets."
[]

[invalid_id]
  type = RunException
  input = invalid_id.i
  cli_args = '--mesh-only'
  expect_err = "Boundary '10' was not found in the mesh!"
  requirement = "The system shall error if the boundary specified for circular sideset fitting does not exist"
[]

[convert_some_sidsets_invalid]
  type = RunException
  input = convert_some_sidesets.i
  cli_args = '--mesh-only Mesh/to_quad8/boundaries_to_rebuild="rma"'
  expect_err = "Boundary 'rma' was not found in the mesh!"
  requirement = "The system shall error if the boundary specified for rebuilding sidesets does not exist"
[]

[point_already_on_origin]
  type = RunException
  input = offcenter.i
  cli_args = 'Mesh/to_quad8/boundary="3" --mesh-only'
  expect_err = "Node ID 0 of element 0 is already on the origin \(0, 0, 0\).\nThis node lacks the nonzero unit vector needed to move it."
  requirement = "The system shall error if a point is already located on the origin, because then it lacks a nonzero unit vector to move it to a circular surface."
[]

[layers_too_many]
  type = RunException
  input = multiple_origins.i
  cli_args = 'Mesh/to_quad8/layers="10" --mesh-only'
  expect_err = "Boundary layer sweeping requires finding exactly one neighbor element"
  requirement = "The system shall error if there is an obvious mismatch between the number of boundary layers and the mesh."
[]

[invalid_elem]
  type = RunException
  input = invalid_elem.i
  cli_args = '--mesh-only'
  expect_err = "This mesh generator can only be applied to meshes that contain QUAD9 or HEX27 elements!"
  requirement = "The system shall error if an invalid element type is used with a hex27 to hex20 converter"
[]

[multiple_sides]
  type = RunException
  input = multiple_sides.i
  cli_args = '--mesh-only'
  expect_err = "This mesh generator cannot be applied to elements that have more than one face on the circular sideset!"
  requirement = "The system shall error if attempting to move elements to a circular surface when those elements have more than one face on the circular sideset."
[]

[repeated_sides]
  type = RunException
  input = repeated_sides.i
  cli_args = '--mesh-only'
  expect_err = "This mesh generator cannot be applied to elements that have more than one face on the circular sideset!"
  requirement = "The system shall error if attempting to move elements to a circular surface when those elements have more than one face on the circular sidesets."
[]

[invalid_id]
  type = RunException
  input = invalid_id.i
  cli_args = '--mesh-only'
  expect_err = "Boundary '10' was not found in the mesh!"
  requirement = "The system shall error if the boundary specified for circular sideset fitting does not exist"
[]

[convert_some_sidsets_invalid]
  type = RunException
  input = convert_some_sidesets.i
  cli_args = '--mesh-only Mesh/to_hex20/boundaries_to_rebuild="rma"'
  expect_err = "Boundary 'rma' was not found in the mesh!"
  requirement = "The system shall error if the boundary specified for rebuilding sidesets does not exist"
[]

[invalid_radius]
  type = RunException
  input = convert_multiple.i
  cli_args = 'Mesh/to_hex20/radius="0.05 -0.01" --mesh-only'
  expect_err = "All entries in 'radius' must be non-zero and positive!"
  requirement = "The system shall error if the invalid values are used for the radii."
[]

[mismatch_radius_length]
  type = RunException
  input = convert_multiple.i
  cli_args = 'Mesh/to_hex20/radius="0.05" --mesh-only'
  expect_err = "'boundary' and 'radius' must be the same length!"
  requirement = "The system shall error if the radius and boundary are not the same length."
[]

[mismatch_origin_length]
  type = RunException
  input = convert_multiple.i
  cli_args = 'Mesh/to_hex20/origins="0.0 0.0 0.0" --mesh-only'
  expect_err = "'boundary' and 'origins' must be the same length!"
  requirement = "The system shall error if the origin and boundary are not the same length."
[]

[mismatch_origin_file_length]
  type = RunException
  input = convert_multiple.i
  cli_args = 'Mesh/to_hex20/origins_files="a.txt" --mesh-only'
  expect_err = "'boundary' and 'origins_files' must be the same length!"
  requirement = "The system shall error if the origin and boundary are not the same length."
[]

[mismatch_origin_space]
  type = RunException
  input = convert_multiple.i
  cli_args = 'Mesh/to_hex20/origins="0.0 0.0; 0.0 0.0" --mesh-only'
  expect_err = "When using multiple origins for one boundary, each entry in 'origins' must have a length\ndivisible by 3 to represent \(x, y, z\) coordinates!"
  requirement = "The system shall error if the origin entries are not the correct length."
[]

[mismatch_origin_empty]
  type = RunException
  input = convert_multiple.i
  cli_args = 'Mesh/to_hex20/origins=" ; 0.0 0.0 0.0" --mesh-only'
  expect_err = "Zero-length entry in 'origins' detected! Please be sure that each entry in 'origins' has a length\ndivisible by 3 to represent \(x, y, z\) coordinates."
  requirement = "The system shall error if the origin entries are not the correct length."
[]

[layers_length]
  type = RunException
  input = layers.i
  cli_args = 'Mesh/to_hex20/layers="0 1" --mesh-only'
  expect_err = "'boundary' and 'layers' must be the same length!"
  requirement = "The system shall error if the number of layers does not match the number of boundaries to move"
[]

[layers_too_many]
  type = RunException
  input = layers.i
  cli_args = 'Mesh/to_hex20/layers="10" --mesh-only'
  expect_err = "Boundary layer sweeping requires finding exactly one neighbor element"
  requirement = "The system shall error if there is an obvious mismatch between the number of boundary layers and the mesh."
[]

[too_many_origins]
  type = RunException
  input = multiple_origins.i
  cli_args = 'Mesh/to_hex20/origins_files=a.txt --mesh-only'
  expect_err = "Cannot specify both 'origins' and 'origins_files'!"
  requirement = "The system shall error if trying to set the origins in more than one manner"
[]

[invalid_origin_length]
  type = RunException
  input = multiple_origins_files.i
  cli_args = "Mesh/to_hex20/origins_files=invalid_origins.txt --mesh-only"
  expect_err = "All entries in 'invalid_origins.txt' must contain exactly 3 entries to represent \(x, y, z\) coordinates!"
  requirement = "The system shall error if invalid points are provided for the origins"
[]

[invalid_directory]
  type = RunException
  input = nek.i
  cli_args = 'Problem/casename="invalid/pyramid"'
  expect_err = "Failed to find 'invalid/'! Did you set the 'casename' correctly?"
  requirement = "The system shall error if an invalid directory path is provided for the case"
  capabilities = 'nekrs'
[]

[invalid_write_fld]
  type = RunException
  input = nek.i
  expect_err = "The 'write_fld_files' setting should only be true when multiple Nek simulations are run as sub-apps on a master app. Your input has Nek as the master app."
  requirement = "The system shall error if trying to write output files for a Nek input without sibling apps"
  capabilities = 'nekrs'
[]

[missing_mesh_solver]
  type = RunException
  input = nek.i
  cli_args = "Mesh/displacements='disp_x disp_y disp_z' Problem/casename='nomesh_solver' --error"
  capabilities = 'nekrs'
  max_parallel = 64
  expect_err = "Your NekRSMesh has 'displacements', but 'nomesh_solver.par' does not have a"
  requirement = "The system shall error if Cardinal has displacements associated with NekRSMesh, but there is no mesh solver."
[]

[missing_mv_boundary]
  type = RunException
  input = nek.i
  cli_args = "Mesh/volume=false Mesh/boundary='2' Mesh/displacements='disp_x disp_y disp_z'"
  capabilities = 'nekrs'
  max_parallel = 64

  expect_err = "For boundary-coupled moving mesh problems, you need at least one boundary in"
  requirement = "The system shall error if the Nek .par file has a mesh solverbut the nekRS .par file has no moving mesh (codedFixedValue) boundary in the [Mesh] block."
[]

[missing_boundary]
  type = RunException
  input = nek.i
  cli_args = "Mesh/volume=true Mesh/displacements='disp_x disp_y disp_z'"
  capabilities = 'nekrs'
  max_parallel = 64
  expect_err = "'elast_nomv.par' has a solver in the"
  requirement = "The system shall error if Cardinal is using the NekRS mesh blending solver without indicating the moving boundary of interest"
[]

[displacements]
  type = RunException
  input = nek.i
  expect_err = "Moving mesh problems require 'displacements' in the \[Mesh\] block!"
  capabilities = 'nekrs'
  requirement = "The system shall error if NekRSMesh is not paired with displacements for moving mesh problems."
[]

[volume_for_user_solver]
  type = RunException
  input = nek.i
  cli_args = "Mesh/volume=false Mesh/displacements='disp_x disp_y disp_z'"
  capabilities = 'nekrs'
  expect_err = "'user.par' has 'solver = user' in the"
  requirement = "The system shall error if Cardinal has solver=user in the par file's MESH block, but there is no volume mesh mirror."
[]

[invalid_boundary_id]
  type = RunException
  input = nek.i

  # nekRS can't use more processors than elements
  max_parallel = 12

  expect_err = "Invalid 'boundary' entry: 8\n\nnekRS assumes the boundary IDs are ordered contiguously beginning at 1. For this problem, nekRS has 6 boundaries. Did you enter a valid 'boundary' in 'nek.i'?"
  requirement = "MOOSE shall throw an error if an invalid boundary is specified for the construction of nekRS's mesh as a MooseMesh."
  capabilities = 'nekrs'
[]

[temperature]
  type = RunException
  input = nek.i
  expect_err = "Cannot find 'temperature' because your Nek case files do not have a temperature variable!"
  requirement = "The system shall throw an error if trying to use temperature as a field for cases that do not have a temperature variable"
  capabilities = 'nekrs'
[]

[scalar01]
  type = RunException
  input = nek.i
  cli_args = 'Postprocessors/max/field=scalar01'
  expect_err = "Cannot find 'scalar01' because your Nek case files do not have a scalar01 variable!"
  requirement = "The system shall throw an error if trying to use scalar01 as a field for problems that don't have a scalar01 variable."
  capabilities = 'nekrs'
[]

[scalar02]
  type = RunException
  input = nek.i
  cli_args = 'Postprocessors/max/field=scalar02'
  expect_err = "Cannot find 'scalar02' because your Nek case files do not have a scalar02 variable!"
  requirement = "The system shall throw an error if trying to use scalar02 as a field for problems that don't have a scalar02 variable."
  capabilities = 'nekrs'
[]

[scalar03]
  type = RunException
  input = nek.i
  cli_args = 'Postprocessors/max/field=scalar03'
  expect_err = "Cannot find 'scalar03' because your Nek case files do not have a scalar03 variable!"
  requirement = "The system shall throw an error if trying to use scalar03 as a field for problems that don't have a scalar03 variable."
  capabilities = 'nekrs'
[]

[usrwrk00]
  type = RunException
  input = nek.i
  cli_args = 'Postprocessors/max/field=usrwrk00 Problem/n_usrwrk_slots=0'
  expect_err = "Cannot find 'usrwrk00' because you have only allocated 'n_usrwrk_slots = 0'"
  requirement = "The system shall throw an error if trying to use usrwrk00 as a field for problems that don't have sufficient usrwrk slots."
  capabilities = 'nekrs'
[]

[usrwrk01]
  type = RunException
  input = nek.i
  cli_args = 'Postprocessors/max/field=usrwrk01 Problem/n_usrwrk_slots=1'
  expect_err = "Cannot find 'usrwrk01' because you have only allocated 'n_usrwrk_slots = 1'"
  requirement = "The system shall throw an error if trying to use usrwrk01 as a field for problems that don't have sufficient usrwrk slots."
  capabilities = 'nekrs'
[]

[usrwrk02]
  type = RunException
  input = nek.i
  cli_args = 'Postprocessors/max/field=usrwrk02 Problem/n_usrwrk_slots=2'
  expect_err = "Cannot find 'usrwrk02' because you have only allocated 'n_usrwrk_slots = 2'"
  requirement = "The system shall throw an error if trying to use usrwrk02 as a field for problems that don't have sufficient usrwrk slots."
  capabilities = 'nekrs'
[]

[duplicate_auxvar]
  type = RunException
  input = auxvar.i
  expect_err = "Cardinal is trying to add an auxiliary variable named 'temp', but you already have a variable by this name."
  requirement = "The system shall error if the user manually specifies a duplicate name for an output field."
  capabilities = 'nekrs'
[]

[duplicate_var]
  type = RunException
  input = nonlinear.i
  expect_err = "Cardinal is trying to add a nonlinear variable named 'temp', but you already have a variable by this name."
  requirement = "The system shall error if the user manually specifies a duplicate name for an output field."
  capabilities = 'nekrs'
[]

[executioner]
  type = RunException
  input = executioner.i
  expect_err = "A 'Transient' executioner must be used with NekRSProblem, but you have specified the 'Steady' executioner!"
  requirement = "The system shall error if NekRSProblem is not paired with the correct executioner."
  max_parallel = 12
  capabilities = 'nekrs'
[]

[dimensionalize]
  type = RunException
  input = dimensionalize.i
  expect_err = "The \[Dimensionalize\] block can only be used with wrapped Nek cases!"
  requirement = "The system shall error if the Dimensionalize action is not paired with the correct problem."
  max_parallel = 12
  capabilities = 'nekrs'
[]

[mesh]
  type = RunException
  input = mesh.i
  expect_err = "The mesh for NekRSProblem must be of type 'NekRSMesh', but you have specified a 'GeneratedMesh'!"
  requirement = "The system shall error if NekRSProblem is not paired with the correct mesh type."
  max_parallel = 12
  capabilities = 'nekrs'
[]

[problem_base]
  type = RunException
  input = problem_base.i
  expect_err = "NekBinnedVolumeAverage can only be used with NekRS-wrapped cases!"
  requirement = "The system shall error if a Nek object is not paired with the correct problem."
  max_parallel = 12
  capabilities = 'nekrs'
[]

[problem_mesh]
  type = RunException
  input = problem_mesh.i
  expect_err = "This mesh can only be used with wrapped Nek cases!"
  requirement = "The system shall error if a NekRSMesh is used without a corresponding Nek-wrappedproblem."
  max_parallel = 12
  capabilities = 'nekrs'
[]

[timestepper]
  type = RunException
  input = timestepper.i
  expect_err = "The 'NekTimeStepper' stepper must be used with NekRSProblem, but you have specified the 'ConstantDT' time stepper!"
  requirement = "The system shall error if NekRSProblem is not paired with the correct time stepper."
  max_parallel = 12
  capabilities = 'nekrs'
[]

[missing_flux_bc]
  type = RunException
  input = nek_bc.i
  expect_err = "In order to send a boundary heat flux to NekRS, you must have a heat flux condition for each 'boundary' set in 'NekRSMesh'! Boundary 2 is of type 'zeroGradient' instead of 'fixedGradient'."
  requirement = "MOOSE shall throw an error if there is no receiving heat flux boundary condition on the nekRS boundaries that are coupled to MOOSE."
  max_parallel = 12
  capabilities = 'nekrs'
[]

[boundary_id]
  type = RunException
  input = boundary_id.i
  expect_err = "Invalid 'boundary' entry: 8\n\nnekRS assumes the boundary IDs are ordered contiguously beginning at 1. For this problem, nekRS has 6 boundaries. Did you enter a valid 'boundary'?"
  requirement = "MOOSE shall throw an error if an invalid boundary is specified for the construction of nekRS's mesh as a MooseMesh."
  max_parallel = 12
  capabilities = 'nekrs'
[]

[scaling_mismatch]
  type = RunException
  input = mesh_scaling.i
  expect_err = "If solving NekRS in nondimensional form, you must choose reference dimensional scales in the same units as expected by MOOSE,"
  requirement = "The system shall error if there is a mismatch between the scaling of the mesh and NekRS problem."
  max_parallel = 12
  capabilities = 'nekrs'
[]

[invalid_transfer_pp]
  type = RunException
  input = nek_master.i
  expect_err = "The default value for the 'transfer_in' postprocessor received by nekRS must not be false! Make sure that the master application's postprocessor is not zero."
  requirement = "When using the minimized transfers setting, the default value for the postprocessor in the master application must not be zero."
  capabilities = 'nekrs'
[]

[too_few_mpi_ranks]
  type = RunException
  input = nek_master.i

  # The error message we are checking is specific to the case where the MPI ranks are fewer
  # than the number of Nek cases (3 for this example). This test will pass with 2 processes
  # if you did precompilation, but because we can't do that easily on CIVET, we just restrict
  # this test to 1 process.
  max_parallel = 1
  min_parallel = 1

  expect_err = "NekRS does not currently support setting up multiple cases with the same MPI communicator."
  requirement = "The system shall error if the same MPI communicator is used to set up more than one Nek case."
  capabilities = 'nekrs'
[]

[no_occa_source_kernel]
  type = RunException
  input = nek.i

  # nekRS can't use more processors than elements
  max_parallel = 8

  expect_err = "In order to send a volumetric heat source to NekRS, you must have an OCCA source kernel in the passive scalar equations"
  requirement = "The system shall throw an error if there is no heat source kernel when using volume coupling"
  capabilities = 'nekrs'
[]

[flux]
  type = RunException
  input = nek.i

  # nekRS can't use more processors than elements
  max_parallel = 8

  expect_err = "By setting 'solver = none' for temperature in 'brick.par', NekRS will not solve for temperature. The heat flux sent by this object will be unused."
  cli_args = '--error'
  requirement = "MOOSE shall throw a warning if there is no temperature passive scalar solve in NekRS when passing heat flux"
  capabilities = 'nekrs'
[]

[source]
  type = RunException
  input = source.i

  # nekRS can't use more processors than elements
  max_parallel = 8

  expect_err = "By setting 'solver = none' for temperature in 'brick.par', NekRS will not solve for temperature. The volumetric heat source sent by this object will be unused."
  cli_args = '--error'
  requirement = "MOOSE shall throw a warning if there is no temperature passive scalar solve in NekRS when passing heat flux"
  capabilities = 'nekrs'
[]

[flux]
  type = RunException
  input = nek.i
  expect_err = "In order to read or write NekRS's boundary heat flux, your case files must have a \[TEMPERATURE\] block. Note that you can set 'solver = none' in 'brick.par' if you don't want to solve for temperature."
  requirement = "MOOSE shall throw an error if there is no temperature passive scalar variable initialized in nekRS for flux coupling."
  capabilities = 'nekrs'
[]

[source]
  type = RunException
  input = source.i
  expect_err = "In order to send a volumetric heat source to NekRS, your case files must have a \[TEMPERATURE\] block. Note that you can set 'solver = none' in 'brick.par' if you don't want to solve for temperature."
  requirement = "MOOSE shall throw an error if there is no temperature passive scalar variable initialized in nekRS for source coupling."
  capabilities = 'nekrs'
[]

[occupied_scratch_space]
  type = RunException
  input = nek.i
  expect_err = "The nrs_t.usrwrk and nrs_t.o_usrwrk arrays are automatically allocated by Cardinal"
  requirement = "MOOSE shall throw an error if the user attempts to allocate the scratch space arrays in NekRS, since they are automatically allocated by Cardinal."
  capabilities = 'nekrs'
[]

[duplicate_scratch]
  type = RunException
  input = nek.i
  cli_args = 'Problem/FieldTransfers/flux/usrwrk_slot="1 1"'
  expect_err = "There are duplicate entries in 'usrwrk_slot': 1 1 ; duplicate entries are not allowed because the field transfer will overwrite itself."
  requirement = "MOOSE shall throw an error if a single transfer tries to occupy the same slot more than once"
  capabilities = 'nekrs'
[]

[exceed_allocated_field]
  type = RunException
  input = nek.i
  cli_args = 'Problem/FieldTransfers/flux/usrwrk_slot="7"'
  expect_err = "Cannot write into usrwrk slot 7 because only 7 have been allocated with 'n_usrwrk_slots'. Slots are zero-indexed, so the maximum acceptable value in 'usrwrk_slot' is 6."
  requirement = "MOOSE shall throw an error if a attempting to write a field into a usrwrk slot which has not been allocated"
  capabilities = 'nekrs'
[]

[exceed_allocated_scalar]
  type = RunException
  input = nek.i
  cli_args = 'Problem/ScalarTransfers/scalar/usrwrk_slot="7"'
  expect_err = "Cannot write into usrwrk slot 7 because only 7 have been allocated with 'n_usrwrk_slots'. Slots are zero-indexed, so the maximum acceptable value in 'usrwrk_slot' is 6."
  requirement = "MOOSE shall throw an error if a attempting to write a scalar into a usrwrk slot which has not been allocated"
  capabilities = 'nekrs'
[]

[field_duplicated_by_field]
  type = RunException
  input = nek.i
  cli_args = 'Problem/FieldTransfers/flux/usrwrk_slot="2"'
  expect_err = "A duplicate slot, 2, is being used by another FieldTransfer."
  requirement = "MOOSE shall throw an error if a attempting to write a field into a usrwrk slot already claimed by another field transfer"
  capabilities = 'nekrs'
[]

[scalar_duplicated_by_field]
  type = RunException
  input = scalar.i
  expect_err = "The usrwrk slot 3 is already used by the FieldTransfers for writing field data into NekRS. You cannot set 'usrwrk_slot' to any of: 3 4"
  requirement = "MOOSE shall throw an error if a attempting to write a scalar into a usrwrk slot already claimed by a field transfer"
  capabilities = 'nekrs'
[]

[flux_no_boundary]
  type = RunException
  input = flux.i
  expect_err = "NekBoundaryFlux can only be used when there is boundary coupling of NekRS with MOOSE, i.e. when 'boundary' is provided in NekRSMesh."
  requirement = "The system shall error when a boundary flux transfer is applied when there is not boundary coupling"
  capabilities = 'nekrs'
[]

[source_no_volume]
  type = RunException
  input = source.i
  cli_args = 'Mesh/volume=false Mesh/boundary="6" Problem/FieldTransfers/source/usrwrk_slot="0"'
  expect_err = "The NekVolumetricSource object can only be used when there is volumetric coupling of NekRS with MOOSE, i.e. when 'volume = true' in NekRSMesh."
  requirement = "The system shall error when a volumetric source transfer is applied when there is not volume coupling"
  capabilities = 'nekrs'
[]

[flux_slots]
  type = RunException
  input = flux.i
  cli_args = 'Mesh/boundary="6" Problem/FieldTransfers/flux/usrwrk_slot="1 2"'
  expect_err = "'usrwrk_slot' must be of length 1 for boundary flux transfers; you have entered a vector of length 2"
  requirement = "The system shall error when the usrwrk slot request does not match the needed number of slots for a flux transfer"
  capabilities = 'nekrs'
[]

[source_slots]
  type = RunException
  input = source.i
  expect_err = "'usrwrk_slot' must be of length 1 for volumetric source transfers; you have entered a vector of length 2"
  requirement = "The system shall error when the usrwrk slot request does not match the needed number of slots for a source transfer"
  capabilities = 'nekrs'
[]

[problem_field]
  type = RunException
  input = wrong_problem.i
  expect_err = "The \[FieldTransfers\] block can only be used with wrapped Nek cases! You need to change the \[Problem\] block to 'NekRSProblem'."
  requirement = "The system shall error if trying to use field transfer syntax only relevant for NekRS wrapped cases with a non-Nek case."
  capabilities = 'nekrs'
[]

[problem_scalar]
  type = RunException
  input = wrong_problem_s.i
  expect_err = "The \[ScalarTransfers\] block can only be used with wrapped Nek cases! You need to change the \[Problem\] block to 'NekRSProblem'."
  requirement = "The system shall error if trying to use scalar transfer syntax only relevant for NekRS wrapped cases with a non-Nek case."
  capabilities = 'nekrs'
[]

[second_exact]
  type = RunException
  input = exact.i
  cli_args = 'Mesh/order=SECOND'
  expect_err = "When building an exact mesh mirror, the 'order' must be FIRST!"
  requirement = "The system shall error if trying to build an exact mesh mirror that is second order."
  capabilities = 'nekrs'
[]

[too_high_slot]
  type = RunException
  input = nek_fld.i
  expect_err = "Cannot write field file for usrwrk slot greater than the total number of allocated slots: 2!"
  requirement = "The system shall error if trying to write a usrwrk slot greater than the total number of allocated slots"
  capabilities = 'nekrs'
[]

[mismatch_length]
  type = RunException
  input = nek_fld.i
  cli_args = 'Problem/usrwrk_output="0 1" Problem/usrwrk_output_prefix="abc"'
  expect_err = "The length of 'usrwrk_output' must match the length of 'usrwrk_output_prefix'!"
  requirement = "The system shall error if there is a mismatch between parameter lengths for writing usrwrk field files"
  capabilities = 'nekrs'
[]

[bad_name]
  type = RunException
  input = bad_name.i
  expect_err = "We tried to choose a default 'field' as 'temp', but this value is not an option in the 'field' enumeration. Please provide the 'field' parameter."
  requirement = "The system shall error if the default choice for the field cannot be matched from the object name."
  capabilities = 'nekrs'
[]

[invalid_mesh_solid]
  type = RunException
  input = nek.i
  cli_args = 'Postprocessors/Area_BC3_flow/mesh="solid"'
  expect_err = "This object does not support operations on the solid part of the NekRS mesh!"
  requirement = "The system shall throw an error if trying to act on only the NekRS solid mesh for side postprocessors."
  capabilities = 'nekrs'
[]

[adaptive_mesh_template]
  type = RunException
  input = mesh.i
  cli_args = "Problem/Tallies/Mesh/mesh_template='../meshes/sphere.e'"
  mesh_mode = 'replicated'
  expect_err = "Adaptivity is not supported when loading a mesh from 'mesh_template'!"
  requirement = "The system shall error if adaptivity is active and tallying on a mesh template instead of the mesh block."
  capabilities = 'openmc'
[]

[adaptive_relaxation]
  type = RunException
  input = cell.i
  cli_args = "Problem/relaxation='constant'"
  expect_err = "When adaptivity is requested or a displaced problem is used, the mapping from the OpenMC model to the \[Mesh\] may vary in time."
  requirement = "The system shall error if adaptivity is active and a relaxation scheme is requested."
  capabilities = 'openmc'
[]

[unmapped_cells]
  type = RunException
  input = unmapped_cells.i
  cli_args = '--error'
  expect_err = "Your DAGMC geometry contains unmapped cells! The skinner assumes that the DAG geometry used in the OpenMC model maps one to one to the mesh mirror; if that is not the case the skinner may delete some parts of your OpenMC model when the underlying geometry is regenerated. You have 1 unmapped DAGMC cells out of 3 DAGMC cells."
  requirement = "The system shall warn the user when there is a mismatch between the mesh mirror and the initial OpenMC DAGMC geometry."
  capabilities = 'dagmc'
[]

[cannot_skin_solid]
  type = RunException
  input = only_solid.i
  expect_err = "Detected inconsistent settings for density skinning and 'density_blocks'"
  requirement = "The system shall error if attempting to apply density skinning without any fluid blocks ready to receive variable density."
  mesh_mode = 'replicated'
  capabilities = 'dagmc'
[]

[mismatch]
  type = RunException
  input = openmc.i
  expect_err = "The 'skinner' expects to find one OpenMC material mapped to each \[Mesh\] subdomain, but 2 materials\nmapped to subdomain 1. This indicates your \[Mesh\] is not consistent with the .h5m model.\n\nThe materials which mapped to subdomain 1 are:\n\n1\n2"
  requirement = "The system shall error if there is an obvious mismatch between the [Mesh] and DAGMC model for the case where the number of DAGMC materials which map to each [Mesh] subdomain do not match."
  capabilities = 'dagmc'
[]

[wrong_uo]
  type = RunException
  input = wrong_uo.i
  expect_err = "The 'skinner' user object must be of type MoabSkinner!"
  requirement = "The system shall error if the skinner user object is not the correct type"
  capabilities = 'dagmc'
[]

[missing_graveyard]
  type = RunException
  input = missing_graveyard.i
  cli_args = '--error'
  expect_err = "Overriding graveyard setting from false to true.\nTo hide this warning, set 'build_graveyard = true'"
  requirement = "The system shall warn if the graveyard is missing for OpenMC skinned models"
  capabilities = 'dagmc'
[]

[no_symmetry]
  type = RunException
  input = no_symmetry.i
  expect_err = "Cannot combine the 'skinner' with 'symmetry_mapper'!"
  requirement = "The system shall error if applying a symmetry mapping to an OpenMC model which must already exactly match the mesh."
  capabilities = 'dagmc'
[]

[properties]
  type = RunException
  input = properties.i
  expect_err = "Cannot load initial temperature and density properties from HDF5 files"
  requirement = "The system shall error if loading properties from HDF5 for skinned problems"
  capabilities = 'dagmc'
[]

[dag_cell_not_root]
  type = RunException
  input = openmc.i
  expect_err = "The 'skinner' can only be used when the cell using the DAGMC universe as a fill is contained in the root universe."
  requirement = "The system shall error if the cell containing the DAGMC universe is not contained in the root universe. If so, we cannot guarantee that the DAGMC geometry is not replicated and the skinner may produce an incorrect skin."
  capabilities = 'dagmc'
[]

[dag_in_lattice]
  type = RunException
  input = openmc.i
  expect_err = "The 'skinner' cannot be used when the DAGMC universe is contained in lattice geometry."
  requirement = "The system shall error if the DAGMC universe is used as a lattice element. If so, the DAGMC geometry may be replicated and so the skinner may produce an incorrect skin."
  capabilities = 'dagmc'
[]

[dag_lattice_outer]
  type = RunException
  input = openmc.i
  expect_err = "The 'skinner' cannot be used when the DAGMC universe is used as the outer universe of a lattice."
  requirement = "The system shall error if the DAGMC universe is used as a lattice element. If so, the DAGMC geometry may be replicated and so the skinner may produce an incorrect skin."
  capabilities = 'dagmc'
[]

[csg_with_dag_feedback]
  type = RunException
  input = openmc.i
  expect_err = "At present, the 'skinner' can only be used when the only OpenMC geometry which maps to the MOOSE mesh is DAGMC geometry. Your geometry contains CSG cells which map to the MOOSE mesh."
  requirement = "The system shall error if the user attempts to map both CSG and DAGMC geometry to the MOOSE mesh."
  capabilities = 'dagmc'
[]

[multi_dag_uni_cells]
  type = RunException
  input = openmc.i
  expect_err = "The 'skinner' can only be used when the DAGMC universe in the OpenMC geometry is used as a cell fill at most once."
  requirement = "The system shall error if the DAGMC universe is used by multiple cells. If so, the DAGMC geometry is replicated and so the skinner will produce an incorrect skin."
  capabilities = 'dagmc'
[]

[multi_dag_uni]
  type = RunException
  input = openmc.i
  expect_err = "The 'skinner' can only be used when the OpenMC geometry contains a single DAGMC universe."
  requirement = "The system shall error if there are more than one DAGMC universe. If so, the universe to skin cannot be automatically determined."
  capabilities = 'dagmc'
[]

[warn_T_rho]
  type = RunException
  input = openmc.i
  cli_args = 'Mesh/scale/vector_value="50.0 0.0 0.0" --error'
  expect_err = "The \[Mesh\] has 86 elements providing temperature and density feedback \(the elements in the intersection of 'temperature_blocks' and 'density_blocks'\), but only 0 got mapped to OpenMC cells."
  requirement = "The system shall give a warning when T+rho feedback is specified, but not all specified elements mapped into OpenMC"
  capabilities = 'openmc'
[]

[warn_T]
  type = RunException
  input = openmc.i
  cli_args = 'Mesh/scale/vector_value="-50.0 0.0 0.0" --error'
  expect_err = "The \[Mesh\] has 94 elements providing temperature feedback \(the elements in 'temperature_blocks'\), but only 0 got mapped to OpenMC cells."
  requirement = "The system shall give a warning when T feedback is specified, but not all specified elements mapped into OpenMC"
  capabilities = 'openmc'
[]

[warn_rho]
  type = RunException
  input = openmc.i
  cli_args = 'Mesh/scale/vector_value="0.0 -25.0 0.0" --error'
  expect_err = "The \[Mesh\] has 102 elements providing density feedback \(the elements in 'density_blocks'\), but only 0 got mapped to OpenMC cells."
  requirement = "The system shall give a warning when rho feedback is specified, but not all specified elements mapped into OpenMC"
  capabilities = 'openmc'
[]

[duplicate_variable]
  type = RunException
  input = openmc.i
  cli_args = "AuxVariables/heat_source/order=FIRST"
  expect_err = "Cardinal is trying to add an auxiliary variable named 'heat_source', but you already have a variable by this name."
  requirement = "The system shall error if the user adds a duplicate variable with a name Cardinal reserves for OpenMC coupling."
  capabilities = 'openmc'
[]

[nonmaterial_fluid]
  type = RunException
  input = non_material_fluid.i
  expect_err = "Density transfer does not currently support cells filled with universes or lattices!"
  requirement = "The system shall error if trying to set density in a cell filled by a universe or lattice."
  capabilities = 'openmc'
[]

[wrong_length]
  type = RunException
  input = openmc_incorrect_length.i
  expect_err = "'density_variables' and 'density_blocks' must be the same length!"
  requirement = "The system shall error if the blocks and variables are not the same length"
  capabilities = 'openmc'
[]

[empty]
  type = RunException
  input = openmc.i
  cli_args = 'Problem/density_blocks=" ; 2"'
  expect_err = "Entries in 'density_blocks' cannot be empty!"
  requirement = "The system shall error if a sub-vector is empty"
  capabilities = 'openmc'
[]

[multi_temp]
  type = RunException
  input = openmc.i
  cli_args = 'Problem/density_variables="density1 density2; density3"'
  expect_err = "Each entry in 'density_variables' must be of length 1. Entry 0 is of length 2."
  requirement = "The system shall error if an entry in density_variables is not of unity length"
  capabilities = 'openmc'
[]

[block_already_used]
  type = RunException
  input = openmc.i
  cli_args = 'Problem/density_variables="solid_density; solid_density; solid_density; solid_density" Problem/density_blocks="1; 2; 2; 3"'
  expect_err = "Subdomains cannot be repeated in 'density_blocks'! Subdomain '2' is duplicated."
  requirement = "The system shall error if trying to collate multiple density variables onto the same block due to undefined behavior"
  capabilities = 'openmc'
[]

[wrong_length]
  type = RunException
  input = openmc_incorrect_length.i
  expect_err = "'temperature_variables' and 'temperature_blocks' must be the same length!"
  requirement = "The system shall error if the blocks and variables are not the same length"
  capabilities = 'openmc'
[]

[empty]
  type = RunException
  input = openmc.i
  cli_args = 'Problem/temperature_blocks=" ; 2"'
  expect_err = "Entries in 'temperature_blocks' cannot be empty!"
  requirement = "The system shall error if a sub-vector is empty"
  capabilities = 'openmc'
[]

[multi_temp]
  type = RunException
  input = openmc.i
  cli_args = 'Problem/temperature_variables="solid_temp solid_temp; fluid_temp"'
  expect_err = "Each entry in 'temperature_variables' must be of length 1. Entry 0 is of length 2."
  requirement = "The system shall error if an entry in temperature_variables is not of unity length"
  capabilities = 'openmc'
[]

[block_already_used]
  type = RunException
  input = openmc.i
  cli_args = 'Problem/temperature_variables="solid_temp; solid_temp; solid_temp; solid_temp" Problem/temperature_blocks="1; 2; 2; 3"'
  expect_err = "Subdomains cannot be repeated in 'temperature_blocks'! Subdomain '2' is duplicated."
  requirement = "The system shall error if trying to collate multiple temperature variables onto the same block due to undefined behavior"
  capabilities = 'openmc'
[]

[warn_unused]
  type = RunException
  input = openmc.i
  cli_args = 'Problem/identical_cell_fills="0 100" --error'
  expect_err = "You specified 'identical_cell_fills', but all cells which mapped to these subdomains"
  requirement = "The system shall warn the user if the identical cell fill is unused because all mapped cells are simple, material-fills."
  capabilities = 'openmc'
[]

[different_fill_universes]
  type = RunException
  input = openmc.i
  expect_err = "Not all cells contain cell ID 2."
  requirement = "The system shall error if trying to utilize identical cell fills but the filling cell IDs are not identical among the cells"
  capabilities = 'openmc'
[]

[non_solid]
  type = RunException
  input = openmc.i
  cli_args = 'Problem/temperature_blocks="1 2" Problem/density_blocks="2" Problem/identical_cell_fills="2"'
  expect_err = "Entries in 'identical_cell_fills' cannot be contained in 'density_blocks'"
  requirement = "The system shall error if trying to utilize identical cell fills for a non-solid block"
  capabilities = 'openmc'
[]

[inconsistent_map]
  type = RunException
  input = openmc.i
  cli_args = 'Problem/cell_level=0'
  expect_err = "Cell id 22, instance  0 \(of  1\) mapped to inconsistent 'identical_cell_fills' settings.\nSubdomain 2 is in 'identical_cell_fills', but 1 is not."
  requirement = "The system shall error if inconsistent settings are applied for the identical cell mapping"
  capabilities = 'openmc'
[]

[noncontinguous_triso_univs]
  type = RunException
  input = openmc.i
  expect_err = "The cell caching failed to get correct instances for material cell ID 1302"
  requirement = "The system shall error if the single-increment applied to the tally cell contained material instances fails, such as when a TRISO universe is not being tallied."
  capabilities = 'openmc'
[]

[triso_lattice]
  type = RunException
  input = openmc.i
  expect_err = "Cell 10, instance 0 has already had its temperature set by Cardinal to 625"
  requirement = "The system shall error if Cardinal tries to change the temperature of a given OpenMC cell more than once, since this indicates a problem with model setup."
  capabilities = 'openmc'
[]

[not_enough_provided_bnds]
  type = RunException
  input = cell.i
  cli_args = 'Problem/Filters/Azimuthal/azimuthal_angle_boundaries="0.0"'
  expect_err = 'At least two azimuthal angles are required to create bins!'
  requirement = "The system shall error if 'azimuthal_angle_boundaries' doesn't contain enough boundaries to form bins."
  capabilities = 'openmc'
[]

[no_bins]
  type = RunException
  input = cell.i
  expect_err = "You have either set 'num_equal_divisions' and 'azimuthal_angle_boundaries' or have not specified a bin option! Please specify either 'num_equal_divisions' or 'azimuthal_angle_boundaries'."
  requirement = "The system shall error if neither 'num_equal_divisions' or 'azimuthal_angle_boundaries' are provided."
  capabilities = 'openmc'
[]

[both_bins]
  type = RunException
  input = cell.i
  cli_args = 'Problem/Filters/Azimuthal/num_equal_divisions=2 Problem/Filters/Azimuthal/azimuthal_angle_boundaries="0.0 1.5708 ${fparse pi}"'
  expect_err = "You have either set 'num_equal_divisions' and 'azimuthal_angle_boundaries' or have not specified a bin option! Please specify either 'num_equal_divisions' or 'azimuthal_angle_boundaries'."
  requirement = "The system shall error if both 'num_equal_divisions' and 'azimuthal_angle_boundaries' are provided."
  capabilities = 'openmc'
[]

[not_enough_bnds]
  type = RunException
  input = cell.i
  cli_args = 'Problem/Filters/Energy/energy_boundaries="1.0"'
  expect_err = "At least two energy values are required to create energy bins!"
  requirement = "The system shall error if there aren't enough energy boundaries to form an EnergyTally."
  capabilities = 'openmc'
[]

[missing_bins]
  type = RunException
  input = cell.i
  expect_err = "You have either set both 'energy_boundaries' and 'group_structure' or have not specified a bin option. Please specify either 'energy_boundaries' or 'group_structure'."
  requirement = "The system shall error if no energy bins are provided."
  capabilities = 'openmc'
[]

[both_bins]
  type = RunException
  input = cell.i
  cli_args = 'Problem/Filters/Energy/group_structure=CASMO_2 Problem/Filters/Energy/energy_boundaries="0.0 6.25e-1 2.0e7"'
  expect_err = "You have either set both 'energy_boundaries' and 'group_structure' or have not specified a bin option. Please specify either 'energy_boundaries' or 'group_structure'."
  requirement = "The system shall error if no energy bins are provided."
  capabilities = 'openmc'
[]

[duplicate_bnds]
  type = RunException
  input = cell.i
  cli_args = 'Problem/Filters/Energy/energy_boundaries="0.0 6.25e-1 6.25e-1 2.0e7"'
  expect_err = "You have added duplicate energy boundaries!"
  requirement = "The system shall error if duplicate energy boundaries are provided."
  capabilities = 'openmc'
[]

[negative_bnds]
  type = RunException
  input = cell.i
  cli_args = 'Problem/Filters/Energy/energy_boundaries="-1.0 0.0 6.25e-1 2.0e7"'
  expect_err = "Energy group boundaries must be positive to create energy bins!"
  requirement = "The system shall error if negative energy boundaries are provided."
  capabilities = 'openmc'
[]

[force_analog]
  type = RunException
  input = cell.i
  cli_args = 'Problem/Filters/EnergyOut/group_structure=CASMO_2 Problem/Tallies/Scattering/estimator=collision'
  expect_err = "The filter EnergyOut requires an analog estimator!"
  requirement = "The system shall error if the user attempts to use a non-analog estimator with an EnergyOutFilter."
  capabilities = 'openmc'
[]

[force_analog]
  type = RunException
  input = cell.i
  cli_args = 'Problem/Tallies/Scattering/estimator=collision'
  expect_err = "The filter Legendre requires an analog estimator!"
  requirement = "The system shall error if the user attempts to use a non-analog estimator with an AngularLegendreFilter."
  capabilities = 'openmc'
[]

[not_enough_provided_bnds]
  type = RunException
  input = cell.i
  cli_args = 'Problem/Filters/Polar/polar_angle_boundaries="0.0"'
  expect_err = 'At least two polar angles are required to create bins!'
  requirement = "The system shall error if 'polar_angle_boundaries' doesn't contain enough boundaries to form bins."
  capabilities = 'openmc'
[]

[no_bins]
  type = RunException
  input = cell.i
  expect_err = "You have either set 'num_equal_divisions' and 'polar_angle_boundaries' or have not specified a bin option! Please specify either 'num_equal_divisions' or 'polar_angle_boundaries'."
  requirement = "The system shall error if neither 'num_equal_divisions' or 'polar_angle_boundaries' are provided."
  capabilities = 'openmc'
[]

[both_bins]
  type = RunException
  input = cell.i
  cli_args = 'Problem/Filters/Polar/num_equal_divisions=2 Problem/Filters/Polar/polar_angle_boundaries="0.0 1.5708 ${fparse pi}"'
  expect_err = "You have either set 'num_equal_divisions' and 'polar_angle_boundaries' or have not specified a bin option! Please specify either 'num_equal_divisions' or 'polar_angle_boundaries'."
  requirement = "The system shall error if both 'num_equal_divisions' and 'polar_angle_boundaries' are provided."
  capabilities = 'openmc'
[]

[missing_filter]
  type = RunException
  input = no_filter.i
  cli_args = 'Problem/Tallies/Flux/filters="blank"'
  expect_err = "Filter with the name blank does not exist!"
  requirement = "The system shall error if a non-existent filter is requested by a tally."
  capabilities = 'openmc'
[]

[wrong_problem]
  type = RunException
  input = wrong_problem.i
  expect_err = "The simulation must use an OpenMCCellAverageProblem when using the filter system!"
  requirement = "The system shall error if a filter is added when an OpenMCCellAverageProblem is not present."
  capabilities = 'openmc'
[]

[missing_filter]
  type = RunException
  input = cell.i
  cli_args = 'Problem/Filters/SPH_XML/filter_id=30'
  expect_err = "A filter with the id 30 does not exist in the OpenMC model! Please make sure the filter has been added in the OpenMC model and you've supplied the correct filter id."
  requirement = "The system shall error if a filter with the id requested has not been added by the tallie xml file."
  capabilities = 'openmc'
[]

[spatial_filter_error]
  type = RunException
  input = cell.i
  cli_args = 'Problem/Filters/SPH_XML/filter_id=2'
  expect_err = "The filter with the id 2 is a spatial filter. FromXMLFilter currently does not support the addition of spatial filters from the OpenMC XML files because they would clash with the OpenMC -> MOOSE mapping performed by Cardinal's tally objects."
  requirement = "The system shall error if the user selects a spatial filter."
  capabilities = 'openmc'
[]

[func_exp_warning]
  type = RunException
  input = cell.i
  cli_args = '--error'
  expect_err = "You have selected a functional expansion filter. Tallies which use this filter may fail normalization as the sum over all tally bins may not be well posed if any bins contain functional expansion coefficients."
  requirement = "The system shall warn the user if they have selected a functional expansion filter and set allow_expansion_filters = true."
  capabilities = 'openmc'
[]

[func_exp_error]
  type = RunException
  input = cell.i
  cli_args = 'Problem/Filters/SPH_XML/allow_expansion_filters=false'
  expect_err = "You have selected a functional expansion filter. Tallies which use this filter may fail normalization as the sum over all tally bins may not be well posed if any bins contain functional expansion coefficients. If you still wish to use this filter, set 'allow_expansion_filters' to true."
  requirement = "The system shall error if the user selected a functional expansion filter without setting allow_expansion_filters = true."
  capabilities = 'openmc'
[]

[normalize_unused]
  type = RunException
  input = overlap_solid.i
  cli_args = "Problem/normalize_by_global_tally=true --error"
  expect_err = "When running OpenMC in fixed source mode, the 'normalize_by_global_tally' parameter is unused"
  requirement = "The system shall notify the user that the settings related to normalizing by global or local tallies are inconsequential for fixed source mode."
  capabilities = 'openmc'
[]

[missing_power]
  type = RunException
  input = overlap_solid.i
  cli_args = 'Problem/check_tally_sum=true'
  expect_err = "kappa-fission tallies do not match the global kappa-fission tally"
  requirement = "The system shall error if the total tally sum does not match the system-wide value for fixed source simulations."
  capabilities = 'openmc'
[]

[missing_name]
  type = RunException
  input = flux.i
  cli_args = 'Problem/Tallies/Cell/score="flux" Problem/Tallies/Cell/name="f"'
  expect_err = "When specifying 'name', the score indicated in 'source_rate_normalization' must be\nlisted in 'score' so that we know what you want to name that score \(heating\)"
  requirement = "The system shall error if the user tries to name only a partial set of the total tally scores."
  capabilities = 'openmc'
[]

[missing_norm]
  type = RunException
  input = missing_norm.i
  expect_err = "When using a non-heating tally \(flux, H3_production\) in eigenvalue mode"
  requirement = "The system shall error if the user omits the required normalization tally for non-heating scores in eigenvalue mode"
  capabilities = 'openmc'
[]

[electron]
  type = RunException
  input = hide_tally_vars.i
  cli_args = "Problem/MGXS/particle='electron'"
  expect_err = "Multi-group cross sections can only be generated for neutrons or photons."
  requirement = "The system shall error if the user requests electron cross sections."
  capabilities = 'openmc'
[]

[positron]
  type = RunException
  input = hide_tally_vars.i
  cli_args = "Problem/MGXS/particle='positron'"
  expect_err = "Multi-group cross sections can only be generated for neutrons or photons."
  requirement = "The system shall error if the user requests positron cross sections."
  capabilities = 'openmc'
[]

[photon_fission_xs]
  type = RunException
  input = hide_tally_vars.i
  cli_args = "Problem/MGXS/particle='photon' Problem/MGXS/add_fission_heating='false'"
  expect_err = "Multi-group fission cross sections"
  requirement = "The system shall error if the user requests photon cross sections and includes fission."
  capabilities = 'openmc'
[]

[photon_fission_heating]
  type = RunException
  input = hide_tally_vars.i
  cli_args = "Problem/MGXS/particle='photon' Problem/MGXS/add_fission='false'"
  expect_err = "Multi-group fission heating"
  requirement = "The system shall error if the user requests photon cross sections and includes fission."
  capabilities = 'openmc'
[]

[l1_scatter_with_transport_corr]
  type = RunException
  input = all_mgxs_cell_l1.i
  cli_args = "--error Problem/MGXS/transport_correction=true"
  expect_err = "Transport-corrected scattering cross sections can only be used with isotropic scattering"
  requirement = "The system shall warn the user if they request transport corrected scattering cross sections with L > 0."
  capabilities = 'openmc'
[]

[error_mesh_with_tracklength]
  type = RunException
  input = all_mgxs_mesh.i
  cli_args = "--error Problem/MGXS/estimator='tracklength'"
  expect_err = "You've selected an unstructured mesh tally discretization"
  requirement = "The system shall warn the user if they select a mesh tally and request a tracklength estimator."
  capabilities = 'openmc'
[]

[error_non_analog]
  type = RunException
  input = all_mgxs_mesh.i
  cli_args = "--error Problem/MGXS/estimator='collision'"
  expect_err = "You've requested the generation of scattering"
  requirement = "The system shall warn the user if they wish to generate scattering / fission / diffusion group properties without an analog estimator."
  capabilities = 'openmc'
[]

[partial_overlap_moose_union_msg]
  type = RunException
  input = partial_overlap_moose_union.i
  cli_args = '--error'
  expect_err = "The \[Mesh\] has 1024 elements providing temperature feedback \(the elements in 'temperature_blocks'\), but only 768 got mapped to OpenMC cells."
  requirement = "A warning shall be printed if any portion of the MOOSE solid blocks did not get mapped to OpenMC cells."
  capabilities = 'openmc'
[]

[not_rxn_rate]
  type = RunException
  input = 'openmc.i'
  cli_args = 'Adaptivity/Indicators/optical_depth_hmin/rxn_rate=kappa_fission'
  requirement = 'The system shall error if a non-reaction rate score is provided to ElementOpticalDepthIndicator.'
  expect_err = 'At present the ElementOpticalDepthIndicator only works with reaction rate scores. kappa_fission is not a valid reaction rate score.'
  mesh_mode = 'replicated'
  capabilities = 'openmc'
[]

[missing_score]
  type = RunException
  input = 'openmc.i'
  cli_args = 'Adaptivity/Indicators/optical_depth_hmin/rxn_rate=fission'
  requirement = 'The system shall error if a a reaction rate score is requested, but not available in a tally.'
  expect_err = 'The problem does not contain any score named fission!'
  mesh_mode = 'replicated'
  capabilities = 'openmc'
[]

[missing_flux]
  type = RunException
  input = 'openmc.i'
  cli_args = 'Problem/Tallies/Mesh/score="kappa_fission total"'
  requirement = 'The system shall error if the flux is not available in a tally.'
  expect_err = 'In order to use an ElementOpticalDepthIndicator one of your'
  mesh_mode = 'replicated'
  capabilities = 'openmc'
[]

[no_score]
  type = RunException
  input = 'openmc.i'
  cli_args = 'Adaptivity/Indicators/stat_err/score=flux'
  requirement = 'The system shall error if the provided score does not exist in StatRelErrorIndicator.'
  expect_err = 'The problem does not contain any score named flux!'
  mesh_mode = 'replicated'
  capabilities = 'openmc'
[]

[no_rel_err]
  type = RunException
  input = 'openmc.i'
  cli_args = 'Problem/Tallies/Mesh/output=""'
  requirement = 'The system shall error if no tallies are storing the relative error of the provided score.'
  expect_err = 'The problem does not contain any tallies that output the relative error for the score kappa_fission!'
  mesh_mode = 'replicated'
  capabilities = 'openmc'
[]

[invalid_bin]
  type = RunException
  input = 'openmc.i'
  cli_args = 'Adaptivity/Indicators/stat_err/ext_filter_bin=1'
  requirement = 'The system shall error if the provided tally external filter bin is greater than the total number of external filter bins.'
  expect_err = 'The external filter bin provided is invalid for the number of external filter bins'
  mesh_mode = 'replicated'
  capabilities = 'openmc'
[]

[non_k_eig]
  type = RunException
  input = openmc.i
  expect_err = "Kinetic parameters can only be calculated in k-eigenvalue mode!"
  requirement = "The system shall error if the problem attempts to enable IFP calculations when running in fixed source mode."
  capabilities = 'openmc'
[]

[no_ifp_lambda]
  type = RunException
  input = both.i
  cli_args = 'Problem/calc_kinetics_params=false'
  expect_err = "LambdaEffective can only be used if the OpenMC problem is computing kinetics parameters!"
  requirement = "The system shall error if the problem does not enable IFP calculations and attempts to add an LambdaEffective post processor."
  capabilities = 'openmc'
[]

[no_ifp_beta]
  type = RunException
  input = beta.i
  expect_err = "BetaEffective can only be used if the OpenMC problem is computing kinetics parameters!"
  requirement = "The system shall error if the problem does not enable IFP calculations and attempts to add a BetaEffective post processor."
  capabilities = 'openmc'
[]

[more_ifp_gen_then_inactive]
  type = RunException
  input = both.i
  cli_args = 'Problem/ifp_generations=20'
  expect_err = "'ifp_generations' must be less than or equal to the number of inactive batches!"
  requirement = "The system shall error if the problem does not enable IFP calculations and attempts to add a BetaEffective post processor."
  capabilities = 'openmc'
[]

[moose_mesh_tally_distributed]
  type = RunException
  input = one_mesh_no_input_file.i
  mesh_mode = 'distributed'
  expect_err = "Directly tallying on the \[Mesh\] block by OpenMC is not yet supported for distributed meshes!"
  requirement = "The system shall error if attempting to directly tally on a MOOSE mesh that is distributed, since all meshes are always replicated in OpenMC."
  capabilities = 'openmc'
[]

[scaling]
  type = RunException
  input = one_mesh_no_input_file.i
  cli_args = 'Problem/scaling=2.0'
  expect_err = "Directly tallying on the \[Mesh\] is only supported for 'scaling' of unity."
  requirement = "The system shall error if attempting to directly tally on a MOOSE mesh that has a scaling not equal to 1.0."
  capabilities = 'openmc'
[]

[disable_renumbering]
  type = RunException
  input = one_mesh.i
  cli_args = 'Mesh/allow_renumbering=true --distributed-mesh'
  expect_err = "Mesh tallies currently require 'allow_renumbering = false' to be set in the \[Mesh\]!"
  requirement = "Mesh tallies shall temporarily require disabled renumbering until capability is available"
  capabilities = 'openmc'
[]

[file_mesh_block_restrict]
  type = RunException
  input = one_mesh.i
  cli_args = 'Problem/Tallies/Mesh/block=100'
  expect_err = "Block restriction is currently not supported for mesh tallies which load a mesh from a file!"
  requirement = "Mesh tallies shall error if the user attempts to apply a block restriction when using a mesh template."
  capabilities = 'openmc'
[]

[block_restrict_no_blocks]
  type = RunException
  input = one_mesh_no_input_file.i
  cli_args = "Problem/Tallies/Mesh/block='' Mesh/parallel_type=replicated"
  expect_err = "Subdomain names must be provided if using 'block'!"
  requirement = "Mesh tallies shall error if the user attempts to apply a block restriction with no blocks."
  capabilities = 'openmc'
[]

[inconsistency]
  type = RunException
  input = cell_tally.i
  cli_args = '--error'
  expect_err = "Your problem has a moving mesh, but you have not provided a 'skinner'"
  requirement = 'The system shall warn the user if there is an inconsistency between a moving mesh and the underlying OpenMC geometry.'
  capabilities = 'dagmc'
[]

[file_mesh]
  type = RunException
  input = mesh_tally_file.i
  prereq = make_mesh
  expect_err = "Tallying on a file-based mesh is not supported for moving-mesh cases"
  requirement = 'The system shall error if tallying on a file mesh for moving mesh cases, because there will be a disagreement between the mesh elements and the [Mesh].'
  mesh_mode = 'replicated'
  capabilities = 'dagmc'
[]

[photon_heating]
  type = RunException
  input = openmc.i
  expect_err = "Tracklength estimators are currently incompatible with photon transport and heating scores!"
  requirement = "The system shall error if using incompatible tally estimator with a photon transport heating score."
  capabilities = 'openmc'
  issues = '#1114'
  design = 'AddTallyAction.md'
[]

[photon_nu_scatter_heating]
  type = RunException
  input = openmc.i
  expect_err = "A single tally cannot score both nu_scatter and heating when photon transport is enabled"
  requirement = "The system shall error if using a single tally with a photon transport heating score and nu-scatter score."
  cli_args = 'Problem/Tallies/Cell/score="nu_scatter heating" Problem/Tallies/Cell/estimator=""'
  capabilities = 'openmc'
  issues = '#1089'
  design = 'AddTallyAction.md'
[]

[no_relax_with_fixed_mesh]
  type = RunException
  input = openmc_adapt.i
  expect_err = "When adaptivity is requested or a displaced problem is used, the mapping from the OpenMC model to the \[Mesh\] may vary in time."
  requirement = "The system shall correctly error if trying to use relaxation with a time-varying mesh."
  capabilities = 'openmc'
[]

[missing_pebble]
  type = RunException
  input = openmc_missing_pebble.i
  min_parallel = 4
  min_threads = 2
  expect_err = "kappa-fission tallies do not match the global kappa-fission tally"
  requirement = "The system shall error if the heating tallies are missing power from other parts of the problem."
  capabilities = 'openmc'
[]

[wrong_uo]
  type = RunException
  input = wrong_uo.i
  prereq = generate_mesh
  expect_err = "The 'symmetry_mapper' user object has to be of type SymmetryPointGenerator!"
  requirement = "The system shall error if the symmetry mapper is not of the correct type"
  capabilities = 'openmc'
[]

[reaction_rates]
  type = CSVDiff
  input = openmc_mgxs_rxn.i
  detail = "The system shall compute nu-scatter, nu-fission, and inverse-velocity scores fixed source mode."
  csvdiff = openmc_mgxs_rxn_out.csv
  capabilities = 'openmc'
[]

[nu_scatter_analog]
  type = RunException
  input = openmc_mgxs_rxn.i
  detail = "The system shall error if the user attempts to specify a nu-scatter score without an analog estimator."
  capabilities = 'openmc'
  cli_args = 'Problem/Tallies/Cell/estimator=tracklength'
  expect_err = 'Non-analog estimators are not supported for nu_scatter scores!'
[]

[not_const_mon]
  type = RunException
  input = 'openmc.i'
  cli_args = 'AuxVariables/grad_kappa_fission/order=FIRST'
  requirement = 'The system shall error if the variable provided to FDTallyGradAux is not of type CONSTANT MONOMIAL_VEC.'
  expect_err = 'FDTallyGradAux only supports CONSTANT MONOMIAL_VEC shape functions.'
  mesh_mode = 'replicated'
  capabilities = 'openmc'
[]

[missing_score]
  type = RunException
  input = 'openmc.i'
  cli_args = 'AuxKernels/comp_grad_kappa_fission/score=fission'
  requirement = 'The system shall error if a score is requested, but not available in a tally.'
  expect_err = 'The problem does not contain any score named fission!'
  mesh_mode = 'replicated'
  capabilities = 'openmc'
[]

[invalid_bin_index]
  type = RunException
  input = 'openmc.i'
  cli_args = 'AuxKernels/comp_grad_kappa_fission/ext_filter_bin=1'
  requirement = 'The system shall error if the external filter bin provided by the user is out of bounds for the filters applied to the given score.'
  expect_err = 'The external filter bin provided is invalid'
  mesh_mode = 'replicated'
  capabilities = 'openmc'
[]

[duplicate_scores]
  type = RunException
  input = multi_cell.i
  cli_args = 'Problem/Tallies/Cell_2/score="flux kappa_fission"'
  expect_err = "You have added 2 tallies which score kappa-fission!"
  requirement = "The system shall error if the user provides multiple tallies with overlapping scores."
  capabilities = 'openmc'
[]

[multi_no_norm]
  type = RunException
  input = multi_cell.i
  cli_args = 'Problem/Tallies/Cell_1/score="heating"'
  expect_err = "The local tallies added in the \[Tallies\] block do not contain the requested heating score"
  requirement = "The system shall error if more than one tally is provided and the requested heating score is in none of the tallies."
  capabilities = 'openmc'
[]

[length_igore_zero]
  type = RunException
  input = ignore_zero.i
  cli_args = 'Problem/Tallies/Cell/trigger_ignore_zeros="true true"'
  requirement = "The system shall enforce correct trigger ignore zero length"
  expect_err = "'trigger_ignore_zeros' \(size 2\) must have the same length as 'score' \(size 1\)"
  capabilities = 'openmc'
[]

[set_trigger_ignore_zero]
  type = RunException
  input = ignore_zero.i
  cli_args = 'Problem/Tallies/Cell/trigger_ignore_zeros=""'
  requirement = "The system shall ensure that the users provide values of trigger_ignore_zeros when the parameter is set."
  expect_err = "trigger_ignore_zeros cannot be empty!"
  capabilities = 'openmc'
[]

[length_trigger]
  type = RunException
  input = multi_rel_err.i
  cli_args = 'Problem/Tallies/Cell/trigger="rel_err"'
  requirement = "The system shall enforce correct trigger length"
  expect_err = "'trigger' \(size 1\) must have the same length as 'score' \(size 2\)"
  capabilities = 'openmc'
[]

[length_threshold]
  type = RunException
  input = multi_rel_err.i
  cli_args = 'Problem/Tallies/Cell/trigger_threshold="1e-2"'
  requirement = "The system shall enforce correct trigger threshold length"
  expect_err = "'trigger_threshold' \(size 1\) must have the same length as 'score' \(size 2\)"
  capabilities = 'openmc'
[]

[nonexistent_block]
  type = RunException
  input = nonexistent_block.i
  expect_err = "Block 'who' specified in 'block' not found in mesh!"
  requirement = "The system shall error if the user specifies a block for coupling that does not exist."
  capabilities = 'openmc'
[]

[empty_block]
  type = RunException
  input = nonexistent_block.i
  cli_args = 'Problem/temperature_blocks=""'
  expect_err = "'temperature_blocks' cannot be empty!"
  requirement = "The system shall error if an empty vector is provided for the blocks"
  capabilities = 'openmc'
[]

[no_overlap]
  type = RunException
  input = no_overlap.i
  expect_err = "Did not find any overlap between MOOSE elements and OpenMC cells for the specified blocks!"
  requirement = "The system shall error if the MOOSE blocks and OpenMC cells don't overlap"
  capabilities = 'openmc'
[]

[skipping_moose_feedback]
  type = RunException
  input = skipping_moose_feedback.i
  cli_args = '--error'
  expect_err = "The \[Mesh\] has 1024 elements providing temperature feedback \(the elements in 'temperature_blocks'\), but only 768 got mapped to OpenMC cells."
  requirement = "The system shall print a warning if some MOOSE elements are unmapped"
  capabilities = 'openmc'
[]

[multiple_phases]
  type = RunException
  input = multiple_phases.i
  expect_err = "Cell id 4, instance 0 \(of 1\) mapped to:\n\n    16  elements with temperature feedback\n     0  elements with density feedback\n  3486  elements with both temperature and density feedback\n     0  uncoupled elements"
  requirement = "The system shall error if one OpenMC cell maps to more than one type of feedback"
  capabilities = 'openmc'
[]

[multiple_tally_settings]
  type = RunException
  input = multiple_tally_settings.i
  expect_err = "cell id 4, instance 0 \(of 1\) maps to blocks with different tally settings!\nBlock 100 is in 'block', but block 200 is not."
  requirement = "The system shall error if one OpenMC cell maps to multiple subdomains that don't all have the same tally setting"
  capabilities = 'openmc'
[]

[absent_solid_block]
  type = RunException
  input = absent_solid_block.i
  expect_err = "Feedback was specified using 'temperature_blocks' and/or 'density_blocks', but no MOOSE elements mapped to OpenMC cells!"
  requirement = "The system shall error if the user sets feedback blocks, but none of the elements map to OpenMC"
  capabilities = 'openmc'
[]

[unequal_volumes]
  type = RunException
  input = unequal_volumes.i
  expect_err = "Detected un-equal mapped tally volumes!\n cell id 1, instance 0 \(of 1\) maps to a volume of 13.2213 \(cm3\)\n cell id 2, instance 0 \(of 1\) maps to a volume of 10.6346 \(cm3\)."
  requirement = "The system shall error if the user enforces equal mapped tally volumes but the mapped volumes are not identical across tally bins"
  capabilities = 'openmc'
[]

[insufficient_materials]
  type = RunException
  input = fluid.i
  expect_err = "material 2 is present in more than one density feedback cell.\n"
  requirement = "The system shall error if we attempt to set a density in a material that is repeated throughout our list of fluid cells."
  capabilities = 'openmc'
[]

[temp]
  type = RunException
  input = temp.i
  expect_err = "mapped to cell 2 in the OpenMC model is inside a universe used as the 'outer' universe of a lattice."
  requirement = "The system shall error if attempting to pass temperature feedback to a lattice outer universe due to lack of instance support in OpenMC"
  capabilities = 'openmc'
[]

[zero_density]
  type = RunException
  input = zero_density.i
  expect_err = "Densities less than or equal to zero cannot be set in the OpenMC model!\n\n cell id 1, instance 0 \(of 1\) set to density 0 \(kg/m3\)"
  requirement = "The system shall error if we attempt to set a density less than or equal to zero in OpenMC"
  capabilities = 'openmc'
[]

[void_density]
  type = RunException
  input = void_density.i
  cli_args = '--error'
  expect_err = "Skipping setting density for cell id 2, instance 0 \(of 1\) because this cell is void \(vacuum\)"
  requirement = "The system shall error if we attempt to set a density in a void OpenMC cell"
  capabilities = 'openmc'
[]

[k]
  type = RunException
  input = k.i
  expect_err = "Eigenvalues are only computed when running OpenMC in eigenvalue mode!"
  requirement = "The system shall error if attempting to extract the eigenvalue from an OpenMC run that is not run with eigenvalue mode."
  capabilities = 'openmc'
[]

[k_std_dev]
  type = RunException
  input = k.i
  cli_args = 'Postprocessors/k/output=std_dev'
  expect_err = "Eigenvalues are only computed when running OpenMC in eigenvalue mode!"
  requirement = "The system shall error if attempting to extract the eigenvalue standard deviation from an OpenMC run that is not run with eigenvalue mode."
  capabilities = 'openmc'
[]

[k_trigger]
  type = RunException
  input = k_trigger.i
  expect_err = "Cannot specify a 'k_trigger' for OpenMC runs that are not eigenvalue mode!"
  requirement = "The system shall error if attempting to set a k trigger for an OpenMC mode that doesn't have a notion of eigenvalues"
  capabilities = 'openmc'
[]

[incorrect_problem]
  type = RunException
  input = openmc.i
  expect_err = "TallyRelativeError can only be used with problems of type 'OpenMCCellAverageProblem'!"
  requirement = "The system shall error if an OpenMC object is used without the correct OpenMC wrapped problem."
  capabilities = 'openmc'
[]

[incorrect_var_type]
  type = RunException
  input = incorrect_var_type.i
  expect_err = "This auxkernel can only be used with elemental variables!"
  requirement = "The system shall error if a auxkernel that queries OpenMC data structures is not used with the correct variable type."
  capabilities = 'openmc'
[]

[invalid_batches]
  type = RunException
  input = invalid_batches.i
  expect_err = "In attempting to set the number of batches, OpenMC reported:\n\nNumber of active batches must be greater than zero."
  requirement = "The system shall error if attempting to set a negative number of active batches"
  capabilities = 'openmc'
[]

[invalid_max_batches]
  type = RunException
  input = invalid_max_batches.i
  expect_err = "In attempting to set the maximum number of batches, OpenMC reported:\n\nNumber of active batches must be greater than zero."
  requirement = "The system shall error if attempting to set a negative number of active batches"
  capabilities = 'openmc'
[]

[missing_properties]
  type = RunException
  input = missing_properties.i
  expect_err = "In attempting to load temperature and density from a properties.h5 file, OpenMC reported:"
  requirement = "The system shall error if a properties file is loaded but does not exist"
  capabilities = 'openmc'
[]

[no_dag]
  type = RunException
  input = no_dag.i
  expect_err = "When the OpenMC model does not contain any DagMC universes, the 'skinner' parameter is unused!"
  requirement = "The system shall error if using a skinner without a DagMC geometry"
  capabilities = 'dagmc'
[]

[duplicate_levels]
  type = RunException
  input = levels.i
  expect_err = "Either 'cell_level' or 'lowest_cell_level' must be specified. You have given either both or none."
  requirement = "The system shall error if both or none of the cell level options have been prescribed."
  capabilities = 'dagmc'
[]

[fluid_too_high]
  type = RunException
  input = fluid_too_high.i
  expect_err = "Requested coordinate level of 1 exceeds number of nested coordinate levels"
  requirement = "The system shall error if the specified coordinate level for a phase is within the maximum coordinate levels across the OpenMC domain, but invalid for the particular region of the geometry."
  capabilities = 'openmc'
[]

[level_too_high]
  type = RunException
  input = level_too_high.i
  expect_err = "Coordinate level for finding cells cannot be greater than total number of coordinate levels: 1!"
  requirement = "The system shall error if the specified coordinate level for finding a cell is greater than the maximum number of coordinate levels throughout the geometry."
  capabilities = 'openmc'
[]

[material_duplication]
  type = RunException
  input = materials.i
  expect_err = "material 1 is present in more than one OpenMC cell with different density feedback settings!"
  requirement = "The system shall error if a fluid material exists in non-fluid parts of the domain, because density would inadvertently be changed in other parts of the OpenMC model."
  capabilities = 'openmc'
[]

[incorrect_scaling]
  type = RunException
  input = incorrect_scaling.i
  expect_err = "The centroids of the 'mesh_template' differ from the centroids of the"
  requirement = "The system shall error if the mesh template is not provided in the same units as the [Mesh]."
  capabilities = 'openmc'
[]

[incorrect_order]
  type = RunException
  input = incorrect_order.i
  expect_err = "Centroid for element 256 in the"
  requirement = "The system shall error if the mesh template does not exactly match the [Mesh], such as when the order of mesh translations does not match the order of inputs in a CombinerGenerator."
  capabilities = 'openmc'
[]

[incorrect_file]
  type = RunException
  input = incorrect_file.i
  expect_err = "Centroid for element 0 in the"
  requirement = "The system shall error if the mesh template does not exactly match the [Mesh], such as when a totally different mesh is used (pincell versus pebbles)."
  capabilities = 'openmc'
[]

[invalid_estimator]
  type = RunException
  input = incorrect_file.i
  cli_args = 'Problem/Tallies/Mesh/mesh_template=../../neutronics/meshes/sphere.e Problem/Tallies/Mesh/estimator=tracklength'
  expect_err = "Tracklength estimators are currently incompatible with mesh tallies!"
  requirement = "The system shall error if a tracklength estimator is attempted with unstructured mesh tallies, since this capability is not supported in libMesh."
  capabilities = 'openmc'
[]

[invalid_row]
  type = RunException
  input = invalid_row.i
  expect_err = "All entries in 'mesh_translations_file' must contain exactly 3 coordinates."
  requirement = "The system shall error if a particular set of coordinates in the mesh translations does not have all requisite x, y, and z components."
  capabilities = 'openmc'
[]

[volume]
  type = RunException
  input = particle.i
  expect_err = "Running OpenMC in plotting, particle, and volume modes is not supported"
  requirement = "The system shall error if attempting to run OpenMC in particle restart mode through Cardinal."
  capabilities = 'openmc'
[]

[plot]
  type = RunException
  input = plot.i
  expect_err = "Running OpenMC in plotting, particle, and volume modes is not supported"
  requirement = "The system shall error if attempting to run OpenMC in plotting mode through Cardinal."
  capabilities = 'openmc'
[]

[volume]
  type = RunException
  input = volume.i
  expect_err = "Running OpenMC in plotting, particle, and volume modes is not supported"
  requirement = "The system shall error if attempting to run OpenMC in volume mode through Cardinal."
  capabilities = 'openmc'
[]

[no_range]
  type = RunException
  input = openmc.i
  cli_args = '--error'
  expect_err = "For multiphysics simulations, we recommend setting the 'temperature_range'"
  requirement = "The system shall warn the user if they did not set the temperature range, protecting against seg faults within the tracking loop when trying to access nuclear data at temperatures that Cardinal wants to apply, but that weren't actually loaded at initialization."
  capabilities = 'openmc'
[]

[separate_tallies]
  type = RunException
  input = separate_tallies.i
  expect_err = "Cannot assume separate tallies"
  requirement = "The system shall error if attempting to use separate tallies when a global tally exists"
  capabilities = 'openmc'
[]

[invalid_length]
  type = RunException
  input = length.i
  cli_args = 'Problem/Tallies/Cell/score="damage_energy kappa_fission" Problem/Tallies/Cell/name="heat_source"'
  expect_err = "'name' must be the same length as 'score'!"
  requirement = "The system shall error if name and score are not the same length."
  capabilities = 'openmc'
[]

[missing_threshold]
  type = RunException
  input = length.i
  cli_args = 'Problem/Tallies/Cell/trigger="rel_err"'
  expect_err = "You must either specify none or both of 'trigger' and 'trigger_threshold'. You have specified only one."
  requirement = "The system shall error if trigger and trigger_threshold are not simultaneously specified"
  capabilities = 'openmc'
[]

[duplicate_name]
  type = RunException
  input = length.i
  cli_args = 'Problem/Tallies/Cell/score="damage_energy kappa_fission" Problem/Tallies/Cell/name="heat_source heat_source"'
  expect_err = "Entries cannot be repeated in 'name'!"
  requirement = "The system shall error if name has duplicate entries."
  capabilities = 'openmc'
[]

[duplicate_score]
  type = RunException
  input = length.i
  cli_args = 'Problem/Tallies/Cell/score="damage_energy damage_energy" Problem/Tallies/Cell/name="heat1 heat2"'
  expect_err = "Entries cannot be repeated in 'score'!"
  requirement = "The system shall error if score has duplicate entries."
  capabilities = 'openmc'
[]

[interpolation_min]
  type = RunException
  input = openmc.i
  cli_args = 'ICs/temp/value=-100'
  expect_err = "In attempting to set cell id 1, instance 0 \(of 1\) to temperature -100 \(K\), OpenMC reported:\n\n"
  requirement = "The system shall error if we attempt to set a temperature in OpenMC below the lower bound of available data when using the interpolation method."
  capabilities = 'openmc'
[]

[interpolation_max]
  type = RunException
  input = openmc.i
  expect_err = "In attempting to set cell id 1, instance 0 \(of 1\) to temperature 100000 \(K\), OpenMC reported:\n\n"
  requirement = "The system shall error if we attempt to set a temperature in OpenMC above the upper bound of available data when using the interpolation method."
  capabilities = 'openmc'
[]

[nonexistent_score]
  type = RunException
  input = openmc.i
  cli_args = 'Postprocessors/max_rel_err/tally_score=flux'
  # This test has very few particles, and OpenMC will error if there aren't enough source particles
  # in the fission bank on a process
  max_parallel = 8
  expect_err = "To extract the relative error of the 'flux' score"
  requirement = "The system shall error if trying to extract score information that does not exist"
  capabilities = 'openmc'
[]

[u00]
  type = RunException
  input = unknown.i
  cli_args = 'Postprocessors/usrwrk/field=usrwrk00 --error'
  expect_err = "The units of 'usrwrk00' are unknown, so we cannot dimensionalize any objects using 'field = usrwrk00'."
  detail = 'usrwrk slot 0'
  capabilities = 'nekrs'
[]

[u01]
  type = RunException
  input = unknown.i
  cli_args = 'Postprocessors/usrwrk/field=usrwrk01 --error'
  expect_err = "The units of 'usrwrk01' are unknown, so we cannot dimensionalize any objects using 'field = usrwrk01'."
  detail = 'usrwrk slot 1'
  capabilities = 'nekrs'
[]

[u02]
  type = RunException
  input = unknown.i
  cli_args = '--error'
  expect_err = "The units of 'usrwrk02' are unknown, so we cannot dimensionalize any objects using 'field = usrwrk02'."
  detail = 'usrwrk slot 2'
  capabilities = 'nekrs'
[]

[invalid_mesh]
  type = RunException
  input = nek.i
  cli_args = 'Postprocessors/pressure_x/mesh=all'
  expect_err = "The 'NekPressureSurfaceForce' postprocessor can only be applied to"
  requirement = "The system shall error if trying to compute pressure drag on non-fluid NekRS boundaries"
  capabilities = 'nekrs'
[]

[invalid_field]
  type = RunException
  input = nek.i
  cli_args = "Postprocessors/max_temp_side1/field=velocity_component Postprocessors/max_temp_side1/velocity_direction='1 0 0'"
  expect_err = "Setting 'field = velocity_component' is not yet implemented"
  requirement = "System shall error if using an unsupported field with a side extrema postprocessor."
  capabilities = 'nekrs'
[]

[invalid_slot]
  type = RunException
  input = nek.i
  expect_err = "'usrwrk_slot' must be less than number of allocated usrwrk slots: 7"
  requirement = "The system shall error if the requested usrwrk slot to integrate exceeds the number allocated"
  capabilities = 'nekrs'
[]

[invalid_mesh]
  type = RunException
  input = nek.i
  cli_args = 'Postprocessors/viscous_1/mesh=all'
  expect_err = "The 'NekViscousSurfaceForce' postprocessor can only be applied to"
  requirement = "The system shall error if trying to compute viscous drag on non-fluid NekRS boundaries"
  capabilities = 'nekrs'
[]

[invalid_field]
  type = RunException
  input = nek.i
  cli_args = "Postprocessors/max_temp/field=velocity_component Postprocessors/max_temp/velocity_direction='1 0 0'"
  expect_err = "Setting 'field = velocity_component' is not yet implemented"
  requirement = "System shall error if using an unsupported field with a volume extrema postprocessor."
  capabilities = 'nekrs'
[]

[invalid_field]
  type = RunException
  input = nek.i
  cli_args = "Postprocessors/weighted_T_side1/field=velocity_component Postprocessors/weighted_T_side1/velocity_direction='1 0 0'"
  expect_err = "This class does not support 'field = velocity_component'"
  requirement = "System shall error if using an unsupported field with a mass flux weighted postprocessor."
  capabilities = 'nekrs'
[]

[volume]
  type = RunException
  input = nek.i
  cli_args = 'Mesh/volume=true'
  expect_err = "The NekBoundaryFlux does not currently support writing heat flux on a boundary when the Mesh has 'volume = true.'"
  requirement = "The system shall error if trying to write heat flux on a boundary when the mesh mirror is a volume mesh."
  issues = '#1166'
  capabilities = 'nekrs'
[]

[too_many_slots]
  type = RunException
  input = nek.i
  cli_args = 'Problem/FieldTransfers/temperature/usrwrk_slot="0 1"'
  expect_err = "'usrwrk_slot' must be of length 1 for field transfers to_nek; you have entered a vector of length 2"
  requirement = "The system shall error if too many usrwrk slots are specified for a single field transfer"
  issues = '#1166'
  capabilities = 'nekrs'
[]

[type_error]
  type = RunException
  input = type_error.i
  expect_err = "This user object requires exactly one bin distribution to be a side distribution; you have specified: 0"
  requirement = "The system shall error if the userobjects aren't derived from the correct base class."
  capabilities = 'nekrs'
[]

[bins_too_fine]
  type = RunException
  input = nek.i
  cli_args = "UserObjects/axial_binning/num_layers=1000"
  expect_err = "Failed to map any GLL points to bin 1!"
  requirement = "The system shall error if there are zero contributions to a gap bin."
  capabilities = 'nekrs'
[]

[conflicting_bins]
  type = RunException
  input = duplicate_directions.i
  expect_err = "Cannot combine multiple distributions in the same coordinate direction!\nBin 'x_bins2' conflicts with bin 'x_bins'"
  requirement = "System shall error if user attemps to combine multiple bins that specify the same coordinate direction."
  capabilities = 'nekrs'
[]

[bins_too_fine]
  type = RunException
  input = nek.i
  cli_args = 'UserObjects/z_bins/num_layers=1000'
  expect_err = 'Failed to map any element centroids to bin 0!'
  requirement = 'System shall error if no points map to a spatial bin'
  capabilities = 'nekrs'
[]

[invalid_max_temp]
  type = RunException
  input = skinner.i
  cli_args = 'UserObjects/moab/temperature_max=350.0'
  mesh_mode = 'replicated'
  expect_err = "'temperature_max' must be greater than 'temperature_min'"
  requirement = "The system shall error if the maximum temperature is lower than the minimum temperature for the skinner bins"
  capabilities = 'dagmc'
[]

[invalid_max_density]
  type = RunException
  input = skinner.i
  cli_args = 'UserObjects/moab/density_max=-0.6'
  mesh_mode = 'replicated'
  expect_err = "'density_max' must be greater than 'density_min'"
  requirement = "The system shall error if the maximum density is lower than the minimum density for the skinner bins"
  capabilities = 'dagmc'
[]

[too_low_temp]
  type = RunException
  input = skinner.i
  cli_args = 'UserObjects/moab/temperature_min=550.0'
  mesh_mode = 'replicated'
  expect_err = "Variable 'temp' has value below minimum range of bins. Please decrease 'temperature_min'."
  requirement = "The system shall error if the temperature is below the minimum bin bound"
  capabilities = 'dagmc'
[]

[too_high_temp]
  type = RunException
  input = skinner.i
  cli_args = 'UserObjects/moab/temperature_max=450.0'
  mesh_mode = 'replicated'
  expect_err = "Variable 'temp' has value above maximum range of bins. Please increase 'temperature_max'."
  requirement = "The system shall error if the temperature is above the maximum bin bound"
  capabilities = 'dagmc'
[]

[too_low_density]
  type = RunException
  input = skinner.i
  cli_args = 'UserObjects/moab/density_min=1010.0'
  mesh_mode = 'replicated'
  expect_err = "Variable 'rho' has value below minimum range of bins. Please decrease 'density_min'."
  requirement = "The system shall error if the density is below the minimum bin bound"
  capabilities = 'dagmc'
[]

[too_high_density]
  type = RunException
  input = skinner.i
  cli_args = 'UserObjects/moab/density_max=950.0'
  mesh_mode = 'replicated'
  expect_err = "Variable 'rho' has value above maximum range of bins. Please increase 'density_max'."
  requirement = "The system shall error if the density is above the maximum bin bound"
  capabilities = 'dagmc'
[]

[invalid_mesh]
  type = RunException
  input = skinner.i
  cli_args = 'Mesh/cube/file=../../../neutronics/meshes/sphere.e'
  mesh_mode = 'replicated'
  expect_err = "The MoabSkinner can only be used with a tetrahedral \[Mesh\]!"
  requirement = "The system shall error if the skinned mesh does not contain tetrahedral elements"
  capabilities = 'dagmc'
[]

[invalid_graveyard_scales]
  type = RunException
  input = skinner.i
  cli_args = 'UserObjects/moab/graveyard_scale_outer=1.01'
  mesh_mode = 'replicated'
  expect_err = "'graveyard_scale_outer' must be greater than 'graveyard_scale_inner'!"
  requirement = "The system shall error if the outer graveyard surface is not larger than the inner graveyard surface"
  capabilities = 'dagmc'
[]

[no_aux_temp]
  type = RunException
  input = skinner.i
  cli_args = 'UserObjects/moab/temperature=temperature'
  expect_err = "Cannot find auxiliary variable 'temperature'!"
  mesh_mode = 'replicated'
  requirement = "The system shall error if the specified temperature auxiliary variable cannot be found"
  capabilities = 'dagmc'
[]

[no_aux_density]
  type = RunException
  input = skinner.i
  cli_args = 'UserObjects/moab/density=den'
  mesh_mode = 'replicated'
  expect_err = "Cannot find auxiliary variable 'den'!"
  requirement = "The system shall error if the specified density auxiliary variable cannot be found"
  capabilities = 'dagmc'
[]

[overlap_t_rho]
  type = RunException
  input = skinner.i
  cli_args = 'UserObjects/moab/density=temp'
  mesh_mode = 'replicated'
  expect_err = "The 'temperature' and 'density' variables cannot be the same!"
  requirement = "The system shall error if the specified density and temperature auxiliary variables are the same"
  capabilities = 'dagmc'
[]

[distributed]
  type = RunException
  input = skinner.i
  mesh_mode = 'distributed'
  expect_err = "MoabSkinner does not yet support distributed meshes!"
  requirement = "The system shall error if trying to run in distributed mesh mode"
  capabilities = 'dagmc'
[]

[incorrect_material_names]
  type = RunException
  input = skinner.i
  cli_args = 'UserObjects/moab/material_names="mat1 mat2"'
  mesh_mode = 'replicated'
  expect_err = "This parameter must be the same length as the number of subdomains in the mesh \(1\)"
  requirement = "The system shall error if the material_names provided to the skinner do not match the required length"
  capabilities = 'dagmc'
[]

[wrong_type]
  type = RunException
  input = wrong_type.i
  mesh_mode = 'replicated'
  expect_err = "Auxiliary variable 'temp' must be a CONSTANT MONOMIAL type!"
  requirement = "The system shall error if the requirements for a binning variable type are violated."
  capabilities = 'dagmc'
[]

[nonexistent_id]
  type = RunException
  input = openmc.i
  cli_args = 'UserObjects/mat1/material_id=3'
  expect_err = 'In attempting to get the material index for material with ID 3, OpenMC reported:\n\nNo material exists with ID=3.'
  requirement = 'The system shall error if trying to change nuclide densities for a non-existing material ID.'
  capabilities = 'openmc'
[]

[nonexistent_nuclide]
  type = RunException
  input = openmc.i
  cli_args = 'UserObjects/mat1/names="fake fake2"'
  expect_err = "In attempting to set nuclide densities in the 'mat1' UserObject, OpenMC reported:\n\nNuclide 'fake' is not present in library."
  requirement = "The system shall error if trying to add a nuclide not accessible in the cross section library."
  capabilities = 'openmc'
[]

[different_length]
  type = RunException
  input = only_density.i
  cli_args = 'UserObjects/mat1/names="a b" UserObjects/mat1/densities="1.0"'
  expect_err = "'names' and 'densities' must be the same length!"
  requirement = "The system shall error if inconsistent lengths for names and densities are provided."
  capabilities = 'openmc'
[]

[nonexistent_tally]
  type = RunException
  input = tally_param_checks.i
  cli_args = 'UserObjects/tally_editor_uo/tally_id=3000'
  expect_err = 'Tally 3000 does not exist in the OpenMC model'
  detail = 'trying to edit a non-existant tally'
  capabilities = 'openmc'
[]

[nonexistent_nuclide]
  type = RunException
  input = tally_param_checks.i
  cli_args = 'UserObjects/tally_editor_uo/nuclides="fake fake2"'
  expect_err = "Nuclide 'fake' is not present in library."
  detail = "trying to add a nuclide not accessible in the cross section library"
  capabilities = 'openmc'
[]

[invalid_score]
  type = RunException
  input = tally_param_checks.i
  cli_args = 'UserObjects/tally_editor_uo/scores="invalid"'
  expect_err = 'Invalid tally score "invalid".'
  detail = 'trying to add an invalid score to a tally'
  capabilities = 'openmc'
[]

[nonexistent_filter]
  type = RunException
  input = add_filter.i
  cli_args = 'UserObjects/new_filter/create_filter=false'
  expect_err = 'Filter 100 does not exist and create_filter is false'
  detail = 'the filter referenced by an OpenMCFilterEditor via ID does not exist and is not flagged for creation'
  capabilities = 'openmc'
[]

[clashing_filter_types]
  type = RunException
  input = add_filter.i
  cli_args = 'UserObjects/new_filter/filter_type="universe" UserObjects/new_filter/filter_id=1'
  expect_err = 'An existing filter, Filter 1, is of type "cell" and cannot be changed to type "universe"'
  detail = 'an OpenMCDomainFilter editor exists with the same filter ID but a different filter type'
  capabilities = 'openmc'
[]

[clashing_filter_ids]
  type = RunException
  input = clashing_filter_ids.i
  expect_err = 'Filter ID \(10\) found in multiple OpenMCDomainFilterEditors'
  detail = 'more than one OpenMCDomainFilterEditor eixsts with the same filter ID'
  capabilities = 'openmc'
[]

[clashing_tally_ids]
  type = RunException
  input = clashing_tally_ids.i
  expect_err = 'Tally ID \(10\) found in multiple OpenMCTallyEditors'
  detail = 'more than one OpenMCTallyEditor eixsts with the same tally ID'
  capabilities = 'openmc'
[]

[clashing_mapped_tally]
  type = RunException
  input = clash_mapped_tally.i
  expect_err = 'Tally ID 3 is a tally which Cardinal has automatically created and is controlling'
  detail = 'an OpenMCTallyEditor eixsts for a mapped tally created by Cardinal'
  capabilities = 'openmc'
[]

[invalid_boundary]
  type = RunException
  input = invalid_boundary.i
  expect_err = "Invalid 'boundary' entry: 5"
  requirement = "The system shall error if an invalid boundary ID is specified"
  capabilities = 'nekrs'
[]

[type_error]
  type = RunException
  input = type_error.i
  expect_err = "Bin user object with name 'dummy' must inherit from SpatialBinUserObject."
  requirement = "The system shall error if the userobjects aren't derived from the correct base class."
  capabilities = 'nekrs'
[]

[ordering_error]
  type = RunException
  input = order_error.i
  expect_err = "Bin user object with name 'subchannel_binning' not found in problem. The user objects in 'bins' must be listed before the 'vol_avg' user object."
  requirement = "The system shall error if the userobjects aren't listed in the correct order in the input file."
  capabilities = 'nekrs'
[]

[conflicting_bins]
  type = RunException
  input = duplicate_directions.i
  expect_err = "Cannot combine multiple distributions in the same coordinate direction!\nBin 'x_bins' conflicts with bin 'subchannel_binning'"
  requirement = "System shall error if user attemps to combine multiple bins that specify the same coordinate direction."
  capabilities = 'nekrs'
[]

[wrong_type]
  type = RunException
  input = wrong_type.i
  expect_err = "This user object requires all bins to be volume distributions"
  requirement = "System shall error if a side user object is provided to a volume binning user object."
  capabilities = 'nekrs'
[]

[invalid_component]
  type = RunException
  input = 1d.i
  cli_args = "UserObjects/vol_avg/field=velocity_component UserObjects/vol_avg/velocity_component=normal"
  expect_err = "Setting 'velocity_component = normal' is not supported"
  requirement = "System shall error if attempting to use a normal velocity component with a user object that does not have normals defined"
  capabilities = 'nekrs'
[]

[non_perpendicular_axis]
  type = RunException
  input = test.i
  cli_args = 'UserObjects/spg/rotation_axis="1.0 0.0 0.0" UserObjects/spg/rotation_angle=90.0'
  expect_err = "The 'rotation_axis' must be perpendicular to the 'normal'!"
  requirement = "The system shall error if the rotation axis is not perpendicular to the symmetry normal"
[]

[non_integer_angle]
  type = RunException
  input = test.i
  cli_args = 'UserObjects/spg/rotation_axis="0.0 1.0 0.0" UserObjects/spg/rotation_angle=92.0'
  expect_err = "The unit circle must be evenly divisible by the 'rotation_angle'!"
  requirement = "The system shall error if the rotation angle does not describe a valid symmetry wedge"
[]

[warn_instances]
  type = RunException
  input = openmc.i
  cli_args = '--error'
  expect_err = "OpenMC's stochastic volume calculation cannot individually measure volumes of cell INSTANCES."
  requirement = "The system shall warn the user if encountering volume calculations needing instance-level granularity, since this is not available yet in OpenMC itself."
  capabilities = 'openmc'
[]

[invalid_box]
  type = RunException
  input = openmc.i
  cli_args = 'UserObjects/vol/lower_left="10.0 0.0 0.0"'
  expect_err = "The 'upper_right' \(2.5, 2.5, 10\) must be greater than the 'lower_left' \(10, 0, 0\)!"
  requirement = "The system shall error if an invalid bounding box is specified for volume calculations"
  capabilities = 'openmc'
[]

[missing_vol]
  type = RunException
  input = no_vol.i
  expect_err = "To display the actual OpenMC cell volumes"
  requirement = "The system shall error if trying to view stochastic volumes without the stochastic volume calculation having been created."
  capabilities = 'openmc'
[]