Optimize

Executioner for optimization problems.

Overview

This is executioner performs optimization using the TAO optimization toolkit. The specific algorithm used is specified using the "tao_solver" parameter. The options and connection with TAO algorithms is shown in Table 1. Additional solver options can be given to the TAO solver using the "petsc_options", "petsc_options_iname", and "petsc_options_value" parameters or from command-line.

Table 1: List of available optimization algorithms

Algorithm	"tao_solver"	TAO Option	`tao_type`
Newton Trust Region	`taontr`	TAONTR	`ntr`
Bounded Newton Trust Region	`taobntr`	TAOBNTR	`bntr`
Bounded Conjugate Gradient	`taobncg`	TAOBNCG	`bncg`
Newton Line Search	`taonls`	TAONLS	`nls`
Bounded Newton Line Search	`taobnls`	TAOBNLS	`bnls`
Limited Memory Variable Metric	`taolmvm`	TAOLMVM	`lmvm`
Bounded Limited Memory Variable Metric	`taoblmvm`	TAOBLMVM	`blmvm`
Nelder-Mead	`taonm`	TAONM	`nm`
Bounded Quasi-Newton Line Search	`taobqnls`	TAOBQNLS	`bqnls`
Orthant-wise Limited Memory	`taoowlqn`	TAOOWLQN	`taoowlqn`
Gradient Projection Conjugate Gradient	`taogpcg`	TAOGPCG	`gpcg`
Bundle Method for Regularized Risk Minimization	`taobmrm`	TAOBMRM	`bmrm`
Augmented Lagrangian Multiplier Method	`taoalmm`	TAOALMM	`almm`

This executioner relies on a OptimizationReporter to define the constraints, bounds, objective, and gradient of the form function. The objective is defined by the computeObjective member in the OptimizationReporter class. The gradient is defined by computeGradient and the bounds are defined by getUpperBounds and getLowerBounds. Whether it is necessary to define each of these members is based on whether the selected algorithm needs it, see Summary of Tao Solvers for more information. The Hessian is computed using a matrix-free method, where it evaluates the action of the Hessian on the form function parameters (the values that are being optimized). It does this by evaluating a homogeneous version of the objective function and subsequently computes the gradient. For constrained optimization the taoalmm algorithm needs to be used. When the taoalmm algorithm is selected the necessary methods for that algorithm are generated and only in an OptimizationReporter does the user need to provide the type and number of constraints.

To aid in the computation of the objective, gradient, and Hessian, this executioner includes additional execution flags that MOOSE objects (like MultiApps) can be evaluated on. Having execute_on = forward will execute the object(s) just before computeObjective is called and execute_on = adjoint will execute the object()s just before computeGradient is called. Having execute_on = homogeneous_forward will execute the object(s) during the matrix-free Hessian computation, before calling adjoint and computeGradient.

The form function's parameters are represented as a vector of values and is tied to reporter values within the OptimizationReporter.

Example Input Syntax

The following performs optimization using th Newton line search algorithm. The additional options set the optimization tolerance to $var element = document.getElementById("moose-equation-d5441ad8-caad-45b7-a5cc-a8f05ce14c9b");katex.render("10^{-5}", element, {displayMode:false,throwOnError:false});$ , set the max iterations to 10, and set the linear solver type to conjugate gradient with no preconditioning.

[Executioner<<<{"href": "../../syntax/Executioner/index.html"}>>>]
  type = Optimize
  tao_solver = taonls
  petsc_options_iname = '-tao_gttol -tao_max_it -tao_nls_pc_type -tao_nls_ksp_type'
  petsc_options_value = '1e-5 10 none cg'
  verbose = true
[]

Input Parameters

tao_solverTao solver to use for optimization.
C++ Type:MooseEnum
Options:taontr, taobntr, taobncg, taonls, taobnls, taobqnktr, taontl, taobntl, taolmvm, taoblmvm, taonm, taobqnls, taoowlqn, taogpcg, taobmrm, taoalmm
Controllable:No
Description:Tao solver to use for optimization.

Required Parameters

output_optimization_iterationsFalseUse the time step as the current iteration for outputting optimization history.
Default:False
C++ Type:bool
Controllable:No
Description:Use the time step as the current iteration for outputting optimization history.
solve_onFORWARD ADJOINT HOMOGENEOUS_FORWARDList of flags indicating when inner system solve should occur.
Default:FORWARD ADJOINT HOMOGENEOUS_FORWARD
C++ Type:ExecFlagEnum
Options:FORWARD, ADJOINT, HOMOGENEOUS_FORWARD, NONE
Controllable:No
Description:List of flags indicating when inner system solve should occur.
time0System time
Default:0
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:System time
verboseFalseSet to true to print additional information
Default:False
C++ Type:bool
Controllable:No
Description:Set to true to print additional information

Optional Parameters

accept_on_max_fixed_point_iterationFalseTrue to treat reaching the maximum number of fixed point iterations as converged.
Default:False
C++ Type:bool
Controllable:No
Description:True to treat reaching the maximum number of fixed point iterations as converged.
auto_advanceFalseWhether to automatically advance sub-applications regardless of whether their solve converges, for transient executioners only.
Default:False
C++ Type:bool
Controllable:No
Description:Whether to automatically advance sub-applications regardless of whether their solve converges, for transient executioners only.
custom_abs_tol1e-50The absolute nonlinear residual to shoot for during fixed point iterations. This check is performed based on postprocessor defined by the custom_pp residual.
Default:1e-50
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:The absolute nonlinear residual to shoot for during fixed point iterations. This check is performed based on postprocessor defined by the custom_pp residual.
custom_ppPostprocessor for custom fixed point convergence check.
C++ Type:PostprocessorName
Unit:(no unit assumed)
Controllable:No
Description:Postprocessor for custom fixed point convergence check.
custom_rel_tol1e-08The relative nonlinear residual drop to shoot for during fixed point iterations. This check is performed based on the postprocessor defined by custom_pp residual.
Default:1e-08
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:The relative nonlinear residual drop to shoot for during fixed point iterations. This check is performed based on the postprocessor defined by custom_pp residual.
direct_pp_valueFalseTrue to use direct postprocessor value (scaled by value on first iteration). False (default) to use difference in postprocessor value between fixed point iterations.
Default:False
C++ Type:bool
Controllable:No
Description:True to use direct postprocessor value (scaled by value on first iteration). False (default) to use difference in postprocessor value between fixed point iterations.
disable_fixed_point_residual_norm_checkFalseDisable the residual norm evaluation thus the three parameters fixed_point_rel_tol, fixed_point_abs_tol and fixed_point_force_norms.
Default:False
C++ Type:bool
Controllable:No
Description:Disable the residual norm evaluation thus the three parameters fixed_point_rel_tol, fixed_point_abs_tol and fixed_point_force_norms.
fixed_point_abs_tol1e-50The absolute nonlinear residual to shoot for during fixed point iterations. This check is performed based on the main app's nonlinear residual.
Default:1e-50
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:The absolute nonlinear residual to shoot for during fixed point iterations. This check is performed based on the main app's nonlinear residual.
fixed_point_algorithmpicardThe fixed point algorithm to converge the sequence of problems.
Default:picard
C++ Type:MooseEnum
Options:picard, secant, steffensen
Controllable:No
Description:The fixed point algorithm to converge the sequence of problems.
fixed_point_force_normsFalseForce the evaluation of both the TIMESTEP_BEGIN and TIMESTEP_END norms regardless of the existence of active MultiApps with those execute_on flags, default: false.
Default:False
C++ Type:bool
Controllable:No
Description:Force the evaluation of both the TIMESTEP_BEGIN and TIMESTEP_END norms regardless of the existence of active MultiApps with those execute_on flags, default: false.
fixed_point_max_its1Specifies the maximum number of fixed point iterations.
Default:1
C++ Type:unsigned int
Controllable:No
Description:Specifies the maximum number of fixed point iterations.
fixed_point_min_its1Specifies the minimum number of fixed point iterations.
Default:1
C++ Type:unsigned int
Controllable:No
Description:Specifies the minimum number of fixed point iterations.
fixed_point_rel_tol1e-08The relative nonlinear residual drop to shoot for during fixed point iterations. This check is performed based on the main app's nonlinear residual.
Default:1e-08
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:The relative nonlinear residual drop to shoot for during fixed point iterations. This check is performed based on the main app's nonlinear residual.
multiapp_fixed_point_convergenceName of the Convergence object to use to assess convergence of the MultiApp fixed point solve. If not provided, a default Convergence will be constructed internally from the executioner parameters.
C++ Type:ConvergenceName
Controllable:No
Description:Name of the Convergence object to use to assess convergence of the MultiApp fixed point solve. If not provided, a default Convergence will be constructed internally from the executioner parameters.
relaxation_factor1Fraction of newly computed value to keep.Set between 0 and 2.
Default:1
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:Fraction of newly computed value to keep.Set between 0 and 2.
transformed_postprocessorsList of main app postprocessors to transform during fixed point iterations
C++ Type:std::vector<PostprocessorName>
Unit:(no unit assumed)
Controllable:No
Description:List of main app postprocessors to transform during fixed point iterations
transformed_variablesList of main app variables to transform during fixed point iterations
C++ Type:std::vector<std::string>
Controllable:No
Description:List of main app variables to transform during fixed point iterations

Fixed Point Iterations Parameters

automatic_scalingFalseWhether to use automatic scaling for the variables.
Default:False
C++ Type:bool
Controllable:No
Description:Whether to use automatic scaling for the variables.
compute_scaling_once1 Whether the scaling factors should only be computed once at the beginning of the simulation through an extra Jacobian evaluation. If this is set to false, then the scaling factors will be computed during an extra Jacobian evaluation at the beginning of every time step. Vector entries correspond to each nonlinear system.
Default:1
C++ Type:std::vector<bool>
Controllable:No
Description:Whether the scaling factors should only be computed once at the beginning of the simulation through an extra Jacobian evaluation. If this is set to false, then the scaling factors will be computed during an extra Jacobian evaluation at the beginning of every time step. Vector entries correspond to each nonlinear system.
ignore_variables_for_autoscalingList of variables that do not participate in autoscaling. Vector entries correspond to each nonlinear system.
C++ Type:std::vector<std::vector<std::string>>
Controllable:No
Description:List of variables that do not participate in autoscaling. Vector entries correspond to each nonlinear system.
off_diagonals_in_auto_scaling0 Whether to consider off-diagonals when determining automatic scaling factors. Vector entries correspond to each nonlinear system.
Default:0
C++ Type:std::vector<bool>
Controllable:No
Description:Whether to consider off-diagonals when determining automatic scaling factors. Vector entries correspond to each nonlinear system.
resid_vs_jac_scaling_param0 A parameter that indicates the weighting of the residual vs the Jacobian in determining variable scaling parameters. A value of 1 indicates pure residual-based scaling. A value of 0 indicates pure Jacobian-based scaling. Vector entries correspond to each nonlinear system.
Default:0
C++ Type:std::vector<double>
Unit:(no unit assumed)
Controllable:No
Description:A parameter that indicates the weighting of the residual vs the Jacobian in determining variable scaling parameters. A value of 1 indicates pure residual-based scaling. A value of 0 indicates pure Jacobian-based scaling. Vector entries correspond to each nonlinear system.
scaling_group_variablesName of variables that are grouped together for determining scale factors. (Multiple groups can be provided, separated by semicolon). Vector entries correspond to each nonlinear system.
C++ Type:std::vector<std::vector<std::vector<std::string, std::allocator<std::string>>>>
Controllable:No
Description:Name of variables that are grouped together for determining scale factors. (Multiple groups can be provided, separated by semicolon). Vector entries correspond to each nonlinear system.

Solver Variable Scaling Parameters

contact_line_search_allowed_lambda_cuts2The number of times lambda is allowed to be cut in half in the contact line search. We recommend this number be roughly bounded by 0 <= allowed_lambda_cuts <= 3
Default:2
C++ Type:unsigned int
Controllable:No
Description:The number of times lambda is allowed to be cut in half in the contact line search. We recommend this number be roughly bounded by 0 <= allowed_lambda_cuts <= 3
contact_line_search_ltolThe linear relative tolerance to be used while the contact state is changing between non-linear iterations. We recommend that this tolerance be looser than the standard linear tolerance
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:The linear relative tolerance to be used while the contact state is changing between non-linear iterations. We recommend that this tolerance be looser than the standard linear tolerance
line_searchdefaultSpecifies the line search type (Note: none = basic)
Default:default
C++ Type:MooseEnum
Options:basic, bt, contact, cp, default, l2, none, project, shell
Controllable:No
Description:Specifies the line search type (Note: none = basic)
line_search_packagepetscThe solver package to use to conduct the line-search
Default:petsc
C++ Type:MooseEnum
Options:petsc, moose
Controllable:No
Description:The solver package to use to conduct the line-search

Solver Line Search Parameters

control_tagsAdds user-defined labels for accessing object parameters via control logic.
C++ Type:std::vector<std::string>
Controllable:No
Description:Adds user-defined labels for accessing object parameters via control logic.
enableTrueSet the enabled status of the MooseObject.
Default:True
C++ Type:bool
Controllable:No
Description:Set the enabled status of the MooseObject.
outputsVector of output names where you would like to restrict the output of variables(s) associated with this object
C++ Type:std::vector<OutputName>
Controllable:No
Description:Vector of output names where you would like to restrict the output of variables(s) associated with this object
skip_exception_checkFalseSpecifies whether or not to skip exception check
Default:False
C++ Type:bool
Controllable:No
Description:Specifies whether or not to skip exception check

Advanced Parameters

l_abs_tol1e-50Linear Absolute Tolerance
Default:1e-50
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:Linear Absolute Tolerance
l_max_its10000Max Linear Iterations
Default:10000
C++ Type:unsigned int
Controllable:No
Description:Max Linear Iterations
l_tol1e-05Linear Relative Tolerance
Default:1e-05
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:Linear Relative Tolerance
reuse_preconditionerFalseIf true reuse the previously calculated preconditioner for the linearized system across multiple solves spanning nonlinear iterations and time steps. The preconditioner resets as controlled by reuse_preconditioner_max_linear_its
Default:False
C++ Type:bool
Controllable:No
Description:If true reuse the previously calculated preconditioner for the linearized system across multiple solves spanning nonlinear iterations and time steps. The preconditioner resets as controlled by reuse_preconditioner_max_linear_its
reuse_preconditioner_max_linear_its25Reuse the previously calculated preconditioner for the linear system until the number of linear iterations exceeds this number
Default:25
C++ Type:unsigned int
Controllable:No
Description:Reuse the previously calculated preconditioner for the linear system until the number of linear iterations exceeds this number

Linear Solver Parameters

linear_convergenceName of the Convergence object(s) to use to assess convergence of the linear system(s) solve. If not provided, the linear solver tolerance parameters are used
C++ Type:std::vector<ConvergenceName>
Controllable:No
Description:Name of the Convergence object(s) to use to assess convergence of the linear system(s) solve. If not provided, the linear solver tolerance parameters are used
n_max_nonlinear_pingpong100The maximum number of times the nonlinear residual can ping pong before requesting halting the current evaluation and requesting timestep cut for transient simulations
Default:100
C++ Type:unsigned int
Controllable:No
Description:The maximum number of times the nonlinear residual can ping pong before requesting halting the current evaluation and requesting timestep cut for transient simulations
nl_abs_div_tol1e+50Nonlinear Absolute Divergence Tolerance. A negative value disables this check.
Default:1e+50
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:Nonlinear Absolute Divergence Tolerance. A negative value disables this check.
nl_abs_step_tol0Nonlinear Absolute step Tolerance
Default:0
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:Nonlinear Absolute step Tolerance
nl_abs_tol1e-50Nonlinear Absolute Tolerance
Default:1e-50
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:Nonlinear Absolute Tolerance
nl_div_tol1e+10Nonlinear Relative Divergence Tolerance. A negative value disables this check.
Default:1e+10
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:Nonlinear Relative Divergence Tolerance. A negative value disables this check.
nl_forced_its0The Number of Forced Nonlinear Iterations
Default:0
C++ Type:unsigned int
Controllable:No
Description:The Number of Forced Nonlinear Iterations
nl_max_funcs10000Max Nonlinear solver function evaluations
Default:10000
C++ Type:unsigned int
Controllable:No
Description:Max Nonlinear solver function evaluations
nl_max_its50Max Nonlinear Iterations
Default:50
C++ Type:unsigned int
Controllable:No
Description:Max Nonlinear Iterations
nl_rel_step_tol0Nonlinear Relative step Tolerance
Default:0
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:Nonlinear Relative step Tolerance
nl_rel_tol1e-08Nonlinear Relative Tolerance
Default:1e-08
C++ Type:double
Unit:(no unit assumed)
Controllable:No
Description:Nonlinear Relative Tolerance
nonlinear_convergenceName of the Convergence object(s) to use to assess convergence of the nonlinear system(s) solve. If not provided, the default Convergence associated with the Problem will be constructed internally.
C++ Type:std::vector<ConvergenceName>
Controllable:No
Description:Name of the Convergence object(s) to use to assess convergence of the nonlinear system(s) solve. If not provided, the default Convergence associated with the Problem will be constructed internally.
num_grids1The number of grids to use for a grid sequencing algorithm. This includes the final grid, so num_grids = 1 indicates just one solve in a time-step
Default:1
C++ Type:unsigned int
Controllable:No
Description:The number of grids to use for a grid sequencing algorithm. This includes the final grid, so num_grids = 1 indicates just one solve in a time-step
residual_and_jacobian_together0 Whether to compute the residual and Jacobian together. Vector entries correspond to each nonlinear system.
Default:0
C++ Type:std::vector<bool>
Controllable:No
Description:Whether to compute the residual and Jacobian together. Vector entries correspond to each nonlinear system.
snesmf_reuse_baseTrueSpecifies whether or not to reuse the base vector for matrix-free calculation
Default:True
C++ Type:bool
Controllable:No
Description:Specifies whether or not to reuse the base vector for matrix-free calculation
solve_typePJFNK: Preconditioned Jacobian-Free Newton Krylov JFNK: Jacobian-Free Newton Krylov NEWTON: Full Newton Solve FD: Use finite differences to compute Jacobian LINEAR: Solving a linear problem
C++ Type:MooseEnum
Options:PJFNK, JFNK, NEWTON, FD, LINEAR
Controllable:No
Description:PJFNK: Preconditioned Jacobian-Free Newton Krylov JFNK: Jacobian-Free Newton Krylov NEWTON: Full Newton Solve FD: Use finite differences to compute Jacobian LINEAR: Solving a linear problem
splittingTop-level splitting defining a hierarchical decomposition into subsystems to help the solver. Outer-vector of this vector-of-vector parameter correspond to each nonlinear system.
C++ Type:std::vector<std::vector<std::string>>
Controllable:No
Description:Top-level splitting defining a hierarchical decomposition into subsystems to help the solver. Outer-vector of this vector-of-vector parameter correspond to each nonlinear system.
use_pre_SMO_residualFalseCompute the pre-SMO residual norm and use it in the relative convergence check. The pre-SMO residual is computed at the begining of the time step before solution-modifying objects are executed. Solution-modifying objects include preset BCs, constraints, predictors, etc.
Default:False
C++ Type:bool
Controllable:No
Description:Compute the pre-SMO residual norm and use it in the relative convergence check. The pre-SMO residual is computed at the begining of the time step before solution-modifying objects are executed. Solution-modifying objects include preset BCs, constraints, predictors, etc.

Nonlinear Solver Parameters

max_xfem_update4294967295Maximum number of times to update XFEM crack topology in a step due to evolving cracks
Default:4294967295
C++ Type:unsigned int
Controllable:No
Description:Maximum number of times to update XFEM crack topology in a step due to evolving cracks
update_xfem_at_timestep_beginFalseShould XFEM update the mesh at the beginning of the timestep
Default:False
C++ Type:bool
Controllable:No
Description:Should XFEM update the mesh at the beginning of the timestep

Xfem Fixed Point Iterations Parameters

mffd_typewpSpecifies the finite differencing type for Jacobian-free solve types. Note that the default is wp (for Walker and Pernice).
Default:wp
C++ Type:MooseEnum
Options:wp, ds
Controllable:No
Description:Specifies the finite differencing type for Jacobian-free solve types. Note that the default is wp (for Walker and Pernice).
petsc_optionsSingleton PETSc options
C++ Type:MultiMooseEnum
Options:-dm_moose_print_embedding, -dm_view, -KSP_CONVERGED_REASON, -KSP_GMRES_MODIFIEDGRAMSCHMIDT, -KSP_MONITOR, -KSP_MONITOR_SNES_LG, -SNES_KSP_EW, -KSP_SNES_EW, -SNES_CONVERGED_REASON, -SNES_KSP, -SNES_LINESEARCH_MONITOR, -SNES_MF, -SNES_MF_OPERATOR, -SNES_MONITOR, -SNES_TEST_DISPLAY, -SNES_VIEW, -SNES_MONITOR_CANCEL
Controllable:No
Description:Singleton PETSc options
petsc_options_inameNames of PETSc name/value pairs
C++ Type:MultiMooseEnum
Options:-mat_fd_coloring_err, -mat_fd_type, -mat_mffd_type, -pc_asm_overlap, -pc_factor_levels, -pc_factor_mat_ordering_type, -pc_hypre_boomeramg_grid_sweeps_all, -pc_hypre_boomeramg_max_iter, -pc_hypre_boomeramg_strong_threshold, -pc_hypre_type, -pc_type, -sub_pc_type, -KSP_ATOL, -KSP_GMRES_RESTART, -KSP_MAX_IT, -KSP_PC_SIDE, -KSP_RTOL, -KSP_TYPE, -SUB_KSP_TYPE, -SNES_ATOL, -SNES_LINESEARCH_TYPE, -SNES_LS, -SNES_MAX_IT, -SNES_RTOL, -SNES_DIVERGENCE_TOLERANCE, -SNES_TYPE
Controllable:No
Description:Names of PETSc name/value pairs
petsc_options_valueValues of PETSc name/value pairs (must correspond with "petsc_options_iname"
C++ Type:std::vector<std::string>
Controllable:No
Description:Values of PETSc name/value pairs (must correspond with "petsc_options_iname"

Petsc Parameters

multi_system_fixed_pointFalseWhether to perform fixed point (Picard) iterations between the nonlinear systems.
Default:False
C++ Type:bool
Controllable:No
Description:Whether to perform fixed point (Picard) iterations between the nonlinear systems.
multi_system_fixed_point_convergenceConvergence object to determine the convergence of the multi-system fixed point iteration. If unspecified, defaults to checking that every system is converged (based on their own convergence criterion)
C++ Type:ConvergenceName
Controllable:No
Description:Convergence object to determine the convergence of the multi-system fixed point iteration. If unspecified, defaults to checking that every system is converged (based on their own convergence criterion)
system_namesNames of the solver systems (both linear and nonlinear) that will be solved
C++ Type:std::vector<SolverSystemName>
Controllable:No
Description:Names of the solver systems (both linear and nonlinear) that will be solved

Multiple Solver System Parameters

Restart Parameters

(moose/modules/optimization/include/optimizationreporters/OptimizationReporter.h)

// This file is part of the MOOSE framework
// https://mooseframework.inl.gov
//
// All rights reserved, see COPYRIGHT for full restrictions
// https://github.com/idaholab/moose/blob/master/COPYRIGHT
//
// Licensed under LGPL 2.1, please see LICENSE for details
// https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

#include "OptimizationData.h"
#include "OptimizationReporterBase.h"

/**
 * Computes gradient and contains reporters for communicating between optimizeSolve and subapps
 */
class OptimizationReporter : public OptimizationDataTempl<OptimizationReporterBase>
{

public:
  static InputParameters validParams();
  OptimizationReporter(const InputParameters & parameters);

  virtual Real computeObjective() override;
  virtual void setMisfitToSimulatedValues() override;

protected:
  virtual void setICsandBounds() override;
};

(moose/modules/optimization/test/tests/optimizationreporter/point_loads/main.i)

# 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.
measurement_points = '0.5 0.28 0
   0.5 0.6 0
   0.5 0.8 0
   0.5 1.1 0'
measurement_values = '293 304 315 320'
[Optimization]
[]

[OptimizationReporter]
  type = GeneralOptimization
  objective_name = objective_value
  parameter_names = 'parameter_results'
  num_values = '3'
[]

[Reporters]
  [main]
    type = OptimizationData
    measurement_points = ${measurement_points}
    measurement_values = ${measurement_values}
  []
[]

[Executioner]
  type = Optimize
  tao_solver = taonls
  petsc_options_iname = '-tao_gttol -tao_max_it -tao_nls_pc_type -tao_nls_ksp_type'
  petsc_options_value = '1e-5 10 none cg'
  verbose = true
[]

[MultiApps]
  [forward]
    type = FullSolveMultiApp
    input_files = forward.i
    execute_on = "FORWARD"
  []
  [adjoint]
    type = FullSolveMultiApp
    input_files = adjoint.i
    execute_on = "ADJOINT"
  []
  [homogeneousForward]
    type = FullSolveMultiApp
    input_files = forward_homogeneous.i
    execute_on = "HOMOGENEOUS_FORWARD"
  []
[]

[Transfers]
  # FORWARD transfers
  [toForward_measument]
    type = MultiAppReporterTransfer
    to_multi_app = forward
    from_reporters = 'main/measurement_xcoord
                      main/measurement_ycoord
                      main/measurement_zcoord
                      main/measurement_time
                      main/measurement_values
                      OptimizationReporter/parameter_results'
    to_reporters = 'measure_data/measurement_xcoord
                    measure_data/measurement_ycoord
                    measure_data/measurement_zcoord
                    measure_data/measurement_time
                    measure_data/measurement_values
                    point_source/value'
  []
  [fromForward]
    type = MultiAppReporterTransfer
    from_multi_app = forward
    # Note: We are transferring the misfit values into main misfit
    from_reporters = 'measure_data/objective_value measure_data/misfit_values'
    to_reporters = 'OptimizationReporter/objective_value main/misfit_values'
  []

  # ADJOINT transfers
  #NOTE:  the adjoint variable we are transferring is actually the gradient
  [toAdjoint]
    type = MultiAppReporterTransfer
    to_multi_app = adjoint
    from_reporters = 'main/measurement_xcoord
                      main/measurement_ycoord
                      main/measurement_zcoord
                      main/measurement_time
                      main/misfit_values'
    to_reporters = 'misfit/measurement_xcoord
                    misfit/measurement_ycoord
                    misfit/measurement_zcoord
                    misfit/measurement_time
                    misfit/misfit_values'
  []
  [fromAdjoint]
    type = MultiAppReporterTransfer
    from_multi_app = adjoint
    from_reporters = 'gradient/adjoint'
    to_reporters = 'OptimizationReporter/grad_parameter_results'
  []

  # HESSIAN transfers.  Same as forward.
  [toHomoForward]
    type = MultiAppReporterTransfer
    multi_app = homogeneousForward
    direction = to_multiapp
    from_reporters = 'main/measurement_xcoord
                      main/measurement_ycoord
                      main/measurement_zcoord
                      main/measurement_time
                      main/measurement_values
                      OptimizationReporter/parameter_results'
    to_reporters = 'measure_data/measurement_xcoord
                    measure_data/measurement_ycoord
                    measure_data/measurement_zcoord
                    measure_data/measurement_time
                    measure_data/measurement_values
                    point_source/value'
  []
  [fromHomoForward]
    type = MultiAppReporterTransfer
    multi_app = homogeneousForward
    direction = from_multiapp
    # Note: We are transferring the simulation values into misfit
    # this has to be done when using general opt and homogenous forward.
    from_reporters = 'measure_data/simulation_values'
    to_reporters = 'main/misfit_values'
  []
[]

[Reporters]
  [optInfo]
    type = OptimizationInfo
  []
[]

[Outputs]
  csv = true
[]

Overview
Example Input Syntax
Input Parameters