Interface for Time Stepping (TS) solver. More...

#include <src/petsc/TsCtx.hpp>

Collaboration diagram for MoFEM::TsCtx:

Public Types
typedef MoFEM::PairNameFEMethodPtr	PairNameFEMethodPtr

typedef MoFEM::FEMethodsSequence	FEMethodsSequence

typedef MoFEM::BasicMethodsSequence	BasicMethodsSequence

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

virtual	~TsCtx ()=default

FEMethodsSequence &	getLoopsIFunction ()
	Get the loops to do IFunction object. More...

FEMethodsSequence &	getLoopsRHSFunction ()
	Get the loops to do RHSFunction object. More...

FEMethodsSequence &	getLoopsIJacobian ()
	Get the loops to do IJacobian object. More...

FEMethodsSequence &	getLoopsRHSJacobian ()
	Get the loops to do RHSJacobian object. More...

FEMethodsSequence &	getLoopsMonitor ()
	Get the loops to do Monitor object. More...

BasicMethodsSequence &	getPreProcessIFunction ()
	Get the preProcess to do IFunction object. More...

BasicMethodsSequence &	getPostProcessIFunction ()
	Get the postProcess to do IFunction object. More...

BasicMethodsSequence &	getPreProcessIJacobian ()
	Get the preProcess to do IJacobian object. More...

BasicMethodsSequence &	getPostProcessIJacobian ()
	Get the postProcess to do IJacobian object. More...

BasicMethodsSequence &	getPreProcessMonitor ()
	Get the preProcess to do Monitor object. More...

BasicMethodsSequence &	getPostProcessMonitor ()
	Get the postProcess to do Monitor object. More...

BasicMethodsSequence &	getPreProcessRHSJacobian ()
	Get the preProcess to do RHSJacobian object. More...

BasicMethodsSequence &	getPostProcessRHSJacobian ()
	Get the postProcess to do RHSJacobian object. More...

BasicMethodsSequence &	getPreProcessRHSFunction ()
	Get the preProcess to do RHSFunction object. More...

BasicMethodsSequence &	getPostProcessRHSFunction ()
	Get the postProcess to do RHSFunction object. More...

MoFEMErrorCode	clearLoops ()
	Clear loops. More...

Public Attributes
MoFEM::Interface &	mField

moab::Interface &	moab

std::string	problemName

MoFEMTypes	bH
	If set to MF_EXIST check if element exist. More...

FEMethodsSequence	loopsIJacobian

FEMethodsSequence	loopsIFunction

FEMethodsSequence	loopsMonitor

FEMethodsSequence	loopsRHSJacobian

FEMethodsSequence	loopsRHSFunction

BasicMethodsSequence	preProcessIJacobian

BasicMethodsSequence	postProcessIJacobian

BasicMethodsSequence	preProcessIFunction

BasicMethodsSequence	postProcessIFunction

BasicMethodsSequence	preProcessMonitor

BasicMethodsSequence	postProcessMonitor

BasicMethodsSequence	preProcessRHSJacobian

BasicMethodsSequence	preProcessRHSFunction

BasicMethodsSequence	postProcessRHSJacobian

BasicMethodsSequence	postProcessRHSFunction

bool	zeroMatrix

Private Attributes
PetscLogEvent	MOFEM_EVENT_TsCtxRHSFunction

PetscLogEvent	MOFEM_EVENT_TsCtxRHSJacobian

PetscLogEvent	MOFEM_EVENT_TsCtxIFunction

PetscLogEvent	MOFEM_EVENT_TsCtxIJacobian

PetscLogEvent	MOFEM_EVENT_TsCtxMonitor

PetscLogEvent	MOFEM_EVENT_TsCtxI2Function

PetscLogEvent	MOFEM_EVENT_TsCtxI2Jacobian

boost::movelib::unique_ptr< bool >	vecAssembleSwitch

boost::movelib::unique_ptr< bool >	matAssembleSwitch

Friends
PetscErrorCode	TsSetIFunction (TS ts, PetscReal t, Vec u, Vec u_t, Vec F, void *ctx)
	Set IFunction for TS solver. More...

PetscErrorCode	TsSetIJacobian (TS ts, PetscReal t, Vec u, Vec U_t, PetscReal a, Mat A, Mat B, void *ctx)
	Set function evaluating jacobina in TS solver. More...

PetscErrorCode	TsMonitorSet (TS ts, PetscInt step, PetscReal t, Vec u, void *ctx)
	Set monitor for TS solver. More...

PetscErrorCode	TsSetRHSFunction (TS ts, PetscReal t, Vec u, Vec F, void *ctx)
	TS solver function. More...

PetscErrorCode	TsSetRHSJacobian (TS ts, PetscReal t, Vec u, Mat A, Mat B, void *ctx)
	TS solver function. More...

PetscErrorCode	TsSetI2Function (TS ts, PetscReal t, Vec U, Vec U_t, Vec U_tt, Vec F, void *ctx)
	Calculation the right hand side for second order PDE in time. More...

PetscErrorCode	TsSetI2Jacobian (TS ts, PetscReal t, Vec U, Vec U_t, Vec U_tt, PetscReal v, PetscReal a, Mat J, Mat P, void *ctx)
	Calculation Jaconian for second order PDE in time. More...

Detailed Description

Interface for Time Stepping (TS) solver.

Definition at line 27 of file TsCtx.hpp.

Member Typedef Documentation

◆ BasicMethodsSequence

typedef MoFEM::BasicMethodsSequence MoFEM::TsCtx::BasicMethodsSequence

Definition at line 37 of file TsCtx.hpp.

◆ FEMethodsSequence

typedef MoFEM::FEMethodsSequence MoFEM::TsCtx::FEMethodsSequence

Examples: nonlinear_dynamics.cpp.

Definition at line 36 of file TsCtx.hpp.

◆ PairNameFEMethodPtr

typedef MoFEM::PairNameFEMethodPtr MoFEM::TsCtx::PairNameFEMethodPtr

Examples: EshelbianPlasticity.cpp, and nonlinear_dynamics.cpp.

Definition at line 35 of file TsCtx.hpp.

Constructor & Destructor Documentation

◆ TsCtx()

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

Definition at line 57 of file TsCtx.hpp.

       : mField(m_field), moab(m_field.get_moab()), problemName(problem_name),
         bH(MF_EXIST), zeroMatrix(true) {
     PetscLogEventRegister("LoopTsIFunction", 0, &MOFEM_EVENT_TsCtxIFunction);
     PetscLogEventRegister("LoopTsIJacobian", 0, &MOFEM_EVENT_TsCtxIJacobian);
     PetscLogEventRegister("LoopTsRHSFunction", 0,
                           &MOFEM_EVENT_TsCtxRHSFunction);
     PetscLogEventRegister("LoopTsRHSJacobian", 0,
                           &MOFEM_EVENT_TsCtxRHSJacobian);
     PetscLogEventRegister("LoopTsMonitor", 0, &MOFEM_EVENT_TsCtxMonitor);
     PetscLogEventRegister("LoopTsI2Function", 0, &MOFEM_EVENT_TsCtxI2Function);
     PetscLogEventRegister("LoopTsI2Jacobian", 0, &MOFEM_EVENT_TsCtxI2Jacobian);
   }

◆ ~TsCtx()

virtual MoFEM::TsCtx::~TsCtx ( )

virtualdefault

Member Function Documentation

◆ clearLoops()

MoFEMErrorCode MoFEM::TsCtx::clearLoops ( )

Clear loops.

Returns: MoFEMErrorCode

Definition at line 17 of file TsCtx.cpp.

                                  {
   MoFEMFunctionBeginHot;
   loopsIJacobian.clear();
   loopsIFunction.clear();
   loopsMonitor.clear();
   loopsRHSJacobian.clear();
   loopsRHSFunction.clear();
   preProcessIJacobian.clear();
   postProcessIJacobian.clear();
   preProcessIFunction.clear();
   postProcessIFunction.clear();
   preProcessMonitor.clear();
   postProcessMonitor.clear();
   preProcessRHSJacobian.clear();
   preProcessRHSFunction.clear();
   postProcessRHSJacobian.clear();
   postProcessRHSFunction.clear();
   MoFEMFunctionReturnHot(0);
 }  

◆ getLoopsIFunction()

FEMethodsSequence& MoFEM::TsCtx::getLoopsIFunction ( )

Get the loops to do IFunction object.

It is sequence of finite elements used to evaluate the right hand side of implicit time solver.

Returns: FEMethodsSequence&

Definition at line 81 of file TsCtx.hpp.

81 { return loopsIFunction; }

◆ getLoopsIJacobian()

FEMethodsSequence& MoFEM::TsCtx::getLoopsIJacobian ( )

Get the loops to do IJacobian object.

It is sequence of finite elements used to evalite the left hand sie of implimcit time solver.

Returns: FEMethodsSequence&

Definition at line 101 of file TsCtx.hpp.

101 { return loopsIJacobian; }

◆ getLoopsMonitor()

FEMethodsSequence& MoFEM::TsCtx::getLoopsMonitor ( )

Get the loops to do Monitor object.

It is sequence used to monitor solution of time solver.

Returns: FEMethodsSequence&

Definition at line 120 of file TsCtx.hpp.

120 { return loopsMonitor; }

◆ getLoopsRHSFunction()

FEMethodsSequence& MoFEM::TsCtx::getLoopsRHSFunction ( )

Get the loops to do RHSFunction object.

It is sequence of finite elements used to evaluate the right hand side of implicit time solver.

Returns: FEMethodsSequence&

Definition at line 91 of file TsCtx.hpp.

91 { return loopsRHSFunction; }

◆ getLoopsRHSJacobian()

FEMethodsSequence& MoFEM::TsCtx::getLoopsRHSJacobian ( )

Get the loops to do RHSJacobian object.

It is sequence of finite elements used to evalite the left hand sie of implimcit time solver.

Returns: FEMethodsSequence&

Definition at line 111 of file TsCtx.hpp.

111 { return loopsRHSJacobian; }

◆ getPostProcessIFunction()

BasicMethodsSequence& MoFEM::TsCtx::getPostProcessIFunction ( )

Get the postProcess to do IFunction object.

Returns: BasicMethodsSequence&

Definition at line 134 of file TsCtx.hpp.

                                                   {
     return postProcessIFunction;
   }

◆ getPostProcessIJacobian()

BasicMethodsSequence& MoFEM::TsCtx::getPostProcessIJacobian ( )

Get the postProcess to do IJacobian object.

Returns: BasicMethodsSequence&

Definition at line 150 of file TsCtx.hpp.

                                                   {
     return postProcessIJacobian;
   }

◆ getPostProcessMonitor()

BasicMethodsSequence& MoFEM::TsCtx::getPostProcessMonitor ( )

Get the postProcess to do Monitor object.

Returns: BasicMethodsSequence&

Definition at line 166 of file TsCtx.hpp.

166 { return postProcessMonitor; }

◆ getPostProcessRHSFunction()

BasicMethodsSequence& MoFEM::TsCtx::getPostProcessRHSFunction ( )

Get the postProcess to do RHSFunction object.

Returns: BasicMethodsSequence&

Definition at line 200 of file TsCtx.hpp.

                                                     {
     return postProcessRHSFunction;
   }

◆ getPostProcessRHSJacobian()

BasicMethodsSequence& MoFEM::TsCtx::getPostProcessRHSJacobian ( )

Get the postProcess to do RHSJacobian object.

Returns: BasicMethodsSequence&

Definition at line 182 of file TsCtx.hpp.

                                                     {
     return postProcessRHSJacobian;
   }

◆ getPreProcessIFunction()

BasicMethodsSequence& MoFEM::TsCtx::getPreProcessIFunction ( )

Get the preProcess to do IFunction object.

Returns: BasicMethodsSequence&

Definition at line 127 of file TsCtx.hpp.

127 { return preProcessIFunction; }

◆ getPreProcessIJacobian()

BasicMethodsSequence& MoFEM::TsCtx::getPreProcessIJacobian ( )

Get the preProcess to do IJacobian object.

Returns: BasicMethodsSequence&

Definition at line 143 of file TsCtx.hpp.

143 { return preProcessIJacobian; }

◆ getPreProcessMonitor()

BasicMethodsSequence& MoFEM::TsCtx::getPreProcessMonitor ( )

Get the preProcess to do Monitor object.

Returns: BasicMethodsSequence&

Definition at line 159 of file TsCtx.hpp.

159 { return preProcessMonitor; }

◆ getPreProcessRHSFunction()

BasicMethodsSequence& MoFEM::TsCtx::getPreProcessRHSFunction ( )

Get the preProcess to do RHSFunction object.

Returns: BasicMethodsSequence&

Definition at line 191 of file TsCtx.hpp.

                                                    {
     return preProcessRHSFunction;
   }

◆ getPreProcessRHSJacobian()

BasicMethodsSequence& MoFEM::TsCtx::getPreProcessRHSJacobian ( )

Get the preProcess to do RHSJacobian object.

Returns: BasicMethodsSequence&

Definition at line 173 of file TsCtx.hpp.

                                                    {
     return preProcessRHSJacobian;
   }

Friends And Related Function Documentation

◆ TsMonitorSet

PetscErrorCode TsMonitorSet	(	TS	ts,
		PetscInt	step,
		PetscReal	t,
		Vec	u,
		void *	ctx
	)

friend

Set monitor for TS solver.

See PETSc for details

Parameters

ts
step
t
u
ctx

Returns: PetscErrorCode

Definition at line 229 of file TsCtx.cpp.

                                        {
   MoFEMFunctionBegin;
   TsCtx *ts_ctx = static_cast<TsCtx *>(ctx);
   PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxMonitor, 0, 0, 0, 0);
   CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
       ts_ctx->problemName, COL, u, INSERT_VALUES, SCATTER_REVERSE);
  
   auto set = [&](auto &fe) {
     fe.ts = ts;
     fe.ts_u = u;
     fe.ts_t = t;
     fe.ts_step = step;
     fe.ts_F = PETSC_NULL;
     fe.ts_ctx = TSMethod::CTX_TSTSMONITORSET;
     fe.snes_ctx = SnesMethod::CTX_SNESNONE;
     fe.ksp_ctx = KspMethod::CTX_KSPNONE;
     fe.data_ctx = PetscData::CtxSetX | PetscData::CtxSetTime;
   };
  
   auto unset = [&](auto &fe) {
     fe.ts_ctx = TSMethod::CTX_TSNONE;
     fe.data_ctx = PetscData::CtxSetNone;
   };
  
   // preproces
   for (auto &bit : ts_ctx->preProcessMonitor) {
     set(*bit);
     CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
                                                           *bit);
     unset(*bit);
   }
  
   auto cache_ptr = boost::make_shared<CacheTuple>();
   CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
  
   for (auto &lit : ts_ctx->loopsMonitor) {
     set(*lit.second);
     CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
                                                *(lit.second), nullptr,
                                                ts_ctx->bH, cache_ptr);
     unset(*lit.second);
   }
  
   // post process
   for (auto &bit : ts_ctx->postProcessMonitor) {
     set(*bit);
     CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
                                                            *bit);
     unset(*bit);
   }
  
   PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxMonitor, 0, 0, 0, 0);
   MoFEMFunctionReturn(0);
 }

◆ TsSetI2Function

PetscErrorCode TsSetI2Function	(	TS	ts,
		PetscReal	t,
		Vec	U,
		Vec	U_t,
		Vec	U_tt,
		Vec	F,
		void *	ctx
	)

friend

Calculation the right hand side for second order PDE in time.

PETSc for details

Parameters

ts
t
u
u_t
u_tt
F
ctx

Returns: PetscErrorCode

Definition at line 569 of file TsCtx.cpp.

                                                  {
   MoFEMFunctionBegin;
   TsCtx *ts_ctx = static_cast<TsCtx *>(ctx);
   PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxIFunction, 0, 0, 0, 0);
   CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR VecGhostUpdateBegin(u_t, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR VecGhostUpdateEnd(u_t, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR VecGhostUpdateBegin(u_tt, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR VecGhostUpdateEnd(u_tt, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
       ts_ctx->problemName, COL, u, 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);
  
   ts_ctx->vecAssembleSwitch = boost::movelib::make_unique<bool>(true);
  
   int step;
 #if PETSC_VERSION_GE(3, 8, 0)
   CHKERR TSGetStepNumber(ts, &step);
 #else
   CHKERR TSGetTimeStepNumber(ts, &step);
 #endif
  
   auto set = [&](auto &fe) {
     fe.ts_u = u;
     fe.ts_u_t = u_t;
     fe.ts_u_tt = u_tt;
     fe.ts_F = F;
     fe.ts_t = t;
     fe.ts_step = step;
     fe.ts_ctx = TSMethod::CTX_TSSETIFUNCTION;
     fe.snes_ctx = SnesMethod::CTX_SNESSETFUNCTION;
     fe.ksp_ctx = KspMethod::CTX_SETFUNCTION;
     fe.data_ctx = PetscData::CtxSetF | PetscData::CtxSetX |
                   PetscData::CtxSetX_T | PetscData::CtxSetX_TT |
                   PetscData::CtxSetTime;
     fe.ts = ts;
   };
  
   auto unset = [&](auto &fe) {
     fe.ts_ctx = TSMethod::CTX_TSNONE;
     fe.snes_ctx = SnesMethod::CTX_SNESNONE;
     fe.ksp_ctx = KspMethod::CTX_KSPNONE;
     fe.data_ctx = PetscData::CtxSetNone;
   };
  
   // preprocess
   for (auto &bit : ts_ctx->preProcessIFunction) {
     bit->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
     set(*bit);
     CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
                                                           *bit);
     unset(*bit);
     ts_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
   }
  
   auto cache_ptr = boost::make_shared<CacheTuple>();
   CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
  
   // fe loops
   for (auto &lit : ts_ctx->loopsIFunction) {
     lit.second->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
     set(*lit.second);
     CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
                                                *(lit.second), nullptr,
                                                ts_ctx->bH, cache_ptr);
     unset(*lit.second);
     ts_ctx->vecAssembleSwitch = boost::move(lit.second->vecAssembleSwitch);
   }
  
   // post process
   for (auto &bit : ts_ctx->postProcessIFunction) {
     bit->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
     set(*bit);
     CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
                                                            *bit);
     unset(*bit);
     ts_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
   }
  
   if (*ts_ctx->vecAssembleSwitch) {
     CHKERR VecGhostUpdateBegin(F, ADD_VALUES, SCATTER_REVERSE);
     CHKERR VecGhostUpdateEnd(F, ADD_VALUES, SCATTER_REVERSE);
     CHKERR VecAssemblyBegin(F);
     CHKERR VecAssemblyEnd(F);
   }
  
   PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxIFunction, 0, 0, 0, 0);
   MoFEMFunctionReturn(0);
 }

◆ TsSetI2Jacobian

PetscErrorCode TsSetI2Jacobian	(	TS	ts,
		PetscReal	t,
		Vec	U,
		Vec	U_t,
		Vec	U_tt,
		PetscReal	v,
		PetscReal	a,
		Mat	J,
		Mat	P,
		void *	ctx
	)

friend

Calculation Jaconian for second order PDE in time.

See PETSc for details

Parameters

ts
t	time at step/stage being solved
u	state vectora
u_t	time derivative of state vector
u_tt	second time derivative of state vector
a	shift for u_t
aa	shift for u_tt
A	Jacobian of G(U) = F(t,U,W+vU,W'+aU), equivalent to dF/dU + vdF/dU_t + adF/dU_tt
B	preconditioning matrix for J, may be same as J
ctx	TsCtx context for matrix evaluation routine

Returns: PetscErrorCode

Definition at line 473 of file TsCtx.cpp.

                                           {
   MoFEMFunctionBegin;
  
   TsCtx *ts_ctx = static_cast<TsCtx *>(ctx);
   PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxI2Function, 0, 0, 0, 0);
   CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR VecGhostUpdateBegin(u_t, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR VecGhostUpdateEnd(u_t, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR VecGhostUpdateBegin(u_tt, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR VecGhostUpdateEnd(u_tt, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
       ts_ctx->problemName, COL, u, INSERT_VALUES, SCATTER_REVERSE);
   if (ts_ctx->zeroMatrix) {
     CHKERR MatZeroEntries(B);
   }
   int step;
 #if PETSC_VERSION_GE(3, 8, 0)
   CHKERR TSGetStepNumber(ts, &step);
 #else
   CHKERR TSGetTimeStepNumber(ts, &step);
 #endif
  
   ts_ctx->matAssembleSwitch =
       boost::movelib::make_unique<bool>(ts_ctx->zeroMatrix);
  
   auto set = [&](auto &fe) {
     fe.ts_u = u;
     fe.ts_u_t = u_t;
     fe.ts_u_tt = u_tt;
     fe.ts_A = A;
     fe.ts_B = B;
     fe.ts_t = t;
     fe.ts_a = a;
     fe.ts_aa = aa;
     fe.ts_step = step;
  
     fe.ts_ctx = TSMethod::CTX_TSSETIJACOBIAN;
     fe.snes_ctx = SnesMethod::CTX_SNESSETJACOBIAN;
     fe.ksp_ctx = KspMethod::CTX_OPERATORS;
     fe.data_ctx = PetscData::CtxSetA | PetscData::CtxSetB | PetscData::CtxSetX |
                   PetscData::CtxSetX_T | PetscData::CtxSetX_TT |
                   PetscData::CtxSetTime;
     fe.ts = ts;
   };
  
   auto unset = [&](auto &fe) {
     fe.ts_ctx = TSMethod::CTX_TSNONE;
     fe.snes_ctx = SnesMethod::CTX_SNESNONE;
     fe.ksp_ctx = KspMethod::CTX_KSPNONE;
     fe.data_ctx = PetscData::CtxSetNone;
   };
  
   // preproces
   for (auto &bit : ts_ctx->preProcessIJacobian) {
     bit->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
     set(*bit);
     CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
                                                           *bit);
     unset(*bit);
     ts_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
   }
  
   auto cache_ptr = boost::make_shared<CacheTuple>();
   CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
  
   for (auto &lit : ts_ctx->loopsIJacobian) {
     lit.second->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
     set(*lit.second);
     CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
                                                *(lit.second), nullptr,
                                                ts_ctx->bH, cache_ptr);
     unset(*lit.second);
     ts_ctx->matAssembleSwitch = boost::move(lit.second->matAssembleSwitch);
   }
  
   // post process
   for (auto &bit : ts_ctx->postProcessIJacobian) {
     bit->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
     set(*bit);
     CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
                                                            *bit);
     unset(*bit);
     ts_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
   }
  
   if (ts_ctx->matAssembleSwitch) {
     CHKERR MatAssemblyBegin(B, MAT_FINAL_ASSEMBLY);
     CHKERR MatAssemblyEnd(B, MAT_FINAL_ASSEMBLY);
   }
   PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxI2Function, 0, 0, 0, 0);
   MoFEMFunctionReturn(0);
 }

◆ TsSetIFunction

PetscErrorCode TsSetIFunction	(	TS	ts,
		PetscReal	t,
		Vec	u,
		Vec	u_t,
		Vec	F,
		void *	ctx
	)

friend

Set IFunction for TS solver.

See petsc for details

Parameters

ts
t
u
u_t
F
ctx

Returns: PetscErrorCode

Definition at line 37 of file TsCtx.cpp.

                                          {
   MoFEMFunctionBegin;
   TsCtx *ts_ctx = static_cast<TsCtx *>(ctx);
   PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxIFunction, 0, 0, 0, 0);
   CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR VecGhostUpdateBegin(u_t, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR VecGhostUpdateEnd(u_t, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
       ts_ctx->problemName, COL, u, 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);
  
   ts_ctx->vecAssembleSwitch = boost::movelib::make_unique<bool>(true);
  
   int step;
 #if PETSC_VERSION_GE(3, 8, 0)
   CHKERR TSGetStepNumber(ts, &step);
 #else
   CHKERR TSGetTimeStepNumber(ts, &step);
 #endif
  
   auto set = [&](auto &fe) {
     fe.ts = ts;
     fe.ts_u = u;
     fe.ts_u_t = u_t;
     fe.ts_F = F;
     fe.ts_t = t;
     fe.ts_step = step;
     fe.ts_ctx = TSMethod::CTX_TSSETIFUNCTION;
     fe.snes_ctx = SnesMethod::CTX_SNESSETFUNCTION;
     fe.ksp_ctx = KspMethod::CTX_SETFUNCTION;
     fe.data_ctx = PetscData::CtxSetF | PetscData::CtxSetX |
                   PetscData::CtxSetX_T | PetscData::CtxSetTime;
   };
  
   auto unset = [&](auto &fe) {
     fe.ts_ctx = TSMethod::CTX_TSNONE;
     fe.snes_ctx = SnesMethod::CTX_SNESNONE;
     fe.ksp_ctx = KspMethod::CTX_KSPNONE;
     fe.data_ctx = PetscData::CtxSetNone;
   };
  
   // preprocess
   for (auto &bit : ts_ctx->preProcessIFunction) {
     bit->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
     set(*bit);
     CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
                                                           *bit);
     unset(*bit);
     ts_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
   }
  
   auto cache_ptr = boost::make_shared<CacheTuple>();
   CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
  
   // fe loops
   for (auto &lit : ts_ctx->loopsIFunction) {
     lit.second->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
     set(*lit.second);
     CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
                                                *(lit.second), nullptr,
                                                ts_ctx->bH, cache_ptr);
     unset(*lit.second);
     ts_ctx->vecAssembleSwitch = boost::move(lit.second->vecAssembleSwitch);
   }
  
   // post process
   for (auto &bit : ts_ctx->postProcessIFunction) {
     bit->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
     set(*bit);
     CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
                                                            *bit);
     unset(*bit);
     ts_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
   }
  
   if (*ts_ctx->vecAssembleSwitch) {
     CHKERR VecGhostUpdateBegin(F, ADD_VALUES, SCATTER_REVERSE);
     CHKERR VecGhostUpdateEnd(F, ADD_VALUES, SCATTER_REVERSE);
     CHKERR VecAssemblyBegin(F);
     CHKERR VecAssemblyEnd(F);
   }
  
   PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxIFunction, 0, 0, 0, 0);
   MoFEMFunctionReturn(0);
 }

◆ TsSetIJacobian

PetscErrorCode TsSetIJacobian	(	TS	ts,
		PetscReal	t,
		Vec	u,
		Vec	U_t,
		PetscReal	a,
		Mat	A,
		Mat	B,
		void *	ctx
	)

friend

Set function evaluating jacobina in TS solver.

See PETSc for details

Parameters

ts
t
u
u_t
a
A
B
ctx

Returns: PetscErrorCode

Definition at line 140 of file TsCtx.cpp.

                                                        {
   MoFEMFunctionBegin;
  
   TsCtx *ts_ctx = static_cast<TsCtx *>(ctx);
   PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxIFunction, 0, 0, 0, 0);
   CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR VecGhostUpdateBegin(u_t, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR VecGhostUpdateEnd(u_t, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
       ts_ctx->problemName, COL, u, INSERT_VALUES, SCATTER_REVERSE);
   if (ts_ctx->zeroMatrix) {
     CHKERR MatZeroEntries(B);
   }
   int step;
 #if PETSC_VERSION_GE(3, 8, 0)
   CHKERR TSGetStepNumber(ts, &step);
 #else
   CHKERR TSGetTimeStepNumber(ts, &step);
 #endif
  
   ts_ctx->matAssembleSwitch =
       boost::movelib::make_unique<bool>(ts_ctx->zeroMatrix);
  
   auto set = [&](auto &fe) {
     fe.ts = ts;
     fe.ts_u = u;
     fe.ts_u_t = u_t;
     fe.ts_A = A;
     fe.ts_B = B;
     fe.ts_t = t;
     fe.ts_a = a;
     fe.ts_step = step;
     fe.ts_ctx = TSMethod::CTX_TSSETIJACOBIAN;
     fe.snes_ctx = SnesMethod::CTX_SNESSETJACOBIAN;
     fe.ksp_ctx = KspMethod::CTX_OPERATORS;
     fe.data_ctx = PetscData::CtxSetA | PetscData::CtxSetB | PetscData::CtxSetX |
                   PetscData::CtxSetX_T | PetscData::CtxSetTime;
   };
  
   auto unset = [&](auto &fe) {
     fe.ts_ctx = TSMethod::CTX_TSNONE;
     fe.snes_ctx = SnesMethod::CTX_SNESNONE;
     fe.ksp_ctx = KspMethod::CTX_KSPNONE;
     fe.data_ctx = PetscData::CtxSetNone;
   };
  
   // preproces
   for (auto &bit : ts_ctx->preProcessIJacobian) {
     bit->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
     set(*bit);
     CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
                                                           *bit);
     unset(*bit);
     ts_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
   }
  
   auto cache_ptr = boost::make_shared<CacheTuple>();
   CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
  
   for (auto &lit : ts_ctx->loopsIJacobian) {
     lit.second->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
     set(*lit.second);
     CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
                                                *(lit.second), nullptr,
                                                ts_ctx->bH, cache_ptr);
     unset(*lit.second);
     ts_ctx->matAssembleSwitch = boost::move(lit.second->matAssembleSwitch);
   }
  
   // post process
   for (auto &bit : ts_ctx->postProcessIJacobian) {
     bit->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
     set(*bit);
     CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
                                                            *bit);
     unset(*bit);
     ts_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
   }
  
   if (ts_ctx->matAssembleSwitch) {
     CHKERR MatAssemblyBegin(B, MAT_FINAL_ASSEMBLY);
     CHKERR MatAssemblyEnd(B, MAT_FINAL_ASSEMBLY);
   }
   PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxIFunction, 0, 0, 0, 0);
   MoFEMFunctionReturn(0);
 }

◆ TsSetRHSFunction

PetscErrorCode TsSetRHSFunction	(	TS	ts,
		PetscReal	t,
		Vec	u,
		Vec	F,
		void *	ctx
	)

friend

TS solver function.

See PETSc for details

Parameters

ts
t
u
F
ctx

Returns: PetscErrorCode

Definition at line 287 of file TsCtx.cpp.

                                                                              {
   MoFEMFunctionBegin;
   TsCtx *ts_ctx = static_cast<TsCtx *>(ctx);
   PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxRHSFunction, 0, 0, 0, 0);
   CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
       ts_ctx->problemName, COL, u, 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);
  
   ts_ctx->vecAssembleSwitch = boost::movelib::make_unique<bool>(true);
  
   int step;
 #if PETSC_VERSION_GE(3, 8, 0)
   CHKERR TSGetStepNumber(ts, &step);
 #else
   CHKERR TSGetTimeStepNumber(ts, &step);
 #endif
  
   auto set = [&](auto &fe) {
     fe.ts_u = u;
     fe.ts_F = F;
     fe.ts_t = t;
     fe.ts = ts;
     fe.ts_step = step;
     fe.ts_ctx = TSMethod::CTX_TSSETRHSFUNCTION;
     fe.snes_ctx = SnesMethod::CTX_SNESSETFUNCTION;
     fe.ksp_ctx = KspMethod::CTX_SETFUNCTION;
     fe.data_ctx =
         PetscData::CtxSetF | PetscData::CtxSetX | PetscData::CtxSetTime;
   };
  
   auto unset = [&](auto &fe) {
     fe.ts_ctx = TSMethod::CTX_TSNONE;
     fe.snes_ctx = SnesMethod::CTX_SNESNONE;
     fe.ksp_ctx = KspMethod::CTX_KSPNONE;
     fe.data_ctx = PetscData::CtxSetNone;
   };
  
   for (auto &bit : ts_ctx->preProcessRHSJacobian) {
     bit->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
     set(*bit);
     CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
                                                           *bit);
     unset(*bit);
     ts_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
   }
  
   auto cache_ptr = boost::make_shared<CacheTuple>();
   CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
  
   // fe loops
   for (auto &lit : ts_ctx->loopsRHSFunction) {
     lit.second->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
     set(*lit.second);
     CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
                                                *(lit.second), nullptr,
                                                ts_ctx->bH, cache_ptr);
     unset(*lit.second);
     ts_ctx->vecAssembleSwitch = boost::move(lit.second->vecAssembleSwitch);
   }
  
   // post process
   for (auto &bit : ts_ctx->postProcessRHSJacobian) {
     bit->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
     set(*bit);
     CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
                                                            *bit);
     unset(*bit);
     ts_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
   }
  
   if (*ts_ctx->vecAssembleSwitch) {
     CHKERR VecGhostUpdateBegin(F, ADD_VALUES, SCATTER_REVERSE);
     CHKERR VecGhostUpdateEnd(F, ADD_VALUES, SCATTER_REVERSE);
     CHKERR VecAssemblyBegin(F);
     CHKERR VecAssemblyEnd(F);
   }
  
   PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxRHSFunction, 0, 0, 0, 0);
   MoFEMFunctionReturn(0);
 }

◆ TsSetRHSJacobian

PetscErrorCode TsSetRHSJacobian	(	TS	ts,
		PetscReal	t,
		Vec	u,
		Mat	A,
		Mat	B,
		void *	ctx
	)

friend

TS solver function.

See PETSc for details

Parameters

ts
t
u
A
B
ctx

Returns: PetscErrorCode

Definition at line 385 of file TsCtx.cpp.

                                            {
   MoFEMFunctionBegin;
   TsCtx *ts_ctx = static_cast<TsCtx *>(ctx);
   PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxRHSJacobian, 0, 0, 0, 0);
   CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
   CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
       ts_ctx->problemName, COL, u, INSERT_VALUES, SCATTER_REVERSE);
  
   if (ts_ctx->zeroMatrix) {
     CHKERR MatZeroEntries(B);
   }
  
   ts_ctx->matAssembleSwitch =
       boost::movelib::make_unique<bool>(ts_ctx->zeroMatrix);
  
   int step;
 #if PETSC_VERSION_GE(3, 8, 0)
   CHKERR TSGetStepNumber(ts, &step);
 #else
   CHKERR TSGetTimeStepNumber(ts, &step);
 #endif
  
   auto set = [&](auto &fe) {
     fe.ts_u = u;
     fe.ts_A = A;
     fe.ts_B = B;
     fe.ts_t = t;
     fe.ts_step = step;
     fe.ts_ctx = TSMethod::CTX_TSSETRHSJACOBIAN;
     fe.snes_ctx = SnesMethod::CTX_SNESSETJACOBIAN;
     fe.ksp_ctx = KspMethod::CTX_OPERATORS;
     fe.data_ctx = PetscData::CtxSetA | PetscData::CtxSetB | PetscData::CtxSetX |
                   PetscData::CtxSetTime;
     fe.ts = ts;
   };
  
   auto unset = [&](auto &fe) {
     fe.ts_ctx = TSMethod::CTX_TSNONE;
     fe.snes_ctx = SnesMethod::CTX_SNESNONE;
     fe.ksp_ctx = KspMethod::CTX_KSPNONE;
     fe.data_ctx = PetscData::CtxSetNone;
   };
  
   // preprocess
   for (auto &bit : ts_ctx->preProcessRHSJacobian) {
     bit->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
     set(*bit);
     CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
                                                           *bit);
     unset(*bit);
     ts_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
   }
  
   auto cache_ptr = boost::make_shared<CacheTuple>();
   CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
  
   // fe loops
   for (auto &lit : ts_ctx->loopsRHSJacobian) {
     lit.second->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
     set(*lit.second);
     CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
                                                *(lit.second), nullptr,
                                                ts_ctx->bH, cache_ptr);
     unset(*lit.second);
     ts_ctx->matAssembleSwitch = boost::move(lit.second->matAssembleSwitch);
   }
  
   // post process
   for (auto &bit : ts_ctx->postProcessRHSJacobian) {
     bit->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
     set(*bit);
     CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
                                                            *bit);
     unset(*bit);
     ts_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
   }
  
   if (ts_ctx->matAssembleSwitch) {
     CHKERR MatAssemblyBegin(B, MAT_FINAL_ASSEMBLY);
     CHKERR MatAssemblyEnd(B, MAT_FINAL_ASSEMBLY);
   }
  
   PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxRHSJacobian, 0, 0, 0, 0);
   MoFEMFunctionReturn(0);
 }

Member Data Documentation

◆ bH

MoFEMTypes MoFEM::TsCtx::bH

If set to MF_EXIST check if element exist.

Definition at line 33 of file TsCtx.hpp.

◆ loopsIFunction

FEMethodsSequence MoFEM::TsCtx::loopsIFunction

Definition at line 40 of file TsCtx.hpp.

◆ loopsIJacobian

FEMethodsSequence MoFEM::TsCtx::loopsIJacobian

Definition at line 39 of file TsCtx.hpp.

◆ loopsMonitor

FEMethodsSequence MoFEM::TsCtx::loopsMonitor

Definition at line 41 of file TsCtx.hpp.

◆ loopsRHSFunction

FEMethodsSequence MoFEM::TsCtx::loopsRHSFunction

Definition at line 43 of file TsCtx.hpp.

◆ loopsRHSJacobian

FEMethodsSequence MoFEM::TsCtx::loopsRHSJacobian

Definition at line 42 of file TsCtx.hpp.

◆ matAssembleSwitch

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

private

Definition at line 239 of file TsCtx.hpp.

◆ mField

MoFEM::Interface& MoFEM::TsCtx::mField

Definition at line 29 of file TsCtx.hpp.

◆ moab

moab::Interface& MoFEM::TsCtx::moab

Definition at line 30 of file TsCtx.hpp.

◆ MOFEM_EVENT_TsCtxI2Function

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxI2Function

private

Definition at line 235 of file TsCtx.hpp.

◆ MOFEM_EVENT_TsCtxI2Jacobian

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxI2Jacobian

private

Definition at line 236 of file TsCtx.hpp.

◆ MOFEM_EVENT_TsCtxIFunction

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxIFunction

private

Definition at line 232 of file TsCtx.hpp.

◆ MOFEM_EVENT_TsCtxIJacobian

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxIJacobian

private

Definition at line 233 of file TsCtx.hpp.

◆ MOFEM_EVENT_TsCtxMonitor

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxMonitor

private

Definition at line 234 of file TsCtx.hpp.

◆ MOFEM_EVENT_TsCtxRHSFunction

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxRHSFunction

private

Definition at line 230 of file TsCtx.hpp.

◆ MOFEM_EVENT_TsCtxRHSJacobian

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxRHSJacobian

private

Definition at line 231 of file TsCtx.hpp.

◆ postProcessIFunction

BasicMethodsSequence MoFEM::TsCtx::postProcessIFunction

Definition at line 47 of file TsCtx.hpp.

◆ postProcessIJacobian

BasicMethodsSequence MoFEM::TsCtx::postProcessIJacobian

Definition at line 45 of file TsCtx.hpp.

◆ postProcessMonitor

BasicMethodsSequence MoFEM::TsCtx::postProcessMonitor

Definition at line 49 of file TsCtx.hpp.

◆ postProcessRHSFunction

BasicMethodsSequence MoFEM::TsCtx::postProcessRHSFunction

Definition at line 53 of file TsCtx.hpp.

◆ postProcessRHSJacobian

BasicMethodsSequence MoFEM::TsCtx::postProcessRHSJacobian

Definition at line 52 of file TsCtx.hpp.

◆ preProcessIFunction

BasicMethodsSequence MoFEM::TsCtx::preProcessIFunction

Definition at line 46 of file TsCtx.hpp.

◆ preProcessIJacobian

BasicMethodsSequence MoFEM::TsCtx::preProcessIJacobian

Definition at line 44 of file TsCtx.hpp.

◆ preProcessMonitor

BasicMethodsSequence MoFEM::TsCtx::preProcessMonitor

Definition at line 48 of file TsCtx.hpp.

◆ preProcessRHSFunction

BasicMethodsSequence MoFEM::TsCtx::preProcessRHSFunction

Definition at line 51 of file TsCtx.hpp.

◆ preProcessRHSJacobian

BasicMethodsSequence MoFEM::TsCtx::preProcessRHSJacobian

Definition at line 50 of file TsCtx.hpp.

◆ problemName

std::string MoFEM::TsCtx::problemName

Definition at line 32 of file TsCtx.hpp.

◆ vecAssembleSwitch

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

private

Definition at line 238 of file TsCtx.hpp.

◆ zeroMatrix

bool MoFEM::TsCtx::zeroMatrix

Definition at line 55 of file TsCtx.hpp.

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

src/petsc/TsCtx.hpp
src/petsc/impl/TsCtx.cpp

Public Types

Public Member Functions

Public Attributes

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ BasicMethodsSequence

◆ FEMethodsSequence

◆ PairNameFEMethodPtr

Constructor & Destructor Documentation

◆ TsCtx()

◆ ~TsCtx()

Member Function Documentation

◆ clearLoops()

◆ getLoopsIFunction()

◆ getLoopsIJacobian()

◆ getLoopsMonitor()

◆ getLoopsRHSFunction()

◆ getLoopsRHSJacobian()

◆ getPostProcessIFunction()

◆ getPostProcessIJacobian()

◆ getPostProcessMonitor()

◆ getPostProcessRHSFunction()

◆ getPostProcessRHSJacobian()

◆ getPreProcessIFunction()

◆ getPreProcessIJacobian()

◆ getPreProcessMonitor()

◆ getPreProcessRHSFunction()

◆ getPreProcessRHSJacobian()

Friends And Related Function Documentation

◆ TsMonitorSet

◆ TsSetI2Function

◆ TsSetI2Jacobian

◆ TsSetIFunction

◆ TsSetIJacobian

◆ TsSetRHSFunction

◆ TsSetRHSJacobian

Member Data Documentation

◆ bH

◆ loopsIFunction

◆ loopsIJacobian

◆ loopsMonitor

◆ loopsRHSFunction

◆ loopsRHSJacobian

◆ matAssembleSwitch

◆ mField

◆ moab

◆ MOFEM_EVENT_TsCtxI2Function

◆ MOFEM_EVENT_TsCtxI2Jacobian

◆ MOFEM_EVENT_TsCtxIFunction

◆ MOFEM_EVENT_TsCtxIJacobian

◆ MOFEM_EVENT_TsCtxMonitor

◆ MOFEM_EVENT_TsCtxRHSFunction

◆ MOFEM_EVENT_TsCtxRHSJacobian

◆ postProcessIFunction

◆ postProcessIJacobian

◆ postProcessMonitor

◆ postProcessRHSFunction

◆ postProcessRHSJacobian

◆ preProcessIFunction

◆ preProcessIJacobian

◆ preProcessMonitor

◆ preProcessRHSFunction

◆ preProcessRHSJacobian

◆ problemName

◆ vecAssembleSwitch

◆ zeroMatrix