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

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 ()

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

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.

Private Attributes
boost::movelib::unique_ptr< bool >	vecAssembleSwitch

boost::movelib::unique_ptr< bool >	matAssembleSwitch

PetscLogEvent	MOFEM_EVENT_SnesRhs
	Log events to assemble residual.

PetscLogEvent	MOFEM_EVENT_SnesMat
	Log events to assemble tangent matrix.

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.

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.

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.

◆ 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 50 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);
    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.

Returns: MoFEMErrorCode

Definition at line 23 of file TaoCtx.cpp.

                                  {
  MoFEMFunctionBeginHot;
  loopsHessian.clear();
  loopsObjective.clear();
  loopsGradient.clear();
  preHessian.clear();
  postHessian.clear();
  preObjective.clear();
  postObjective.clear();
  preGradient.clear();
  postGradient.clear();
  MoFEMFunctionReturnHot(0);
}

◆ copyLoops()

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

Copy sequences from another TaoCtx.

Parameters

tao_ctx TaoCtx from which sequences are copied

Returns: error code

Definition at line 9 of file TaoCtx.cpp.

                                                      {
  MoFEMFunctionBeginHot;
  loopsHessian = tao_ctx.loopsHessian;
  loopsObjective = tao_ctx.loopsObjective;
  loopsGradient = tao_ctx.loopsGradient;
  preHessian = tao_ctx.preHessian;
  postHessian = tao_ctx.postHessian;
  preObjective = tao_ctx.preObjective;
  postObjective = tao_ctx.postObjective;
  preGradient = tao_ctx.preGradient;
  postGradient = tao_ctx.postGradient;
  MoFEMFunctionReturnHot(0);
}

◆ getGradientLoops()

FEMethodsSequence & MoFEM::TaoCtx::getGradientLoops ( )

inline

Definition at line 78 of file TaoCtx.hpp.

78{ return loopsGradient; }

◆ getHessianLoops()

FEMethodsSequence & MoFEM::TaoCtx::getHessianLoops ( )

inline

Definition at line 68 of file TaoCtx.hpp.

68{ return loopsHessian; }

◆ getObjectiveLoops()

FEMethodsSequence & MoFEM::TaoCtx::getObjectiveLoops ( )

inline

Definition at line 73 of file TaoCtx.hpp.

73{ return loopsObjective; }

◆ getPostProcGradient()

BasicMethodsSequence & MoFEM::TaoCtx::getPostProcGradient ( )

inline

Definition at line 80 of file TaoCtx.hpp.

80{ return postGradient; }

◆ getPostProcHessian()

BasicMethodsSequence & MoFEM::TaoCtx::getPostProcHessian ( )

inline

Definition at line 70 of file TaoCtx.hpp.

70{ return postHessian; }

◆ getPostProcObjective()

BasicMethodsSequence & MoFEM::TaoCtx::getPostProcObjective ( )

inline

Definition at line 75 of file TaoCtx.hpp.

75{ return postObjective; }

◆ getPreProcGradient()

BasicMethodsSequence & MoFEM::TaoCtx::getPreProcGradient ( )

inline

Definition at line 79 of file TaoCtx.hpp.

79{ return preGradient; }

◆ getPreProcHessian()

BasicMethodsSequence & MoFEM::TaoCtx::getPreProcHessian ( )

inline

Definition at line 69 of file TaoCtx.hpp.

69{ return preHessian; }

◆ getPreProcObjective()

BasicMethodsSequence & MoFEM::TaoCtx::getPreProcObjective ( )

inline

Definition at line 74 of file TaoCtx.hpp.

74{ return preObjective; }

Friends And Related Symbol Documentation

◆ 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 92 of file TaoCtx.cpp.

                                                                {
  TaoCtx *tao_ctx = (TaoCtx *)ctx;
  MoFEMFunctionBegin;
  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_GRADIENT;
    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 186 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);  
}

◆ 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 37 of file TaoCtx.cpp.

                                                                        {
  TaoCtx *tao_ctx = (TaoCtx *)ctx;
  MoFEMFunctionBegin;
  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 178 of file TaoCtx.cpp.

                                                     {
  MoFEMFunctionBegin;
  CHKERR TaoSetObjective(tao, x, f, ctx);
  CHKERR TaoSetGradient(tao, x, g, ctx);
  MoFEMFunctionReturn(0);
}

Member Data Documentation

◆ loopsGradient

FEMethodsSequence MoFEM::TaoCtx::loopsGradient

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

Definition at line 32 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 26 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 29 of file TaoCtx.hpp.

◆ matAssembleSwitch

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

private

Definition at line 106 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_SnesMat

PetscLogEvent MoFEM::TaoCtx::MOFEM_EVENT_SnesMat

private

Log events to assemble tangent matrix.

Definition at line 108 of file TaoCtx.hpp.

◆ MOFEM_EVENT_SnesRhs

PetscLogEvent MoFEM::TaoCtx::MOFEM_EVENT_SnesRhs

private

Log events to assemble residual.

Definition at line 107 of file TaoCtx.hpp.

◆ MOFEM_EVENT_TaoGradient

PetscLogEvent MoFEM::TaoCtx::MOFEM_EVENT_TaoGradient

private

Log event for TAO Gradient.

Definition at line 110 of file TaoCtx.hpp.

◆ MOFEM_EVENT_TaoHessian

PetscLogEvent MoFEM::TaoCtx::MOFEM_EVENT_TaoHessian

private

Log event for TAO Hessian.

Definition at line 109 of file TaoCtx.hpp.

◆ MOFEM_EVENT_TaoObjective

PetscLogEvent MoFEM::TaoCtx::MOFEM_EVENT_TaoObjective

private

Log event for TAO Objective.

Definition at line 111 of file TaoCtx.hpp.

◆ postGradient

BasicMethodsSequence MoFEM::TaoCtx::postGradient

Sequence of methods run after gradient is assembled.

Definition at line 48 of file TaoCtx.hpp.

◆ postHessian

BasicMethodsSequence MoFEM::TaoCtx::postHessian

Sequence of methods run after Hessian is assembled.

Definition at line 38 of file TaoCtx.hpp.

◆ postObjective

BasicMethodsSequence MoFEM::TaoCtx::postObjective

Sequence of methods run after objective is evaluated.

Definition at line 43 of file TaoCtx.hpp.

◆ preGradient

BasicMethodsSequence MoFEM::TaoCtx::preGradient

Sequence of methods run before gradient is assembled.

Definition at line 46 of file TaoCtx.hpp.

◆ preHessian

BasicMethodsSequence MoFEM::TaoCtx::preHessian

Sequence of methods run before Hessian is assembled.

Definition at line 36 of file TaoCtx.hpp.

◆ preObjective

BasicMethodsSequence MoFEM::TaoCtx::preObjective

Sequence of methods run before objective is evaluated.

Definition at line 41 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 105 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 Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ BasicMethodsSequence

◆ FEMethodsSequence

◆ PairNameFEMethodPtr

Constructor & Destructor Documentation

◆ TaoCtx()

◆ ~TaoCtx()

Member Function Documentation

◆ clearLoops()

◆ copyLoops()

◆ getGradientLoops()

◆ getHessianLoops()

◆ getObjectiveLoops()

◆ getPostProcGradient()

◆ getPostProcHessian()

◆ getPostProcObjective()

◆ getPreProcGradient()

◆ getPreProcHessian()

◆ getPreProcObjective()

Friends And Related Symbol Documentation

◆ TaoSetGradient

◆ TaoSetHessian

◆ TaoSetObjective

◆ TaoSetObjectiveAndGradient

Member Data Documentation

◆ loopsGradient

◆ loopsHessian

◆ loopsObjective

◆ matAssembleSwitch

◆ mField

◆ moab

◆ MOFEM_EVENT_SnesMat

◆ MOFEM_EVENT_SnesRhs

◆ MOFEM_EVENT_TaoGradient

◆ MOFEM_EVENT_TaoHessian

◆ MOFEM_EVENT_TaoObjective

◆ postGradient

◆ postHessian

◆ postObjective

◆ preGradient

◆ preHessian

◆ preObjective

◆ problemName

◆ vecAssembleSwitch

◆ vErify