Interface for TAO solvers. More...

#include "src/petsc/TaoCtx.hpp"

Collaboration diagram for MoFEM::TaoCtx:

Public Types
using	PairNameFEMethodPtr = MoFEM::PairNameFEMethodPtr

using	FEMethodsSequence = MoFEM::FEMethodsSequence

using	BasicMethodsSequence = MoFEM::BasicMethodsSequence

using	ObjectiveHook = boost::function< MoFEMErrorCode(Tao tao, Vec x, PetscReal *objective)>

using	GradientHook = boost::function< MoFEMErrorCode(Tao tao, Vec x, Vec gradient)>

using	ObjectiveAndGradientHook = boost::function< MoFEMErrorCode(Tao tao, Vec x, PetscReal *objective, Vec gradient)>

Public Member Functions
	TaoCtx (Interface &m_field, const std::string &problem_name)

virtual	~TaoCtx ()=default

FEMethodsSequence &	getHessianLoops ()

BasicMethodsSequence &	getPreProcHessian ()

BasicMethodsSequence &	getPostProcHessian ()

FEMethodsSequence &	getObjectiveLoops ()

BasicMethodsSequence &	getPreProcObjective ()

BasicMethodsSequence &	getPostProcObjective ()

FEMethodsSequence &	getGradientLoops ()

BasicMethodsSequence &	getPreProcGradient ()

BasicMethodsSequence &	getPostProcGradient ()

FEMethodsSequence &	getEqualityConstraintLoops ()

BasicMethodsSequence &	getPreProcEqualityConstraint ()

BasicMethodsSequence &	getPostProcEqualityConstraint ()

FEMethodsSequence &	getInequalityConstraintLoops ()

BasicMethodsSequence &	getPreProcInequalityConstraint ()

BasicMethodsSequence &	getPostProcInequalityConstraint ()

FEMethodsSequence &	getEqualityJacobianLoops ()

BasicMethodsSequence &	getPreProcEqualityJacobian ()

BasicMethodsSequence &	getPostProcEqualityJacobian ()

FEMethodsSequence &	getInequalityJacobianLoops ()

BasicMethodsSequence &	getPreProcInequalityJacobian ()

BasicMethodsSequence &	getPostProcInequalityJacobian ()

ObjectiveHook &	getObjectiveHook ()
	Get an optional objective evaluator.

GradientHook &	getGradientHook ()
	Get an optional gradient evaluator.

ObjectiveAndGradientHook &	getObjectiveAndGradientHook ()
	Get an optional combined objective-and-gradient evaluator.

MoFEMErrorCode	copyLoops (const TaoCtx &tao_ctx)
	Copy sequences from another TaoCtx.

MoFEMErrorCode	clearLoops ()
	Clear loops.

Public Attributes
MoFEM::Interface &	mField
	database Interface

moab::Interface &	moab
	moab Interface

std::string	problemName
	problem name

bool	vErify
	If true verify vector.

FEMethodsSequence	loopsHessian

FEMethodsSequence	loopsObjective

FEMethodsSequence	loopsGradient

FEMethodsSequence	loopsEqualityConstraint

FEMethodsSequence	loopsInequalityConstraint

FEMethodsSequence	loopsEqualityJacobian

FEMethodsSequence	loopsInequalityJacobian

BasicMethodsSequence	preHessian
	Sequence of methods run before Hessian is assembled.

BasicMethodsSequence	postHessian
	Sequence of methods run after Hessian is assembled.

BasicMethodsSequence	preObjective
	Sequence of methods run before objective is evaluated.

BasicMethodsSequence	postObjective
	Sequence of methods run after objective is evaluated.

BasicMethodsSequence	preGradient
	Sequence of methods run before gradient is assembled.

BasicMethodsSequence	postGradient
	Sequence of methods run after gradient is assembled.

BasicMethodsSequence	preEqualityConstraint

BasicMethodsSequence	postEqualityConstraint

BasicMethodsSequence	preInequalityConstraint

BasicMethodsSequence	postInequalityConstraint

BasicMethodsSequence	preEqualityJacobian

BasicMethodsSequence	postEqualityJacobian

BasicMethodsSequence	preInequalityJacobian

BasicMethodsSequence	postInequalityJacobian

Private Member Functions
PetscErrorCode	evaluateConstraint (Tao tao, Vec x, Vec c, FEMethodsSequence &loops, BasicMethodsSequence &pre_process, BasicMethodsSequence &post_process, TaoMethod::TAOContext evaluation_context, PetscLogEvent log_event)

PetscErrorCode	evaluateConstraintJacobian (Tao tao, Vec x, Mat J, Mat Jpre, FEMethodsSequence &loops, BasicMethodsSequence &pre_process, BasicMethodsSequence &post_process, TaoMethod::TAOContext evaluation_context, PetscLogEvent log_event)

Private Attributes
ObjectiveHook	objectiveHook

GradientHook	gradientHook

ObjectiveAndGradientHook	objectiveAndGradientHook

boost::movelib::unique_ptr< bool >	vecAssembleSwitch

boost::movelib::unique_ptr< bool >	matAssembleSwitch

PetscLogEvent	MOFEM_EVENT_TaoHessian
	Log event for TAO Hessian.

PetscLogEvent	MOFEM_EVENT_TaoGradient
	Log event for TAO Gradient.

PetscLogEvent	MOFEM_EVENT_TaoObjective
	Log event for TAO Objective.

PetscLogEvent	MOFEM_EVENT_TaoEqualityConstraint

PetscLogEvent	MOFEM_EVENT_TaoInequalityConstraint

PetscLogEvent	MOFEM_EVENT_TaoEqualityJacobian

PetscLogEvent	MOFEM_EVENT_TaoInequalityJacobian

Friends
PetscErrorCode	TaoSetObjective (Tao tao, Vec x, PetscReal f, void ctx)
	Sets the objective function value for a TAO optimization context.

PetscErrorCode	TaoSetGradient (Tao tao, Vec x, Vec g, void *ctx)
	Sets the gradient vector for a TAO optimization context.

PetscErrorCode	TaoSetObjectiveAndGradient (Tao tao, Vec x, PetscReal f, Vec g, void ctx)
	Sets the objective function value and gradient for a TAO optimization solver.

PetscErrorCode	TaoSetHessian (Tao tao, Vec x, Mat H, Mat Hpre, void *ctx)
	Sets the Hessian matrix for a TAO optimization context.

PetscErrorCode	TaoSetEqualityConstraints (Tao tao, Vec x, Vec c, void *ctx)
	Evaluate equality constraints for a TAO optimization context.

PetscErrorCode	TaoSetInequalityConstraints (Tao tao, Vec x, Vec c, void *ctx)
	Evaluate inequality constraints for a TAO optimization context.

PetscErrorCode	TaoSetJacobianEquality (Tao tao, Vec x, Mat J, Mat Jpre, void *ctx)
	Assemble the equality constraint Jacobian.

PetscErrorCode	TaoSetJacobianInequality (Tao tao, Vec x, Mat J, Mat Jpre, void *ctx)
	Assemble the inequality constraint Jacobian.

Detailed Description

Interface for TAO solvers.

Definition at line 14 of file TaoCtx.hpp.

Member Typedef Documentation

◆ BasicMethodsSequence

using MoFEM::TaoCtx::BasicMethodsSequence = MoFEM::BasicMethodsSequence

Definition at line 23 of file TaoCtx.hpp.

◆ FEMethodsSequence

using MoFEM::TaoCtx::FEMethodsSequence = MoFEM::FEMethodsSequence

Definition at line 22 of file TaoCtx.hpp.

◆ GradientHook

using MoFEM::TaoCtx::GradientHook = boost::function<MoFEMErrorCode(Tao tao, Vec x, Vec gradient)>

Definition at line 26 of file TaoCtx.hpp.

◆ ObjectiveAndGradientHook

using MoFEM::TaoCtx::ObjectiveAndGradientHook = boost::function<MoFEMErrorCode( Tao tao, Vec x, PetscReal *objective, Vec gradient)>

Definition at line 28 of file TaoCtx.hpp.

◆ ObjectiveHook

using MoFEM::TaoCtx::ObjectiveHook = boost::function<MoFEMErrorCode(Tao tao, Vec x, PetscReal *objective)>

Definition at line 24 of file TaoCtx.hpp.

◆ PairNameFEMethodPtr

using MoFEM::TaoCtx::PairNameFEMethodPtr = MoFEM::PairNameFEMethodPtr

Definition at line 21 of file TaoCtx.hpp.

Constructor & Destructor Documentation

◆ TaoCtx()

MoFEM::TaoCtx::TaoCtx	(	Interface &	m_field,
		const std::string &	problem_name
	)

inline

Definition at line 93 of file TaoCtx.hpp.

      : mField(m_field), moab(m_field.get_moab()), problemName(problem_name),
        vErify(false) {
    PetscLogEventRegister("LoopTAOHessian", 0, &MOFEM_EVENT_TaoHessian);
    PetscLogEventRegister("LoopTAOObjective", 0, &MOFEM_EVENT_TaoObjective);
    PetscLogEventRegister("LoopTAOGradient", 0, &MOFEM_EVENT_TaoGradient);
    PetscLogEventRegister("LoopTAOEqualityConstraint", 0,
                          &MOFEM_EVENT_TaoEqualityConstraint);
    PetscLogEventRegister("LoopTAOInequalityConstraint", 0,
                          &MOFEM_EVENT_TaoInequalityConstraint);
    PetscLogEventRegister("LoopTAOEqualityJacobian", 0,
                          &MOFEM_EVENT_TaoEqualityJacobian);
    PetscLogEventRegister("LoopTAOInequalityJacobian", 0,
                          &MOFEM_EVENT_TaoInequalityJacobian);
    if (!LogManager::checkIfChannelExist("TAO_WORLD")) {
      auto core_log = logging::core::get();
      core_log->add_sink(
          LogManager::createSink(LogManager::getStrmWorld(), "TAO_WORLD"));
      LogManager::setLog("TAO_WORLD");
      MOFEM_LOG_TAG("TAO_WORLD", "TAO");
    }
  }

◆ ~TaoCtx()

virtual MoFEM::TaoCtx::~TaoCtx ( )

virtualdefault

Member Function Documentation

◆ clearLoops()

MoFEMErrorCode MoFEM::TaoCtx::clearLoops ( )

Clear loops.

Evaluator hooks are unchanged.

Returns: MoFEMErrorCode

Definition at line 67 of file TaoCtx.cpp.

                                  {
  MoFEMFunctionBeginHot;
  loopsHessian.clear();
  loopsObjective.clear();
  loopsGradient.clear();
  loopsEqualityConstraint.clear();
  loopsInequalityConstraint.clear();
  loopsEqualityJacobian.clear();
  loopsInequalityJacobian.clear();
  preHessian.clear();
  postHessian.clear();
  preObjective.clear();
  postObjective.clear();
  preGradient.clear();
  postGradient.clear();
  preEqualityConstraint.clear();
  postEqualityConstraint.clear();
  preInequalityConstraint.clear();
  postInequalityConstraint.clear();
  preEqualityJacobian.clear();
  postEqualityJacobian.clear();
  preInequalityJacobian.clear();
  postInequalityJacobian.clear();
  MoFEMFunctionReturnHot(0);
}

◆ copyLoops()

MoFEMErrorCode MoFEM::TaoCtx::copyLoops ( const TaoCtx & tao_ctx )

Copy sequences from another TaoCtx.

Evaluator hooks are unchanged.

Parameters

tao_ctx TaoCtx from which sequences are copied

Returns: error code

Definition at line 41 of file TaoCtx.cpp.

                                                      {
  MoFEMFunctionBeginHot;
  loopsHessian = tao_ctx.loopsHessian;
  loopsObjective = tao_ctx.loopsObjective;
  loopsGradient = tao_ctx.loopsGradient;
  loopsEqualityConstraint = tao_ctx.loopsEqualityConstraint;
  loopsInequalityConstraint = tao_ctx.loopsInequalityConstraint;
  loopsEqualityJacobian = tao_ctx.loopsEqualityJacobian;
  loopsInequalityJacobian = tao_ctx.loopsInequalityJacobian;
  preHessian = tao_ctx.preHessian;
  postHessian = tao_ctx.postHessian;
  preObjective = tao_ctx.preObjective;
  postObjective = tao_ctx.postObjective;
  preGradient = tao_ctx.preGradient;
  postGradient = tao_ctx.postGradient;
  preEqualityConstraint = tao_ctx.preEqualityConstraint;
  postEqualityConstraint = tao_ctx.postEqualityConstraint;
  preInequalityConstraint = tao_ctx.preInequalityConstraint;
  postInequalityConstraint = tao_ctx.postInequalityConstraint;
  preEqualityJacobian = tao_ctx.preEqualityJacobian;
  postEqualityJacobian = tao_ctx.postEqualityJacobian;
  preInequalityJacobian = tao_ctx.preInequalityJacobian;
  postInequalityJacobian = tao_ctx.postInequalityJacobian;
  MoFEMFunctionReturnHot(0);
}

◆ evaluateConstraint()

PetscErrorCode MoFEM::TaoCtx::evaluateConstraint	(	Tao	tao,
		Vec	x,
		Vec	c,
		FEMethodsSequence &	loops,
		BasicMethodsSequence &	pre_process,
		BasicMethodsSequence &	post_process,
		TaoMethod::TAOContext	evaluation_context,
		PetscLogEvent	log_event
	)

private

Definition at line 93 of file TaoCtx.cpp.

                                                                     {
  MoFEMFunctionBegin;
  PetscLogEventBegin(log_event, 0, 0, 0, 0);
 
  CHKERR VecGhostUpdateBegin(x, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(x, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR mField.getInterface<VecManager>()->setLocalGhostVector(
      problemName, COL, x, INSERT_VALUES, SCATTER_REVERSE);
  CHKERR zeroTaoOutputVector(c);
 
  vecAssembleSwitch = boost::movelib::make_unique<bool>(true);
  auto cache_ptr = boost::make_shared<CacheTuple>();
  CHKERR mField.cache_problem_entities(problemName, cache_ptr);
 
  auto set = [&](auto &fe) {
    fe.tao = tao;
    fe.tao_x = x;
    fe.tao_c = c;
    fe.snes_ctx = SnesMethod::CTX_SNESSETFUNCTION;
    fe.ksp_ctx = KspMethod::CTX_SETFUNCTION;
    fe.tao_ctx = evaluation_context;
    fe.data_ctx = PetscData::CtxSetF | PetscData::CtxSetX;
    fe.cacheWeakPtr = cache_ptr;
  };
 
  auto unset = [&](auto &fe) {
    fe.snes_ctx = SnesMethod::CTX_SNESNONE;
    fe.ksp_ctx = KspMethod::CTX_KSPNONE;
    fe.tao_ctx = TaoMethod::CTX_TAO_NONE;
    fe.data_ctx = PetscData::CtxSetNone;
  };
 
  for (auto &method : pre_process) {
    method->vecAssembleSwitch = boost::move(vecAssembleSwitch);
    set(*method);
    CHKERR mField.problem_basic_method_preProcess(problemName, *method);
    unset(*method);
    vecAssembleSwitch = boost::move(method->vecAssembleSwitch);
  }
 
  for (auto &loop : loops) {
    loop.second->vecAssembleSwitch = boost::move(vecAssembleSwitch);
    set(*loop.second);
    CHKERR mField.loop_finite_elements(problemName, loop.first, *loop.second,
                                       nullptr, MF_EXIST, cache_ptr);
    unset(*loop.second);
    vecAssembleSwitch = boost::move(loop.second->vecAssembleSwitch);
  }
 
  for (auto &method : post_process) {
    method->vecAssembleSwitch = boost::move(vecAssembleSwitch);
    set(*method);
    CHKERR mField.problem_basic_method_postProcess(problemName, *method);
    unset(*method);
    vecAssembleSwitch = boost::move(method->vecAssembleSwitch);
  }
 
  if (*vecAssembleSwitch)
    CHKERR assembleTaoOutputVector(c);
 
  PetscLogEventEnd(log_event, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

◆ evaluateConstraintJacobian()

PetscErrorCode MoFEM::TaoCtx::evaluateConstraintJacobian	(	Tao	tao,
		Vec	x,
		Mat	J,
		Mat	Jpre,
		FEMethodsSequence &	loops,
		BasicMethodsSequence &	pre_process,
		BasicMethodsSequence &	post_process,
		TaoMethod::TAOContext	evaluation_context,
		PetscLogEvent	log_event
	)

private

Definition at line 160 of file TaoCtx.cpp.

                                                                     {
  MoFEMFunctionBegin;
  PetscLogEventBegin(log_event, 0, 0, 0, 0);
 
  CHKERR VecGhostUpdateBegin(x, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(x, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR mField.getInterface<VecManager>()->setLocalGhostVector(
      problemName, COL, x, INSERT_VALUES, SCATTER_REVERSE);
 
  matAssembleSwitch = boost::movelib::make_unique<bool>(true);
  CHKERR MatZeroEntries(Jpre);
  if (J != Jpre)
    CHKERR MatZeroEntries(J);
 
  auto cache_ptr = boost::make_shared<CacheTuple>();
  CHKERR mField.cache_problem_entities(problemName, cache_ptr);
 
  auto set = [&](auto &fe) {
    fe.tao = tao;
    fe.tao_x = x;
    fe.tao_J = J;
    fe.tao_Jpre = Jpre;
    fe.ksp_ctx = KspMethod::CTX_OPERATORS;
    fe.snes_ctx = SnesMethod::CTX_SNESSETJACOBIAN;
    fe.tao_ctx = evaluation_context;
    fe.data_ctx = PetscData::CtxSetA | PetscData::CtxSetB | PetscData::CtxSetX;
    fe.cacheWeakPtr = cache_ptr;
  };
 
  auto unset = [&](auto &fe) {
    fe.snes_ctx = SnesMethod::CTX_SNESNONE;
    fe.ksp_ctx = KspMethod::CTX_KSPNONE;
    fe.tao_ctx = TaoMethod::CTX_TAO_NONE;
    fe.data_ctx = PetscData::CtxSetNone;
  };
 
  for (auto &method : pre_process) {
    method->matAssembleSwitch = boost::move(matAssembleSwitch);
    set(*method);
    CHKERR mField.problem_basic_method_preProcess(problemName, *method);
    unset(*method);
    matAssembleSwitch = boost::move(method->matAssembleSwitch);
  }
 
  for (auto &loop : loops) {
    loop.second->matAssembleSwitch = boost::move(matAssembleSwitch);
    set(*loop.second);
    CHKERR mField.loop_finite_elements(problemName, loop.first, *loop.second,
                                       nullptr, MF_EXIST, cache_ptr);
    unset(*loop.second);
    matAssembleSwitch = boost::move(loop.second->matAssembleSwitch);
  }
 
  for (auto &method : post_process) {
    method->matAssembleSwitch = boost::move(matAssembleSwitch);
    set(*method);
    CHKERR mField.problem_basic_method_postProcess(problemName, *method);
    unset(*method);
    matAssembleSwitch = boost::move(method->matAssembleSwitch);
  }
 
  if (*matAssembleSwitch) {
    CHKERR MatAssemblyBegin(Jpre, MAT_FINAL_ASSEMBLY);
    CHKERR MatAssemblyEnd(Jpre, MAT_FINAL_ASSEMBLY);
    if (J != Jpre) {
      CHKERR MatAssemblyBegin(J, MAT_FINAL_ASSEMBLY);
      CHKERR MatAssemblyEnd(J, MAT_FINAL_ASSEMBLY);
    }
  }
 
  PetscLogEventEnd(log_event, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

◆ getEqualityConstraintLoops()

FEMethodsSequence & MoFEM::TaoCtx::getEqualityConstraintLoops ( )

inline

Definition at line 134 of file TaoCtx.hpp.

                                                  {
    return loopsEqualityConstraint;
  }

◆ getEqualityJacobianLoops()

FEMethodsSequence & MoFEM::TaoCtx::getEqualityJacobianLoops ( )

inline

Definition at line 156 of file TaoCtx.hpp.

                                                {
    return loopsEqualityJacobian;
  }

◆ getGradientHook()

GradientHook & MoFEM::TaoCtx::getGradientHook ( )

inline

Get an optional gradient evaluator.

When set, MoFEM::TaoSetGradient delegates the complete evaluation to this hook before scattering controls to the mesh or running element loops. The hook owns state synchronization and gradient assembly.

Definition at line 193 of file TaoCtx.hpp.

193{ return gradientHook; }

MoFEM::TaoCtx::gradientHook

GradientHook gradientHook

Definition TaoCtx.hpp:254

◆ getGradientLoops()

FEMethodsSequence & MoFEM::TaoCtx::getGradientLoops ( )

inline

Definition at line 129 of file TaoCtx.hpp.

129{ return loopsGradient; }

◆ getHessianLoops()

FEMethodsSequence & MoFEM::TaoCtx::getHessianLoops ( )

inline

Definition at line 119 of file TaoCtx.hpp.

119{ return loopsHessian; }

◆ getInequalityConstraintLoops()

FEMethodsSequence & MoFEM::TaoCtx::getInequalityConstraintLoops ( )

inline

Definition at line 145 of file TaoCtx.hpp.

                                                    {
    return loopsInequalityConstraint;
  }

◆ getInequalityJacobianLoops()

FEMethodsSequence & MoFEM::TaoCtx::getInequalityJacobianLoops ( )

inline

Definition at line 167 of file TaoCtx.hpp.

                                                  {
    return loopsInequalityJacobian;
  }

◆ getObjectiveAndGradientHook()

ObjectiveAndGradientHook & MoFEM::TaoCtx::getObjectiveAndGradientHook ( )

inline

Get an optional combined objective-and-gradient evaluator.

When set, MoFEM::TaoSetObjectiveAndGradient delegates the complete evaluation to this hook. This supports reduced objectives which require an application-owned state solve before returning the value and gradient. Otherwise, the separate objective and gradient callbacks are used.

Definition at line 203 of file TaoCtx.hpp.

                                                          {
    return objectiveAndGradientHook;
  }

◆ getObjectiveHook()

ObjectiveHook & MoFEM::TaoCtx::getObjectiveHook ( )

inline

Get an optional objective evaluator.

When set, MoFEM::TaoSetObjective delegates the complete evaluation to this hook before scattering controls to the mesh or running element loops. The hook owns state synchronization and objective evaluation.

Definition at line 184 of file TaoCtx.hpp.

184{ return objectiveHook; }

MoFEM::TaoCtx::objectiveHook

ObjectiveHook objectiveHook

Definition TaoCtx.hpp:253

◆ getObjectiveLoops()

FEMethodsSequence & MoFEM::TaoCtx::getObjectiveLoops ( )

inline

Definition at line 124 of file TaoCtx.hpp.

124{ return loopsObjective; }

◆ getPostProcEqualityConstraint()

BasicMethodsSequence & MoFEM::TaoCtx::getPostProcEqualityConstraint ( )

inline

Definition at line 140 of file TaoCtx.hpp.

                                                        {
    return postEqualityConstraint;
  }

◆ getPostProcEqualityJacobian()

BasicMethodsSequence & MoFEM::TaoCtx::getPostProcEqualityJacobian ( )

inline

Definition at line 162 of file TaoCtx.hpp.

                                                      {
    return postEqualityJacobian;
  }

◆ getPostProcGradient()

BasicMethodsSequence & MoFEM::TaoCtx::getPostProcGradient ( )

inline

Definition at line 131 of file TaoCtx.hpp.

131{ return postGradient; }

◆ getPostProcHessian()

BasicMethodsSequence & MoFEM::TaoCtx::getPostProcHessian ( )

inline

Definition at line 121 of file TaoCtx.hpp.

121{ return postHessian; }

◆ getPostProcInequalityConstraint()

BasicMethodsSequence & MoFEM::TaoCtx::getPostProcInequalityConstraint ( )

inline

Definition at line 151 of file TaoCtx.hpp.

                                                          {
    return postInequalityConstraint;
  }

◆ getPostProcInequalityJacobian()

BasicMethodsSequence & MoFEM::TaoCtx::getPostProcInequalityJacobian ( )

inline

Definition at line 173 of file TaoCtx.hpp.

                                                        {
    return postInequalityJacobian;
  }

◆ getPostProcObjective()

BasicMethodsSequence & MoFEM::TaoCtx::getPostProcObjective ( )

inline

Definition at line 126 of file TaoCtx.hpp.

126{ return postObjective; }

◆ getPreProcEqualityConstraint()

BasicMethodsSequence & MoFEM::TaoCtx::getPreProcEqualityConstraint ( )

inline

Definition at line 137 of file TaoCtx.hpp.

                                                       {
    return preEqualityConstraint;
  }

◆ getPreProcEqualityJacobian()

BasicMethodsSequence & MoFEM::TaoCtx::getPreProcEqualityJacobian ( )

inline

Definition at line 159 of file TaoCtx.hpp.

                                                     {
    return preEqualityJacobian;
  }

◆ getPreProcGradient()

BasicMethodsSequence & MoFEM::TaoCtx::getPreProcGradient ( )

inline

Definition at line 130 of file TaoCtx.hpp.

130{ return preGradient; }

◆ getPreProcHessian()

BasicMethodsSequence & MoFEM::TaoCtx::getPreProcHessian ( )

inline

Definition at line 120 of file TaoCtx.hpp.

120{ return preHessian; }

◆ getPreProcInequalityConstraint()

BasicMethodsSequence & MoFEM::TaoCtx::getPreProcInequalityConstraint ( )

inline

Definition at line 148 of file TaoCtx.hpp.

                                                         {
    return preInequalityConstraint;
  }

◆ getPreProcInequalityJacobian()

BasicMethodsSequence & MoFEM::TaoCtx::getPreProcInequalityJacobian ( )

inline

Definition at line 170 of file TaoCtx.hpp.

                                                       {
    return preInequalityJacobian;
  }

◆ getPreProcObjective()

BasicMethodsSequence & MoFEM::TaoCtx::getPreProcObjective ( )

inline

Definition at line 125 of file TaoCtx.hpp.

125{ return preObjective; }

Friends And Related Symbol Documentation

◆ TaoSetEqualityConstraints

PetscErrorCode TaoSetEqualityConstraints	(	Tao	tao,
		Vec	x,
		Vec	c,
		void *	ctx
	)

friend

Evaluate equality constraints for a TAO optimization context.

Register this callback with TaoSetEqualityConstraintsRoutine().

Definition at line 468 of file TaoCtx.cpp.

                                                                           {
  MoFEMFunctionBegin;
  auto *tao_ctx = static_cast<TaoCtx *>(ctx);
  CHKERR tao_ctx->evaluateConstraint(
      tao, x, c, tao_ctx->loopsEqualityConstraint,
      tao_ctx->preEqualityConstraint, tao_ctx->postEqualityConstraint,
      TaoMethod::CTX_TAO_EQUALITY_CONSTRAINT,
      tao_ctx->MOFEM_EVENT_TaoEqualityConstraint);
  MoFEMFunctionReturn(0);
}

◆ TaoSetGradient

PetscErrorCode TaoSetGradient	(	Tao	tao,
		Vec	x,
		Vec	g,
		void *	ctx
	)

friend

Sets the gradient vector for a TAO optimization context.

Parameters

tao	The TAO optimization solver context.
x	The input vector at which to evaluate the gradient.
g	Pointer to the gradient vector.
ctx	User-defined context for the gradient function.

Returns: PetscErrorCode Error code (0 on success).

Definition at line 296 of file TaoCtx.cpp.

                                                                {
  auto *tao_ctx = static_cast<TaoCtx *>(ctx);
  MoFEMFunctionBegin;
  if (tao_ctx->gradientHook) {
    CHKERR tao_ctx->gradientHook(tao, x, f);
    MoFEMFunctionReturnHot(0);
  }
  PetscLogEventBegin(tao_ctx->MOFEM_EVENT_TaoGradient, 0, 0, 0, 0);
  CHKERR VecGhostUpdateBegin(x, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(x, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR tao_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
      tao_ctx->problemName, COL, x, INSERT_VALUES, SCATTER_REVERSE);
 
  auto zero_ghost_vec = [](Vec g) {
    MoFEMFunctionBegin;
    Vec l;
    CHKERR VecGhostGetLocalForm(g, &l);
    double *a;
    CHKERR VecGetArray(l, &a);
    int s;
    CHKERR VecGetLocalSize(l, &s);
    for (int i = 0; i != s; ++i)
      a[i] = 0;
    CHKERR VecRestoreArray(l, &a);
    CHKERR VecGhostRestoreLocalForm(g, &l);
    MoFEMFunctionReturn(0);
  };
  CHKERR zero_ghost_vec(f);
 
  tao_ctx->vecAssembleSwitch = boost::movelib::make_unique<bool>(true);
  auto cache_ptr = boost::make_shared<CacheTuple>();
  CHKERR tao_ctx->mField.cache_problem_entities(tao_ctx->problemName,
                                                cache_ptr);
 
  auto set = [&](auto &fe) {
    fe.tao = tao;
    fe.tao_x = x;
    fe.tao_f = f;
    fe.snes_ctx = SnesMethod::CTX_SNESSETFUNCTION;
    fe.ksp_ctx = KspMethod::CTX_SETFUNCTION;
    fe.tao_ctx = TaoMethod::CTX_TAO_GRADIENT;
    fe.data_ctx = PetscData::CtxSetF | PetscData::CtxSetX;
    fe.cacheWeakPtr = cache_ptr;
  };
 
  auto unset = [&](auto &fe) {
    fe.snes_ctx = SnesMethod::CTX_SNESNONE;
    fe.ksp_ctx = KspMethod::CTX_KSPNONE;
    fe.tao_ctx = TaoMethod::CTX_TAO_NONE;
    fe.data_ctx = PetscData::CtxSetNone;
  };
 
  for (auto &bit : tao_ctx->preGradient) {
    bit->vecAssembleSwitch = boost::move(tao_ctx->vecAssembleSwitch);
    set(*bit);
    CHKERR tao_ctx->mField.problem_basic_method_preProcess(tao_ctx->problemName,
                                                           *bit);
    unset(*bit);
    tao_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
  }
 
  for (auto &lit : tao_ctx->loopsGradient) {
    lit.second->vecAssembleSwitch = boost::move(tao_ctx->vecAssembleSwitch);
    set(*lit.second);
    CHKERR tao_ctx->mField.loop_finite_elements(tao_ctx->problemName, lit.first,
                                                *lit.second, nullptr, MF_EXIST,
                                                cache_ptr);
    unset(*lit.second);
    tao_ctx->vecAssembleSwitch = boost::move(lit.second->vecAssembleSwitch);
  }
 
  for (auto &bit : tao_ctx->postGradient) {
    bit->vecAssembleSwitch = boost::move(tao_ctx->vecAssembleSwitch);
    set(*bit);
    CHKERR tao_ctx->mField.problem_basic_method_postProcess(
        tao_ctx->problemName, *bit);
    unset(*bit);
    tao_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
  }
 
  if (*(tao_ctx->vecAssembleSwitch)) {
    CHKERR VecGhostUpdateBegin(f, ADD_VALUES, SCATTER_REVERSE);
    CHKERR VecGhostUpdateEnd(f, ADD_VALUES, SCATTER_REVERSE);
    CHKERR VecAssemblyBegin(f);
    CHKERR VecAssemblyEnd(f);
  }
  PetscLogEventEnd(tao_ctx->MOFEM_EVENT_TaoGradient, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

◆ TaoSetHessian

PetscErrorCode TaoSetHessian	(	Tao	tao,
		Vec	x,
		Mat	H,
		Mat	Hpre,
		void *	ctx
	)

friend

Sets the Hessian matrix for a TAO optimization context.

Parameters

tao	The TAO optimization solver context.
x	The input vector at which to evaluate the Hessian.
H	Pointer to the Hessian matrix.
Hpre	Preconditioner matrix (can be NULL).
ctx	User-defined context for the Hessian function.

Returns: PetscErrorCode Error code (0 on success).

Definition at line 399 of file TaoCtx.cpp.

                                                                         {
  TaoCtx *tao_ctx = (TaoCtx *)ctx;
  MoFEMFunctionBegin;
  PetscLogEventBegin(tao_ctx->MOFEM_EVENT_TaoHessian, 0, 0, 0, 0);
 
  tao_ctx->matAssembleSwitch = boost::movelib::make_unique<bool>(true);
  auto cache_ptr = boost::make_shared<CacheTuple>();
  CHKERR tao_ctx->mField.cache_problem_entities(tao_ctx->problemName,
                                                cache_ptr);
 
  auto set = [&](auto &fe) {
    fe.tao = tao;
    fe.tao_A = H;
    fe.tao_B = Hpre;
    fe.ksp_ctx = KspMethod::CTX_OPERATORS;
    fe.snes_ctx = SnesMethod::CTX_SNESSETJACOBIAN;
    fe.tao_ctx = TaoMethod::CTX_TAO_HESSIAN;
    fe.data_ctx = PetscData::CtxSetA | PetscData::CtxSetB | PetscData::CtxSetX;
    fe.cacheWeakPtr = cache_ptr;
  };
 
  auto unset = [&](auto &fe) {
    fe.snes_ctx = SnesMethod::CTX_SNESNONE;
    fe.ksp_ctx = KspMethod::CTX_KSPNONE;
    fe.tao_ctx = TaoMethod::CTX_TAO_NONE;
    fe.data_ctx = PetscData::CtxSetNone;
  };
 
  CHKERR VecGhostUpdateBegin(x, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(x, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR tao_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
      tao_ctx->problemName, COL, x, INSERT_VALUES, SCATTER_REVERSE);
 
  for (auto &bit : tao_ctx->preHessian) {
    bit->matAssembleSwitch = boost::move(tao_ctx->matAssembleSwitch);
    set(*bit);
    CHKERR tao_ctx->mField.problem_basic_method_preProcess(tao_ctx->problemName,
                                                           *bit);
    unset(*bit);
    tao_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
  }
 
  for (auto &lit : tao_ctx->loopsHessian) {
    lit.second->matAssembleSwitch = boost::move(tao_ctx->matAssembleSwitch);
    set(*lit.second);
    CHKERR tao_ctx->mField.loop_finite_elements(tao_ctx->problemName, lit.first,
                                                *(lit.second), nullptr,
                                                MF_EXIST, cache_ptr);
    unset(*lit.second);
    tao_ctx->matAssembleSwitch = boost::move(lit.second->matAssembleSwitch);
  }
 
  for (auto &bit : tao_ctx->postHessian) {
    bit->matAssembleSwitch = boost::move(tao_ctx->matAssembleSwitch);
    set(*bit);
    CHKERR tao_ctx->mField.problem_basic_method_postProcess(
        tao_ctx->problemName, *bit);
    unset(*bit);
    tao_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
  }
 
  if (*tao_ctx->matAssembleSwitch) {
    CHKERR MatAssemblyBegin(Hpre, MAT_FINAL_ASSEMBLY);
    CHKERR MatAssemblyEnd(Hpre, MAT_FINAL_ASSEMBLY);
  }
  PetscLogEventEnd(tao_ctx->MOFEM_EVENT_TaoHessian, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

◆ TaoSetInequalityConstraints

PetscErrorCode TaoSetInequalityConstraints	(	Tao	tao,
		Vec	x,
		Vec	c,
		void *	ctx
	)

friend

Evaluate inequality constraints for a TAO optimization context.

Register this callback with TaoSetInequalityConstraintsRoutine(). PETSc defines feasible inequality constraints by c(x) >= 0.

Definition at line 479 of file TaoCtx.cpp.

                                                                             {
  MoFEMFunctionBegin;
  auto *tao_ctx = static_cast<TaoCtx *>(ctx);
  CHKERR tao_ctx->evaluateConstraint(
      tao, x, c, tao_ctx->loopsInequalityConstraint,
      tao_ctx->preInequalityConstraint, tao_ctx->postInequalityConstraint,
      TaoMethod::CTX_TAO_INEQUALITY_CONSTRAINT,
      tao_ctx->MOFEM_EVENT_TaoInequalityConstraint);
  MoFEMFunctionReturn(0);
}

◆ TaoSetJacobianEquality

PetscErrorCode TaoSetJacobianEquality	(	Tao	tao,
		Vec	x,
		Mat	J,
		Mat	Jpre,
		void *	ctx
	)

friend

Assemble the equality constraint Jacobian.

Register this callback with TaoSetJacobianEqualityRoutine().

Definition at line 490 of file TaoCtx.cpp.

                                                 {
  MoFEMFunctionBegin;
  auto *tao_ctx = static_cast<TaoCtx *>(ctx);
  CHKERR tao_ctx->evaluateConstraintJacobian(
      tao, x, J, Jpre, tao_ctx->loopsEqualityJacobian,
      tao_ctx->preEqualityJacobian, tao_ctx->postEqualityJacobian,
      TaoMethod::CTX_TAO_EQUALITY_JACOBIAN,
      tao_ctx->MOFEM_EVENT_TaoEqualityJacobian);
  MoFEMFunctionReturn(0);
}

◆ TaoSetJacobianInequality

PetscErrorCode TaoSetJacobianInequality	(	Tao	tao,
		Vec	x,
		Mat	J,
		Mat	Jpre,
		void *	ctx
	)

friend

Assemble the inequality constraint Jacobian.

Register this callback with TaoSetJacobianInequalityRoutine().

Definition at line 502 of file TaoCtx.cpp.

                                                   {
  MoFEMFunctionBegin;
  auto *tao_ctx = static_cast<TaoCtx *>(ctx);
  CHKERR tao_ctx->evaluateConstraintJacobian(
      tao, x, J, Jpre, tao_ctx->loopsInequalityJacobian,
      tao_ctx->preInequalityJacobian, tao_ctx->postInequalityJacobian,
      TaoMethod::CTX_TAO_INEQUALITY_JACOBIAN,
      tao_ctx->MOFEM_EVENT_TaoInequalityJacobian);
  MoFEMFunctionReturn(0);
}

◆ TaoSetObjective

PetscErrorCode TaoSetObjective	(	Tao	tao,
		Vec	x,
		PetscReal *	f,
		void *	ctx
	)

friend

Sets the objective function value for a TAO optimization context.

Parameters

tao	The TAO optimization solver context.
x	The input vector at which to evaluate the objective.
f	Pointer to store the computed objective value.
ctx	User-defined context for the objective function.

Returns: PetscErrorCode Error code (0 on success).

Definition at line 237 of file TaoCtx.cpp.

                                                                        {
  auto *tao_ctx = static_cast<TaoCtx *>(ctx);
  MoFEMFunctionBegin;
  if (tao_ctx->objectiveHook) {
    CHKERR tao_ctx->objectiveHook(tao, x, f);
    MoFEMFunctionReturnHot(0);
  }
  PetscLogEventBegin(tao_ctx->MOFEM_EVENT_TaoObjective, 0, 0, 0, 0);
  CHKERR VecGhostUpdateBegin(x, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(x, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR tao_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
      tao_ctx->problemName, COL, x, INSERT_VALUES, SCATTER_REVERSE);
 
  auto cache_ptr = boost::make_shared<CacheTuple>();
  CHKERR tao_ctx->mField.cache_problem_entities(tao_ctx->problemName,
                                                cache_ptr);
 
  auto set = [&](auto &fe) {
    fe.tao = tao;
    fe.tao_x = x;
    fe.tao_ctx = TaoMethod::CTX_TAO_OBJECTIVE;
    fe.data_ctx = PetscData::CtxSetX;
    fe.cacheWeakPtr = cache_ptr;
  };
 
  auto unset = [&](auto &fe) {
    fe.tao_ctx = TaoMethod::CTX_TAO_NONE;
    fe.data_ctx = PetscData::CtxSetNone;
  };
 
  for (auto &bit : tao_ctx->preObjective) {
    bit->vecAssembleSwitch = boost::move(tao_ctx->vecAssembleSwitch);
    set(*bit);
    CHKERR tao_ctx->mField.problem_basic_method_preProcess(tao_ctx->problemName,
                                                           *bit);
    unset(*bit);
  }
 
  for (auto &lit : tao_ctx->loopsObjective) {
    set(*lit.second);
    CHKERR tao_ctx->mField.loop_finite_elements(tao_ctx->problemName, lit.first,
                                                *lit.second, nullptr, MF_EXIST,
                                                cache_ptr);
    unset(*lit.second);
  }
 
  for (auto &bit : tao_ctx->postObjective) {
    bit->vecAssembleSwitch = boost::move(tao_ctx->vecAssembleSwitch);
    set(*bit);
    CHKERR tao_ctx->mField.problem_basic_method_postProcess(
        tao_ctx->problemName, *bit);
    unset(*bit);
    tao_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
  }
 
  PetscLogEventEnd(tao_ctx->MOFEM_EVENT_TaoObjective, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

◆ TaoSetObjectiveAndGradient

PetscErrorCode TaoSetObjectiveAndGradient	(	Tao	tao,
		Vec	x,
		PetscReal *	f,
		Vec	g,
		void *	ctx
	)

friend

Sets the objective function value and gradient for a TAO optimization solver.

Parameters

tao	The TAO solver context.
x	Input vector at which to evaluate the objective and gradient.
f	Pointer to store the computed objective function value.
g	Vector to store the computed gradient.
ctx	User-defined context for objective and gradient evaluation.

Returns: PetscErrorCode Error code (0 on success).

Note: This function is typically called within a user-defined routine to provide both the objective value and its gradient for optimization algorithms.

See also: https://petsc.org/release/docs/manualpages/Tao/TaoSetObjectiveAndGradient.html

Definition at line 386 of file TaoCtx.cpp.

                                                     {
  MoFEMFunctionBegin;
  TaoCtx *tao_ctx = (TaoCtx *)ctx;
  if (tao_ctx->objectiveAndGradientHook) {
    CHKERR tao_ctx->objectiveAndGradientHook(tao, x, f, g);
    MoFEMFunctionReturnHot(0);
  }
  CHKERR TaoSetObjective(tao, x, f, ctx);
  CHKERR TaoSetGradient(tao, x, g, ctx);
  MoFEMFunctionReturn(0);
}

Member Data Documentation

◆ gradientHook

GradientHook MoFEM::TaoCtx::gradientHook

private

Definition at line 254 of file TaoCtx.hpp.

◆ loopsEqualityConstraint

FEMethodsSequence MoFEM::TaoCtx::loopsEqualityConstraint

Sequence of finite element methods for evaluating equality constraints

Definition at line 40 of file TaoCtx.hpp.

◆ loopsEqualityJacobian

FEMethodsSequence MoFEM::TaoCtx::loopsEqualityJacobian

Sequence of finite element methods for assembling the equality constraint Jacobian

Definition at line 46 of file TaoCtx.hpp.

◆ loopsGradient

FEMethodsSequence MoFEM::TaoCtx::loopsGradient

Sequence of finite element methods for assembling the gradient (first derivative) vector in TAO optimization

Definition at line 38 of file TaoCtx.hpp.

◆ loopsHessian

FEMethodsSequence MoFEM::TaoCtx::loopsHessian

Sequence of finite element methods for assembling the Hessian (second derivative) matrix in TAO optimization

Definition at line 32 of file TaoCtx.hpp.

◆ loopsInequalityConstraint

FEMethodsSequence MoFEM::TaoCtx::loopsInequalityConstraint

Sequence of finite element methods for evaluating inequality constraints

Definition at line 43 of file TaoCtx.hpp.

◆ loopsInequalityJacobian

FEMethodsSequence MoFEM::TaoCtx::loopsInequalityJacobian

Sequence of finite element methods for assembling the inequality constraint Jacobian

Definition at line 49 of file TaoCtx.hpp.

◆ loopsObjective

FEMethodsSequence MoFEM::TaoCtx::loopsObjective

Sequence of finite element methods for evaluating the objective function in TAO optimization

Definition at line 35 of file TaoCtx.hpp.

◆ matAssembleSwitch

boost::movelib::unique_ptr<bool> MoFEM::TaoCtx::matAssembleSwitch

private

Definition at line 257 of file TaoCtx.hpp.

◆ mField

MoFEM::Interface& MoFEM::TaoCtx::mField

database Interface

Definition at line 16 of file TaoCtx.hpp.

◆ moab

moab::Interface& MoFEM::TaoCtx::moab

moab Interface

Definition at line 17 of file TaoCtx.hpp.

◆ MOFEM_EVENT_TaoEqualityConstraint

PetscLogEvent MoFEM::TaoCtx::MOFEM_EVENT_TaoEqualityConstraint

private

Definition at line 261 of file TaoCtx.hpp.

◆ MOFEM_EVENT_TaoEqualityJacobian

PetscLogEvent MoFEM::TaoCtx::MOFEM_EVENT_TaoEqualityJacobian

private

Definition at line 263 of file TaoCtx.hpp.

◆ MOFEM_EVENT_TaoGradient

PetscLogEvent MoFEM::TaoCtx::MOFEM_EVENT_TaoGradient

private

Log event for TAO Gradient.

Definition at line 259 of file TaoCtx.hpp.

◆ MOFEM_EVENT_TaoHessian

PetscLogEvent MoFEM::TaoCtx::MOFEM_EVENT_TaoHessian

private

Log event for TAO Hessian.

Definition at line 258 of file TaoCtx.hpp.

◆ MOFEM_EVENT_TaoInequalityConstraint

PetscLogEvent MoFEM::TaoCtx::MOFEM_EVENT_TaoInequalityConstraint

private

Definition at line 262 of file TaoCtx.hpp.

◆ MOFEM_EVENT_TaoInequalityJacobian

PetscLogEvent MoFEM::TaoCtx::MOFEM_EVENT_TaoInequalityJacobian

private

Definition at line 264 of file TaoCtx.hpp.

◆ MOFEM_EVENT_TaoObjective

PetscLogEvent MoFEM::TaoCtx::MOFEM_EVENT_TaoObjective

private

Log event for TAO Objective.

Definition at line 260 of file TaoCtx.hpp.

◆ objectiveAndGradientHook

ObjectiveAndGradientHook MoFEM::TaoCtx::objectiveAndGradientHook

private

Definition at line 255 of file TaoCtx.hpp.

◆ objectiveHook

ObjectiveHook MoFEM::TaoCtx::objectiveHook

private

Definition at line 253 of file TaoCtx.hpp.

◆ postEqualityConstraint

BasicMethodsSequence MoFEM::TaoCtx::postEqualityConstraint

Sequence of methods run after equality constraints are evaluated

Definition at line 71 of file TaoCtx.hpp.

◆ postEqualityJacobian

BasicMethodsSequence MoFEM::TaoCtx::postEqualityJacobian

Sequence of methods run after the equality Jacobian is assembled

Definition at line 83 of file TaoCtx.hpp.

◆ postGradient

BasicMethodsSequence MoFEM::TaoCtx::postGradient

Sequence of methods run after gradient is assembled.

Definition at line 66 of file TaoCtx.hpp.

◆ postHessian

BasicMethodsSequence MoFEM::TaoCtx::postHessian

Sequence of methods run after Hessian is assembled.

Definition at line 56 of file TaoCtx.hpp.

◆ postInequalityConstraint

BasicMethodsSequence MoFEM::TaoCtx::postInequalityConstraint

Sequence of methods run after inequality constraints are evaluated

Definition at line 77 of file TaoCtx.hpp.

◆ postInequalityJacobian

BasicMethodsSequence MoFEM::TaoCtx::postInequalityJacobian

Sequence of methods run after the inequality Jacobian is assembled

Definition at line 89 of file TaoCtx.hpp.

◆ postObjective

BasicMethodsSequence MoFEM::TaoCtx::postObjective

Sequence of methods run after objective is evaluated.

Definition at line 61 of file TaoCtx.hpp.

◆ preEqualityConstraint

BasicMethodsSequence MoFEM::TaoCtx::preEqualityConstraint

Sequence of methods run before equality constraints are evaluated

Definition at line 68 of file TaoCtx.hpp.

◆ preEqualityJacobian

BasicMethodsSequence MoFEM::TaoCtx::preEqualityJacobian

Sequence of methods run before the equality Jacobian is assembled

Definition at line 80 of file TaoCtx.hpp.

◆ preGradient

BasicMethodsSequence MoFEM::TaoCtx::preGradient

Sequence of methods run before gradient is assembled.

Definition at line 64 of file TaoCtx.hpp.

◆ preHessian

BasicMethodsSequence MoFEM::TaoCtx::preHessian

Sequence of methods run before Hessian is assembled.

Definition at line 54 of file TaoCtx.hpp.

◆ preInequalityConstraint

BasicMethodsSequence MoFEM::TaoCtx::preInequalityConstraint

Sequence of methods run before inequality constraints are evaluated

Definition at line 74 of file TaoCtx.hpp.

◆ preInequalityJacobian

BasicMethodsSequence MoFEM::TaoCtx::preInequalityJacobian

Sequence of methods run before the inequality Jacobian is assembled

Definition at line 86 of file TaoCtx.hpp.

◆ preObjective

BasicMethodsSequence MoFEM::TaoCtx::preObjective

Sequence of methods run before objective is evaluated.

Definition at line 59 of file TaoCtx.hpp.

◆ problemName

std::string MoFEM::TaoCtx::problemName

problem name

Definition at line 18 of file TaoCtx.hpp.

◆ vecAssembleSwitch

boost::movelib::unique_ptr<bool> MoFEM::TaoCtx::vecAssembleSwitch

private

Definition at line 256 of file TaoCtx.hpp.

◆ vErify

bool MoFEM::TaoCtx::vErify

If true verify vector.

Definition at line 19 of file TaoCtx.hpp.

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

src/petsc/TaoCtx.hpp
src/petsc/impl/TaoCtx.cpp

Public Types

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ BasicMethodsSequence

◆ FEMethodsSequence

◆ GradientHook

◆ ObjectiveAndGradientHook

◆ ObjectiveHook

◆ PairNameFEMethodPtr

Constructor & Destructor Documentation

◆ TaoCtx()

◆ ~TaoCtx()

Member Function Documentation

◆ clearLoops()

◆ copyLoops()

◆ evaluateConstraint()

◆ evaluateConstraintJacobian()

◆ getEqualityConstraintLoops()

◆ getEqualityJacobianLoops()

◆ getGradientHook()

◆ getGradientLoops()

◆ getHessianLoops()

◆ getInequalityConstraintLoops()

◆ getInequalityJacobianLoops()

◆ getObjectiveAndGradientHook()

◆ getObjectiveHook()

◆ getObjectiveLoops()

◆ getPostProcEqualityConstraint()

◆ getPostProcEqualityJacobian()

◆ getPostProcGradient()

◆ getPostProcHessian()

◆ getPostProcInequalityConstraint()

◆ getPostProcInequalityJacobian()

◆ getPostProcObjective()

◆ getPreProcEqualityConstraint()

◆ getPreProcEqualityJacobian()

◆ getPreProcGradient()

◆ getPreProcHessian()

◆ getPreProcInequalityConstraint()

◆ getPreProcInequalityJacobian()

◆ getPreProcObjective()

Friends And Related Symbol Documentation

◆ TaoSetEqualityConstraints

◆ TaoSetGradient

◆ TaoSetHessian

◆ TaoSetInequalityConstraints

◆ TaoSetJacobianEquality

◆ TaoSetJacobianInequality

◆ TaoSetObjective

◆ TaoSetObjectiveAndGradient

Member Data Documentation

◆ gradientHook

◆ loopsEqualityConstraint

◆ loopsEqualityJacobian

◆ loopsGradient

◆ loopsHessian

◆ loopsInequalityConstraint

◆ loopsInequalityJacobian

◆ loopsObjective

◆ matAssembleSwitch

◆ mField

◆ moab

◆ MOFEM_EVENT_TaoEqualityConstraint

◆ MOFEM_EVENT_TaoEqualityJacobian

◆ MOFEM_EVENT_TaoGradient

◆ MOFEM_EVENT_TaoHessian

◆ MOFEM_EVENT_TaoInequalityConstraint

◆ MOFEM_EVENT_TaoInequalityJacobian

◆ MOFEM_EVENT_TaoObjective

◆ objectiveAndGradientHook

◆ objectiveHook

◆ postEqualityConstraint

◆ postEqualityJacobian

◆ postGradient

◆ postHessian