Cardinal System Design Description

[h]
  type = CSVDiff
  input = nek.i
  csvdiff = nek_out.csv
  requirement = 'The system shall compute a convective heat transfer coefficient using userobjects for the wall heat flux, wall temperature, and bulk temperature.'
  capabilities = 'nekrs'
[]

[sfr_pincell]
  type = Exodiff
  input = nek_master.i
  exodiff = 'nek_master_out.e'
  min_parallel = 6
  custom_cmp = 'exodiff.cmp'
  heavy = true
  requirement = "A coupled MOOSE-nekRS pincell-fluid flow problem shall predict correct conservation of energy and realistic thermal solutions. Exact conservation of energy (based on the power imposed in the solid) will not be observed because some heat flux GLL points are also on Dirichlet boundaries, which win in boundary condition ties."
  capabilities = 'nekrs'
  max_time = 500
[]

[sfr_pincell_vpp]
  type = Exodiff
  input = nek_main_vpp.i
  exodiff = 'nek_master_out.e'
  min_parallel = 6
  custom_cmp = 'exodiff_vpp.cmp'
  heavy = true
  requirement = "Individually conserving heat flux sideset by sideset shall give equivalent results to the all-combined option when there is just one coupling sideset. The gold file for this test is identical to that for the sfr_pincell case."
  capabilities = 'nekrs'
  max_time = 500
[]

[impose_heat_flux]
  type = CSVDiff
  input = nek_isolated.i
  csvdiff = nek_isolated_out.csv
  min_parallel = 6
  requirement = "The system shall allow imposing heat flux through a dummy main application, instead of coupling NekRS via conjugate heat transfer. This is verified by computing the heat flux on the NekRS mesh, which adequately matches an initial value set in a postprocessor. This gold file is also identical to that obtained by running a dummy main app (solid_dummy) that passes in the desired flux_integral initial condition."
  capabilities = 'nekrs'
  issues = '#797'
[]

[negative_min]
  type = RunException
  input = openmc.i
  cli_args = 'Problem/CriticalitySearch/minimum=-1'
  expect_err = "The 'minimum' boron ppm \(-1.000000\) must be positive!"
  requirement = 'The system shall error if an invalid minimum boron ppm is provided.'
  capabilities = 'openmc'
[]

[non_dilute]
  type = RunException
  input = openmc.i
  cli_args = 'Problem/CriticalitySearch/maximum=53000'
  expect_err = "The borated water composition is computed using a dilute species approximation. Results will not be accurate if the boron species is no longer dilute, which we take as 5\% weight concentration or higher. Please decrease 'maximum' \(53000.000000\) to an upper limit which is in the dilute regime."
  requirement = 'The system shall error if an invalid maximum boron ppm is provided.'
  capabilities = 'openmc'
[]

[warn_nuclides]
  type = RunException
  input = openmc.i
  cli_args = 'Problem/CriticalitySearch/material_id=1 --error'
  expect_err = "The criticality search will clear out all nuclides in material 1 and replace them with the naturally-abundant nuclides in hydrogen, oxygen, and boron. Any other nuclides which existed in the material will be deleted.\n\nThe material you provided contains nuclides which are not the natural isotopes of H, B, and O: U234 U235 U238 H3. These will be deleted from material 1 when the boron concentration is changed."
  requirement = "The system shall warn the user if nuclides will be erased by the borated water criticality search. This test covers both non-H,B,O elements as well as non-natural isotopes of these elements."
  capabilities = 'openmc'
[]

[absent_nuclides]
  type = RunException
  input = openmc.i
  cli_args = 'Problem/CriticalitySearch/absent_nuclides="W182" --error'
  expect_err = "Only absent isotopes of hydrogen, oxygen, or boron will be used to adjust natural abundances. The entry 'W182' will be unused."
  requirement = "The system shall warn the user if they are omitting a nuclide from their cross section library which is irrelevant for boric acid control."
  capabilities = 'openmc'
[]

[borated_water]
  type = CSVDiff
  input = openmc.i
  csvdiff = openmc_out.csv
  requirement = "The system shall perform a criticality search based on boron weight ppm in water. This test changes the water density and then searches for a criticality point; the resulting ppm is compared to a standalone OpenMC model (the comparison is done when running with many more particles for both scenarios). The multiplication factors agree within statistics. Due to floating point non-determinism, the actual test only compares that k matches unity within the desired convergence tolerance."
  # the relative nuclide concentrations are also printed to the screen and shown to match against
  # those added by OpenMC's borated_water function
  capabilities = 'openmc'
[]

[wrong_problem]
  type = RunException
  input = wrong_problem.i
  expect_err = "The \[CriticalitySearch\] block can only be used with wrapped OpenMC cases! You need to change the \[Problem\] block to 'OpenMCCellAverageProblem'."
  requirement = 'The system shall error if a criticality search is not paired with the correct problem class.'
  capabilities = 'openmc'
[]

[min_max]
  type = RunException
  input = openmc.i
  cli_args = 'Problem/CriticalitySearch/minimum=1.0 Problem/CriticalitySearch/maximum=-2.0'
  expect_err = "The 'minimum' value \(1.000000\) must be less than the 'maximum' value \(-2.000000\)."
  requirement = 'The system shall error if invalid values are provided for the range of values to consider for the criticality search.'
  capabilities = 'openmc'
[]

[too_tight_tolerance]
  type = RunException
  input = openmc.i
  cli_args = 'Problem/CriticalitySearch/tolerance=1e-6 --error'
  expect_err = "The 'tolerance' for the criticality search \(0.000001\) is smaller than 3-sigma standard deviation in k"
  requirement = 'The system shall warn if the selected tolerance might cause failure to converge due to high statistical noise.'
  capabilities = 'openmc'
[]

[fail_converge]
  type = RunException
  input = openmc.i
  cli_args = 'Problem/CriticalitySearch/tolerance=1e-6'
  expect_err = "Failed to converge criticality search!"
  requirement = 'The system shall error if the criticality search does not converge.'
  capabilities = 'openmc'
[]

[search]
  type = CSVDiff
  input = openmc.i
  csvdiff = openmc_out.csv
  # for computational expediency, the test is run with much fewer particles
  requirement = 'The system shall conduct a criticality search based on material density. This test is created by running a criticality search with a high particle count (1-sigma less than 10 pcm on k) and comparing the critical search result against a standalone OpenMC simulation which is run at the identified critical value of material density. The two approaches match within statistics. Due to floating point non-determinism, the actual test just checks that k converges to the target within the desired tolerance.'
  capabilities = 'openmc'
[]

[search_with_target]
  type = CSVDiff
  input = target.i
  csvdiff = target_out.csv
  # for computational expediency, the test is run with much fewer particles
  requirement = 'The system shall conduct a criticality search with a non-unity target k. This test is created by running a criticality search with a high particle count (1-sigma less than 10 pcm on k) and comparing the critical search result against a standalone OpenMC simulation which is run at the identified critical value of material density. The two approaches match within statistics. Due to floating point non-determinism, the actual test just checks that k converges to the target within the desired tolerance.'
  capabilities = 'openmc'
[]

[negative_min]
  type = RunException
  input = openmc.i
  cli_args = 'Problem/CriticalitySearch/minimum=-1'
  expect_err = "The 'minimum' density \(-1.000000\) must be positive!"
  requirement = 'The system shall error if an invalid minimum density is provided.'
  capabilities = 'openmc'
[]

[bad_lower_bound]
  type = RunException
  input = openmc.i
  cli_args = 'Problem/CriticalitySearch/minimum=-10.0'
  expect_err = "The 'minimum' specified rotation"
  requirement = 'The system shall error if the minmum search value passed to a RotationSearch is negative.'
  capabilities = 'openmc'
[]

[bad_upper_bound]
  type = RunException
  input = openmc.i
  cli_args = 'Problem/CriticalitySearch/maximum=370.0'
  expect_err = "The 'maximum' specified rotation"
  requirement = 'The system shall error if the maximum search value passed to a RotationSearch is greater than 360 degrees.'
  capabilities = 'openmc'
[]

[rotation_search]
  type = CSVDiff
  input = openmc.i
  min_parallel = 6
  csvdiff = openmc_out.csv
  # for computational expediency, the test is run with much fewer particles
  requirement = 'The system shall conduct a criticality search by modifying a cell rotation. This test is created by running a criticality search with a high particle count (1-sigma less than 10 pcm on k) and comparing the critical search result against a standalone OpenMC simulation which is run at the identified critical value of material density. The two approaches match within statistics. Due to floating point non-determinism, the actual test just checks that k converges to the target within the desired tolerance.'
  capabilities = 'openmc'
[]

[prioritize_refine_and]
  type = CSVDiff
  input = 'prioritize_refine_and.i'
  csvdiff = 'prioritize_refine_and_out.csv'
  requirement = 'The system shall be able to prioritize refinement while ANDing markers together.'
[]

[prioritize_coarsen_and]
  type = CSVDiff
  input = 'prioritize_refine_and.i'
  csvdiff = 'prioritize_refine_and_out.csv'
  cli_args = 'Adaptivity/Markers/combo/priority=coarsening'
  requirement = 'The system shall be able to prioritize coarsening while ANDing markers together.'
[]

[prioritize_refine_or]
  type = CSVDiff
  input = 'prioritize_refine_and.i'
  csvdiff = 'prioritize_refine_or_out.csv'
  cli_args = 'Adaptivity/Markers/combo/boolean_operator=or Outputs/file_base=prioritize_refine_or_out'
  requirement = 'The system shall be able to prioritize refinement while ORing markers together.'
[]

[prioritize_coarsen_or]
  type = CSVDiff
  input = 'prioritize_refine_and.i'
  csvdiff = 'prioritize_coarsen_or_out.csv'
  cli_args = 'Adaptivity/Markers/combo/boolean_operator=or Adaptivity/Markers/combo/priority=coarsening Outputs/file_base=prioritize_coarsen_or_out'
  requirement = 'The system shall be able to prioritize coarsening while ORing markers together.'
[]

[adaptive_cell]
  type = Exodiff
  input = cell.i
  exodiff = cell_out.e
  requirement = "The system shall allow problems which contain adaptivity on the mesh mirror for cell tallies."
  capabilities = 'openmc'
[]

[adaptive_mesh]
  type = Exodiff
  input = mesh.i
  exodiff = mesh_out.e
  mesh_mode = 'replicated'
  requirement = "The system shall allow problems which contain adaptivity on the mesh mirror for mesh tallies."
  capabilities = 'openmc'
[]

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

[skip_openmc_unchanged]
  type = Exodiff
  input = unchanged_mesh.i
  exodiff = unchanged_mesh_out.e
  mesh_mode = 'replicated'
  requirement = "The system shall skip running OpenMC when the mesh is unchanged by adaptivity."
  capabilities = 'openmc'
[]

[skip_openmc_unchanged_picard]
  type = Exodiff
  input = unchanged_main.i
  exodiff = unchanged_main_out.e
  requirement = "The system shall run OpenMC on the first Picard iteration regardless of the mesh being previouslyunchanged by adaptivity. This test relies on noise in the solution; if OpenMC runs more than onceper Picard iteration the PRNG seed changes and so the tally results will be different."
  capabilities = 'openmc'
[]

[block_restrict_cell]
  type = RunException
  input = 'block_restrict_err.i'
  expect_err = "The 'block' parameter of the object 'solid_heat_source' must be a subset of the 'block' parameter of the variable 'heat_source'"
  requirement = "The system shall be capable of block restricting CellTally variables."
  capabilities = 'openmc'
  issues = '#1195'
  design = 'CellTally.md MeshTally.md'
[]

[no_coupling]
  type = CSVDiff
  input = no_coupling.i
  csvdiff = no_coupling_out.csv
  requirement = "The system shall allow a mesh tally for coupling OpenMC, without any physics feedback."
  mesh_mode = 'replicated'
  capabilities = 'openmc'
[]

[one_mesh]
  type = Exodiff
  input = one_mesh.i
  exodiff = 'one_mesh_out.e'
  cli_args = 'Problem/output_cell_mapping=false'
  # This test has very few particles, and OpenMC will error if there aren't any particles
  # on a particular process
  max_parallel = 32
  requirement = "The heat source shall be tallied on an unstructured mesh and normalized against a local tally when a single mesh is used."
  capabilities = 'openmc'
[]

[one_mesh_no_input_file]
  type = Exodiff
  input = one_mesh_no_input_file.i
  exodiff = 'one_mesh_out.e'
  cli_args = "Outputs/file_base=one_mesh_out Mesh/parallel_type=replicated"
  # This test has very few particles, and OpenMC will error if there aren't any particles
  # on a particular process
  max_parallel = 32
  requirement = "This test is nearly identical to one_mesh. The difference lies in having no mesh_template in the input file. Without one, the system should be able to directly tally on a moose mesh instead of a file "
  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 = CSVDiff
  input = scaling_mm.i
  csvdiff = scaling_mm_out.csv
  requirement = "The system shall allow users to use a mesh tally based on the mesh mirror with scaling. The gold file contains relative errors for an unscaled version of the test. The test itself scales the mesh down in the mesh block, and scales it back up with 'scaling'. If 'scaling' is not applied to the mesh mirror, the relative errors will change due to the difference in element volumes. The min/max values in the gold files are manually converted from W/cm^3 (no scaling) to W/m^3 (scaled)."
  mesh_mode = 'replicated'
  capabilities = 'openmc'
  issues = '#1246'
[]

[one_mesh_global]
  type = Exodiff
  input = one_mesh_global.i
  exodiff = 'one_mesh_global_out.e'
  # This test has very few particles, and OpenMC will error if there aren't any particles
  # on a particular process
  max_parallel = 32
  requirement = "The heat source shall be tallied on an unstructured mesh and normalized against a global tally when a single mesh is used. This test was run with successively finer meshes (from 256 elements to 94k elements) to show that the power of the mesh tally approaches the value of a cell tally as the difference in volume decreases."
  capabilities = 'openmc'
[]

[block_restrict]
  type = Exodiff
  input = block_restrict.i
  exodiff = block_restrict_out.e
  # This test has very few particles, and OpenMC will error if there aren't any particles
  # on a particular process
  max_parallel = 32
  requirement = "Mesh tallies shall allow for block restrictions to be applied."
  capabilities = 'openmc'
[]

[multiple_meshes]
  type = Exodiff
  input = multiple_meshes.i
  exodiff = 'multiple_meshes_out.e'
  # This test has very few particles, and OpenMC will error if there aren't any particles
  # on a particular process
  max_parallel = 32
  requirement = "The heat source shall be tallied on an unstructured mesh and normalized against a local tally when multiple identical meshes are used."
  capabilities = 'openmc'
[]

[multiple_meshes_global]
  type = Exodiff
  input = multiple_meshes_global.i
  exodiff = 'multiple_meshes_global_out.e'
  # This test has very few particles, and OpenMC will error if there aren't any particles
  # on a particular process
  max_parallel = 32
  requirement = "The heat source shall be tallied on an unstructured mesh and normalized against a global tally when multiple identical meshes are used. This test was run with successively finer meshes (from 256 elements to 94k elements) to show that the power of the mesh tally approaches the value of a cell tally as the difference in volume decreases."
  capabilities = 'openmc'
[]

[different_units]
  type = Exodiff
  input = different_units.i
  exodiff = 'different_units_out.e'
  # This test has very few particles, and OpenMC will error if there aren't any particles
  # on a particular process
  max_parallel = 32
  requirement = "The heat source shall be correctly projected onto a [Mesh] in units of meters when the tally mesh template is in units of centimeters."
  capabilities = 'openmc'
[]

[different_units_and_translations]
  type = Exodiff
  input = different_units_and_translations.i
  exodiff = 'different_units_and_translations_out.e'
  # This test has very few particles, and OpenMC will error if there aren't any particles
  # on a particular process
  max_parallel = 32
  requirement = "The heat source shall be correctly projected onto a [Mesh] in units of meters when the tally mesh template and translations are in units of centimeters. The output was compared against the multiple_meshes case, which used an input entirely specified in terms of centimeters."
  capabilities = 'openmc'
[]

[fission_tally_std_dev]
  type = CSVDiff
  input = fission_tally_std_dev.i
  csvdiff = fission_tally_std_dev_out.csv
  # This test has very few particles, and OpenMC will error if there aren't any particles
  # on a particular process
  max_parallel = 32
  requirement = "The fission tally standard deviation shall be output correctly for unstructured mesh tallies."
  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'
[]

[cell_tally_unmapped]
  type = CSVDiff
  input = cell_with_unmapped.i
  csvdiff = cell_with_unmapped_out.csv
  requirement = "The system shall correctly label elements in blocks which don't contain temperature feedback, density feedback, or a cell tally as unmapped."
  capabilities = 'openmc'
[]

[multi_global_estimator]
  type = CSVDiff
  input = multi_estimator.i
  csvdiff = multi_estimator_out.csv
  requirement = "The system shall correctly normalize local tallies with different estimators using multiple global tallies."
  capabilities = 'openmc'
[]

[multiple_tallies_cell]
  type = CSVDiff
  input = multi_cell.i
  csvdiff = multi_cell_out.csv
  requirement = "The system shall correctly apply and normalize two different CellTally objects with different scores. The gold file was generated using an input that had a single CellTally with multiple scores."
  capabilities = 'openmc'
[]

[multiple_tallies_mesh]
  type = Exodiff
  input = multi_mesh.i
  exodiff = multi_mesh_out.e
  requirement = "The system shall correctly apply and normalize two different MeshTally objects with different scores. The gold file was generated using an input that had a single MeshTally with multiple scores."
  capabilities = 'openmc'
[]

[multiple_tallies_cell_triggers]
  type = CSVDiff
  input = multi_cell_triggers.i
  csvdiff = multi_cell_triggers_out.csv
  requirement = "The system shall correctly apply and normalize two different CellTally objects with different scores and triggers. The gold file was generated using an input that had a single CellTally with multiple scores and triggers."
  capabilities = 'openmc'
[]

[multiple_tallies_mesh_triggers]
  type = Exodiff
  input = multi_mesh_triggers.i
  exodiff = multi_mesh_triggers_out.e
  requirement = "The system shall correctly apply and normalize two different MeshTally objects with different scores and triggers. The gold file was generated using an input that had a single MeshTally with multiple scores and triggers."
  capabilities = 'openmc'
[]

[multiple_tallies_cell_relax]
  type = CSVDiff
  input = multi_cell_relax.i
  csvdiff = multi_cell_relax_out.csv
  requirement = "The system shall correctly apply and normalize two different CellTally objects with different scores when using relaxation. The gold file was generated using an input that had a single CellTally with multiple scores when using relaxation."
  capabilities = 'openmc'
[]

[multiple_tallies_mesh_relax]
  type = Exodiff
  input = multi_mesh_relax.i
  exodiff = multi_mesh_relax_out.e
  requirement = "The system shall correctly apply and normalize two different MeshTally objects with different scores when using relaxation. The gold file was generated using an input that had a single MeshTally with multiple scores when using relaxation."
  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'
[]

[multiple_different_tallies]
  type = Exodiff
  input = multi_diff.i
  exodiff = multi_diff_out.e
  requirement = "The system shall allow calculations with multiple different tallies."
  capabilities = 'openmc'
[]

[multiple_different_outputs]
  type = Exodiff
  input = multi_diff.i
  exodiff = multi_diff_outputs.e
  cli_args = 'Problem/Tallies/Cell/output="unrelaxed_tally_std_dev unrelaxed_tally" Problem/Tallies/Mesh/output="unrelaxed_tally_std_dev" Outputs/file_base=multi_diff_outputs'
  requirement = "The system shall allow calculations with multiple different tally outputs."
  capabilities = 'openmc'
[]

[same_scores]
  type = CSVDiff
  input = same_scores.i
  csvdiff = same_scores_out.csv
  cli_args = 'Problem/normalization_tally="Cell"'
  requirement = "The system shall allow multiple tallies to use the same scores."
  capabilities = 'openmc'
[]

[two_kf_unspecified_norm]
  type = RunException
  input = same_scores.i
  expect_err = "When using a non-heating tally \(flux\) in eigenvalue mode and adding more then one tally in the \[Tallies\] block, the 'normalization_tally' parameter is required!"
  requirement = "The system shall error if two tallies score the normalization score and the user does not specify which to use for normalization."
  capabilities = 'openmc'
[]

[duplicate_names]
  type = RunException
  input = same_scores.i
  cli_args = 'Problem/normalization_tally="Cell" Problem/Tallies/Cell/name="kappa_fission" Problem/Tallies/Mesh/name="kappa_fission flux"'
  expect_err = "Cardinal is trying to add an auxiliary variable named 'kappa_fission' through the Tally system"
  requirement = "The system shall error if two tallies scoring the same score add the same variable names."
  capabilities = 'openmc'
[]

[duplicate_scores_separate_tallies]
  type = RunException
  input = same_scores.i
  cli_args = "Problem/assume_separate_tallies=true Problem/Tallies/Cell/normalize_by_global_tally=false"
  expect_err = "Cannot assume separate tallies when there are multiple tallies"
  requirement = "The system shall error if attempting to use separate tallies when adding two tallies with the same score."
  capabilities = 'openmc'
[]

[adaptive_cell]
  type = Exodiff
  input = cell.i
  exodiff = cell_out.e
  requirement = "The system shall allow problems which contain adaptivity on the mesh mirror for cell tallies."
  capabilities = 'openmc'
[]

[adaptive_mesh]
  type = Exodiff
  input = mesh.i
  exodiff = mesh_out.e
  mesh_mode = 'replicated'
  requirement = "The system shall allow problems which contain adaptivity on the mesh mirror for mesh tallies."
  capabilities = 'openmc'
[]

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

[skip_openmc_unchanged]
  type = Exodiff
  input = unchanged_mesh.i
  exodiff = unchanged_mesh_out.e
  mesh_mode = 'replicated'
  requirement = "The system shall skip running OpenMC when the mesh is unchanged by adaptivity."
  capabilities = 'openmc'
[]

[skip_openmc_unchanged_picard]
  type = Exodiff
  input = unchanged_main.i
  exodiff = unchanged_main_out.e
  requirement = "The system shall run OpenMC on the first Picard iteration regardless of the mesh being previouslyunchanged by adaptivity. This test relies on noise in the solution; if OpenMC runs more than onceper Picard iteration the PRNG seed changes and so the tally results will be different."
  capabilities = 'openmc'
[]

[error]
  type = RunException
  input = openmc.i
  expect_err = "OpenMC coupling to axisymmetric meshes is not yet supported"
  requirement = "The system shall error if attempting to use an axisymmetric mesh mirror because MOOSE's element volume functions only return areas for axisymmetric."
  capabilities = 'openmc'
[]

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

[allows_csg_with_skinner]
  type = CSVDiff
  input = openmc.i
  csvdiff = openmc_out.csv
  requirement = "The system shall allow for the use of CSG and DAGMC geometry when using the MoabSkinner."
  mesh_mode = 'replicated'
  capabilities = 'dagmc'
[]

[allow_mat_diff_cell]
  type = CSVDiff
  input = openmc.i
  csvdiff = openmc_out.csv
  requirement = "The system shall allow a material to be specified both in a cell with density feedback and a cell without density feedback. The gold file for this test was generated with a duplicated material of the feedback cell fill in the respective non-feedback cell."
  capabilities = 'openmc'
[]

[pincell]
  type = CSVDiff
  input = openmc.i
  csvdiff = openmc_out.csv
  requirement = "The system shall allow density feedback in OpenMC models per cell without requiring unique cell materials. This model was compared against a model with unique materials per cell."
  capabilities = 'openmc'
[]

[ifp_changing]
  type = CSVDiff
  input = one_bin.i
  csvdiff = one_bin_out.csv
  requirement = "The system shall be able to compute IFP quantities on changing geometries."
  mesh_mode = 'replicated'
  capabilities = 'dagmc'
[]

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

[compute_both]
  type = CSVDiff
  input = both.i
  csvdiff = both_out.csv
  requirement = "The system shall be able to calculate neutron kinetics parameters."
  capabilities = 'openmc'
[]

[six_group_beta]
  type = CSVDiff
  input = six_grp.i
  csvdiff = six_grp_out.csv
  requirement = "The system shall be able to calculate separate values of beta_eff for each delayed group in the ENDF delayed group structure."
  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'
[]

[nearest]
  type = CSVDiff
  input = 'openmc_nearest.i'
  csvdiff = 'openmc_nearest_out.csv'
  requirement = 'The system shall support nearest temperature interpolation when running in multi-group mode.'
  capabilities = 'openmc'
[]

[interpolation]
  type = CSVDiff
  input = 'openmc_interp.i'
  csvdiff = 'openmc_interp_out.csv'
  requirement = 'The system shall support linear temperature interpolation when running in multi-group mode.'
  capabilities = 'openmc'
[]

[nearest]
  type = CSVDiff
  input = 'openmc.i'
  csvdiff = 'openmc_out.csv'
  requirement = 'The system shall support void regions when running in multi-group mode.'
  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'
[]

[cell_tally]
  type = Exodiff
  input = cell_tally.i
  exodiff = cell_tally_out.e
  requirement = 'The system shall correctly reinitialize cell tallies when the mesh is moving. This is tested by translating the mesh over a stationary OpenMC model. The two cell tallies in the tallies.out file match the expected power density (accounting for the actual fractions of the cell which map to the moving mesh). This test also checks the cell IDs and instances as the mesh translates.'
  capabilities = 'dagmc'
[]

[mesh_tally]
  type = Exodiff
  input = mesh_tally.i
  exodiff = mesh_tally_out.e
  requirement = 'The system shall correctly use a mesh tally on a moving MOOSE mesh. This is tested by translating the mesh over a stationary OpenMC model. The mesh translation exposes 20 percent of the left subdomain, which from a non-moving case we record 8 percent of the total power deposition in this region. For the moving mesh case, the total power deposited in the mesh tally is 92 percent.'
  mesh_mode = 'replicated'
  capabilities = 'dagmc'
[]

[make_mesh]
  type = RunApp
  input = mesh_tally.i
  cli_args = '--mesh-only'
  requirement = 'The system shall generate a file for mesh tallies.'
  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'
[]

[temperature]
  type = Exodiff
  input = temperature.i
  exodiff = temperature_out.e
  requirement = 'The system shall correctly reinitialize temperature mapping and output of cell temperatures to a moving mesh. This is tested by applying temperatures based on the moving mesh.'
  capabilities = 'dagmc'
[]

[density]
  type = Exodiff
  input = density.i
  exodiff = density_out.e
  requirement = 'The system shall correctly reinitialize density mapping and output of cell densities and material fills to a moving mesh. This is tested by applying densities based on the moving mesh.'
  capabilities = 'dagmc'
[]

[volumes]
  type = CSVDiff
  input = volumes.i
  csvdiff = volumes_out.csv
  requirement = 'The system shall correctly reinitialize volume calculations for a moving mesh. This is tested by comparing the OpenMC stochastic volume calculation against postprocessors for changing volumes.'
  mesh_mode = 'replicated' # tet converter is restricted to replicated meshes
  capabilities = 'dagmc'
[]

[scale]
  type = CSVDiff
  input = scale.i
  csvdiff = scale_out.csv
  requirement = 'The system shall change the OpenMC mesh geometry on-the-fly. This is tested by running this case with a very high number of particles and batches, to compare against the CSG case in the reference folder. The reference case is a CSG model created at the deformed state. We cannot match these cases perfectly because we cannot control the seed of the second Picard iteration. The reference case gives k = 0.88782 plus or minus 5 pcm, and our Cardinal case gives 0.88786 plus of minus 5 pcm; these agree within 1 sigma.'
  mesh_mode = 'replicated' # tet converter is restricted to replicated meshes
  capabilities = 'dagmc'
[]

[check_statepoint_exists]
  type = CheckFiles
  input = openmc.i
  check_files = 'statepoint.50.h5'
  # 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
  requirement = "A statepoint file must be written when the batches parameter matches the batches in settings.xml and they are both specified."
  capabilities = 'openmc'
[]

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

[allows_csg_with_skinner]
  type = CSVDiff
  input = openmc.i
  csvdiff = openmc_out.csv
  requirement = "The system shall allow for the use of CSG and DAGMC geometry when using the MoabSkinner."
  mesh_mode = 'replicated'
  capabilities = 'dagmc'
[]

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

[cell_tally]
  type = Exodiff
  input = cell_tally.i
  exodiff = cell_tally_out.e
  requirement = 'The system shall correctly reinitialize cell tallies when the mesh is moving. This is tested by translating the mesh over a stationary OpenMC model. The two cell tallies in the tallies.out file match the expected power density (accounting for the actual fractions of the cell which map to the moving mesh). This test also checks the cell IDs and instances as the mesh translates.'
  capabilities = 'dagmc'
[]

[mesh_tally]
  type = Exodiff
  input = mesh_tally.i
  exodiff = mesh_tally_out.e
  requirement = 'The system shall correctly use a mesh tally on a moving MOOSE mesh. This is tested by translating the mesh over a stationary OpenMC model. The mesh translation exposes 20 percent of the left subdomain, which from a non-moving case we record 8 percent of the total power deposition in this region. For the moving mesh case, the total power deposited in the mesh tally is 92 percent.'
  mesh_mode = 'replicated'
  capabilities = 'dagmc'
[]

[make_mesh]
  type = RunApp
  input = mesh_tally.i
  cli_args = '--mesh-only'
  requirement = 'The system shall generate a file for mesh tallies.'
  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'
[]

[temperature]
  type = Exodiff
  input = temperature.i
  exodiff = temperature_out.e
  requirement = 'The system shall correctly reinitialize temperature mapping and output of cell temperatures to a moving mesh. This is tested by applying temperatures based on the moving mesh.'
  capabilities = 'dagmc'
[]

[density]
  type = Exodiff
  input = density.i
  exodiff = density_out.e
  requirement = 'The system shall correctly reinitialize density mapping and output of cell densities and material fills to a moving mesh. This is tested by applying densities based on the moving mesh.'
  capabilities = 'dagmc'
[]

[volumes]
  type = CSVDiff
  input = volumes.i
  csvdiff = volumes_out.csv
  requirement = 'The system shall correctly reinitialize volume calculations for a moving mesh. This is tested by comparing the OpenMC stochastic volume calculation against postprocessors for changing volumes.'
  mesh_mode = 'replicated' # tet converter is restricted to replicated meshes
  capabilities = 'dagmc'
[]

[scale]
  type = CSVDiff
  input = scale.i
  csvdiff = scale_out.csv
  requirement = 'The system shall change the OpenMC mesh geometry on-the-fly. This is tested by running this case with a very high number of particles and batches, to compare against the CSG case in the reference folder. The reference case is a CSG model created at the deformed state. We cannot match these cases perfectly because we cannot control the seed of the second Picard iteration. The reference case gives k = 0.88782 plus or minus 5 pcm, and our Cardinal case gives 0.88786 plus of minus 5 pcm; these agree within 1 sigma.'
  mesh_mode = 'replicated' # tet converter is restricted to replicated meshes
  capabilities = 'dagmc'
[]

[azimuthal_cell_provided_bins]
  type = CSVDiff
  input = cell.i
  csvdiff = cell_provided_out.csv
  cli_args = 'Problem/Filters/Azimuthal/azimuthal_angle_boundaries="${fparse -pi} 0.0 ${fparse pi}" Outputs/file_base=cell_provided_out'
  requirement = "The system shall be capable of adding an AzimuthalAngleFilter to a CellTally with bins that are provided. This test also ensures the binned fluxes sum to the total flux through the use of global normalization."
  capabilities = 'openmc'
[]

[azimuthal_cell_equally_spaced_bins]
  type = CSVDiff
  input = cell.i
  csvdiff = cell_equal_out.csv
  cli_args = 'Problem/Filters/Azimuthal/num_equal_divisions=2 Outputs/file_base=cell_equal_out'
  requirement = "The system shall be capable of adding an AzimuthalAngleFilter to a CellTally with equally spaced bins. This test also ensures the binned fluxes sum to the total flux through the use of global normalization."
  capabilities = 'openmc'
[]

[azimuthal_mesh]
  type = CSVDiff
  input = mesh.i
  csvdiff = mesh_out.csv
  requirement = "The system shall be capable of adding an AzimuthalAngleFilter to a MeshTally."
  capabilities = 'openmc'
[]

[bin_sum]
  type = Exodiff
  input = mesh_sum.i
  exodiff = mesh_sum_out.e
  requirement = "The system shall correctly compute azimuthal binned fluxes with mesh tallies such that the sum of the flux over each bin equals the total flux. The gold file was generated with an input file that scored the flux without a AzimuthalAngleFilter."
  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'
[]

[bnds_wrong_order]
  type = CSVDiff
  input = cell.i
  cli_args = 'Problem/Filters/Azimuthal/azimuthal_angle_boundaries="${fparse pi} 0.0 ${fparse -pi}" Outputs/file_base=cell_provided_out'
  csvdiff = cell_provided_out.csv
  requirement = "The system shall automatically sort bins to ensure they're monotonically increasing."
  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'
[]

[delayed]
  type = CSVDiff
  input = cell.i
  csvdiff = cell_out.csv
  requirement = "The system shall be capable of adding a DelayedGroupFilter to delayed neutron scores."
  capabilities = 'openmc'
[]

[delayed_scores]
  type = RunException
  input = cell.i
  cli_args = 'Problem/Tallies/DNP/score="total"'
  expect_err = 'The filter Delayed can only be used with delayed_nu_fission and decay_rate scores!'
  requirement = "The system shall error if the use attempts to add a DelayedGroupFilter to a tally with non-delayed scores."
  capabilities = 'openmc'
[]

[energy_cell_bnds]
  type = CSVDiff
  input = cell.i
  csvdiff = cell_out.csv
  cli_args = 'Problem/Filters/Energy/energy_boundaries="0.0 6.25e-1 2.0e7"'
  requirement = "The system shall be capable of adding an EnergyFilter (with energy boundaries provided) to a CellTally. This test also ensures multi-group fluxes sum to the total flux for cell tallies."
  capabilities = 'openmc'
[]

[energy_cell_structure]
  type = CSVDiff
  input = cell.i
  csvdiff = cell_out.csv
  cli_args = 'Problem/Filters/Energy/group_structure=CASMO_2'
  requirement = "The system shall be capable of adding an EnergyFilter (with a group structure) to a CellTally. This test also ensures multi-group fluxes sum to the total flux for cell tallies."
  capabilities = 'openmc'
[]

[energy_mesh]
  type = CSVDiff
  input = mesh.i
  csvdiff = mesh_out.csv
  requirement = "The system shall be capable of adding an EnergyFilter to a MeshTally."
  capabilities = 'openmc'
[]

[group_sum]
  type = Exodiff
  input = mesh_sum.i
  exodiff = mesh_sum_out.e
  requirement = "The system shall correctly compute multi-group fluxes with mesh tallies such that the sum of the flux over each group equals the total flux. The gold file was generated with an input file that scored the flux without an EnergyFilter."
  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'
[]

[bnds_wrong_order]
  type = CSVDiff
  input = cell.i
  cli_args = 'Problem/Filters/Energy/energy_boundaries="2.0e7 6.25e-1 0.0"'
  csvdiff = cell_out.csv
  requirement = "The system shall automatically sort bins to ensure they're monotonically increasing."
  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'
[]

[energy_cell_bnds]
  type = CSVDiff
  input = cell.i
  csvdiff = cell_out.csv
  cli_args = 'Problem/Filters/EnergyOut/energy_boundaries="0.0 6.25e-1 2.0e7"'
  requirement = "The system shall be capable of adding an EnergyOutFilter (with energy boundaries provided)."
  capabilities = 'openmc'
[]

[energy_cell_structure]
  type = CSVDiff
  input = cell.i
  csvdiff = cell_out.csv
  cli_args = 'Problem/Filters/EnergyOut/group_structure=CASMO_2'
  requirement = "The system shall be capable of adding an EnergyOutFilter (with a group structure)."
  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'
[]

[legendre_l1]
  type = CSVDiff
  input = cell.i
  csvdiff = cell_out.csv
  requirement = "The system shall support Legendre filters in the scattering angle."
  capabilities = 'openmc'
[]

[l0_in_l1_vs_no_legendre]
  type = CSVDiff
  input = cell_l0_from_l1.i
  csvdiff = cell_l0_from_l1_out.csv
  requirement = "The L0 Legendre moment in a L>0 Legendre expansion shall match the scattering reaction rate computed without a Legendre filter. This ensures that the L>0 Legendre moments are skipped during normalization.The gold file for this test was generated without a Legendre filter."
  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'
[]

[filter_particles]
  type = CSVDiff
  input = cell.i
  csvdiff = cell_out.csv
  requirement = "The system shall be capable of adding a ParticleFilter for all particle types supported in OpenMC."
  capabilities = 'openmc'
[]

[polar_cell_provided_bins]
  type = CSVDiff
  input = cell.i
  csvdiff = cell_provided_out.csv
  cli_args = 'Problem/Filters/Polar/polar_angle_boundaries="0.0 1.5708 ${fparse pi}" Outputs/file_base=cell_provided_out'
  requirement = "The system shall be capable of adding an PolarAngleFilter to a CellTally with bins that are provided. This test also ensures the binned fluxes sum to the total flux through the use of global normalization."
  capabilities = 'openmc'
[]

[polar_cell_equally_spaced_bins]
  type = CSVDiff
  input = cell.i
  csvdiff = cell_equal_out.csv
  cli_args = 'Problem/Filters/Polar/num_equal_divisions=2 Outputs/file_base=cell_equal_out'
  requirement = "The system shall be capable of adding an PolarAngleFilter to a CellTally with equally spaced bins. This test also ensures the binned fluxes sum to the total flux through the use of global normalization."
  capabilities = 'openmc'
[]

[polar_mesh]
  type = CSVDiff
  input = mesh.i
  csvdiff = mesh_out.csv
  requirement = "The system shall be capable of adding an PolarAngleFilter to a MeshTally."
  capabilities = 'openmc'
[]

[bin_sum]
  type = Exodiff
  input = mesh_sum.i
  exodiff = mesh_sum_out.e
  requirement = "The system shall correctly compute polar binned fluxes with mesh tallies such that the sum of the flux over each bin equals the total flux. The gold file was generated with an input file that scored the flux without a PolarAngleFilter."
  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'
[]

[bnds_wrong_order]
  type = CSVDiff
  input = cell.i
  cli_args = 'Problem/Filters/Polar/polar_angle_boundaries="${fparse pi} 1.5708 0.0" Outputs/file_base=cell_provided_out'
  csvdiff = cell_provided_out.csv
  requirement = "The system shall automatically sort bins to ensure they're monotonically increasing."
  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'
[]

[sh_l1]
  type = CSVDiff
  input = openmc_l1.i
  csvdiff = openmc_l1_out.csv
  requirement = "The system shall support spherical harmonics filters."
  capabilities = 'openmc'
[]

[sh_l1_mult]
  type = CSVDiff
  input = openmc_l1_mult.i
  csvdiff = openmc_l1_mult_out.csv
  requirement = "The system shall support spherical harmonics filters composed with other filters."
  capabilities = 'openmc'
[]

[sh_l0_in_l1_vs_no_sh]
  type = CSVDiff
  input = openmc_l0_from_l1.i
  csvdiff = openmc_l0_from_l1_out.csv
  requirement = "The L0 spherical harmonics moment in a L>0 SH expansion shall match the scalar fluxes computed without a spherical harmonics filter. This ensures that the L>0 SH moments are skipped during normalization.The gold file for this test was generated without a SH filter."
  capabilities = 'openmc'
[]

[multi_filter]
  type = CSVDiff
  input = multi_filter.i
  csvdiff = multi_filter_out.csv
  requirement = "The system shall support multiple filters within a tally."
  capabilities = 'openmc'
[]

[no_norm_score]
  type = CSVDiff
  input = filter_no_norm_score.i
  csvdiff = filter_no_norm_score_out.csv
  requirement = "The system shall support the automatic addition of the requested source rate normalization score to a single tally when using filters."
  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'
[]

[arbitrary_cell]
  type = CSVDiff
  input = cell.i
  csvdiff = cell_out.csv
  requirement = "The system shall allow cell tallies to access filters added in the OpenMC tallies XML file."
  capabilities = 'openmc'
[]

[arbitrary_mesh]
  type = CSVDiff
  input = mesh.i
  csvdiff = mesh_out.csv
  requirement = "The system shall allow mesh tallies to access filters added in the OpenMC tallies XML file."
  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'
[]

[calc]
  type = CSVDiff
  input = mg_diffusion_coeff.i
  csvdiff = mg_diffusion_coeff_out.csv
  detail = "The system shall calculate multi-group particle diffusion coefficients."
  capabilities = 'openmc'
[]

[catch_zero_flux]
  type = CSVDiff
  input = mg_diffusion_coeff.i
  csvdiff = diff_zero_flux_out.csv
  cli_args = "Outputs/file_base='diff_zero_flux_out' AuxKernels/comp_diff_g1/scalar_flux='zero_flux'"
  detail = "The system shall prevent divide by zeros when calculating multi-group diffusion coefficients. This also checks for cases where the transport cross section is zero."
  capabilities = 'openmc'
[]

[calc]
  type = CSVDiff
  input = mg_tc_scatter_xs.i
  csvdiff = mg_tc_scatter_xs_out.csv
  detail = "The system shall calculate multi-group transport corrected P0 scattering cross sections."
  capabilities = 'openmc'
[]

[catch_zero_flux]
  type = CSVDiff
  input = mg_tc_scatter_xs.i
  csvdiff = zero_flux_out.csv
  cli_args = "Outputs/file_base='zero_flux_out' AuxKernels/comp_scatter_g1_g1_l0/scalar_flux='zero_flux'"
  detail = "The system shall prevent divide by zeros when calculating transport corrected P0 scattering cross sections."
  capabilities = 'openmc'
[]

[calc]
  type = CSVDiff
  input = generic_mgxs.i
  csvdiff = generic_mgxs_out.csv
  detail = "The system shall calculate multi-group cross sections using an arbitrary reaction rate and normalization factor."
  capabilities = 'openmc'
[]

[catch_zero_flux]
  type = CSVDiff
  input = generic_mgxs.i
  csvdiff = zero_flux_out.csv
  cli_args = "Outputs/file_base='zero_flux_out' AuxKernels/comp_total_g1/normalize_by='zero_flux'"
  detail = "The system shall prevent divide by zeros when calculating cross sections."
  capabilities = 'openmc'
[]

[photon]
  type = CSVDiff
  input = mgxs_photon.i
  csvdiff = mgxs_photon_out.csv
  requirement = "The system shall be capable of setting up MGXS generation for all relevant cross section types for photon."
  capabilities = 'openmc'
[]

[all_cell]
  type = CSVDiff
  input = all_mgxs_cell.i
  csvdiff = all_mgxs_cell_out.csv
  requirement = "The system shall be capable of setting up MGXS generation for all relevant cross section types using mapped distributed cell tallies."
  capabilities = 'openmc'
[]

[l0_scatter_no_tc]
  type = CSVDiff
  input = all_mgxs_cell_l0.i
  csvdiff = all_mgxs_cell_l0_out.csv
  requirement = "The system shall be capable of generating L = 0 scattering cross sections without a transport correction."
  capabilities = 'openmc'
[]

[l1_scatter]
  type = CSVDiff
  input = all_mgxs_cell_l1.i
  csvdiff = all_mgxs_cell_l1_out.csv
  requirement = "The system shall be capable of generating L > 0 scattering MGXS generation."
  capabilities = 'openmc'
[]

[collision]
  type = CSVDiff
  input = subset_cell.i
  cli_args = "Problem/MGXS/estimator='collision' Outputs/file_base='collision_out'"
  csvdiff = collision_out.csv
  requirement = "The system shall be capable of generating certain multi-group cross sections with a collision estimator."
  capabilities = 'openmc'
[]

[tracklength]
  type = CSVDiff
  input = subset_cell.i
  cli_args = "Problem/MGXS/estimator='tracklength' Outputs/file_base='tracklength_out'"
  csvdiff = tracklength_out.csv
  requirement = "The system shall be capable of generating certain multi-group cross sections with a tracklength estimator."
  capabilities = 'openmc'
[]

[all_mesh]
  type = CSVDiff
  input = all_mgxs_mesh.i
  csvdiff = all_mgxs_mesh_out.csv
  mesh_mode = 'replicated'
  requirement = "The system shall be capable of setting up MGXS generation for all relevant cross section types using unstructured mesh tallies."
  capabilities = 'openmc'
[]

[hide_tally_vars]
  type = Exodiff
  input = hide_tally_vars.i
  exodiff = hide_tally_vars_out.e
  requirement = "The system shall be hide tally variables added for MGXS generation unless requested by the user."
  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'
[]

[block_restrict_cell]
  type = RunException
  input = 'block_restrict_err.i'
  expect_err = "The 'block' parameter of the object 'solid_heat_source' must be a subset of the 'block' parameter of the variable 'heat_source'"
  requirement = "The system shall be capable of block restricting CellTally variables."
  capabilities = 'openmc'
  issues = '#1195'
  design = 'CellTally.md MeshTally.md'
[]

[cell_tally_unmapped]
  type = CSVDiff
  input = cell_with_unmapped.i
  csvdiff = cell_with_unmapped_out.csv
  requirement = "The system shall correctly label elements in blocks which don't contain temperature feedback, density feedback, or a cell tally as unmapped."
  capabilities = 'openmc'
[]

[multi_global_estimator]
  type = CSVDiff
  input = multi_estimator.i
  csvdiff = multi_estimator_out.csv
  requirement = "The system shall correctly normalize local tallies with different estimators using multiple global tallies."
  capabilities = 'openmc'
[]

[multiple_tallies_cell]
  type = CSVDiff
  input = multi_cell.i
  csvdiff = multi_cell_out.csv
  requirement = "The system shall correctly apply and normalize two different CellTally objects with different scores. The gold file was generated using an input that had a single CellTally with multiple scores."
  capabilities = 'openmc'
[]

[multiple_tallies_mesh]
  type = Exodiff
  input = multi_mesh.i
  exodiff = multi_mesh_out.e
  requirement = "The system shall correctly apply and normalize two different MeshTally objects with different scores. The gold file was generated using an input that had a single MeshTally with multiple scores."
  capabilities = 'openmc'
[]

[multiple_tallies_cell_triggers]
  type = CSVDiff
  input = multi_cell_triggers.i
  csvdiff = multi_cell_triggers_out.csv
  requirement = "The system shall correctly apply and normalize two different CellTally objects with different scores and triggers. The gold file was generated using an input that had a single CellTally with multiple scores and triggers."
  capabilities = 'openmc'
[]

[multiple_tallies_mesh_triggers]
  type = Exodiff
  input = multi_mesh_triggers.i
  exodiff = multi_mesh_triggers_out.e
  requirement = "The system shall correctly apply and normalize two different MeshTally objects with different scores and triggers. The gold file was generated using an input that had a single MeshTally with multiple scores and triggers."
  capabilities = 'openmc'
[]

[multiple_tallies_cell_relax]
  type = CSVDiff
  input = multi_cell_relax.i
  csvdiff = multi_cell_relax_out.csv
  requirement = "The system shall correctly apply and normalize two different CellTally objects with different scores when using relaxation. The gold file was generated using an input that had a single CellTally with multiple scores when using relaxation."
  capabilities = 'openmc'
[]

[multiple_tallies_mesh_relax]
  type = Exodiff
  input = multi_mesh_relax.i
  exodiff = multi_mesh_relax_out.e
  requirement = "The system shall correctly apply and normalize two different MeshTally objects with different scores when using relaxation. The gold file was generated using an input that had a single MeshTally with multiple scores when using relaxation."
  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'
[]

[multiple_different_tallies]
  type = Exodiff
  input = multi_diff.i
  exodiff = multi_diff_out.e
  requirement = "The system shall allow calculations with multiple different tallies."
  capabilities = 'openmc'
[]

[multiple_different_outputs]
  type = Exodiff
  input = multi_diff.i
  exodiff = multi_diff_outputs.e
  cli_args = 'Problem/Tallies/Cell/output="unrelaxed_tally_std_dev unrelaxed_tally" Problem/Tallies/Mesh/output="unrelaxed_tally_std_dev" Outputs/file_base=multi_diff_outputs'
  requirement = "The system shall allow calculations with multiple different tally outputs."
  capabilities = 'openmc'
[]

[same_scores]
  type = CSVDiff
  input = same_scores.i
  csvdiff = same_scores_out.csv
  cli_args = 'Problem/normalization_tally="Cell"'
  requirement = "The system shall allow multiple tallies to use the same scores."
  capabilities = 'openmc'
[]

[two_kf_unspecified_norm]
  type = RunException
  input = same_scores.i
  expect_err = "When using a non-heating tally \(flux\) in eigenvalue mode and adding more then one tally in the \[Tallies\] block, the 'normalization_tally' parameter is required!"
  requirement = "The system shall error if two tallies score the normalization score and the user does not specify which to use for normalization."
  capabilities = 'openmc'
[]

[duplicate_names]
  type = RunException
  input = same_scores.i
  cli_args = 'Problem/normalization_tally="Cell" Problem/Tallies/Cell/name="kappa_fission" Problem/Tallies/Mesh/name="kappa_fission flux"'
  expect_err = "Cardinal is trying to add an auxiliary variable named 'kappa_fission' through the Tally system"
  requirement = "The system shall error if two tallies scoring the same score add the same variable names."
  capabilities = 'openmc'
[]

[duplicate_scores_separate_tallies]
  type = RunException
  input = same_scores.i
  cli_args = "Problem/assume_separate_tallies=true Problem/Tallies/Cell/normalize_by_global_tally=false"
  expect_err = "Cannot assume separate tallies when there are multiple tallies"
  requirement = "The system shall error if attempting to use separate tallies when adding two tallies with the same score."
  capabilities = 'openmc'
[]

[all_h]
  type = Exodiff
  input = 'openmc.i'
  exodiff = 'openmc_out.e'
  requirement = 'The system shall allow for the calculation of the optical depth using the min/max vertex separation or the cube root of the element volume.'
  mesh_mode = 'replicated'
  capabilities = 'openmc'
[]

[invert_all_h]
  type = Exodiff
  input = 'openmc.i'
  exodiff = 'openmc_inv_out.e'
  cli_args = 'Adaptivity/Indicators/optical_depth_hmin/invert=true Adaptivity/Indicators/optical_depth_hmax/invert=true Adaptivity/Indicators/optical_depth_cuberoot/invert=true Outputs/file_base="openmc_inv_out"'
  requirement = 'The system shall allow for the calculation of the inverse optical depth using the min/max vertex separation or the cube root of the element volume.'
  mesh_mode = 'replicated'
  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'
[]

[duplicate_scores]
  type = CSVDiff
  input = openmc_dup.i
  csvdiff = openmc_dup_out.csv
  cli_args = "Adaptivity/Indicators/optical_depth_cuberoot/rxn_rate_tally='Mesh' Adaptivity/Indicators/optical_depth_cuberoot/flux_tally='Mesh'"
  requirement = "The system shall allow for the computation of optical depth indicators when multiple tallies are added which accumulate the same scores."
  capabilities = 'openmc'
[]

[rel_err]
  type = Exodiff
  input = 'openmc.i'
  exodiff = 'openmc_out.e'
  requirement = 'The system shall allow for the use of the statistical relative error of a tally score as an indicator.'
  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'
[]

[duplicate_scores]
  type = CSVDiff
  input = openmc_dup.i
  csvdiff = openmc_dup_out.csv
  cli_args = "Adaptivity/Indicators/stat_err/tally='Mesh'"
  requirement = "The system shall allow for the computation of relative error indicators when multiple tallies are added which accumulate the same scores."
  capabilities = 'openmc'
[]

[compute_both]
  type = CSVDiff
  input = both.i
  csvdiff = both_out.csv
  requirement = "The system shall be able to calculate neutron kinetics parameters."
  capabilities = 'openmc'
[]

[six_group_beta]
  type = CSVDiff
  input = six_grp.i
  csvdiff = six_grp_out.csv
  requirement = "The system shall be able to calculate separate values of beta_eff for each delayed group in the ENDF delayed group structure."
  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'
[]

[compute_both]
  type = CSVDiff
  input = both.i
  csvdiff = both_out.csv
  requirement = "The system shall be able to calculate neutron kinetics parameters."
  capabilities = 'openmc'
[]

[six_group_beta]
  type = CSVDiff
  input = six_grp.i
  csvdiff = six_grp_out.csv
  requirement = "The system shall be able to calculate separate values of beta_eff for each delayed group in the ENDF delayed group structure."
  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'
[]

[mark]
  type = Exodiff
  input = 'openmc.i'
  exodiff = 'openmc_out.e'
  requirement = 'The system shall allow the use of a look ahead marker to mitigate cyclic refinement.'
  mesh_mode = 'replicated'
  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'
[]

[cell_tally]
  type = Exodiff
  input = cell_tally.i
  exodiff = cell_tally_out.e
  requirement = 'The system shall correctly reinitialize cell tallies when the mesh is moving. This is tested by translating the mesh over a stationary OpenMC model. The two cell tallies in the tallies.out file match the expected power density (accounting for the actual fractions of the cell which map to the moving mesh). This test also checks the cell IDs and instances as the mesh translates.'
  capabilities = 'dagmc'
[]

[mesh_tally]
  type = Exodiff
  input = mesh_tally.i
  exodiff = mesh_tally_out.e
  requirement = 'The system shall correctly use a mesh tally on a moving MOOSE mesh. This is tested by translating the mesh over a stationary OpenMC model. The mesh translation exposes 20 percent of the left subdomain, which from a non-moving case we record 8 percent of the total power deposition in this region. For the moving mesh case, the total power deposited in the mesh tally is 92 percent.'
  mesh_mode = 'replicated'
  capabilities = 'dagmc'
[]

[make_mesh]
  type = RunApp
  input = mesh_tally.i
  cli_args = '--mesh-only'
  requirement = 'The system shall generate a file for mesh tallies.'
  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'
[]

[temperature]
  type = Exodiff
  input = temperature.i
  exodiff = temperature_out.e
  requirement = 'The system shall correctly reinitialize temperature mapping and output of cell temperatures to a moving mesh. This is tested by applying temperatures based on the moving mesh.'
  capabilities = 'dagmc'
[]

[density]
  type = Exodiff
  input = density.i
  exodiff = density_out.e
  requirement = 'The system shall correctly reinitialize density mapping and output of cell densities and material fills to a moving mesh. This is tested by applying densities based on the moving mesh.'
  capabilities = 'dagmc'
[]

[volumes]
  type = CSVDiff
  input = volumes.i
  csvdiff = volumes_out.csv
  requirement = 'The system shall correctly reinitialize volume calculations for a moving mesh. This is tested by comparing the OpenMC stochastic volume calculation against postprocessors for changing volumes.'
  mesh_mode = 'replicated' # tet converter is restricted to replicated meshes
  capabilities = 'dagmc'
[]

[scale]
  type = CSVDiff
  input = scale.i
  csvdiff = scale_out.csv
  requirement = 'The system shall change the OpenMC mesh geometry on-the-fly. This is tested by running this case with a very high number of particles and batches, to compare against the CSG case in the reference folder. The reference case is a CSG model created at the deformed state. We cannot match these cases perfectly because we cannot control the seed of the second Picard iteration. The reference case gives k = 0.88782 plus or minus 5 pcm, and our Cardinal case gives 0.88786 plus of minus 5 pcm; these agree within 1 sigma.'
  mesh_mode = 'replicated' # tet converter is restricted to replicated meshes
  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'
[]

[reaction_rates]
  type = CSVDiff
  input = openmc.i
  csvdiff = openmc_out.csv
  requirement = "The system shall allow tallying of absorption/fission/scattering/total reaction rates in fixed source mode."
  capabilities = 'openmc'
  issues = '#912'
  design = 'AddTallyAction.md'
[]

[reaction_rates]
  type = CSVDiff
  input = openmc_mgxs_rxn.i
  detail = "The system shall compute nu-scatter, nu-fission, and inverse-velocity scores in 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!'
[]

[reaction_rates]
  type = CSVDiff
  input = openmc_delayed_rxn.i
  detail = "The system shall compute prompt-nu-fission, delayed-nu-fission, and decay-rate scores in fixed source mode."
  csvdiff = openmc_delayed_rxn_out.csv
  capabilities = 'openmc'
[]

[cell_tally_unmapped]
  type = CSVDiff
  input = cell_with_unmapped.i
  csvdiff = cell_with_unmapped_out.csv
  requirement = "The system shall correctly label elements in blocks which don't contain temperature feedback, density feedback, or a cell tally as unmapped."
  capabilities = 'openmc'
[]

[multi_global_estimator]
  type = CSVDiff
  input = multi_estimator.i
  csvdiff = multi_estimator_out.csv
  requirement = "The system shall correctly normalize local tallies with different estimators using multiple global tallies."
  capabilities = 'openmc'
[]

[multiple_tallies_cell]
  type = CSVDiff
  input = multi_cell.i
  csvdiff = multi_cell_out.csv
  requirement = "The system shall correctly apply and normalize two different CellTally objects with different scores. The gold file was generated using an input that had a single CellTally with multiple scores."
  capabilities = 'openmc'
[]

[multiple_tallies_mesh]
  type = Exodiff
  input = multi_mesh.i
  exodiff = multi_mesh_out.e
  requirement = "The system shall correctly apply and normalize two different MeshTally objects with different scores. The gold file was generated using an input that had a single MeshTally with multiple scores."
  capabilities = 'openmc'
[]

[multiple_tallies_cell_triggers]
  type = CSVDiff
  input = multi_cell_triggers.i
  csvdiff = multi_cell_triggers_out.csv
  requirement = "The system shall correctly apply and normalize two different CellTally objects with different scores and triggers. The gold file was generated using an input that had a single CellTally with multiple scores and triggers."
  capabilities = 'openmc'
[]

[multiple_tallies_mesh_triggers]
  type = Exodiff
  input = multi_mesh_triggers.i
  exodiff = multi_mesh_triggers_out.e
  requirement = "The system shall correctly apply and normalize two different MeshTally objects with different scores and triggers. The gold file was generated using an input that had a single MeshTally with multiple scores and triggers."
  capabilities = 'openmc'
[]

[multiple_tallies_cell_relax]
  type = CSVDiff
  input = multi_cell_relax.i
  csvdiff = multi_cell_relax_out.csv
  requirement = "The system shall correctly apply and normalize two different CellTally objects with different scores when using relaxation. The gold file was generated using an input that had a single CellTally with multiple scores when using relaxation."
  capabilities = 'openmc'
[]

[multiple_tallies_mesh_relax]
  type = Exodiff
  input = multi_mesh_relax.i
  exodiff = multi_mesh_relax_out.e
  requirement = "The system shall correctly apply and normalize two different MeshTally objects with different scores when using relaxation. The gold file was generated using an input that had a single MeshTally with multiple scores when using relaxation."
  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'
[]

[multiple_different_tallies]
  type = Exodiff
  input = multi_diff.i
  exodiff = multi_diff_out.e
  requirement = "The system shall allow calculations with multiple different tallies."
  capabilities = 'openmc'
[]

[multiple_different_outputs]
  type = Exodiff
  input = multi_diff.i
  exodiff = multi_diff_outputs.e
  cli_args = 'Problem/Tallies/Cell/output="unrelaxed_tally_std_dev unrelaxed_tally" Problem/Tallies/Mesh/output="unrelaxed_tally_std_dev" Outputs/file_base=multi_diff_outputs'
  requirement = "The system shall allow calculations with multiple different tally outputs."
  capabilities = 'openmc'
[]

[same_scores]
  type = CSVDiff
  input = same_scores.i
  csvdiff = same_scores_out.csv
  cli_args = 'Problem/normalization_tally="Cell"'
  requirement = "The system shall allow multiple tallies to use the same scores."
  capabilities = 'openmc'
[]

[two_kf_unspecified_norm]
  type = RunException
  input = same_scores.i
  expect_err = "When using a non-heating tally \(flux\) in eigenvalue mode and adding more then one tally in the \[Tallies\] block, the 'normalization_tally' parameter is required!"
  requirement = "The system shall error if two tallies score the normalization score and the user does not specify which to use for normalization."
  capabilities = 'openmc'
[]

[duplicate_names]
  type = RunException
  input = same_scores.i
  cli_args = 'Problem/normalization_tally="Cell" Problem/Tallies/Cell/name="kappa_fission" Problem/Tallies/Mesh/name="kappa_fission flux"'
  expect_err = "Cardinal is trying to add an auxiliary variable named 'kappa_fission' through the Tally system"
  requirement = "The system shall error if two tallies scoring the same score add the same variable names."
  capabilities = 'openmc'
[]

[duplicate_scores_separate_tallies]
  type = RunException
  input = same_scores.i
  cli_args = "Problem/assume_separate_tallies=true Problem/Tallies/Cell/normalize_by_global_tally=false"
  expect_err = "Cannot assume separate tallies when there are multiple tallies"
  requirement = "The system shall error if attempting to use separate tallies when adding two tallies with the same score."
  capabilities = 'openmc'
[]

[gradients]
  type = Exodiff
  input = 'openmc.i'
  exodiff = 'openmc_out.e'
  requirement = 'The system shall allow for the approximation of tally gradients using finite differences.'
  mesh_mode = 'replicated'
  capabilities = 'openmc'
[]

[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 = CSVDiff
  input = openmc_dup.i
  csvdiff = openmc_dup_out.csv
  cli_args = "AuxKernels/comp_grad_kappa_fission/tally='Mesh'"
  requirement = "The system shall allow for the computation of tally gradients with finite differences when multiple tallies are added which accumulate the same scores."
  capabilities = 'openmc'
[]

[fission_tally_relative_error]
  type = CSVDiff
  input = openmc.i
  csvdiff = 'openmc_out.csv'
  # 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
  requirement = "The maximum and minimum tally relative errors shall be correctly retrieved from the OpenMC solution."
  capabilities = 'openmc'
[]

[multi_score]
  type = CSVDiff
  input = multi.i
  csvdiff = 'multi_out.csv'
  # 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
  requirement = "The maximum and minimum tally relative errors shall be correctly retrieved from the OpenMC solution when using multiple scores."
  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 = "The problem does not contain any score named flux!"
  requirement = "The system shall error if trying to extract score information that does not exist"
  capabilities = 'openmc'
[]

[manual_rel_err_calc]
  type = CSVDiff
  input = ratio.i
  csvdiff = 'ratio_out.csv'
  # 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
  requirement = "The system shall prove equivalence between a by-hand calculation of relative error (std_dev output divided by tally value) as compared to the tally relative error postprocessor."
  capabilities = 'openmc'
[]

[duplicate_scores]
  type = CSVDiff
  input = openmc_dup.i
  csvdiff = openmc_dup_out.csv
  # 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
  cli_args = "Postprocessors/max_rel_err/tally=Mesh Postprocessors/min_rel_err/tally=Mesh Postprocessors/avg_rel_err/tally=Mesh"
  requirement = "The system shall allow for the computation of tally relative errors when multiple tallies accumulating the same scores are added to the problem."
  capabilities = 'openmc'
[]

[duplicate_scores_tally_not_provided]
  type = RunException
  input = openmc_dup.i
  requirement = "The system shall error if two tallies accumulate the same scores and the user doesn't select one to use for computing a relative error metric."
  expect_err = "When adding more than one tally with kappa-fission in the \[Tallies\] block, the 'tally' parameter is required!"
  capabilities = 'openmc'
[]

[duplicate_scores_missing_tally]
  type = RunException
  input = openmc_dup.i
  cli_args = "Postprocessors/max_rel_err/tally=na Postprocessors/min_rel_err/tally=Mesh Postprocessors/avg_rel_err/tally=Mesh"
  requirement = "The system shall error if the user provides a non-existent tally."
  expect_err = "This tally does not exist"
  capabilities = 'openmc'
[]

[duplicate_scores_tally_has_no_score]
  type = RunException
  input = openmc_dup.i
  cli_args = "Postprocessors/max_rel_err/tally=Cell_2 Postprocessors/min_rel_err/tally=Mesh Postprocessors/avg_rel_err/tally=Mesh"
  requirement = "The system shall error if the user provides a tally that does not accumulate the score."
  expect_err = "This tally does not score kappa-fission!"
  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'
[]

[nek_side_average]
  type = CSVDiff
  input = nek.i
  csvdiff = nek_out.csv
  rel_err = 1e-2
  requirement = "NekSideAverage shall correctly compute area-averaged temperatures on the nekRS mesh. The gold file was created by running the moose.i input, which computes the same averages using existing MOOSE postprocessors on the same mesh on auxvariables that match the functional form of the solution fields initialized in the pyramid.udf. Perfect agreement is not to be expected, since the underlying basis functions and quadrature rules are different between nekRS and MOOSE's linear Lagrange variables - we just require that they are reasonably close."
  capabilities = 'nekrs'
  issues = '#1015' # not finished
[]

[drag]
  type = CSVDiff
  input = nek.i
  csvdiff = nek_out.csv
  requirement = "The system shall allow total viscous drag to be computed in dimensional form. This test compares drag as computed via Nek with by-hand calculations using combinations of native MOOSE postprocessors using the analytic expression for velocity."
  capabilities = 'nekrs'
[]

[invalid_mesh]
  type = RunException
  input = nek.i
  cli_args = 'Postprocessors/viscous_x_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'
[]

[nek]
  type = CSVDiff
  input = nek.i
  csvdiff = nek_out.csv
  requirement = 'dimensional form'
  capabilities = 'nekrs'
[]

[nondimensional]
  type = CSVDiff
  input = nondimensional.i
  csvdiff = nondimensional_out.csv
  requirement = 'nondimensional form'
  capabilities = 'nekrs'
[]

[nek]
  type = CSVDiff
  input = nek.i
  csvdiff = nek_out.csv
  requirement = 'dimensional form'
  capabilities = 'nekrs'
[]

[nondimensional]
  type = CSVDiff
  input = nondimensional.i
  csvdiff = nondimensional_out.csv
  requirement = 'nondimensional form'
  capabilities = 'nekrs'
[]

[drag]
  type = CSVDiff
  input = nek.i
  csvdiff = nek_out.csv
  requirement = "The system shall allow y plus to be computed. The resulting expression is checked against an analytic expression for the friction velocity and by inspection of the wall distance for the first GLL points near the wall."
  capabilities = 'nekrs'
[]

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

[k_eigenvalue]
  type = CSVDiff
  input = openmc.i
  csvdiff = 'openmc_out.csv'
  # 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
  requirement = "The k-eigenvalue and its standard deviation shall be correctly retrieved from the OpenMC solution."
  capabilities = 'openmc'
[]

[flux]
  type = CSVDiff
  input = nek.i
  csvdiff = nek_out.csv
  requirement = "The system shall be able to read the flux from NekRS and write onto a boundary mesh mirror. This is tested by setting a known temperature distribution in NekRS such that the analytic heat flux can be computed and compared."
  issues = '#1166'
  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'
[]

[multiple_source_transfers]
  type = CSVDiff
  input = nek.i
  csvdiff = nek_out.csv
  requirement = "The system shall be able to write multiple incoming volumetric source terms to NekRS. This is tested by writing two constant fields into the usrwrk array, and then integrating them over boundaries to ensure different fields are stored in each."
  issues = '#1230'
  capabilities = 'nekrs'
[]

[multiple_flux_transfers]
  type = CSVDiff
  input = nek.i
  csvdiff = nek_out.csv
  requirement = "The system shall be able to write multiple incoming boundary flux terms to NekRS. This is tested by writing two constant fields into the usrwrk array, and then integrating them over boundaries to ensure different fields are stored in each."
  issues = '#1230'
  capabilities = 'nekrs'
[]

[multiple_source_transfers]
  type = CSVDiff
  input = nek.i
  csvdiff = nek_out.csv
  requirement = "The system shall be able to write multiple incoming volumetric source terms to NekRS. This is tested by writing two constant fields into the usrwrk array, and then integrating them over boundaries to ensure different fields are stored in each."
  issues = '#1230'
  capabilities = 'nekrs'
[]

[multiple_flux_transfers]
  type = CSVDiff
  input = nek.i
  csvdiff = nek_out.csv
  requirement = "The system shall be able to write multiple incoming boundary flux terms to NekRS. This is tested by writing two constant fields into the usrwrk array, and then integrating them over boundaries to ensure different fields are stored in each."
  issues = '#1230'
  capabilities = 'nekrs'
[]

[multiple_source_transfers]
  type = CSVDiff
  input = nek.i
  csvdiff = nek_out.csv
  requirement = "The system shall be able to write multiple incoming volumetric source terms to NekRS. This is tested by writing two constant fields into the usrwrk array, and then integrating them over boundaries to ensure different fields are stored in each."
  issues = '#1230'
  capabilities = 'nekrs'
[]

[multiple_flux_transfers]
  type = CSVDiff
  input = nek.i
  csvdiff = nek_out.csv
  requirement = "The system shall be able to write multiple incoming boundary flux terms to NekRS. This is tested by writing two constant fields into the usrwrk array, and then integrating them over boundaries to ensure different fields are stored in each."
  issues = '#1230'
  capabilities = 'nekrs'
[]

[temperature_input]
  type = CSVDiff
  input = nek.i
  csvdiff = nek_out.csv
  requirement = "The system shall be able to write into the scratch space a temperature which NekRS can use in its case files. This is tested by passing in a temperature field on a boundary and then applying that field as a Dirichlet condition."
  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'
[]

[multiple_field_transfers]
  type = CSVDiff
  input = temp.i
  csvdiff = temp_out.csv
  requirement = "The system shall be able to write multiple incoming field transfers to NekRS. This is tested by writing two constant fields into the usrwrk array, and then integrating them over boundaries to ensure different fields are stored in each."
  issues = '#1230'
  capabilities = 'nekrs'
[]

[temperature_input]
  type = CSVDiff
  input = nek.i
  csvdiff = nek_out.csv
  requirement = "The system shall be able to write into the scratch space a temperature which NekRS can use in its case files. This is tested by passing in a temperature field in the volume and applying this field to the temperature instead of solving it."
  issues = '#1166'
  capabilities = 'nekrs'
[]

[no_extra_integer_provided_boolean_combo]
  type = RunException
  input = boolean_combo_no_eeid.i
  cli_args = '--error'
  mesh_mode = "replicated"
  expect_err = "boolean_combo extra element integer is missing in the mesh. Adding extra element integer boolean_combo"
  requirement = "The system shall throw a warning if the extra element integer is not found in mesh."
[]

[mesh_is_not_replicated]
  type = RunException
  input = common_error.i
  mesh_mode = "distributed"
  expect_err = "Mesh must be replicated"
  requirement = "The system shall error if a non-replicated mesh is used while clustering."
[]

[element_needs_to_be_constant_monomial]
  type = RunException
  input = common_error.i
  mesh_mode = "replicated"
  cli_args = "AuxVariables/metric_var/family=LAGRANGE AuxVariables/metric_var/order=FIRST"
  expect_err = "metric_var must be of type CONSTANT MONOMIAL"
  requirement = "The system shall error if the 'metric_variable' is not constant monomial."
[]

[lower_fraction_is_more_than_upper_fraction]
  type = RunException
  input = common_error.i
  mesh_mode = "replicated"
  cli_args = "UserObjects/value_fraction/lower_fraction=0.6 UserObjects/value_fraction/upper_fraction=0.5"
  expect_err = "lower_fraction \+ upper_fraction must be less than 1"
  requirement = "The system shall error if 'lower_faction + upper_fraction' is more than 1."
[]

[grid]
  type = Exodiff
  input = example_input.i
  exodiff = example_input_out.e
  requirement = "The system shall reproduce the clustering pattern by evaluating a
                   boolean expression which combines multiple threshold-based heuristics and
                   operates on element pairs."
  mesh_mode = 'replicated'
[]

[grid]
  type = Exodiff
  input = example.i
  exodiff = example_out.e
  requirement = "The system shall be able to cluster mesh elements by identifying elements with equal
                   metric values within a specified tolerance using a value-difference heuristic."
  mesh_mode = 'replicated'
[]

[grid]
  type = Exodiff
  input = example.i
  exodiff = example_out.e
  requirement = "The system shall be able to cluster elements by identifying element pairs whose
                   variable values both fall within either a specified upper or lower fraction of the extremes."
  mesh_mode = 'replicated'
[]

[grid]
  type = Exodiff
  input = example.i
  exodiff = example_out.e
  requirement = "The system shall be able to cluster elements by identifying element pairs whose metric values
                   both fall within a range defined by a user-specified percentage above and below given
                   reference values, with multiple ranges combined through a boolean expression."
  mesh_mode = 'replicated'
[]

[translate_multiple_cells]
  type = Exodiff
  input = translate_cells.i
  exodiff = translate_cells_out.e
  requirement = 'The system shall correctly reinitialize OpenMC coupling when multiple geometry cells are translated.This is tested by translating the mesh while also translating OpenMC universe which contains the coupled cells.'
  capabilities = 'openmc'
[]

[duplicate_cell_id]
  type = RunException
  input = translate_cells.i
  cli_args = "UserObjects/translate_top/cell_ids='2013 2013'"
  expect_err = "UserObjects/translate_top/cell_ids: Duplicate OpenMC cell IDs were detected. Provide each ID only once."
  requirement = "The system shall error if the same cell id is provided more than once."
  capabilities = 'openmc'
[]

[translate_cells]
  type = Exodiff
  input = translate_cells.i
  exodiff = translate_cells_out.e
  requirement = 'The system shall correctly reinitialize OpenMC coupling when the geometry is translated.This is tested by translating the mesh while also translating OpenMC universe which contains the coupled cells.'
  capabilities = 'openmc'
[]

[scaled_translation]
  type = Exodiff
  input = scaled.i
  exodiff = scaled_out.e
  requirement = 'The system shall correctly reinitialize OpenMC coupling when a scaled geometry is translated.This is tested by translating the scaled mesh while also translating OpenMC universe which contains the coupled cells.'
  capabilities = 'openmc'
[]

[rotate_cells]
  type = Exodiff
  input = rotate_cells.i
  exodiff = rotate_cells_out.e
  requirement = 'The system shall correctly reinitialize OpenMC coupling when the geometry is rotated.This is tested by rotating the mesh while also rotating OpenMC universe which contains the coupled cells.'
  capabilities = 'openmc'
[]

[cells_shadow]
  type = Exodiff
  input = cells_shadow.i
  exodiff = cells_shadow_out.e
  requirement = 'The system shall correctly reinitialize OpenMC coupling when the geometry is translated.This is tested by translating an OpenMC geometry on a stationary mesh and ensure elements are reset correctly.'
  capabilities = 'openmc'
[]

[invalid_phi]
  type = RunException
  input = rotate_cells.i
  cli_args = 'UserObjects/rotate_cells/vector_value="361 0 0"'
  expect_err = 'Rotation transformation angle φ must be in the range \[0, 360\) degrees'
  capabilities = 'openmc'
[]

[invalid_theta]
  type = RunException
  input = rotate_cells.i
  cli_args = 'UserObjects/rotate_cells/vector_value="0 361 0"'
  expect_err = 'Rotation transformation angle θ must be in the range \[0, 360\) degrees'
  capabilities = 'openmc'
[]

[invalid_psi]
  type = RunException
  input = rotate_cells.i
  cli_args = 'UserObjects/rotate_cells/vector_value="0 0 361"'
  expect_err = 'Rotation transformation angle ψ must be in the range \[0, 360\) degrees'
  capabilities = 'openmc'
[]

[empty_cell_ids]
  type = RunException
  input = empty_cell_ids.i
  expect_err = 'UserObjects/translate_cells/cell_ids: At least one OpenMC cell ID must be provided.'
  capabilities = 'openmc'
[]

[wrong_vector_size]
  type = RunException
  input = translate_cells.i
  cli_args = 'UserObjects/translate_cells/vector_value="shift_x"'
  expect_err = "UserObjects/translate_cells/vector_value: Provide exactly 3 values/postprocessors: 'dx dy dz' in mesh units for translationtransform or 'φ, θ, ψ' in degrees for rotation transform."
  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 = 'Unknown reaction name "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'
[]

[nuclides]
  type = CheckFiles
  input = tally_param_checks.i
  check_files = tallies.out
  file_expect_out = 'U238'
  requirement = 'Ensure that nuclides specified by a tally editor UO are present in the tally output'
  cli_args = 'UserObjects/tally_editor_uo/nuclides="U238"'
  capabilities = 'openmc'
[]

[scatter_tally]
  type = CheckFiles
  input = scatter.i
  check_files = tallies.out
  requirement = 'Ensure that the scattering score specified by a tally editor UO are present in the tally output'
  file_expect_out = 'Scattering Rate'
  capabilities = 'openmc'
[]

[absorption_u238]
  type = CheckFiles
  input = nuclide_absorption.i
  check_files = tallies.out
  requirement = 'Ensure that the absorption score for a specific nuclide specified by a tally editor UO are present in the tally output'
  file_expect_out = 'U238\n   Absorption Rate'
  capabilities = 'openmc'
[]

[add_cell_filter]
  type = CheckFiles
  input = add_filter.i
  check_files = tallies.out
  requirement = 'Ensure that a cell filter specified by a tally editor UO are present in the tally output'
  file_expect_out = 'Cell'
  capabilities = 'openmc'
[]

[add_material_filter]
  type = CheckFiles
  input = add_filter.i
  check_files = tallies.out
  cli_args = 'UserObjects/new_filter/filter_type="material"'
  requirement = 'Ensure that a material filter specified by a tally editor UO are present in the tally output'
  file_expect_out = 'Material'
  capabilities = 'openmc'
[]

[add_universe_filter]
  type = CheckFiles
  input = add_filter.i
  check_files = tallies.out
  cli_args = 'UserObjects/new_filter/filter_type="universe"'
  requirement = 'Ensure that a universe filters specified by a tally editor UO are present in the tally output'
  file_expect_out = 'Universe'
  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 = 'Unknown reaction name "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'
[]

[nuclides]
  type = CheckFiles
  input = tally_param_checks.i
  check_files = tallies.out
  file_expect_out = 'U238'
  requirement = 'Ensure that nuclides specified by a tally editor UO are present in the tally output'
  cli_args = 'UserObjects/tally_editor_uo/nuclides="U238"'
  capabilities = 'openmc'
[]

[scatter_tally]
  type = CheckFiles
  input = scatter.i
  check_files = tallies.out
  requirement = 'Ensure that the scattering score specified by a tally editor UO are present in the tally output'
  file_expect_out = 'Scattering Rate'
  capabilities = 'openmc'
[]

[absorption_u238]
  type = CheckFiles
  input = nuclide_absorption.i
  check_files = tallies.out
  requirement = 'Ensure that the absorption score for a specific nuclide specified by a tally editor UO are present in the tally output'
  file_expect_out = 'U238\n   Absorption Rate'
  capabilities = 'openmc'
[]

[add_cell_filter]
  type = CheckFiles
  input = add_filter.i
  check_files = tallies.out
  requirement = 'Ensure that a cell filter specified by a tally editor UO are present in the tally output'
  file_expect_out = 'Cell'
  capabilities = 'openmc'
[]

[add_material_filter]
  type = CheckFiles
  input = add_filter.i
  check_files = tallies.out
  cli_args = 'UserObjects/new_filter/filter_type="material"'
  requirement = 'Ensure that a material filter specified by a tally editor UO are present in the tally output'
  file_expect_out = 'Material'
  capabilities = 'openmc'
[]

[add_universe_filter]
  type = CheckFiles
  input = add_filter.i
  check_files = tallies.out
  cli_args = 'UserObjects/new_filter/filter_type="universe"'
  requirement = 'Ensure that a universe filters specified by a tally editor UO are present in the tally output'
  file_expect_out = 'Universe'
  capabilities = 'openmc'
[]