Optimization Requirements Traceability Matrix

[secant]
  type = CSVDiff
  input = secant.i
  csvdiff = secant_out.csv
  design = 'SecantInversionControl.md'
  requirement = "The system shall solve a scalar inverse coupling problem by using a Control to adjust a parameter with the secant method, driven by fixed-point iteration, so that a sub-app output matches a target function at each time step."
[]

[secant_error_on_max_iteration]
  type = RunException
  input = secant.i
  # A distinct file_base keeps this reuse of secant.i from sharing the secant test's output and
  # recover checkpoint.
  cli_args = 'Convergence/inv_conv/max_iterations=1 Executioner/dtmin=0.3 Outputs/csv=false Outputs/file_base=secant_error_on_max_out'
  expect_err = 'Solve failed and timestep already at or below dtmin'
  design = 'SecantInversionControl.md'
  requirement = "The system shall, when the fixed-point iteration cannot converge within the maximum number of iterations and the time step cannot be reduced further, cut the time step and error out."
[]

[secant_accept_on_max_iteration]
  type = RunApp
  input = secant.i
  # A distinct file_base keeps this reuse of secant.i from sharing the secant test's output and
  # recover checkpoint.
  cli_args = 'Convergence/inv_conv/max_iterations=1 Convergence/inv_conv/converge_at_max_iterations=true Convergence/inv_conv/verbose=true Outputs/csv=false Outputs/file_base=secant_accept_on_max_out'
  # verbose=true makes the Convergence announce the accept-on-max decision; matching it confirms
  # the run actually took the accept-on-max branch rather than merely exiting without error.
  expect_out = 'Converged due to iterations \(1\) >= max iterations \(1\)'
  design = 'SecantInversionControl.md'
  requirement = "The system shall, when the fixed-point iteration reaches the maximum number of iterations and accept-on-max is enabled, accept the best estimate and continue."
[]

[secant_fails_on_nonlinear]
  type = RunException
  input = secant.i
  # The same nonlinear problem the newton_nonlinear test solves: y(p) = p^3 against a target of
  # 1000 from p0 = -3. Secant estimates df/dp from two iterates straddling the inflection at
  # p = 0 and enters a bounded chaotic orbit, so with dtmin = dt the step cannot be cut and the
  # run errors once max_iterations is exhausted.
  cli_args = 'MultiApps/sub/input_files=forward_cubic.i Functions/target_fn/expression=1000 Postprocessors/p/default=-3 Convergence/inv_conv/max_iterations=25 Executioner/num_steps=1 Executioner/dtmin=1 Outputs/csv=false Outputs/file_base=secant_fails_on_nonlinear_out'
  expect_err = 'Solve failed and timestep already at or below dtmin'
  design = 'SecantInversionControl.md NewtonInversionControl.md'
  requirement = "The system shall demonstrate that the secant-based inversion Control fails to converge within a fixed iteration budget on a nonlinear problem that the finite-difference Newton Control solves."
[]

[newton_linear]
  type = CSVDiff
  input = newton.i
  csvdiff = newton_out.csv
  design = 'NewtonInversionControl.md'
  requirement = "The system shall solve a scalar inverse coupling problem using a finite-difference Newton Control driven by fixed-point iteration."
[]

[newton_nonlinear]
  type = CSVDiff
  input = newton.i
  csvdiff = newton_nonlinear_out.csv
  # Nonlinear forward model du/dt = p^3 with target 1000*t needs du = 1000 per step, so the root
  # is p = 10 at every step. The initial guess p0 = -3 sits on the wrong side of the inflection
  # at p = 0; Newton samples a fresh local derivative each step and still converges. Newton
  # spends two fixed-point iterations per update, hence max_iterations = 25.
  cli_args = 'MultiApps/sub/input_files=forward_cubic.i Functions/target_fn/expression="1000*t" Postprocessors/p/default=-3 Convergence/inv_conv/max_iterations=25 Outputs/file_base=newton_nonlinear_out'
  design = 'NewtonInversionControl.md'
  requirement = "The system shall solve a nonlinear scalar inverse problem, where the sub-app output depends nonlinearly on the parameter, using a finite-difference Newton Control."
[]

[action_secant]
  type = CSVDiff
  input = action.i
  csvdiff = action_out.csv
  design = 'SingleParameterInverseSolveAction.md'
  requirement = "The system shall generate a complete secant inverse-solve workflow (forward sub-app, transfers, postprocessors, convergence, and control) from a single SingleParameterInverseSolve block."
[]

[action_newton]
  type = CSVDiff
  input = action.i
  csvdiff = action_newton_out.csv
  # Same nonlinear problem as the hand-written newton_nonlinear test, driven by the action.
  cli_args = 'SingleParameterInverseSolve/method=newton SingleParameterInverseSolve/forward_input=forward_cubic.i Functions/target_fn/expression="1000*t" SingleParameterInverseSolve/initial_parameter=-3 SingleParameterInverseSolve/max_iterations=25 Outputs/file_base=action_newton_out'
  design = 'SingleParameterInverseSolveAction.md'
  requirement = "The system shall generate a complete finite-difference Newton inverse-solve workflow from a single SingleParameterInverseSolve block with the method set to newton."
[]

[action_accept_on_max]
  type = CSVDiff
  input = action.i
  csvdiff = action_accept_on_max_out.csv
  cli_args = 'SingleParameterInverseSolve/max_iterations=1 SingleParameterInverseSolve/accept_on_max_iterations=true SingleParameterInverseSolve/verbose=true Outputs/file_base=action_accept_on_max_out'
  # verbose=true forwards to the generated convergence; matching its announcement confirms the
  # generated workflow actually took the accept-on-max branch.
  expect_out = 'Converged due to iterations \(1\) >= max iterations \(1\)'
  design = 'SingleParameterInverseSolveAction.md'
  requirement = "The system shall, when the single-parameter inverse-solve block reaches the maximum number of fixed-point iterations and accept-on-max is enabled, accept the best estimate and continue without error."
[]

[action_absolute_tolerance]
  type = CSVDiff
  input = action.i
  csvdiff = action_absolute_tolerance_out.csv
  cli_args = 'SingleParameterInverseSolve/relative_tolerance=1e-30 Outputs/file_base=action_absolute_tolerance_out'
  design = 'SingleParameterInverseSolveAction.md'
  requirement = "The system shall converge a single-parameter inverse solve using the absolute tolerance criterion when the relative tolerance is negligible."
[]

[action_newton_accept_on_max]
  type = CSVDiff
  input = action.i
  csvdiff = action_newton_accept_on_max_out.csv
  # max_iterations=2 is even, so the cap falls on a perturbed Newton iteration -- the case where
  # the accepted solution must come from the last base iteration (the initial parameter -3), not
  # the perturbed extrapolation. num_steps=1 keeps that accepted value exact and portable.
  cli_args = 'SingleParameterInverseSolve/method=newton SingleParameterInverseSolve/forward_input=forward_cubic.i Functions/target_fn/expression="1000*t" SingleParameterInverseSolve/initial_parameter=-3 SingleParameterInverseSolve/max_iterations=2 SingleParameterInverseSolve/accept_on_max_iterations=true Executioner/num_steps=1 Outputs/file_base=action_newton_accept_on_max_out'
  design = 'SingleParameterInverseSolveAction.md'
  requirement = "The system shall, when the Newton single-parameter inverse-solve block reaches the maximum number of fixed-point iterations on a perturbed iteration and accept-on-max is enabled, accept the last base estimate and continue without error."
[]

[action_wrong_convergence]
  type = RunException
  input = action.i
  # Points the executioner at a convergence the action did not generate. Distinct from
  # action_missing_convergence below: here the user explicitly named a (wrong) convergence,
  # rather than omitting the line, so the error must report the name they actually wrote.
  cli_args = 'Executioner/multiapp_fixed_point_convergence=not_the_generated_convergence Outputs/csv=false Outputs/file_base=action_wrong_convergence_out'
  expect_err = "currently set to 'not_the_generated_convergence'"
  design = 'SingleParameterInverseSolveAction.md'
  requirement = "The system shall report a helpful error, naming the convergence the user actually assigned, when the single-parameter inverse-solve block's generated convergence is not assigned to the executioner's multiapp_fixed_point_convergence."
[]

[action_missing_convergence]
  type = RunException
  input = action_no_convergence.i
  # Omits the executioner line entirely, rather than assigning a wrong name (see
  # action_wrong_convergence above): MOOSE then silently creates and assigns a default
  # convergence, so the error must say the line was never given rather than naming that default
  # as if the user had written it.
  cli_args = 'Outputs/csv=false Outputs/file_base=action_missing_convergence_out'
  expect_err = "No 'multiapp_fixed_point_convergence' was given, so MOOSE created a default one"
  design = 'SingleParameterInverseSolveAction.md'
  requirement = "The system shall report a helpful error, distinguishing MOOSE's own default convergence from a user-assigned one, when the single-parameter inverse-solve block's generated convergence is not assigned to the executioner's multiapp_fixed_point_convergence."
[]

[forward]
  type = CSVDiff
  input = reporter_time_point_source.i
  csvdiff = 'reporter_time_point_source_out_sample_0000.csv
                 reporter_time_point_source_out_sample_0001.csv
                 reporter_time_point_source_out_sample_0002.csv
                 reporter_time_point_source_out_sample_0003.csv'
  detail = 'forward time stepping;'
[]

[reverse]
  type = CSVDiff
  input = reporter_time_point_source.i
  cli_args = 'DiracKernels/vpp_point_source/reverse_time_end=0.3 Outputs/file_base=reporter_time_point_source_reverse'
  csvdiff = 'reporter_time_point_source_reverse_sample_0000.csv
                 reporter_time_point_source_reverse_sample_0001.csv
                 reporter_time_point_source_reverse_sample_0002.csv
                 reporter_time_point_source_reverse_sample_0003.csv'
  detail = 'reverse time stepping;'
[]

[fd]
  type = RunApp
  input = debug_fd.i
  cli_args = '-tao_ls_type unit'
  allow_test_objects = True
  expect_out = 'Solution converged'
  max_threads = 1 # Optimize executioner does not support multiple threads
  detail = 'using finite-difference to compute the gradient;'
[]

[gradient_test]
  type = TaoGradientTester
  input = debug_gradient.i
  allow_test_objects = True
  max_rel_tol = 1e-6
  detail = 'verifying the adjoint gradient against finite differences.'
[]

[quadraticObjCon]
  type = CSVDiff
  input = quadratic_minimize_constrained.i
  csvdiff = quadratic_minimize_constrained_out_OptimizationReporter_0001.csv
  rel_err = 1e-4
  allow_test_objects = True
  max_threads = 1 # Optimize executioner does not support multiple threads
  capabilities = 'petsc>=3.15'

  issues = '#24930'
  requirement = "The system shall minimize a constrained quadratic objective function from a test object using the TAO ALMM solver."
[]

[inequality_constraint]
  type = JSONDiff
  input = main_auto_adjoint.i
  jsondiff = main_auto_adjoint_out_forward0.json
  rel_err = 1e-4
  # steady solve
  recover = false
  capabilities = 'petsc>=3.15'
  max_threads = 1 # Optimize executioner does not support multiple threads

  issues = '#24930'
  requirement = "The system shall minimize an inequality  constrained quadratic objective function from a test object."
[]

[equality_constraint]
  issues = '#24930'
  max_threads = 1 # Optimize executioner does not support multiple threads
  input = main.i
  csvdiff = main_out.csv
  type = CSVDiff
  requirement = "The system shall be able to minimize a constrained shape optimization problem using the ALMM algorithm."
  heavy = true
  recover = false
  allow_warnings = true
  capabilities = 'petsc>=3.15'
[]

[forward_and_adjoint]
  type = CSVDiff
  input = forward_and_adjoint.i
  csvdiff = forward_and_adjoint_out.csv
  recover = false
  requirement = 'The system shall honor user-specified execution ordering of user objects during both the forward and adjoint stages of a steady adjoint solve.'
[]

[self_adjoint]
  type = Exodiff
  input = self_adjoint.i
  exodiff = self_adjoint_out.e
  detail = 'are self-adjoint,'
[]

[nonhomogeneous_bc]
  type = Exodiff
  input = nonhomogeneous_bc.i
  exodiff = nonhomogeneous_bc_out.e
  detail = 'have non-homogeneous boundary conditions,'
[]

[multi_variable]
  type = Exodiff
  input = multi_variable.i
  exodiff = multi_variable_out.e
  detail = 'have multiple coupled variables,'
[]

[array_variable]
  type = Exodiff
  input = array_variable.i
  exodiff = array_variable_out.e
  detail = 'use array variables, and'
[]

[nonlinear]
  type = Exodiff
  input = nonlinear_diffusion.i
  exodiff = nonlinear_diffusion_out.e
  detail = 'have non-linear material properties.'
[]

[adjoint_rhs]
  type = RunApp
  input = adjoint_rhs.i
  min_parallel = 2
  recover = false
  detail = 'run in parallel and apply 100s of dirac point sources in the adjoint problem.'
[]

[self_adjoint_amr]
  type = Exodiff
  input = self_adjoint.i
  exodiff = self_adjoint_amr_out.e
  cli_args = "Mesh/refine/type=RefineSidesetGenerator Mesh/refine/input=gmg
                Mesh/refine/boundaries='left top' Mesh/refine/refinement='2 2'
                Mesh/refine/boundary_side='both both' Outputs/file_base=self_adjoint_amr_out"
  issues = '#30377'
  requirement = 'The system shall enforce the hanging node constraints on the adjoint solution when solving a steady-state problem on a mesh containing hanging nodes, including on a refined boundary that carries a nodal boundary condition.'
[]

[self_adjoint]
  type = CSVDiff
  input = self_adjoint.i
  csvdiff = 'self_adjoint_forward.csv self_adjoint_adjoint.csv'
  detail = 'are self-adjoint,'
[]

[multi_variable]
  type = CSVDiff
  input = multi_variable.i
  csvdiff = 'multi_variable_forward.csv multi_variable_adjoint.csv'
  detail = 'have multiple coupled variables,'
[]

[nonlinear]
  type = CSVDiff
  input = nonlinear_diffusivity.i
  csvdiff = 'nonlinear_diffusivity_forward.csv nonlinear_diffusivity_adjoint.csv'
  detail = 'have non-linear steady-state material properties, and'
[]

[nonuniform_tstep]
  type = CSVDiff
  input = nonuniform_tstep.i
  csvdiff = 'nonuniform_tstep_forward.csv nonuniform_tstep_adjoint.csv'
  detail = 'have non-uniform time stepping.'
[]

[self_adjoint_amr]
  type = CSVDiff
  input = self_adjoint.i
  csvdiff = 'self_adjoint_amr_forward.csv self_adjoint_amr_adjoint.csv'
  cli_args = 'Mesh/refine/type=RefineSidesetGenerator Mesh/refine/input=gmg
                Mesh/refine/boundaries=left Mesh/refine/refinement=2
                Outputs/file_base=self_adjoint_amr
                Outputs/forward/file_base=self_adjoint_amr_forward
                Outputs/adjoint/file_base=self_adjoint_amr_adjoint'
  issues = '#30377'
  requirement = 'The system shall enforce the hanging node constraints on the adjoint solution when solving a transient problem on a mesh containing hanging nodes.'
[]

[x]
  type = Exodiff
  input = nearest_reporter_point.i
  cli_args = 'Functions/active=xx AuxKernels/val_aux/function=xx Outputs/file_base=rnp_x'
  exodiff = 'rnp_x.e'
  detail = 'x-coordinate data;'
[]

[xy]
  type = Exodiff
  input = nearest_reporter_point.i
  cli_args = 'Functions/active=xy AuxKernels/val_aux/function=xy Outputs/file_base=rnp_xy'
  exodiff = 'rnp_xy.e'
  detail = 'x- and y-coordinate data;'
[]

[xyz]
  type = Exodiff
  input = nearest_reporter_point.i
  cli_args = 'Functions/active=xyz AuxKernels/val_aux/function=xyz Outputs/file_base=rnp_xyz'
  exodiff = 'rnp_xyz.e'
  detail = 'x-, y-, and z-coordinate data;'
[]

[xyzt]
  type = Exodiff
  input = nearest_reporter_point.i
  cli_args = 'Functions/active=xyzt AuxKernels/val_aux/function=xyzt Outputs/file_base=rnp_xyzt'
  exodiff = 'rnp_xyzt.e'
  detail = 'time, x-, y-, and z-coordinate data;'
[]

[v]
  type = RunException
  input = nearest_reporter_point.i
  cli_args = 'Functions/active=errorv AuxKernels/val_aux/function=errorv'
  expect_err = 'Size of value vector \(\d*\) does not match number of coordinates specified \(\d*\).'
  detail = 'the size of value vector is wrong;'
[]

[x]
  type = RunException
  input = nearest_reporter_point.i
  cli_args = 'Functions/active=errorx AuxKernels/val_aux/function=errorx'
  expect_err = 'Number of x coordinates \(\d*\) does not match number of values \(\d*\).'
  detail = 'x-coordinate data is wrong size;'
[]

[y]
  type = RunException
  input = nearest_reporter_point.i
  cli_args = 'Functions/active=errory AuxKernels/val_aux/function=errory'
  expect_err = 'Number of y coordinates \(\d*\) does not match number of values \(\d*\).'
  detail = 'y-coordinate data is wrong size;'
[]

[z]
  type = RunException
  input = nearest_reporter_point.i
  cli_args = 'Functions/active=errorz AuxKernels/val_aux/function=errorz'
  expect_err = 'Number of z coordinates \(\d*\) does not match number of values \(\d*\).'
  detail = 'z-coordinate data is wrong size;'
[]

[t]
  type = RunException
  input = nearest_reporter_point.i
  cli_args = 'Functions/active=errort AuxKernels/val_aux/function=errort'
  expect_err = 'Number of times \(\d*\) does not match number of values \(\d*\).'
  detail = 'time data is wrong size;'
[]

[create_1d]
  type = CheckFiles
  input = create_mesh_1d.i
  check_files = 'create_mesh_1d_out.e create_mesh_1d_out_param_vec_0001.csv'
  detail = 'creating 1D mesh and '
[]

[evaluate]
  type = Exodiff
  input = parameter_mesh_1d.i
  prereq = parameter_mesh/create_1d
  exodiff = parameter_mesh_1d_out.e
  detail = 'evaluating the 1d parameter values;'
[]

[create_2d]
  type = CheckFiles
  input = create_mesh_2d.i
  check_files = 'create_mesh_2d_out.e create_mesh_2d_out_param_vec_0001.csv'
  detail = 'creating 2D mesh and'
  recover = false
[]

[evaluate_2d]
  type = Exodiff
  input = parameter_mesh_2d.i
  prereq = parameter_mesh/create_2d
  exodiff = parameter_mesh_2d_out.e
  detail = 'evaluating the 2D mesh parameter values;'
[]

[create_3d]
  type = CheckFiles
  input = create_mesh_3d.i
  check_files = 'create_mesh_3d_out.e create_mesh_3d_out_param_vec_0001.csv'
  detail = 'creating 3d mesh and'
  recover = false
[]

[evaluate_3d]
  type = Exodiff
  input = parameter_mesh_3d.i
  prereq = parameter_mesh/create_3d
  exodiff = parameter_mesh_3d_out.e
  detail = 'evaluating the 3d mesh parameter values;'
[]

[create_tri]
  type = CheckFiles
  input = create_mesh_2d.i
  cli_args = 'Mesh/gmg/elem_type=TRI'
  check_files = 'create_mesh_2d_out.e create_mesh_2d_out_param_vec_0001.csv'
  detail = 'using triangle element meshes'
[]

[evaluate_tri]
  type = Exodiff
  input = parameter_mesh_2d.i
  prereq = parameter_mesh/create_tri
  cli_args = 'Outputs/file_base=parameter_mesh_tri_out'
  exodiff = parameter_mesh_tri_out.e
  detail = 'evaluating the triangle mesh parameter values;'
[]

[create_tet]
  type = CheckFiles
  input = create_mesh_3d.i
  cli_args = 'Mesh/gmg/elem_type=TET'
  check_files = 'create_mesh_3d_out.e create_mesh_3d_out_param_vec_0001.csv'
  detail = 'using tetrahedral element meshes'
[]

[evaluate_tet]
  type = Exodiff
  input = parameter_mesh_3d.i
  prereq = parameter_mesh/create_tet
  cli_args = 'Outputs/file_base=parameter_mesh_tet_out'
  exodiff = parameter_mesh_tet_out.e
  detail = 'evaluating the tetrahedral mesh parameter values;'
[]

[create_second]
  type = CheckFiles
  input = create_mesh_2d.i
  cli_args = 'Mesh/gmg/elem_type=QUAD8'
  check_files = 'create_mesh_2d_out.e create_mesh_2d_out_param_vec_0001.csv'
  detail = 'using second order element meshes'
  recover = false
[]

[evaluate_second]
  type = RunException
  input = parameter_mesh_2d.i
  prereq = check_dbgs/create_second
  expect_err = "Closet point projection currently does not support second order elements."
  detail = 'with closest point projection;'
  recover = false
[]

[create]
  type = CheckFiles
  input = create_mesh.i
  check_files = 'create_mesh_out.e create_mesh_out_param_vec_0001.csv'
  detail = 'creating first-order mesh and '
[]

[evaluate]
  type = Exodiff
  input = parameter_mesh.i
  allow_test_objects = True
  prereq = parameter_mesh/create
  exodiff = parameter_mesh_out.e
  detail = 'evaluating the first-order parameter values;'
[]

[create_second]
  type = CheckFiles
  input = create_mesh_second.i
  check_files = 'create_mesh_second_out.e create_mesh_second_out_param_vec_0001.csv'
  detail = 'creating second-order mesh and '
[]

[evaluate_second]
  type = Exodiff
  input = parameter_mesh_second.i
  allow_test_objects = True
  prereq = parameter_mesh/create_second
  exodiff = parameter_mesh_second_out.e
  detail = 'evaluating the second-order parameter values;'
[]

[create_dg]
  type = CheckFiles
  input = create_mesh_dg.i
  check_files = 'create_mesh_dg_out.e create_mesh_dg_out_param_vec_0001.csv'
  detail = 'creating piece-wise constant mesh and '
[]

[evaluate_dg]
  type = Exodiff
  input = parameter_mesh_dg.i
  allow_test_objects = True
  prereq = parameter_mesh/create_dg
  exodiff = parameter_mesh_dg_out.e
  detail = 'evaluating the piece-wise constant parameter values;'
[]

[evaluate_transient]
  type = Exodiff
  input = parameter_mesh_transient.i
  allow_test_objects = True
  prereq = parameter_mesh/create
  exodiff = parameter_mesh_transient_out.e
  detail = 'evaluating transient parameter values;'
[]

[compute_gradient]
  type = CSVDiff
  input = parsed_function.i
  allow_test_objects = true
  csvdiff = parsed_function_out_test_0001.csv
  detail = 'computing parameter gradient;'
[]

[wrong_vector_size]
  type = RunException
  input = parsed_function.i
  allow_test_objects = true
  cli_args = "Reporters/params/real_vector_values='1 2 3'"
  expect_err = "Size of vector \(\d+\) does not match number of specified 'param_names' \(\d+\)\."
  detail = 'erroring if vector is incorrect size;'
[]

[manual_scaling]
  type = JSONDiff
  input = main.i
  jsondiff = main_out.json
  recover = false
  max_threads = 1 # Optimize executioner does not support multiple threads
  detail = "by manually providing scaling factors for the forward problem variables,"
[]

[automatic_scaling]
  type = JSONDiff
  input = main.i
  jsondiff = main_out.json
  recover = false
  max_threads = 1 # Optimize executioner does not support multiple threads
  cli_args = "MultiApps/forward/cli_args='Executioner/automatic_scaling=true'"
  detail = "or by using the automatic scaling option."
[]

[scaling_factor_for_adjoint_variables]
  type = 'RunException'
  input = main.i
  max_threads = 1 # Optimize executioner does not support multiple threads
  cli_args = "MultiApps/forward/cli_args='Variables/T_real_adj/scaling=5'"
  expect_err = 'User cannot supply scaling factors for adjoint variables.   Adjoint system is scaled automatically by the forward system.'
  detail = "scalings are manually assigned to adjoint variables to remind users that no scaling will be performed for adjoint system."
[]

[iterOutput]
  type = CSVDiff
  max_threads = 1 # Optimize executioner does not support multiple threads
  rel_err = 1e-2
  abs_zero = 1e-1
  input = main.i
  csvdiff = "main_out_optInfo_0001.csv main_out_OptimizationReporter_0001.csv"
  # steady solve
  recover = false
  detail = "a matrix-free Hessian approach or"
[]

[auto_adjoint]
  type = Exodiff
  input = main_auto_adjoint.i
  exodiff = main_auto_adjoint_out_forward0.e
  max_threads = 1 # Optimize executioner does not support multiple threads
  recover = false
  detail = "automatic adjoint evaluation."
[]

[adjoint]
  type = CSVDiff
  max_threads = 1 # Optimize executioner does not support multiple threads
  input = main.i
  abs_zero = 1 # test parameter output; ignore gradient and objectve
  csvdiff = main_out_OptimizationReporter_0001.csv
  recover = false
  detail = 'a gradient evaluated in a separate multiapp with parameter initial conditons 1.5x higher than the true solution; '
[]

[adjoint_reg]
  type = CSVDiff
  input = "main.i regularization_for_main.i"
  csvdiff = main_out_reg_OptimizationReporter_0001.csv
  max_threads = 1 # Optimize executioner does not support multiple threads
  rel_err = 0.1
  abs_zero = 1 # test parameter output; ignore gradient and objectve
  # steady solve
  recover = false
  detail = 'a gradient evaluated in a separate multiapp using Tikhonov regularization and parameter initial conditons 3x higher than the true solution; or '
[]

[auto_adjoint]
  type = CSVDiff
  input = main_auto_adjoint.i
  cli_args = 'Outputs/file_base=main_out'
  csvdiff = main_out_OptimizationReporter_0001.csv
  max_threads = 1 # Optimize executioner does not support multiple threads
  abs_zero = 1 # test parameter output; ignore gradient and objectve
  recover = false
  detail = 'a gradient evaluated with an automatically computed adjoint.'
[]

[linear]
  type = CSVDiff
  max_threads = 1 # Optimize executioner does not support multiple threads
  rel_err = 0.01
  input = main.i
  csvdiff = main_out_OptimizationReporter_0001.csv
  # steady solve
  recover = false
  detail = 'linear diffusion problem;'
[]

[nonlinear]
  type = CSVDiff
  max_threads = 1 # Optimize executioner does not support multiple threads
  rel_err = 0.1
  abs_zero = 0.5
  input = main_nonLinear.i
  csvdiff = main_nonLinear_out_OptimizationReporter_0001.csv
  # steady solve
  recover = false
  detail = 'diffusion problem with nonlinear coefficient;'
[]

[volume]
  type = CSVDiff
  input = main_auto.i
  csvdiff = main_auto_out_OptimizationReporter_0001.csv
  max_threads = 1 # Optimize executioner does not support multiple threads
  rel_err = 3e-3
  abs_zero = 1e-4
  # steady solve
  recover = false
  detail = 'volume measurements,'
[]

[side]
  type = CSVDiff
  input = main_auto_side.i
  csvdiff = main_auto_side_out_OptimizationReporter_0001.csv
  max_threads = 1 # Optimize executioner does not support multiple threads
  rel_err = 1e-4
  abs_zero = 1e-4
  # steady solve
  recover = false
  detail = 'for side only measurements and fewer measurements than controllable parameters.'
[]

[general_optimization]
  type = JSONDiff
  input = main.i
  jsondiff = "main_json.json main_json_forward.json"
  recover = false
  abs_zero = 1.0e-6
  max_threads = 1
  capabilities = 'petsc>=3.15'
  issues = '#24930 #27193'
  requirement = "The system shall be able to minimize an objective function that is reporter transfer using TAO and output parameters used for each evaulation."
[]

[no_measurement_transfer]
  type = CSVDiff
  input = main_auto_adjoint.i
  csvdiff = 'main_out_OptimizationReporter_0001.csv'
  max_threads = 1 # Optimize executioner does not support multiple threads
  abs_zero = 1e-4 # Set above the gradient tolerance which is 1e-5.
  rel_err = 1e-4
  # steady solve
  recover = false
  detail = 'the measurement data defined on the forward_and_adjoint app; '
[]

[measurement_transfer]
  type = CSVDiff
  absent_out = 'type: ilu'
  input = main_auto_adjoint_transfer_data.i
  cli_args = '-nl0_ksp_view -adjoint_ksp_view'
  csvdiff = 'main_out_OptimizationReporter_0001.csv'
  max_threads = 1 # Optimize executioner does not support multiple threads
  abs_zero = 1e-4
  rel_err = 1e-4
  # steady solve
  recover = false
  detail = "the measurement data defined on the main app and transferred to theforward_and_adjoint app while maintaining the correct preconditioning on the adjoint system;"
[]

[separate_multiapps]
  type = CSVDiff
  input = main_separate_multiapps.i
  csvdiff = 'main_out_OptimizationReporter_0001.csv'
  max_threads = 1 # Optimize executioner does not support multiple threads
  abs_zero = 1e-4
  rel_err = 1e-4
  # steady solve
  recover = false
  detail = 'the measurment data defined on the separate subapps;'
[]

[separate_multiapps_with_reg]
  type = CSVDiff
  input = "main_separate_multiapps.i regularization_for_main.i"
  cli_args = 'Outputs/file_base=main_reg_out  measurement_points="0.5 0.28 0 0.5 1.1 0" measurement_values="293 320"'
  csvdiff = 'main_reg_out_OptimizationReporter_0001.csv'
  max_threads = 1 # Optimize executioner does not support multiple threads
  abs_zero = 1e-4
  rel_err = 1e-4
  # steady solve
  recover = false
  detail = 'the measurment data defined on the separate subapps and using regularization;'
[]

[adjoint_grad]
  type = CSVDiff
  max_threads = 1 # Optimize executioner does not support multiple threads
  rel_err = 0.01
  abs_zero = 0.01
  input = main.i
  csvdiff = main_out_OptimizationReporter_0001.csv
  # steady solve
  recover = false
  issues = '#21885'
  design = 'ElementOptimizationDiffusionCoefFunctionInnerProduct.md'
  requirement = 'The system shall be able to perform gradient based material parameter inversion for a single material property.'
[]

[grad_check]
  type = TaoGradientTester
  input = main.i
  requirement = 'The system shall be able to perform gradient based material parameter inversion for a single material property and perform a grad check.'
[]

[mesh]
  type = CheckFiles
  input = parameter_mesh.i
  cli_args = '--mesh-only'
  check_files = parameter_mesh_in.e
  recover = False
  detail = 'creating the source mesh;'
[]

[constant]
  type = Exodiff
  input = main.i
  cli_args = 'OptimizationReporter/parameter_families=MONOMIAL OptimizationReporter/parameter_orders=CONSTANT
                  forward:Functions/src_func/family=MONOMIAL forward:Functions/src_func/order=CONSTANT
                  forward:AuxVariables/source/family=MONOMIAL forward:AuxVariables/source/order=CONSTANT
                  adjoint:Functions/src_func/family=MONOMIAL adjoint:Functions/src_func/order=CONSTANT
                  Outputs/file_base=main_constant_out'
  exodiff = main_constant_out_forward0.e
  prereq = 'mesh_source/mesh'
  max_threads = 1 # Optimize executioner does not support multiple threads
  detail = 'performing the inverse optimization with a piece-wise source;'
[]

[linear]
  type = Exodiff
  input = main.i
  exodiff = main_out_forward0.e
  prereq = 'mesh_source/mesh'
  max_threads = 1 # Optimize executioner does not support multiple threads
  detail = 'performing the inverse optimization with a linearly varying source;'
[]

[second]
  type = Exodiff
  input = main.i
  cli_args = 'OptimizationReporter/parameter_orders=SECOND
                  forward:Functions/src_func/order=SECOND
                  adjoint:Functions/src_func/order=SECOND
                  Outputs/file_base=main_second_out'
  exodiff = main_second_out_forward0.e
  prereq = 'mesh_source/mesh'
  max_threads = 1 # Optimize executioner does not support multiple threads
  detail = 'performing the inverse optimization with a quadratically varying source;'
[]

[bounded]
  type = Exodiff
  input = main.i
  cli_args = 'OptimizationReporter/upper_bounds=100 OptimizationReporter/lower_bounds=0
                  Executioner/tao_solver=taoblmvm
                  Outputs/file_base=main_bounded_out'
  exodiff = main_bounded_out_forward0.e
  max_threads = 1 # Optimize executioner does not support multiple threads
  prereq = 'mesh_source/mesh'
  detail = 'performing the inverse optimization with bounds;'
[]

[auto_adjoint]
  type = Exodiff
  input = main_auto_adjoint.i
  exodiff = main_auto_adjoint_out_forward0.e
  prereq = 'mesh_source/mesh'
  max_threads = 1 # Optimize executioner does not support multiple threads
  detail = 'performing the inverse optimization with an automatically computed adjoint;'
[]

[restartMesh]
  type = CheckFiles
  input = parameter_mesh_restart.i
  prereq = 'mesh_source/linear'
  check_files = parameter_mesh_restart_out.e
  recover = False
  detail = 'creating a mesh with initial conditions;'
[]

[linearRestart]
  type = CSVDiff
  input = main_linearRestart.i
  csvdiff = main_linearRestart_out_optInfo_0001.csv
  abs_zero = 1e-4
  prereq = 'mesh_source/restartMesh'
  max_threads = 1 # Optimize executioner does not support multiple threads
  detail = 'performing the inverse optimization with exact solution initial conditions that will make it converge in a single step;'
[]

[meshes]
  type = RunException
  input = main.i
  cli_args = 'OptimizationReporter/parameter_meshes=\'parameter_mesh_in.e parameter_mesh_in.e\''
  max_threads = 1 # Optimize executioner does not support multiple threads
  expect_err = 'There must be a mesh associated with each group of parameters\.'
  detail = 'meshes;'
[]

[family]
  type = RunException
  input = main.i
  cli_args = 'OptimizationReporter/parameter_families=\'LAGRANGE LAGRANGE\''
  max_threads = 1 # Optimize executioner does not support multiple threads
  expect_err = 'There must be a family associated with each group of parameters\.'
  detail = 'finite-element families;'
[]

[order]
  type = RunException
  input = main.i
  cli_args = 'OptimizationReporter/parameter_orders=\'FIRST FIRST\''
  max_threads = 1 # Optimize executioner does not support multiple threads
  expect_err = 'There must be an order associated with each group of parameters\.'
  detail = 'finite-element orders;'
[]

[initial_condition]
  type = RunException
  input = main.i
  cli_args = 'OptimizationReporter/initial_condition=\'0; 0\''
  max_threads = 1 # Optimize executioner does not support multiple threads
  expect_err = 'There must be a vector of initial_condition per parameter group\.'
  detail = 'initial conditions;'
[]

[forward]
  type = RunException
  input = main.i
  cli_args = 'forward:Functions/src_func/order=SECOND'
  expect_err = 'Size of parameter vector \(\d+\) does not match number of degrees of freedom in mesh \(\d+\)\.'
  max_threads = 1 # Optimize executioner does not support multiple threads
  prereq = 'mesh_source/mesh'
  detail = 'forward problem;'
[]

[adjoint]
  type = RunException
  input = main.i
  cli_args = 'adjoint:Functions/src_func/order=SECOND'
  expect_err = 'The gradient for parameter \w+ has changed, expected \d+ versus \d+\.'
  max_threads = 1 # Optimize executioner does not support multiple threads
  prereq = 'mesh_source/mesh'
  detail = 'adjoint problem;'
[]

[nonlinear_material]
  type = CSVDiff
  input = main.i
  csvdiff = main_out_OptimizationReporter_0001.csv
  abs_zero = 1e-5
  max_threads = 1 # Optimize executioner does not support multiple threads
  recover = False
  requirement = 'The system shall be able perform inverse source optimization on a problem with nonlinear material properties using automatically computed adjoint.'
[]

[input]
  type = JSONDiff
  input = optRep_fromInput.i
  jsondiff = optRep_fromInput_out.json
  allow_test_objects = true
  detail = "measurement data from the input file; "
[]

[csv_paramBounds]
  type = JSONDiff
  input = optRep_fromCsv_paramBounds.i
  jsondiff = optRep_fromCsv_paramBounds_out.json
  allow_test_objects = true
  detail = "with lower bounds, upper bounds and initial conditions provided for every parameter and measurement data from a CSV file; "
[]

[csv_groupBounds]
  type = JSONDiff
  input = optRep_fromCsv_groupBounds.i
  jsondiff = optRep_fromCsv_groupBounds_out.json
  allow_test_objects = true
  detail = "with lower bounds, upper bounds and initial conditions constant for each group and measurement data from a CSV file; "
[]

[csv_mixBounds]
  type = JSONDiff
  input = optRep_fromCsv_mixBounds.i
  jsondiff = optRep_fromCsv_mixBounds_out.json
  allow_test_objects = true
  detail = "with lower bounds, upper bounds and initial conditions are a mix of constant per group and every parameter in a group and measurement data from a CSV file; "
[]

[missing_group_params]
  type = RunException
  input = optRep_fromCsv_mixBounds.i
  allow_test_objects = true
  cli_args = 'OptimizationReporter/upper_bounds=\'0\''
  max_threads = 1 # Optimize executioner does not support multiple threads
  expect_err = 'There must be a vector of upper_bounds per parameter group\.  The upper_bounds input format is std::vector<std::vector<Real>> so each vector should be seperated by \";\" even if it is a single value per group for a constant upper_bounds\.'
  detail = ' and error if parameters are provided but do not include a parameter for every group; '
[]

[too_many_params]
  type = RunException
  input = optRep_fromCsv_mixBounds.i
  allow_test_objects = true
  cli_args = 'OptimizationReporter/upper_bounds=\'0;0;0 0\''
  max_threads = 1 # Optimize executioner does not support multiple threads
  expect_err = 'When upper_bounds are given in input file, there must either be a single value per parameter group or a value for every parameter in the group\.'
  detail = ' and error if an incorrect number of parameters are provided for a group; '
[]

[readData]
  type = CSVDiff
  input = two_vars_file.i
  csvdiff = two_vars_file_out_measure_data_0001.csv
  requirement = "The system shall be able to read variable weights and use them to scale the misfit."
[]

[mesh]
  type = CheckFiles
  input = parameter_mesh_boundsIC.i
  check_files = parameter_mesh_boundsIC_out.e
  recover = False
  detail = 'by first creating the parameter mesh containing the data;'
[]

[allMeshParams]
  type = JSONDiff
  input = paramMeshOptRep.i
  cli_args = 'OptimizationReporter/initial_condition_mesh_variable=initialConditions
                  OptimizationReporter/lower_bound_mesh_variable=lowerBounds
                  OptimizationReporter/upper_bound_mesh_variable=upperBounds
                  OptimizationReporter/num_parameter_times=3
                  OptimizationReporter/exodus_timesteps_for_parameter_mesh_variable=\'2 3 4\''
  jsondiff = paramMeshOptRep_outjson.json
  allow_test_objects = true
  prereq = 'oneParameterGroup/mesh'
  detail = "with initial conditions, upper and lower bounds defined on the mesh for all timesteps; "
[]

[allInputParams]
  type = RunApp
  input = paramMeshOptRep.i
  cli_args = 'OptimizationReporter/initial_condition=6
                  OptimizationReporter/lower_bounds=5
                  OptimizationReporter/upper_bounds=7
                  OptimizationReporter/num_parameter_times=1
                  UserObjects/optReporterTester/values_to_set_parameters_to=\'10 20 30 40 50 60\'
                  UserObjects/optReporterTester/expected_lower_bounds=\'5 5 5 5 5 5\'
                  UserObjects/optReporterTester/expected_upper_bounds=\'7 7 7 7 7 7\''
  allow_test_objects = true
  prereq = 'oneParameterGroup/mesh'
  detail = "with initial conditions, upper and lower bounds defined in input file; "
[]

[mixedParams]
  type = RunApp
  input = paramMeshOptRep.i
  cli_args = 'OptimizationReporter/initial_condition_mesh_variable=initialConditions
                  OptimizationReporter/lower_bounds=5
                  OptimizationReporter/upper_bound_mesh_variable=upperBounds
                  OptimizationReporter/num_parameter_times=1
                  UserObjects/optReporterTester/values_to_set_parameters_to=\'10 20 30 40 50 60\'
                  UserObjects/optReporterTester/expected_lower_bounds=\'5 5 5 5 5 5\'
                  UserObjects/optReporterTester/expected_upper_bounds=\'2 3.5 3.5 2 5 5\''
  allow_test_objects = true
  prereq = 'oneParameterGroup/mesh'
  detail = "with initial conditions and lower bound read from input file and upper bound read from the last timestep in the mesh."
[]

[allMeshTwoParams]
  type = JSONDiff
  input = twoParamMeshOptRep.i
  cli_args = 'OptimizationReporter/initial_condition_mesh_variable=\'initialConditions elemInitialConditions\'
                  OptimizationReporter/lower_bound_mesh_variable=\'lowerBounds elemLowerBounds\'
                  OptimizationReporter/upper_bound_mesh_variable=\'upperBounds elemUpperBounds\'
                  OptimizationReporter/num_parameter_times=3
                  OptimizationReporter/exodus_timesteps_for_parameter_mesh_variable=\'2 3 4\''
  jsondiff = twoParamMeshOptRep_outjson.json
  allow_test_objects = true
  prereq = 'oneParameterGroup/mesh'
  detail = "for initial conditions, upper and lower bounds defined on the mesh for all timesteps; "
[]

[allInputTwoParams]
  type = RunApp
  input = twoParamMeshOptRep.i
  cli_args = 'OptimizationReporter/initial_condition=\'6; 7\'
                  OptimizationReporter/lower_bounds=\'5; 4\'
                  OptimizationReporter/upper_bounds=\'8; 9\'
                  OptimizationReporter/num_parameter_times=1
                  UserObjects/optReporterTester/values_to_set_parameters_to=\'10 20 30 40 50 60 0 0\'
                  UserObjects/optReporterTester/expected_lower_bounds=\'5 5 5 5 5 5 4 4\'
                  UserObjects/optReporterTester/expected_upper_bounds=\'8 8 8 8 8 8 9 9\''
  allow_test_objects = true
  prereq = 'oneParameterGroup/mesh'
  detail = "for initial conditions, upper and lower bounds defined in input file; "
[]

[mixedTwoParams]
  type = RunApp
  input = twoParamMeshOptRep.i
  cli_args = 'OptimizationReporter/initial_condition_mesh_variable=\'initialConditions elemInitialConditions\'
                  OptimizationReporter/lower_bounds=\'5; 8\'
                  OptimizationReporter/upper_bound_mesh_variable=\'upperBounds elemUpperBounds\'
                  OptimizationReporter/num_parameter_times=1
                  UserObjects/optReporterTester/values_to_set_parameters_to=\'10 20 30 40 50 60 0 0\'
                  UserObjects/optReporterTester/expected_lower_bounds=\'5 5 5 5 5 5 8 8\'
                  UserObjects/optReporterTester/expected_upper_bounds=\'2 3.5 3.5 2 5 5 2.75 4.25\''
  allow_test_objects = true
  prereq = 'oneParameterGroup/mesh'
  detail = "for initial conditions and lower bound read from input file and upper bound read from the last timestep in the mesh; "
[]

[twoParamsHO]
  type = RunApp
  input = twoParamMeshOptRep.i
  cli_args = 'OptimizationReporter/initial_condition_mesh_variable=\'initialConditions initialConditionsSecond\'
                  OptimizationReporter/lower_bound_mesh_variable=\'lowerBounds lowerBoundsSecond\'
                  OptimizationReporter/upper_bound_mesh_variable=\'upperBounds upperBoundsSecond\'
                  OptimizationReporter/parameter_families=\'LAGRANGE LAGRANGE\'
                  OptimizationReporter/parameter_orders=\'FIRST SECOND\'
                  OptimizationReporter/num_parameter_times=1
                  UserObjects/optReporterTester/values_to_set_parameters_to=\'10 20 30 40 50 60 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\'
                  UserObjects/optReporterTester/expected_lower_bounds=\'0 1.5 1.5 0 3 3 0 0 3 3 0 1.5 3 1.5 1.5 0 3 0 1.5 3 1.5\'
                  UserObjects/optReporterTester/expected_upper_bounds=\'2 3.5 3.5 2 5 5 2 2 5 5 2 3.5 5 3.5 3.5 2 5 2 3.5 5 3.50\''
  allow_test_objects = true
  prereq = 'oneParameterGroup/mesh'
  detail = "for the first group being first order Lagrange and second group being second order Lagrange nodal variables."
[]

[errorMixedParams]
  type = RunException
  input = paramMeshOptRep.i
  cli_args = 'OptimizationReporter/initial_condition=6
                  OptimizationReporter/lower_bound_mesh_variable=lowerBounds
                  OptimizationReporter/lower_bounds=5
                  OptimizationReporter/upper_bound_mesh_variable=upperBounds
                  OptimizationReporter/num_parameter_times=1'
  allow_test_objects = true
  expect_err = 'Lower bounds for all parameter groups can only be defined by lower_bound_mesh_variable or lower_bounds but not both.'
  detail = "by having input and mesh parameters for the same bound; "
[]

[errorMissingMeshParam]
  type = RunException
  input = paramMeshOptRep.i
  cli_args = 'OptimizationReporter/lower_bound_mesh_variable=notOnMesh'
  allow_test_objects = true
  expect_err = 'Exodus file did not contain the parameter name being intitialized.'
  detail = "by having a parameter not on the exodus mesh; "
[]

[errorMismatchSteps]
  type = RunException
  input = paramMeshOptRep.i
  cli_args = 'OptimizationReporter/lower_bound_mesh_variable=lowerBounds
                  OptimizationReporter/num_parameter_times=2
                  OptimizationReporter/exodus_timesteps_for_parameter_mesh_variable=\'2 3 4\''
  allow_test_objects = true
  expect_err = 'Number of timesteps to read mesh data specified by \"exodus_timesteps_for_parameter_mesh_variable\" incorrect.'
  detail = "by not having the same number of optimization timesteps and timesteps for reading parameter data from the mesh; "
[]

[errorNoSteps]
  type = RunException
  input = paramMeshOptRep.i
  cli_args = 'OptimizationReporter/lower_bounds=5
                  OptimizationReporter/num_parameter_times=3
                  OptimizationReporter/exodus_timesteps_for_parameter_mesh_variable=\'2 3 4\''
  allow_test_objects = true
  expect_err = '\"exodus_timesteps_for_parameter_mesh_variable\" should only be specified if reading values from a mesh.'
  detail = "by specifying a timestep for reading parameter data from the exodus file but not parameter data is being read from the mesh because it is all specified in the input file; "
[]

[errorBadStep]
  type = RunException
  input = paramMeshOptRep.i
  cli_args = 'OptimizationReporter/lower_bound_mesh_variable=lowerBounds
      OptimizationReporter/upper_bound_mesh_variable=upperBounds
      UserObjects/optReporterTester/expected_lower_bounds=\'5 5 5 5 5 5\'
      UserObjects/optReporterTester/expected_upper_bounds=\'2 3.5 3.5 2 5 5\'
                  OptimizationReporter/num_parameter_times=3
                  OptimizationReporter/exodus_timesteps_for_parameter_mesh_variable=\'2 3 8\''
  allow_test_objects = true
  expect_err = 'Invalid value passed as "time_step". Expected a valid integer less than 4, received 8'
  detail = "by specifying a timestep that is bigger than the timestpes on the exodus the exodus mesh."
[]

[hessian]
  # DO NOT CHANGE THIS TEST
  # this test is documented as an example in forceInv_pointLoads.md
  # if this test is changed, the figures will need to be updated.
  type = CSVDiff
  input = main.i
  csvdiff = main_out_OptimizationReporter_0001.csv
  max_threads = 1 # Optimize executioner does not support multiple threads
  rel_err = 0.1
  abs_zero = 10
  # steady solve
  recover = false
  detail = 'Hessian-based optimization,'
[]

[hessian_reg]
  type = CSVDiff
  input = "main.i regularization_for_main.i"
  csvdiff = main_out_reg_OptimizationReporter_0001.csv
  cli_args = 'measurement_points="0.5 0.28 0 0.5 1.1 0" measurement_values="293 320"'
  max_threads = 1 # Optimize executioner does not support multiple threads
  rel_err = 0.1
  abs_zero = 10
  # steady solve
  recover = false
  detail = 'ill-posed Hessian-based optimization with Tikhonov regularization,'
[]

[adjoint]
  type = CSVDiff
  input = main.i
  cli_args = "Executioner/tao_solver=taolmvm Executioner/petsc_options_iname='-tao_gttol' Executioner/petsc_options_value='1e-5'"
  csvdiff = main_out_OptimizationReporter_0001.csv
  max_threads = 1 # Optimize executioner does not support multiple threads
  rel_err = 0.1
  abs_zero = 10
  # steady solve
  recover = false
  detail = 'gradient-based optimization, '
[]

[adjoint_reg]
  type = CSVDiff
  input = "main.i regularization_for_main.i"
  cli_args = "Executioner/tao_solver=taolmvm Executioner/petsc_options_iname='-tao_gttol' Executioner/petsc_options_value='1e-5' measurement_points='0.5 0.28 0 0.5 1.1 0' measurement_values='293 320'"
  csvdiff = main_out_reg_OptimizationReporter_0001.csv
  max_threads = 1 # Optimize executioner does not support multiple threads
  rel_err = 0.1
  abs_zero = 10
  # steady solve
  recover = false
  detail = 'ill-posed gradient-based optimization with Tikhonov regularization, '
[]

[auto_adjoint]
  type = CSVDiff
  input = main_auto_adjoint.i
  absent_out = 'type: ilu'
  # We want all the ksp viewers to catch someone making a change that affects solver prefixes
  cli_args = 'Outputs/file_base=main_out -nl0_ksp_view -adjoint_ksp_view -ksp_view'
  csvdiff = main_out_OptimizationReporter_0001.csv
  max_threads = 1 # Optimize executioner does not support multiple threads
  rel_err = 0.1
  abs_zero = 10
  # steady solve
  recover = false
  detail = 'gradient-based optimization with an automatically computed adjoint that uses the same preconditioner as the forward solve, or '
[]

[auto_adjoint_reg]
  type = CSVDiff
  cli_args = "OptimizationReporter/initial_condition='1000 1000 1000' measurement_points='0.5 0.28 0 0.5 1.1 0' measurement_values='293 320'"
  input = 'main_auto_adjoint.i regularization_for_main.i'
  csvdiff = main_out_reg_OptimizationReporter_0001.csv
  max_threads = 1 # Optimize executioner does not support multiple threads
  rel_err = 0.1
  abs_zero = 10
  # steady solve
  recover = false
  detail = 'gradient-based optimization with an automatically computed adjoint, with Tikhonov regularization, and initial conditions do not affect the converged regularized solution, or'
[]

[grad_test]
  type = TaoGradientTester
  input = 'main_auto_adjoint.i'
  max_rel_tol = 5e-4
  max_threads = 1 # Optimize executioner does not support multiple threads
  detail = 'gradient check for automatic adjoint;'
[]

[reg_grad_test]
  type = TaoGradientTester
  input = 'main_auto_adjoint.i regularization_for_main.i'
  max_rel_tol = 5e-4
  max_threads = 1 # Optimize executioner does not support multiple threads
  detail = 'gradient check for automatic adjoint with Tikhonov regularization.'
[]

[shifted_function]
  design = 'ReporterOffsetFunctionMaterial.md'
  issues = '#28871'
  type = 'Exodiff'
  input = 'reporter_offset_mat.i'
  exodiff = 'reporter_offset_mat_out.e'
  requirement = "The system shall support calculating material properties as the sum of the evaluations of a functor at the current location, with each term offset using a set of points provided through reporters."
[]

[mesh]
  type = CheckFiles
  input = initial_param_mesh.i
  check_files = initial_param_mesh_in.e
  recover = False
  detail = 'by first creating a mesh containing the data needed for optimization on a mesh;'
[]

[coarse_mesh]
  type = CheckFiles
  input = initial_param_mesh.i
  cli_args = 'Outputs/file_base=initial_param_mesh_coarse_in
                  Mesh/cmg/ix="2 4 2"
                  Mesh/cmg/iy="2"'
  check_files = initial_param_mesh_coarse_in.e
  recover = False
  detail = 'by first creating a coarse mesh containing the data needed for optimization on a mesh;'
[]

[input_file_ICs]
  type = 'Exodiff'
  input = 'main.i optimizationReporterInputIC.i'
  rel_err = 1e-3 # we have a low gradient tolerance
  abs_zero = 1e-5
  exodiff = 'optimizationReporterInputIC_out_forward_and_adjoint0.e'
  # Optimize executioner does not support multiple threads
  max_threads = 1
  recover = False
  detail = " with initial conditions read from the input file;"
[]

[mesh_ICs]
  prereq = 'gradient_l2_regularization/mesh'
  type = 'Exodiff'
  input = 'main.i optimizationReporterMeshIC.i'
  rel_err = 1e-3 # we have a low gradient tolerance
  abs_zero = 1e-5
  exodiff = 'optimizationReporterMeshIC_out_forward_and_adjoint0.e'
  # Optimize executioner does not support multiple threads
  max_threads = 1
  recover = False
  detail = " with initial conditions read from the mesh;"
[]

[grad_check]
  prereq = 'gradient_l2_regularization/coarse_mesh'
  type = TaoGradientTester
  input = 'main.i optimizationReporterMeshIC.i'
  cli_args = 'OptimizationReporter/parameter_meshes="initial_param_mesh_coarse_in.e"
                  forward_and_adjoint0:Functions/source_function/exodus_mesh="initial_param_mesh_coarse_in.e"'
  max_rel_tol = 1e-4
  detail = " the adjoint gradient will be accurate."
[]

[mismatched_coeffs_types]
  type = 'RunException'
  input = 'main.i optimizationReporterInputIC.i'
  cli_args = 'OptimizationReporter/regularization_types="L2_GRADIENT L2_GRADIENT"
                  OptimizationReporter/regularization_coeffs="0.1"'
  # Optimize executioner does not support multiple threads
  max_threads = 1
  expect_err = 'Number of regularization coefficients \(1\) must match number of regularization types \(2\)'
  detail = "when the number of regularization coefficients doesn't match the number of regularization types;"
[]

[invalid_regularization_type]
  type = 'RunException'
  input = 'main.i optimizationReporterInputIC.i'
  cli_args = 'OptimizationReporter/regularization_types="INVALID_TYPE"
                  OptimizationReporter/regularization_coeffs="0.1"'
  # Optimize executioner does not support multiple threads
  max_threads = 1
  expect_err = 'Invalid option "INVALID_TYPE" in MultiMooseEnum'
  detail = "when an invalid regularization type is specified;"
[]

[empty_coeffs_with_types]
  type = 'RunException'
  input = 'main.i optimizationReporterInputIC.i'
  cli_args = 'OptimizationReporter/regularization_types="L2_GRADIENT"
                  OptimizationReporter/regularization_coeffs=""'
  # Optimize executioner does not support multiple threads
  max_threads = 1
  expect_err = 'Number of regularization coefficients \(0\) must match number of regularization types \(1\)'
  detail = "when regularization types are specified but no coefficients are provided;"
[]

[adjoint_grad_iteration_output]
  type = Exodiff
  max_threads = 1
  # Optimize executioner does not support multiple threads
  input = main.i
  exodiff = adjoint.e
  rel_err = 1.0e-5
  abs_zero = 1.0e-5
  # steady solve
  recover = false
  requirement = 'The system shall be able to perform gradient based material parameter inversion for a single material property and output the iteration-wise exodus output for the adjoint problem.'
[]

[auto_adjoint_iteration_output]
  type = Exodiff
  input = main_auto_adjoint.i
  exodiff = 'main_auto_adjoint_out_forward0_exodus.e'
  # Optimize executioner does not support multiple threads
  max_threads = 1
  # steady solve
  recover = false
  requirement = 'The system shall be able to invert for point loads using gradient-based optimization with an automatically computed adjoint and output the exodus output per iteration for the combined forward and adjoint problem variables.'
[]

[forward_exact]
  type = CSVDiff
  input = transient_synthetic_data.i
  csvdiff = transient_synthetic_data_csv_sample_0011.csv
  allow_test_objects = true
  requirement = 'The system shall create synthetic transient data in a consumable format.'
[]

[sampler_opt]
  requirement = "The system shall be able to find an optimal value to a linear combination of parallel forward problems run using the sampler system."
  type = CSVDiff
  input = optimize.i
  csvdiff = optimize_out.csv
  min_parallel = 6
  max_parallel = 6
  max_threads = 1
  # skip recover for steady solve
  recover = false
[]

[simp]
  type = Exodiff
  input = 2d.i
  exodiff = '2d_out.e'
  rel_err = 1.0e-4
  requirement = 'The system shall be able to run a diffusion problem through the density update machinery with filtered fake sensitivities to optimize the material distribution applying a bisection algorithm.'
[]

[simp_restricted]
  type = Exodiff
  input = 2d.i
  exodiff = '2d_out.e'
  rel_err = 1.0e-4
  cli_args = 'UserObjects/update/block=1'
  requirement = 'The system shall be able to run a diffusion problem through the density update machinery with filtered fake sensitivities to optimize the material distribution applying a bisection algorithm to a block restricted system.'
[]

[simp_multi]
  type = Exodiff
  input = 2d_twoconstraints.i
  exodiff = '2d_twoconstraints_out.e'
  rel_err = 1.0e-4
  requirement = 'The system shall be able to run a diffusion problem through the density update for multiple materials, volume constraint, and cost constraint machinery with filtered fake sensitivities to optimize the material distribution applying a bisection algorithm.'
[]

[simp_multi_restricted]
  type = Exodiff
  input = 2d_twoconstraints.i
  exodiff = '2d_twoconstraints_out.e'
  rel_err = 1.0e-4
  cli_args = 'UserObjects/update/block=1'
  requirement = 'The system shall be able to run a diffusion problem through the density update for multiple materials, volume constraint, and cost constraint machinery with filtered fake sensitivities to optimize the material distribution applying a bisection algorithm to a block restricted system.'
[]

[forward]
  type = CheckFiles
  input = forward.i
  check_files = 'forward_out.e'
  detail = 'producing the exodus file;'
[]

[reverse]
  type = RunApp
  input = adjoint.i
  prereq = adjoint_solution/forward
  detail = 'loading on to the same mesh;'
[]

[reverse_space_interp]
  type = RunApp
  input = adjoint.i
  cli_args = 'Mesh/gmg/nx=5'
  prereq = adjoint_solution/forward
  detail = 'loading on to a coarser mesh;'
[]

[reverse_time_interp]
  type = RunApp
  input = adjoint.i
  cli_args = 'Executioner/dt=1.25 Functions/u_reverse_fun/expression="(x + y) * (11.25 - t)"'
  prereq = adjoint_solution/forward
  detail = 'interpolating different time steps;'
[]

[error_file_format]
  type = RunException
  input = adjoint.i
  cli_args = 'UserObjects/u_reverse_solution/mesh=forward_out.xda'
  expect_err = 'Performing transient adjoint simulation currently only works if the forward solution is written and read from exodus format.'
  detail = 'erroring if file is not exodus;'
[]

[analytic]
  type = RunApp
  input = element_reaction_inner_product.i
  requirement = 'The system shall be able to compute the inner product between two variables weighted by the derivative of a function with respect to the vector it depends on.'
[]

[vector_nearest_point]
  type = CSVDiff
  input = element_source_inner_product.i
  csvdiff = element_source_inner_product_out_inner_product_0011.csv
  recover = false # Can't do recover since there is no mesh
  issues = '#22215'
  requirement = 'The system shall be able to compute the inner product of a variable and a nearest node optimization volumetric source function.'
[]