solveObject to interface with Petsc Tao More...

#include <OptimizeSolve.h>

Inheritance diagram for OptimizeSolve:

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	OptimizeSolve (Executioner &ex)

virtual bool	solve () override

const OptimizationReporterBase &	getOptimizationReporter () const

void	getTaoSolutionStatus (std::vector< int > &tot_iters, std::vector< double > &gnorm, std::vector< int > &obj_iters, std::vector< double > &cnorm, std::vector< int > &grad_iters, std::vector< double > &xdiff, std::vector< int > &hess_iters, std::vector< double > &f, std::vector< int > &tot_solves) const
	Record tao TaoGetSolutionStatus data for output by a reporter.

virtual void	initialSetup ()

virtual void	setInnerSolve (SolveObject &solve)

virtual bool	enabled () const

std::shared_ptr< MooseObject >	getSharedPtr ()

std::shared_ptr< const MooseObject >	getSharedPtr () const

bool	isKokkosObject () const

MooseApp &	getMooseApp () const

const std::string &	type () const

const std::string &	name () const

std::string	typeAndName () const

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

const T &	getParam (const std::string &name) const

std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const

const T *	queryParam (const std::string &name) const

const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const

T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const

bool	isParamValid (const std::string &name) const

bool	isParamSetByUser (const std::string &name) const

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const

void	paramError (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramInfo (const std::string &param, Args... args) const

std::string	messagePrefix (const bool hit_prefix=true) const

std::string	errorPrefix (const std::string &) const

void	mooseError (Args &&... args) const

void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

void	mooseErrorNonPrefixed (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseDeprecatedNoTrace (Args &&... args) const

void	mooseInfo (Args &&... args) const

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const

std::string	getDataFileName (const std::string &param) const

std::string	getDataFileNameByName (const std::string &relative_path) const

std::string	getDataFilePath (const std::string &relative_path) const

PerfGraph &	perfGraph ()

bool	isDefaultPostprocessorValue (const std::string &param_name, const unsigned int index=0) const

bool	hasPostprocessor (const std::string &param_name, const unsigned int index=0) const

bool	hasPostprocessorByName (const PostprocessorName &name) const

std::size_t	coupledPostprocessors (const std::string &param_name) const

const PostprocessorName &	getPostprocessorName (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValue (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValue (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const

virtual const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name) const

virtual const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOlderByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOlderByName (const PostprocessorName &name) const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

static void	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node, const bool show_trace=true)

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console

Static Public Attributes
static const std::string	type_param

static const std::string	name_param

static const std::string	unique_name_param

static const std::string	app_param

static const std::string	moose_base_param

static const std::string	kokkos_object_param

Protected Member Functions
virtual PetscErrorCode	variableBounds (Tao tao)
	Bounds routine.

virtual Real	objectiveFunction ()
	Objective routine.

virtual void	gradientFunction (libMesh::PetscVector< Number > &gradient)
	Gradient routine.

virtual PetscErrorCode	applyHessian (libMesh::PetscVector< Number > &s, libMesh::PetscVector< Number > &Hs)
	Hessian application routine.

OptimizationReporterBase *	getObjFunction ()
	function to get the objective reporter

void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const

std::string	timedSectionName (const std::string &section_name) const

virtual void	addPostprocessorDependencyHelper (const PostprocessorName &) const

Protected Attributes
const libMesh::Parallel::Communicator	_my_comm
	Communicator used for operations.

const ExecFlagEnum &	_solve_on
	List of execute flags for when to solve the system.

OptimizationReporterBase *	_obj_function = nullptr
	objective function defining objective, gradient, and hessian

Tao	_tao
	Tao optimization object.

Executioner &	_executioner

FEProblemBase &	_problem

DisplacedProblem *	_displaced_problem

MooseMesh &	_mesh

MooseMesh *	_displaced_mesh

SystemBase &	_solver_sys

AuxiliarySystem &	_aux

SolveObject *	_inner_solve

const bool &	_enabled

MooseApp &	_app

Factory &	_factory

ActionFactory &	_action_factory

const std::string &	_type

const std::string &	_name

const InputParameters &	_pars

MooseApp &	_pg_moose_app

const std::string	_prefix

const Parallel::Communicator &	_communicator

Private Types
enum class	TaoSolverEnum { NEWTON_TRUST_REGION , BOUNDED_NEWTON_TRUST_REGION , BOUNDED_CONJUGATE_GRADIENT , NEWTON_LINE_SEARCH , BOUNDED_NEWTON_LINE_SEARCH , BOUNDED_QUASI_NEWTON_TRUST_REGION , NEWTON_TRUST_LINE , BOUNDED_NEWTON_TRUST_LINE , NELDER_MEAD , BOUNDED_QUASI_NEWTON_LINE_SEARCH , ORTHANT_QUASI_NEWTON , GRADIENT_PROJECTION_CONJUGATE_GRADIENT , BUNDLE_RISK_MIN , AUGMENTED_LAGRANGIAN_MULTIPLIER_METHOD }
	Enum of tao solver types. More...

Private Member Functions
PetscErrorCode	taoSolve ()
	Here is where we call tao and solve.

void	setTaoSolutionStatus (double f, int its, double gnorm, double cnorm, double xdiff)
	output optimization iteration solve data

PetscErrorCode	taoALCreate ()
	Used for creating petsc structures when using the ALMM algorithm.

PetscErrorCode	taoALDestroy ()
	Used for destroying petsc structures when using the ALMM algorithm.

const PostprocessorName &	getPostprocessorNameInternal (const std::string &param_name, const unsigned int index, const bool allow_default_value=true) const

bool	isDefaultPostprocessorValueByName (const PostprocessorName &name) const

PostprocessorValue	getDefaultPostprocessorValueByName (const PostprocessorName &name) const

void	checkParam (const std::string &param_name, const unsigned int index=std::numeric_limits< unsigned int >::max()) const

bool	postprocessorsAdded () const

const PostprocessorValue &	getPostprocessorValueInternal (const std::string &param_name, unsigned int index, std::size_t t_index) const

const PostprocessorValue &	getPostprocessorValueInternal (const std::string &param_name, unsigned int index, std::size_t t_index) const

const PostprocessorValue &	getPostprocessorValueByNameInternal (const PostprocessorName &name, std::size_t t_index) const

const PostprocessorValue &	getPostprocessorValueByNameInternal (const PostprocessorName &name, std::size_t t_index) const

Static Private Member Functions
static const hit::Node *	getHitNode (const InputParameters &params)

static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)


static PetscErrorCode	objectiveFunctionWrapper (Tao tao, Vec x, Real objective, void ctx)

static PetscErrorCode	hessianFunctionWrapper (Tao tao, Vec x, Mat hessian, Mat pc, void *ctx)

static PetscErrorCode	applyHessianWrapper (Mat H, Vec s, Vec Hs)

static PetscErrorCode	objectiveAndGradientFunctionWrapper (Tao tao, Vec x, Real objective, Vec gradient, void ctx)

static PetscErrorCode	variableBoundsWrapper (Tao, Vec xl, Vec xu, void *ctx)

static PetscErrorCode	monitor (Tao tao, void *ctx)

static PetscErrorCode	equalityFunctionWrapper (Tao tao, Vec x, Vec ce, void *ctx)

static PetscErrorCode	equalityGradientFunctionWrapper (Tao tao, Vec x, Mat gradient_e, Mat gradient_epre, void *ctx)

static PetscErrorCode	inequalityFunctionWrapper (Tao tao, Vec x, Vec ci, void *ctx)

static PetscErrorCode	inequalityGradientFunctionWrapper (Tao tao, Vec x, Mat gradient_i, Mat gradient_ipre, void *ctx)

Private Attributes
bool	_verbose
	control optimization executioner output

bool	_output_opt_iters
	Use time step as the iteration counter for purposes of outputting.

std::vector< int >	_total_iterate_vec
	total solves per iteration

std::vector< int >	_obj_iterate_vec
	number of objective solves per iteration

std::vector< int >	_grad_iterate_vec
	gradient solves per iteration

std::vector< int >	_hess_iterate_vec
	Hessian solves per iteration.

std::vector< int >	_function_solve_vec
	total solves per iteration

std::vector< double >	_f_vec
	objective value per iteration

std::vector< double >	_gnorm_vec
	gradient norm per iteration

std::vector< double >	_cnorm_vec
	infeasibility norm per iteration

std::vector< double >	_xdiff_vec
	step length per iteration

enum OptimizeSolve::TaoSolverEnum	_tao_solver_enum

dof_id_type	_ndof
	Number of parameters being optimized.

std::unique_ptr< libMesh::PetscVector< Number > >	_parameters
	Parameters (solution) given to TAO.

Mat	_hessian
	Hessian (matrix) - usually a matrix-free representation.

Vec	_ce
	Equality constraint vector.

Vec	_ci
	Inequality constraint vector.

Mat	_gradient_e
	Equality constraint gradient.

Mat	_gradient_i
	Inequality constraint gradient.

const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base

const FEProblemBase *	_si_problem

const MooseObject &	_ppi_moose_object

const InputParameters &	_ppi_params

const FEProblemBase &	_ppi_feproblem

std::map< PostprocessorName, std::unique_ptr< PostprocessorValue > >	_default_values


int	_obj_iterate = 0

int	_grad_iterate = 0

int	_hess_iterate = 0


Moose::PetscSupport::PetscOptions	_petsc_options

SolverParams	_solver_params

Detailed Description

solveObject to interface with Petsc Tao

Definition at line 28 of file OptimizeSolve.h.

Member Enumeration Documentation

◆ TaoSolverEnum

enum class OptimizeSolve::TaoSolverEnum

strongprivate

Enum of tao solver types.

Enumerator
NEWTON_TRUST_REGION
BOUNDED_NEWTON_TRUST_REGION
BOUNDED_CONJUGATE_GRADIENT
NEWTON_LINE_SEARCH
BOUNDED_NEWTON_LINE_SEARCH
BOUNDED_QUASI_NEWTON_TRUST_REGION
NEWTON_TRUST_LINE
BOUNDED_NEWTON_TRUST_LINE
NELDER_MEAD
BOUNDED_QUASI_NEWTON_LINE_SEARCH
ORTHANT_QUASI_NEWTON
GRADIENT_PROJECTION_CONJUGATE_GRADIENT
BUNDLE_RISK_MIN
AUGMENTED_LAGRANGIAN_MULTIPLIER_METHOD

Definition at line 154 of file OptimizeSolve.h.

                                 {
    NEWTON_TRUST_REGION,
    BOUNDED_NEWTON_TRUST_REGION,
    BOUNDED_CONJUGATE_GRADIENT,
    NEWTON_LINE_SEARCH,
    BOUNDED_NEWTON_LINE_SEARCH,
    BOUNDED_QUASI_NEWTON_TRUST_REGION,
    NEWTON_TRUST_LINE,
    BOUNDED_NEWTON_TRUST_LINE,
    NELDER_MEAD,
    BOUNDED_QUASI_NEWTON_LINE_SEARCH,
    ORTHANT_QUASI_NEWTON,
    GRADIENT_PROJECTION_CONJUGATE_GRADIENT,
    BUNDLE_RISK_MIN,
    AUGMENTED_LAGRANGIAN_MULTIPLIER_METHOD
  } _tao_solver_enum;

Constructor & Destructor Documentation

◆ OptimizeSolve()

OptimizeSolve::OptimizeSolve ( Executioner & ex )

Definition at line 42 of file OptimizeSolve.C.

  : SolveObject(ex),
    _my_comm(MPI_COMM_SELF),
    _solve_on(getParam<ExecFlagEnum>("solve_on")),
    _verbose(getParam<bool>("verbose")),
    _output_opt_iters(getParam<bool>("output_optimization_iterations")),
    _tao_solver_enum(getParam<MooseEnum>("tao_solver").getEnum<TaoSolverEnum>()),
    _parameters(std::make_unique<libMesh::PetscVector<Number>>(_my_comm))
{
  if (_problem.numThreads() > 1)
    mooseError("OptimizeSolve does not currently support threaded execution");
 
  if (_output_opt_iters && _problem.isTransient())
    mooseDocumentedError(
        "moose", 27225, "Outputting for transient executioners has not been implemented.");
}

Member Function Documentation

◆ applyHessian()

PetscErrorCode OptimizeSolve::applyHessian	(	libMesh::PetscVector< Number > &	s,
		libMesh::PetscVector< Number > &	Hs
	)

protectedvirtual

Hessian application routine.

Definition at line 427 of file OptimizeSolve.C.

{
  PetscFunctionBegin;
  TIME_SECTION("applyHessian", 2, "Hessian forward/adjoint solve");
  // What happens for material inversion when the Hessian
  // is dependent on the parameters? Deal with it later???
  // see notes on how this needs to change for Material inversion
  if (_problem.hasMultiApps() &&
      !_problem.hasMultiApps(OptimizationAppTypes::EXEC_HOMOGENEOUS_FORWARD))
    mooseError("Hessian based optimization algorithms require a sub-app with:\n"
               "   execute_on = HOMOGENEOUS_FORWARD");
  _obj_function->updateParameters(s);
 
  Moose::PetscSupport::petscSetOptions(_petsc_options, _solver_params);
  _problem.execute(OptimizationAppTypes::EXEC_HOMOGENEOUS_FORWARD);
  _problem.restoreMultiApps(OptimizationAppTypes::EXEC_HOMOGENEOUS_FORWARD);
  if (!_problem.execMultiApps(OptimizationAppTypes::EXEC_HOMOGENEOUS_FORWARD))
    mooseError("Homogeneous forward solve multiapp failed!");
  if (_solve_on.isValueSet(OptimizationAppTypes::EXEC_HOMOGENEOUS_FORWARD))
    _inner_solve->solve();
 
  // The adjoint solve below applies the misfit as its source. For the Hessian action, that source
  // is the simulated values from the homogeneous forward solve, so the input must transfer
  // 'simulation_values' from the homogeneous forward sub-app into 'misfit_values'.
  Moose::PetscSupport::petscSetOptions(_petsc_options, _solver_params);
  _problem.execute(OptimizationAppTypes::EXEC_ADJOINT);
  _problem.restoreMultiApps(OptimizationAppTypes::EXEC_ADJOINT);
  if (!_problem.execMultiApps(OptimizationAppTypes::EXEC_ADJOINT))
    mooseError("Adjoint solve multiapp failed!");
  if (_solve_on.isValueSet(OptimizationAppTypes::EXEC_ADJOINT))
    _inner_solve->solve();
 
  _obj_function->computeGradient(Hs);
  _hess_iterate++;
  PetscFunctionReturn(PETSC_SUCCESS);
}

◆ applyHessianWrapper()

PetscErrorCode OptimizeSolve::applyHessianWrapper	(	Mat	H,
		Vec	s,
		Vec	Hs
	)

staticprivate

Definition at line 362 of file OptimizeSolve.C.

{
  void * ctx;
 
  PetscFunctionBegin;
  LibmeshPetscCallQ(MatShellGetContext(H, &ctx));
 
  auto * solver = static_cast<OptimizeSolve *>(ctx);
  libMesh::PetscVector<Number> sbar(s, solver->_my_comm);
  libMesh::PetscVector<Number> Hsbar(Hs, solver->_my_comm);
  return solver->applyHessian(sbar, Hsbar);
}

Referenced by hessianFunctionWrapper().

◆ equalityFunctionWrapper()

PetscErrorCode OptimizeSolve::equalityFunctionWrapper	(	Tao	tao,
		Vec	x,
		Vec	ce,
		void *	ctx
	)

staticprivate

Definition at line 485 of file OptimizeSolve.C.

{
  PetscFunctionBegin;
  // grab the solver
  auto * solver = static_cast<OptimizeSolve *>(ctx);
  libMesh::PetscVector<Number> eq_con(ce, solver->_my_comm);
  // use the OptimizationReporterBase class to actually compute equality constraints
  OptimizationReporterBase * obj_func = solver->getObjFunction();
  obj_func->computeEqualityConstraints(eq_con);
  PetscFunctionReturn(PETSC_SUCCESS);
}

Referenced by taoALCreate().

◆ equalityGradientFunctionWrapper()

PetscErrorCode OptimizeSolve::equalityGradientFunctionWrapper	(	Tao	tao,
		Vec	x,
		Mat	gradient_e,
		Mat	gradient_epre,
		void *	ctx
	)

staticprivate

Definition at line 498 of file OptimizeSolve.C.

{
  PetscFunctionBegin;
  // grab the solver
  auto * solver = static_cast<OptimizeSolve *>(ctx);
  libMesh::PetscMatrix<Number> grad_eq(gradient_e, solver->_my_comm);
  // use the OptimizationReporterBase class to actually compute equality
  // constraints gradient
  OptimizationReporterBase * obj_func = solver->getObjFunction();
  obj_func->computeEqualityGradient(grad_eq);
  PetscFunctionReturn(PETSC_SUCCESS);
}

Referenced by taoALCreate().

◆ getObjFunction()

OptimizationReporterBase * OptimizeSolve::getObjFunction ( )

inlineprotected

function to get the objective reporter

Definition at line 84 of file OptimizeSolve.h.

84{ return _obj_function; }

◆ getOptimizationReporter()

const OptimizationReporterBase & OptimizeSolve::getOptimizationReporter ( ) const

inline

Definition at line 36 of file OptimizeSolve.h.

36{ return *_obj_function; }

◆ getTaoSolutionStatus()

void OptimizeSolve::getTaoSolutionStatus	(	std::vector< int > &	tot_iters,
		std::vector< double > &	gnorm,
		std::vector< int > &	obj_iters,
		std::vector< double > &	cnorm,
		std::vector< int > &	grad_iters,
		std::vector< double > &	xdiff,
		std::vector< int > &	hess_iters,
		std::vector< double > &	f,
		std::vector< int > &	tot_solves
	)		const

Record tao TaoGetSolutionStatus data for output by a reporter.

Parameters

tot_iters	total solves per iteration
gnorm	gradient norm per iteration
obj_iters	number of objective solves per iteration
cnorm	infeasibility norm per iteration
grad_iters	gradient solves per iteration
xdiff	step length per iteration
hess_iters	Hessian solves per iteration
f	objective value per iteration
tot_solves	total solves per iteration

Definition at line 225 of file OptimizeSolve.C.

{
  const auto num = _total_iterate_vec.size();
  tot_iters.resize(num);
  obj_iters.resize(num);
  grad_iters.resize(num);
  hess_iters.resize(num);
  tot_solves.resize(num);
  f.resize(num);
  gnorm.resize(num);
  cnorm.resize(num);
  xdiff.resize(num);
 
  for (const auto i : make_range(num))
  {
    tot_iters[i] = _total_iterate_vec[i];
    obj_iters[i] = _obj_iterate_vec[i];
    grad_iters[i] = _grad_iterate_vec[i];
    hess_iters[i] = _hess_iterate_vec[i];
    tot_solves[i] = _function_solve_vec[i];
    f[i] = _f_vec[i];
    gnorm[i] = _gnorm_vec[i];
    cnorm[i] = _cnorm_vec[i];
    xdiff[i] = _xdiff_vec[i];
  }
}

Referenced by OptimizationInfo::execute().

◆ gradientFunction()

void OptimizeSolve::gradientFunction ( libMesh::PetscVector< Number > & gradient )

protectedvirtual

Gradient routine.

Definition at line 409 of file OptimizeSolve.C.

{
  TIME_SECTION("gradientFunction", 2, "Gradient adjoint solve");
  _obj_function->updateParameters(*_parameters);
 
  Moose::PetscSupport::petscSetOptions(_petsc_options, _solver_params);
  _problem.execute(OptimizationAppTypes::EXEC_ADJOINT);
  _problem.restoreMultiApps(OptimizationAppTypes::EXEC_ADJOINT);
  if (!_problem.execMultiApps(OptimizationAppTypes::EXEC_ADJOINT))
    mooseError("Adjoint solve multiapp failed!");
  if (_solve_on.isValueSet(OptimizationAppTypes::EXEC_ADJOINT))
    _inner_solve->solve();
 
  _grad_iterate++;
  _obj_function->computeGradient(gradient);
}

◆ hessianFunctionWrapper()

PetscErrorCode OptimizeSolve::hessianFunctionWrapper	(	Tao	tao,
		Vec	x,
		Mat	hessian,
		Mat	pc,
		void *	ctx
	)

staticprivate

Definition at line 350 of file OptimizeSolve.C.

{
  PetscFunctionBegin;
  // Define Hessian-vector multiplication routine
  auto * solver = static_cast<OptimizeSolve *>(ctx);
  LibmeshPetscCallQ(MatShellSetOperation(
      solver->_hessian, MATOP_MULT, (void (*)(void))OptimizeSolve::applyHessianWrapper));
  PetscFunctionReturn(PETSC_SUCCESS);
}

Referenced by taoSolve().

◆ inequalityFunctionWrapper()

PetscErrorCode OptimizeSolve::inequalityFunctionWrapper	(	Tao	tao,
		Vec	x,
		Vec	ci,
		void *	ctx
	)

staticprivate

Definition at line 513 of file OptimizeSolve.C.

{
  PetscFunctionBegin;
  // grab the solver
  auto * solver = static_cast<OptimizeSolve *>(ctx);
  libMesh::PetscVector<Number> ineq_con(ci, solver->_my_comm);
  // use the OptimizationReporterBase class to actually compute equality constraints
  OptimizationReporterBase * obj_func = solver->getObjFunction();
  obj_func->computeInequalityConstraints(ineq_con);
  PetscFunctionReturn(PETSC_SUCCESS);
}

Referenced by taoALCreate().

◆ inequalityGradientFunctionWrapper()

PetscErrorCode OptimizeSolve::inequalityGradientFunctionWrapper	(	Tao	tao,
		Vec	x,
		Mat	gradient_i,
		Mat	gradient_ipre,
		void *	ctx
	)

staticprivate

Definition at line 526 of file OptimizeSolve.C.

{
  PetscFunctionBegin;
  // grab the solver
  auto * solver = static_cast<OptimizeSolve *>(ctx);
  libMesh::PetscMatrix<Number> grad_ineq(gradient_i, solver->_my_comm);
  // use the OptimizationReporterBase class to actually compute equality
  // constraints gradient
  OptimizationReporterBase * obj_func = solver->getObjFunction();
  obj_func->computeInequalityGradient(grad_ineq);
  PetscFunctionReturn(PETSC_SUCCESS);
}

Referenced by taoALCreate().

◆ monitor()

PetscErrorCode OptimizeSolve::monitor	(	Tao	tao,
		void *	ctx
	)

staticprivate

Definition at line 303 of file OptimizeSolve.C.

{
  TaoConvergedReason reason;
  PetscInt its;
  PetscReal f, gnorm, cnorm, xdiff;
 
  PetscFunctionBegin;
  LibmeshPetscCallQ(TaoGetSolutionStatus(tao, &its, &f, &gnorm, &cnorm, &xdiff, &reason));
 
  auto * solver = static_cast<OptimizeSolve *>(ctx);
  solver->setTaoSolutionStatus((double)f, (int)its, (double)gnorm, (double)cnorm, (double)xdiff);
 
  PetscFunctionReturn(PETSC_SUCCESS);
}

Referenced by taoSolve().

◆ objectiveAndGradientFunctionWrapper()

PetscErrorCode OptimizeSolve::objectiveAndGradientFunctionWrapper	(	Tao	tao,
		Vec	x,
		Real *	objective,
		Vec	gradient,
		void *	ctx
	)

staticprivate

Definition at line 333 of file OptimizeSolve.C.

{
  PetscFunctionBegin;
  auto * solver = static_cast<OptimizeSolve *>(ctx);
 
  libMesh::PetscVector<Number> param(x, solver->_my_comm);
  solver->_parameters->swap(param);
 
  (*objective) = solver->objectiveFunction();
  libMesh::PetscVector<Number> grad(gradient, solver->_my_comm);
  solver->gradientFunction(grad);
  solver->_parameters->swap(param);
  PetscFunctionReturn(PETSC_SUCCESS);
}

Referenced by taoSolve().

◆ objectiveFunction()

Real OptimizeSolve::objectiveFunction ( )

protectedvirtual

Objective routine.

Definition at line 386 of file OptimizeSolve.C.

{
  TIME_SECTION("objectiveFunction", 2, "Objective forward solve");
  _obj_function->updateParameters(*_parameters);
 
  Moose::PetscSupport::petscSetOptions(_petsc_options, _solver_params);
  _problem.execute(OptimizationAppTypes::EXEC_FORWARD);
 
  _problem.restoreMultiApps(OptimizationAppTypes::EXEC_FORWARD);
  if (!_problem.execMultiApps(OptimizationAppTypes::EXEC_FORWARD))
  {
    // We do this so we can output for failed solves.
    _problem.outputStep(OptimizationAppTypes::EXEC_FORWARD);
    mooseError("Forward solve multiapp failed!");
  }
  if (_solve_on.isValueSet(OptimizationAppTypes::EXEC_FORWARD))
    _inner_solve->solve();
 
  _obj_iterate++;
  return _obj_function->computeObjective();
}

◆ objectiveFunctionWrapper()

PetscErrorCode OptimizeSolve::objectiveFunctionWrapper	(	Tao	tao,
		Vec	x,
		Real *	objective,
		void *	ctx
	)

staticprivate

Function wrappers for tao

Definition at line 319 of file OptimizeSolve.C.

{
  PetscFunctionBegin;
  auto * solver = static_cast<OptimizeSolve *>(ctx);
 
  libMesh::PetscVector<Number> param(x, solver->_my_comm);
  solver->_parameters->swap(param);
 
  (*objective) = solver->objectiveFunction();
  solver->_parameters->swap(param);
  PetscFunctionReturn(PETSC_SUCCESS);
}

Referenced by taoSolve().

◆ setTaoSolutionStatus()

void OptimizeSolve::setTaoSolutionStatus	(	double	f,
		int	its,
		double	gnorm,
		double	cnorm,
		double	xdiff
	)

private

output optimization iteration solve data

Definition at line 261 of file OptimizeSolve.C.

{
  // set data from TAO
  _total_iterate_vec.push_back(its);
  _f_vec.push_back(f);
  _gnorm_vec.push_back(gnorm);
  _cnorm_vec.push_back(cnorm);
  _xdiff_vec.push_back(xdiff);
  // set data we collect on this optimization iteration and then reset for next iteration
  _obj_iterate_vec.push_back(_obj_iterate);
  _grad_iterate_vec.push_back(_grad_iterate);
  _hess_iterate_vec.push_back(_hess_iterate);
  // count total number of FE solves
  int solves = _obj_iterate + _grad_iterate + 2 * _hess_iterate;
  _function_solve_vec.push_back(solves);
  _obj_iterate = 0;
  _grad_iterate = 0;
  _hess_iterate = 0;
 
  // Pass down the iteration number if the subapp is of the Steady/SteadyAndAdjoint type.
  // This enables exodus per-iteration output.
  for (auto & sub_app : _app.getExecutioner()->feProblem().getMultiAppWarehouse().getObjects())
  {
    if (auto steady = dynamic_cast<Steady *>(sub_app->getExecutioner(0)))
      steady->setIterationNumberOutput((unsigned int)its);
  }
 
  // Output the converged iteration outputs
  _problem.outputStep(OptimizationAppTypes::EXEC_FORWARD);
 
  // Increment timestep. In steady problems timestep = time for outputting.
  // See Output.C
  if (_output_opt_iters)
    _problem.timeStep() += 1;
 
  // print verbose per iteration output
  if (_verbose)
    _console << "TAO SOLVER: iteration=" << its << "\tf=" << f << "\tgnorm=" << gnorm
             << "\tcnorm=" << cnorm << "\txdiff=" << xdiff << std::endl;
}

Referenced by monitor().

◆ solve()

bool OptimizeSolve::solve ( )

overridevirtual

Implements SolveObject.

Definition at line 60 of file OptimizeSolve.C.

{
  TIME_SECTION("optimizeSolve", 1, "Optimization Solve");
  // Initial solve
  _inner_solve->solve();
 
  // Grab objective function
  if (!_problem.hasUserObject("OptimizationReporter"))
    mooseError("No OptimizationReporter object found.");
  _obj_function = &_problem.getUserObject<OptimizationReporterBase>("OptimizationReporter");
 
  // Initialize solution and matrix
  _obj_function->setInitialCondition(*_parameters);
  _ndof = _parameters->size();
 
  // time step defaults 1, we want to start at 0 for first iteration to be
  // consistent with TAO iterations.
  if (_output_opt_iters)
    _problem.timeStep() = 0;
  bool solveInfo = (taoSolve() == 0);
  return solveInfo;
}

Referenced by Optimize::execute().

◆ taoALCreate()

PetscErrorCode OptimizeSolve::taoALCreate ( )

private

Used for creating petsc structures when using the ALMM algorithm.

Definition at line 541 of file OptimizeSolve.C.

{
  PetscFunctionBegin;
  if (_obj_function->getNumEqCons())
  {
    // Create equality vector
    LibmeshPetscCallQ(VecCreate(_my_comm.get(), &_ce));
    LibmeshPetscCallQ(
        VecSetSizes(_ce, _obj_function->getNumEqCons(), _obj_function->getNumEqCons()));
    LibmeshPetscCallQ(VecSetFromOptions(_ce));
    LibmeshPetscCallQ(VecSetUp(_ce));
 
    // Set equality jacobian matrix
    LibmeshPetscCallQ(MatCreate(_my_comm.get(), &_gradient_e));
    LibmeshPetscCallQ(MatSetSizes(
        _gradient_e, _obj_function->getNumEqCons(), _ndof, _obj_function->getNumEqCons(), _ndof));
    LibmeshPetscCallQ(MatSetFromOptions(_gradient_e));
    LibmeshPetscCallQ(MatSetUp(_gradient_e));
 
    // Set the Equality Constraints
    LibmeshPetscCallQ(TaoSetEqualityConstraintsRoutine(_tao, _ce, equalityFunctionWrapper, this));
 
    // Set the Equality Constraints Jacobian
    LibmeshPetscCallQ(TaoSetJacobianEqualityRoutine(
        _tao, _gradient_e, _gradient_e, equalityGradientFunctionWrapper, this));
  }
 
  if (_obj_function->getNumInEqCons())
  {
    // Create inequality vector
    LibmeshPetscCallQ(VecCreate(_my_comm.get(), &_ci));
    LibmeshPetscCallQ(
        VecSetSizes(_ci, _obj_function->getNumInEqCons(), _obj_function->getNumInEqCons()));
    LibmeshPetscCallQ(VecSetFromOptions(_ci));
    LibmeshPetscCallQ(VecSetUp(_ci));
 
    // Set inequality jacobian matrix
    LibmeshPetscCallQ(MatCreate(_my_comm.get(), &_gradient_i));
    LibmeshPetscCallQ(MatSetSizes(_gradient_i,
                                  _obj_function->getNumInEqCons(),
                                  _ndof,
                                  _obj_function->getNumInEqCons(),
                                  _ndof));
    LibmeshPetscCallQ(MatSetFromOptions(_gradient_i));
    LibmeshPetscCallQ(MatSetUp(_gradient_i));
 
    // Set the Inequality constraints
    LibmeshPetscCallQ(
        TaoSetInequalityConstraintsRoutine(_tao, _ci, inequalityFunctionWrapper, this));
 
    // Set the Inequality constraints Jacobian
    LibmeshPetscCallQ(TaoSetJacobianInequalityRoutine(
        _tao, _gradient_i, _gradient_i, inequalityGradientFunctionWrapper, this));
  }
  PetscFunctionReturn(PETSC_SUCCESS);
}

Referenced by taoSolve().

◆ taoALDestroy()

PetscErrorCode OptimizeSolve::taoALDestroy ( )

private

Used for destroying petsc structures when using the ALMM algorithm.

Definition at line 599 of file OptimizeSolve.C.

{
  PetscFunctionBegin;
  if (_obj_function->getNumEqCons())
  {
    LibmeshPetscCallQ(VecDestroy(&_ce));
    LibmeshPetscCallQ(MatDestroy(&_gradient_e));
  }
  if (_obj_function->getNumInEqCons())
  {
    LibmeshPetscCallQ(VecDestroy(&_ci));
    LibmeshPetscCallQ(MatDestroy(&_gradient_i));
  }
 
  PetscFunctionReturn(PETSC_SUCCESS);
}

Referenced by taoSolve().

◆ taoSolve()

PetscErrorCode OptimizeSolve::taoSolve ( )

private

Here is where we call tao and solve.

Definition at line 84 of file OptimizeSolve.C.

{
  PetscFunctionBegin;
  // Initialize tao object
  LibmeshPetscCallQ(TaoCreate(_my_comm.get(), &_tao));
 
#if PETSC_RELEASE_LESS_THAN(3, 21, 0)
  LibmeshPetscCallQ(TaoSetMonitor(_tao, monitor, this, nullptr));
#else
  LibmeshPetscCallQ(TaoMonitorSet(_tao, monitor, this, nullptr));
#endif
 
  switch (_tao_solver_enum)
  {
    case TaoSolverEnum::NEWTON_TRUST_REGION:
      LibmeshPetscCallQ(TaoSetType(_tao, TAONTR));
      break;
    case TaoSolverEnum::BOUNDED_NEWTON_TRUST_REGION:
      LibmeshPetscCallQ(TaoSetType(_tao, TAOBNTR));
      break;
    case TaoSolverEnum::BOUNDED_CONJUGATE_GRADIENT:
      LibmeshPetscCallQ(TaoSetType(_tao, TAOBNCG));
      break;
    case TaoSolverEnum::NEWTON_LINE_SEARCH:
      LibmeshPetscCallQ(TaoSetType(_tao, TAONLS));
      break;
    case TaoSolverEnum::BOUNDED_NEWTON_LINE_SEARCH:
      LibmeshPetscCallQ(TaoSetType(_tao, TAOBNLS));
      break;
    case TaoSolverEnum::BOUNDED_QUASI_NEWTON_TRUST_REGION:
      LibmeshPetscCallQ(TaoSetType(_tao, TAOBQNKTR));
      break;
    case TaoSolverEnum::NEWTON_TRUST_LINE:
      LibmeshPetscCallQ(TaoSetType(_tao, TAONTL));
      break;
    case TaoSolverEnum::BOUNDED_NEWTON_TRUST_LINE:
      LibmeshPetscCallQ(TaoSetType(_tao, TAOBNTL));
      break;
    case TaoSolverEnum::NELDER_MEAD:
      LibmeshPetscCallQ(TaoSetType(_tao, TAONM));
      break;
 
    case TaoSolverEnum::BOUNDED_QUASI_NEWTON_LINE_SEARCH:
      LibmeshPetscCallQ(TaoSetType(_tao, TAOBQNLS));
      break;
    case TaoSolverEnum::ORTHANT_QUASI_NEWTON:
      LibmeshPetscCallQ(TaoSetType(_tao, TAOOWLQN));
      break;
    case TaoSolverEnum::GRADIENT_PROJECTION_CONJUGATE_GRADIENT:
      LibmeshPetscCallQ(TaoSetType(_tao, TAOGPCG));
      break;
    case TaoSolverEnum::BUNDLE_RISK_MIN:
      LibmeshPetscCallQ(TaoSetType(_tao, TAOBMRM));
      break;
    case TaoSolverEnum::AUGMENTED_LAGRANGIAN_MULTIPLIER_METHOD:
#if !PETSC_VERSION_LESS_THAN(3, 15, 0)
      LibmeshPetscCallQ(TaoSetType(_tao, TAOALMM));
      // Need to cancel monitors for ALMM, if not there is a segfault at MOOSE destruction. Setup
      // default constraint monitor.
#if PETSC_RELEASE_GREATER_EQUALS(3, 21, 0)
      LibmeshPetscCallQ(TaoMonitorCancel(_tao));
#else
      LibmeshPetscCallQ(TaoCancelMonitors(_tao));
#endif
      LibmeshPetscCallQ(PetscOptionsSetValue(NULL, "-tao_cmonitor", NULL));
      break;
#else
      mooseError("ALMM is only compatible with PETSc versions above 3.14. ");
#endif
 
    default:
      mooseError("Invalid Tao solve type");
  }
 
    // Set objective and gradient functions
#if !PETSC_VERSION_LESS_THAN(3, 17, 0)
  LibmeshPetscCallQ(TaoSetObjective(_tao, objectiveFunctionWrapper, this));
#else
  LibmeshPetscCallQ(TaoSetObjectiveRoutine(_tao, objectiveFunctionWrapper, this));
#endif
#if !PETSC_VERSION_LESS_THAN(3, 17, 0)
  LibmeshPetscCallQ(
      TaoSetObjectiveAndGradient(_tao, NULL, objectiveAndGradientFunctionWrapper, this));
#else
  LibmeshPetscCallQ(
      TaoSetObjectiveAndGradientRoutine(_tao, objectiveAndGradientFunctionWrapper, this));
#endif
 
  // Set matrix-free version of the Hessian function
  LibmeshPetscCallQ(MatCreateShell(_my_comm.get(), _ndof, _ndof, _ndof, _ndof, this, &_hessian));
  // Link matrix-free Hessian to Tao
#if !PETSC_VERSION_LESS_THAN(3, 17, 0)
  LibmeshPetscCallQ(TaoSetHessian(_tao, _hessian, _hessian, hessianFunctionWrapper, this));
#else
  LibmeshPetscCallQ(TaoSetHessianRoutine(_tao, _hessian, _hessian, hessianFunctionWrapper, this));
#endif
 
  // Set initial guess
#if !PETSC_VERSION_LESS_THAN(3, 17, 0)
  LibmeshPetscCallQ(TaoSetSolution(_tao, _parameters->vec()));
#else
  LibmeshPetscCallQ(TaoSetInitialVector(_tao, _parameters->vec()));
#endif
 
  // Set TAO petsc options
  LibmeshPetscCallQ(TaoSetFromOptions(_tao));
 
  // save nonTAO PETSC options to reset before every call to execute()
  _petsc_options = _problem.getPetscOptions();
  // We only use a single system solve at this point
  _solver_params = _problem.solverParams(0);
 
  // Set bounds for bounded optimization
  LibmeshPetscCallQ(TaoSetVariableBoundsRoutine(_tao, variableBoundsWrapper, this));
 
  if (_tao_solver_enum == TaoSolverEnum::AUGMENTED_LAGRANGIAN_MULTIPLIER_METHOD)
    LibmeshPetscCallQ(taoALCreate());
 
  // Backup multiapps so transient problems start with the same initial condition
  _problem.backupMultiApps(OptimizationAppTypes::EXEC_FORWARD);
  _problem.backupMultiApps(OptimizationAppTypes::EXEC_ADJOINT);
  _problem.backupMultiApps(OptimizationAppTypes::EXEC_HOMOGENEOUS_FORWARD);
 
  // Solve optimization
  LibmeshPetscCallQ(TaoSolve(_tao));
 
  // Print solve statistics
  if (getParam<bool>("verbose"))
    LibmeshPetscCallQ(TaoView(_tao, PETSC_VIEWER_STDOUT_WORLD));
 
  LibmeshPetscCallQ(TaoDestroy(&_tao));
 
  LibmeshPetscCallQ(MatDestroy(&_hessian));
 
  if (_tao_solver_enum == TaoSolverEnum::AUGMENTED_LAGRANGIAN_MULTIPLIER_METHOD)
    LibmeshPetscCallQ(taoALDestroy());
 
  PetscFunctionReturn(PETSC_SUCCESS);
}

Referenced by solve().

◆ validParams()

InputParameters OptimizeSolve::validParams ( )

static

Definition at line 18 of file OptimizeSolve.C.

{
  InputParameters params = emptyInputParameters();
  MooseEnum tao_solver_enum("taontr taobntr taobncg taonls taobnls taobqnktr taontl taobntl "
                            "taonm taobqnls taoowlqn taogpcg taobmrm taoalmm");
  params.addRequiredParam<MooseEnum>(
      "tao_solver", tao_solver_enum, "Tao solver to use for optimization.");
  ExecFlagEnum exec_enum = ExecFlagEnum();
  exec_enum.addAvailableFlags(EXEC_NONE,
                              OptimizationAppTypes::EXEC_FORWARD,
                              OptimizationAppTypes::EXEC_ADJOINT,
                              OptimizationAppTypes::EXEC_HOMOGENEOUS_FORWARD);
  exec_enum = {OptimizationAppTypes::EXEC_FORWARD,
               OptimizationAppTypes::EXEC_ADJOINT,
               OptimizationAppTypes::EXEC_HOMOGENEOUS_FORWARD};
  params.addParam<ExecFlagEnum>(
      "solve_on", exec_enum, "List of flags indicating when inner system solve should occur.");
  params.addParam<bool>(
      "output_optimization_iterations",
      false,
      "Use the time step as the current iteration for outputting optimization history.");
  return params;
}

Referenced by Optimize::validParams().

◆ variableBounds()

PetscErrorCode OptimizeSolve::variableBounds ( Tao tao )

protectedvirtual

Bounds routine.

Definition at line 465 of file OptimizeSolve.C.

{
  PetscFunctionBegin;
  unsigned int sz = _obj_function->getNumParams();
 
  libMesh::PetscVector<Number> xl(_my_comm, sz);
  libMesh::PetscVector<Number> xu(_my_comm, sz);
 
  // copy values from upper and lower bounds to xl and xu
  for (const auto i : make_range(sz))
  {
    xl.set(i, _obj_function->getLowerBound(i));
    xu.set(i, _obj_function->getUpperBound(i));
  }
  // set upper and lower bounds in tao solver
  LibmeshPetscCallQ(TaoSetVariableBounds(tao, xl.vec(), xu.vec()));
  PetscFunctionReturn(PETSC_SUCCESS);
}

◆ variableBoundsWrapper()

PetscErrorCode OptimizeSolve::variableBoundsWrapper	(	Tao	tao,
		Vec	xl,
		Vec	xu,
		void *	ctx
	)

staticprivate

Definition at line 376 of file OptimizeSolve.C.

{
  PetscFunctionBegin;
  auto * solver = static_cast<OptimizeSolve *>(ctx);
 
  LibmeshPetscCallQ(solver->variableBounds(tao));
  PetscFunctionReturn(PETSC_SUCCESS);
}

Referenced by taoSolve().

Member Data Documentation

◆ _ce

Vec OptimizeSolve::_ce

private

Equality constraint vector.

Definition at line 181 of file OptimizeSolve.h.

Referenced by taoALCreate(), and taoALDestroy().

◆ _ci

Vec OptimizeSolve::_ci

private

Inequality constraint vector.

Definition at line 184 of file OptimizeSolve.h.

Referenced by taoALCreate(), and taoALDestroy().

◆ _cnorm_vec

std::vector<double> OptimizeSolve::_cnorm_vec

private

infeasibility norm per iteration

Definition at line 117 of file OptimizeSolve.h.

Referenced by getTaoSolutionStatus(), and setTaoSolutionStatus().

◆ _f_vec

std::vector<double> OptimizeSolve::_f_vec

private

objective value per iteration

Definition at line 113 of file OptimizeSolve.h.

Referenced by getTaoSolutionStatus(), and setTaoSolutionStatus().

◆ _function_solve_vec

std::vector<int> OptimizeSolve::_function_solve_vec

private

total solves per iteration

Definition at line 111 of file OptimizeSolve.h.

Referenced by getTaoSolutionStatus(), and setTaoSolutionStatus().

◆ _gnorm_vec

std::vector<double> OptimizeSolve::_gnorm_vec

private

gradient norm per iteration

Definition at line 115 of file OptimizeSolve.h.

Referenced by getTaoSolutionStatus(), and setTaoSolutionStatus().

◆ _grad_iterate

int OptimizeSolve::_grad_iterate = 0

private

Definition at line 99 of file OptimizeSolve.h.

Referenced by gradientFunction(), and setTaoSolutionStatus().

◆ _grad_iterate_vec

std::vector<int> OptimizeSolve::_grad_iterate_vec

private

gradient solves per iteration

Definition at line 107 of file OptimizeSolve.h.

Referenced by getTaoSolutionStatus(), and setTaoSolutionStatus().

◆ _gradient_e

Mat OptimizeSolve::_gradient_e

private

Equality constraint gradient.

Definition at line 187 of file OptimizeSolve.h.

Referenced by taoALCreate(), and taoALDestroy().

◆ _gradient_i

Mat OptimizeSolve::_gradient_i

private

Inequality constraint gradient.

Definition at line 190 of file OptimizeSolve.h.

Referenced by taoALCreate(), and taoALDestroy().

◆ _hess_iterate

int OptimizeSolve::_hess_iterate = 0

private

Definition at line 100 of file OptimizeSolve.h.

Referenced by applyHessian(), and setTaoSolutionStatus().

◆ _hess_iterate_vec

std::vector<int> OptimizeSolve::_hess_iterate_vec

private

Hessian solves per iteration.

Definition at line 109 of file OptimizeSolve.h.

Referenced by getTaoSolutionStatus(), and setTaoSolutionStatus().

◆ _hessian

Mat OptimizeSolve::_hessian

private

Hessian (matrix) - usually a matrix-free representation.

Definition at line 178 of file OptimizeSolve.h.

Referenced by taoSolve().

◆ _my_comm

const libMesh::Parallel::Communicator OptimizeSolve::_my_comm

protected

Communicator used for operations.

Definition at line 75 of file OptimizeSolve.h.

Referenced by taoALCreate(), taoSolve(), and variableBounds().

◆ _ndof

dof_id_type OptimizeSolve::_ndof

private

Number of parameters being optimized.

Definition at line 172 of file OptimizeSolve.h.

Referenced by solve(), taoALCreate(), and taoSolve().

◆ _obj_function

OptimizationReporterBase* OptimizeSolve::_obj_function = nullptr

protected

objective function defining objective, gradient, and hessian

Definition at line 81 of file OptimizeSolve.h.

Referenced by applyHessian(), getObjFunction(), getOptimizationReporter(), gradientFunction(), objectiveFunction(), solve(), taoALCreate(), taoALDestroy(), and variableBounds().

◆ _obj_iterate

int OptimizeSolve::_obj_iterate = 0

private

count individual solves for output

Definition at line 98 of file OptimizeSolve.h.

Referenced by objectiveFunction(), and setTaoSolutionStatus().

◆ _obj_iterate_vec

std::vector<int> OptimizeSolve::_obj_iterate_vec

private

number of objective solves per iteration

Definition at line 105 of file OptimizeSolve.h.

Referenced by getTaoSolutionStatus(), and setTaoSolutionStatus().

◆ _output_opt_iters

bool OptimizeSolve::_output_opt_iters

private

Use time step as the iteration counter for purposes of outputting.

Definition at line 94 of file OptimizeSolve.h.

Referenced by OptimizeSolve(), setTaoSolutionStatus(), and solve().

◆ _parameters

std::unique_ptr<libMesh::PetscVector<Number> > OptimizeSolve::_parameters

private

Parameters (solution) given to TAO.

Definition at line 175 of file OptimizeSolve.h.

Referenced by gradientFunction(), objectiveFunction(), solve(), and taoSolve().

◆ _petsc_options

Moose::PetscSupport::PetscOptions OptimizeSolve::_petsc_options

private

These are needed to reset the petsc options for the optimization solve using Moose::PetscSupport::petscSetOptions This only sets the finite difference options, the other optimizeSolve options are set-up in TAO using TaoSetFromOptions()

Definition at line 126 of file OptimizeSolve.h.

Referenced by applyHessian(), gradientFunction(), objectiveFunction(), and taoSolve().

◆ _solve_on

const ExecFlagEnum& OptimizeSolve::_solve_on

protected

List of execute flags for when to solve the system.

Definition at line 78 of file OptimizeSolve.h.

Referenced by applyHessian(), gradientFunction(), and objectiveFunction().

◆ _solver_params

SolverParams OptimizeSolve::_solver_params

private

Definition at line 127 of file OptimizeSolve.h.

Referenced by applyHessian(), gradientFunction(), objectiveFunction(), and taoSolve().

◆ _tao

Tao OptimizeSolve::_tao

protected

Tao optimization object.

Definition at line 87 of file OptimizeSolve.h.

Referenced by taoALCreate(), and taoSolve().

◆ _tao_solver_enum

enum OptimizeSolve::TaoSolverEnum OptimizeSolve::_tao_solver_enum

private

Referenced by taoSolve().

◆ _total_iterate_vec

std::vector<int> OptimizeSolve::_total_iterate_vec

private

total solves per iteration

Definition at line 103 of file OptimizeSolve.h.

Referenced by getTaoSolutionStatus(), and setTaoSolutionStatus().

◆ _verbose

bool OptimizeSolve::_verbose

private

control optimization executioner output

Definition at line 91 of file OptimizeSolve.h.

Referenced by setTaoSolutionStatus().

◆ _xdiff_vec

std::vector<double> OptimizeSolve::_xdiff_vec

private

step length per iteration

Definition at line 119 of file OptimizeSolve.h.

Referenced by getTaoSolutionStatus(), and setTaoSolutionStatus().

The documentation for this class was generated from the following files:

optimization/include/executioners/OptimizeSolve.h
optimization/src/executioners/OptimizeSolve.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ TaoSolverEnum

Constructor & Destructor Documentation

◆ OptimizeSolve()

Member Function Documentation

◆ applyHessian()

◆ applyHessianWrapper()

◆ equalityFunctionWrapper()

◆ equalityGradientFunctionWrapper()

◆ getObjFunction()

◆ getOptimizationReporter()

◆ getTaoSolutionStatus()

◆ gradientFunction()

◆ hessianFunctionWrapper()

◆ inequalityFunctionWrapper()

◆ inequalityGradientFunctionWrapper()

◆ monitor()

◆ objectiveAndGradientFunctionWrapper()

◆ objectiveFunction()

◆ objectiveFunctionWrapper()

◆ setTaoSolutionStatus()

◆ solve()

◆ taoALCreate()

◆ taoALDestroy()

◆ taoSolve()

◆ validParams()

◆ variableBounds()

◆ variableBoundsWrapper()

Member Data Documentation

◆ _ce

◆ _ci

◆ _cnorm_vec

◆ _f_vec

◆ _function_solve_vec

◆ _gnorm_vec

◆ _grad_iterate

◆ _grad_iterate_vec

◆ _gradient_e

◆ _gradient_i

◆ _hess_iterate

◆ _hess_iterate_vec

◆ _hessian

◆ _my_comm

◆ _ndof

◆ _obj_function

◆ _obj_iterate

◆ _obj_iterate_vec

◆ _output_opt_iters

◆ _parameters

◆ _petsc_options

◆ _solve_on

◆ _solver_params

◆ _tao

◆ _tao_solver_enum

◆ _total_iterate_vec

◆ _verbose

◆ _xdiff_vec