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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

MoFEMErrorCode	clearLoops ()
	Clear loops.

Public Attributes
MoFEM::Interface &	mField

moab::Interface &	moab

std::string	problemName

MoFEMTypes	bH
	If set to MF_EXIST check if element exist.

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

boost::function< MoFEMErrorCode(TS ts, PetscReal t, Vec u, Vec u_t, Vec u_tt, Vec F, void *ctx)>	tsDebugHook

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.

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

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

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

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

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.

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 Jacobian for second order PDE in time.

Detailed Description

Interface for Time Stepping (TS) solver.

Examples: mofem/tutorials/adv-3/level_set.cpp, mofem/users_modules/basic_finite_elements/nonlinear_elasticity/nonlinear_dynamics.cpp, and mofem/users_modules/bone_remodelling/src/impl/Remodeling.cpp.

Definition at line 17 of file TsCtx.hpp.

Member Typedef Documentation

◆ BasicMethodsSequence

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

Definition at line 27 of file TsCtx.hpp.

◆ FEMethodsSequence

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

Definition at line 26 of file TsCtx.hpp.

◆ PairNameFEMethodPtr

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

Definition at line 25 of file TsCtx.hpp.

Constructor & Destructor Documentation

◆ TsCtx()

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

Definition at line 5 of file TsCtx.cpp.

    : 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);
 
  if (!LogManager::checkIfChannelExist("TSWORLD")) {
    auto core_log = logging::core::get();
 
    core_log->add_sink(
        LogManager::createSink(LogManager::getStrmWorld(), "TSWORLD"));
    core_log->add_sink(
        LogManager::createSink(LogManager::getStrmSync(), "TSSYNC"));
    core_log->add_sink(
        LogManager::createSink(LogManager::getStrmSelf(), "TSSELF"));
 
    LogManager::setLog("TSWORLD");
    LogManager::setLog("TSSYNC");
    LogManager::setLog("TSSELF");
 
    MOFEM_LOG_TAG("TSWORLD", "TS");
    MOFEM_LOG_TAG("TSSYNC", "TS");
    MOFEM_LOG_TAG("TSSELF", "TS");
  }
}

◆ ~TsCtx()

virtual MoFEM::TsCtx::~TsCtx ( )

virtualdefault

Member Function Documentation

◆ clearLoops()

MoFEMErrorCode MoFEM::TsCtx::clearLoops ( )

Clear loops.

Returns: MoFEMErrorCode

Definition at line 36 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 ( )

inline

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&

Examples: mofem/users_modules/basic_finite_elements/nonlinear_elasticity/nonlinear_dynamics.cpp.

Definition at line 63 of file TsCtx.hpp.

63{ return loopsIFunction; }

◆ getLoopsIJacobian()

FEMethodsSequence & MoFEM::TsCtx::getLoopsIJacobian ( )

inline

Get the loops to do IJacobian object.

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

Returns: FEMethodsSequence&

Definition at line 83 of file TsCtx.hpp.

83{ return loopsIJacobian; }

◆ getLoopsMonitor()

FEMethodsSequence & MoFEM::TsCtx::getLoopsMonitor ( )

inline

Get the loops to do Monitor object.

It is sequence used to monitor solution of time solver.

Returns: FEMethodsSequence&

Examples: mofem/users_modules/basic_finite_elements/nonlinear_elasticity/nonlinear_dynamics.cpp, and mofem/users_modules/eshelbian_plasticity/src/impl/EshelbianPlasticity.cpp.

Definition at line 102 of file TsCtx.hpp.

102{ return loopsMonitor; }

◆ getLoopsRHSFunction()

FEMethodsSequence & MoFEM::TsCtx::getLoopsRHSFunction ( )

inline

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 73 of file TsCtx.hpp.

73{ return loopsRHSFunction; }

◆ getLoopsRHSJacobian()

FEMethodsSequence & MoFEM::TsCtx::getLoopsRHSJacobian ( )

inline

Get the loops to do RHSJacobian object.

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

Returns: FEMethodsSequence&

Definition at line 93 of file TsCtx.hpp.

93{ return loopsRHSJacobian; }

◆ getPostProcessIFunction()

BasicMethodsSequence & MoFEM::TsCtx::getPostProcessIFunction ( )

inline

Get the postProcess to do IFunction object.

Returns: BasicMethodsSequence&

Examples: mofem/users_modules/basic_finite_elements/nonlinear_elasticity/nonlinear_dynamics.cpp.

Definition at line 116 of file TsCtx.hpp.

                                                  {
    return postProcessIFunction;
  }

◆ getPostProcessIJacobian()

BasicMethodsSequence & MoFEM::TsCtx::getPostProcessIJacobian ( )

inline

Get the postProcess to do IJacobian object.

Returns: BasicMethodsSequence&

Examples: mofem/users_modules/basic_finite_elements/nonlinear_elasticity/nonlinear_dynamics.cpp.

Definition at line 132 of file TsCtx.hpp.

                                                  {
    return postProcessIJacobian;
  }

◆ getPostProcessMonitor()

BasicMethodsSequence & MoFEM::TsCtx::getPostProcessMonitor ( )

inline

Get the postProcess to do Monitor object.

Returns: BasicMethodsSequence&

Examples: mofem/tutorials/cor-0to1/src/UnsaturatedFlow.hpp, and mofem/users_modules/bone_remodelling/src/impl/Remodeling.cpp.

Definition at line 148 of file TsCtx.hpp.

148{ return postProcessMonitor; }

◆ getPostProcessRHSFunction()

BasicMethodsSequence & MoFEM::TsCtx::getPostProcessRHSFunction ( )

inline

Get the postProcess to do RHSFunction object.

Returns: BasicMethodsSequence&

Definition at line 182 of file TsCtx.hpp.

                                                    {
    return postProcessRHSFunction;
  }

◆ getPostProcessRHSJacobian()

BasicMethodsSequence & MoFEM::TsCtx::getPostProcessRHSJacobian ( )

inline

Get the postProcess to do RHSJacobian object.

Returns: BasicMethodsSequence&

Definition at line 164 of file TsCtx.hpp.

                                                    {
    return postProcessRHSJacobian;
  }

◆ getPreProcessIFunction()

BasicMethodsSequence & MoFEM::TsCtx::getPreProcessIFunction ( )

inline

Get the preProcess to do IFunction object.

Returns: BasicMethodsSequence&

Examples: mofem/users_modules/basic_finite_elements/nonlinear_elasticity/nonlinear_dynamics.cpp.

Definition at line 109 of file TsCtx.hpp.

109{ return preProcessIFunction; }

◆ getPreProcessIJacobian()

BasicMethodsSequence & MoFEM::TsCtx::getPreProcessIJacobian ( )

inline

Get the preProcess to do IJacobian object.

Returns: BasicMethodsSequence&

Examples: mofem/users_modules/basic_finite_elements/nonlinear_elasticity/nonlinear_dynamics.cpp.

Definition at line 125 of file TsCtx.hpp.

125{ return preProcessIJacobian; }

◆ getPreProcessMonitor()

BasicMethodsSequence & MoFEM::TsCtx::getPreProcessMonitor ( )

inline

Get the preProcess to do Monitor object.

Returns: BasicMethodsSequence&

Definition at line 141 of file TsCtx.hpp.

141{ return preProcessMonitor; }

◆ getPreProcessRHSFunction()

BasicMethodsSequence & MoFEM::TsCtx::getPreProcessRHSFunction ( )

inline

Get the preProcess to do RHSFunction object.

Returns: BasicMethodsSequence&

Definition at line 173 of file TsCtx.hpp.

                                                   {
    return preProcessRHSFunction;
  }

◆ getPreProcessRHSJacobian()

BasicMethodsSequence & MoFEM::TsCtx::getPreProcessRHSJacobian ( )

inline

Get the preProcess to do RHSJacobian object.

Returns: BasicMethodsSequence&

Definition at line 155 of file TsCtx.hpp.

                                                   {
    return preProcessRHSJacobian;
  }

Friends And Related Symbol 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 263 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 cache_ptr = boost::make_shared<CacheTuple>();
  CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
 
  auto set = [&](auto &fe) {
    fe.ts = ts;
    fe.ts_u = u;
    fe.ts_t = t;
    fe.ts_step = step;
    fe.ts_F = PETSC_NULLPTR;
    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;
 
    CHKERR TSGetSNES(ts, &fe.snes);
    CHKERR SNESGetKSP(fe.snes, &fe.ksp);
 
    fe.cacheWeakPtr = cache_ptr;
    CHK_THROW_MESSAGE(TSGetTimeStep(ts, &fe.ts_dt), "get time step failed");
  };
 
  auto unset = [&](auto &fe) {
    fe.ts_ctx = TSMethod::CTX_TSNONE;
    fe.data_ctx = PetscData::CtxSetNone;
  };
 
  // preprocess
  for (auto &bit : ts_ctx->preProcessMonitor) {
    set(*bit);
    CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
                                                          *bit);
    unset(*bit);
  }
 
  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 620 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);
  auto cache_ptr = boost::make_shared<CacheTuple>();
  CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
 
  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;
 
    CHKERR TSGetSNES(ts, &fe.snes);
    CHKERR SNESGetKSP(fe.snes, &fe.ksp);
 
    fe.ts = ts;
    fe.cacheWeakPtr = cache_ptr;
    CHK_THROW_MESSAGE(TSGetTimeStep(ts, &fe.ts_dt), "get time step failed");
  };
 
  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);
  }
 
  // 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);
  }
 
  if (ts_ctx->tsDebugHook) {
    CHKERR ts_ctx->tsDebugHook(ts, t, u, u_t, u_tt, F, ctx);
  }
 
  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 Jacobian 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 519 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 cache_ptr = boost::make_shared<CacheTuple>();
  CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
 
  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;
 
    CHKERR TSGetSNES(ts, &fe.snes);
    CHKERR SNESGetKSP(fe.snes, &fe.ksp);
                  
    fe.ts = ts;
    fe.cacheWeakPtr = cache_ptr;
    CHK_THROW_MESSAGE(TSGetTimeStep(ts, &fe.ts_dt), "get time step failed");
  };
 
  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->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);
  }
 
  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 56 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 cache_ptr = boost::make_shared<CacheTuple>();
  CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
 
  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;
 
    CHKERR TSGetSNES(ts, &fe.snes);
    CHKERR SNESGetKSP(fe.snes, &fe.ksp);
 
    fe.cacheWeakPtr = cache_ptr;
    CHK_THROW_MESSAGE(TSGetTimeStep(ts, &fe.ts_dt), "get time step failed");
  };
 
  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);
  }
 
  // 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);
  }
 
  if(ts_ctx->tsDebugHook) {
    CHKERR ts_ctx->tsDebugHook(ts, t, u, u_t, PETSC_NULLPTR, F, ctx);
  }
 
  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 jacobian in TS solver.

See PETSc for details

Parameters

ts
t
u
u_t
a
A
B
ctx

Returns: PetscErrorCode

Definition at line 169 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 cache_ptr = boost::make_shared<CacheTuple>();
  CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
 
  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;
 
    CHKERR TSGetSNES(ts, &fe.snes);
    CHKERR SNESGetKSP(fe.snes, &fe.ksp);
 
    fe.cacheWeakPtr = cache_ptr;
    CHK_THROW_MESSAGE(TSGetTimeStep(ts, &fe.ts_dt), "get time step failed");
  };
 
  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);
  }
 
  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 327 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);
  auto cache_ptr = boost::make_shared<CacheTuple>();
  CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
 
  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;
    fe.cacheWeakPtr = cache_ptr;
    CHK_THROW_MESSAGE(TSGetTimeStep(ts, &fe.ts_dt), "get time step failed");
  };
 
  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->preProcessRHSFunction) {
    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);
  }
 
  // 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->postProcessRHSFunction) {
    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);
  }
 
  if (ts_ctx->tsDebugHook) {
    CHKERR ts_ctx->tsDebugHook(ts, t, u, PETSC_NULLPTR, PETSC_NULLPTR, F, ctx);
  }
 
  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 430 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);
  auto cache_ptr = boost::make_shared<CacheTuple>();
  CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
 
  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;
    fe.cacheWeakPtr = cache_ptr;
    CHK_THROW_MESSAGE(TSGetTimeStep(ts, &fe.ts_dt), "get time step failed");
  };
 
  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);
  }
 
  // 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 23 of file TsCtx.hpp.

◆ loopsIFunction

FEMethodsSequence MoFEM::TsCtx::loopsIFunction

Definition at line 30 of file TsCtx.hpp.

◆ loopsIJacobian

FEMethodsSequence MoFEM::TsCtx::loopsIJacobian

Definition at line 29 of file TsCtx.hpp.

◆ loopsMonitor

FEMethodsSequence MoFEM::TsCtx::loopsMonitor

Definition at line 31 of file TsCtx.hpp.

◆ loopsRHSFunction

FEMethodsSequence MoFEM::TsCtx::loopsRHSFunction

Definition at line 33 of file TsCtx.hpp.

◆ loopsRHSJacobian

FEMethodsSequence MoFEM::TsCtx::loopsRHSJacobian

Definition at line 32 of file TsCtx.hpp.

◆ matAssembleSwitch

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

private

Definition at line 221 of file TsCtx.hpp.

◆ mField

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

Definition at line 19 of file TsCtx.hpp.

◆ moab

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

Definition at line 20 of file TsCtx.hpp.

◆ MOFEM_EVENT_TsCtxI2Function

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxI2Function

private

Definition at line 217 of file TsCtx.hpp.

◆ MOFEM_EVENT_TsCtxI2Jacobian

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxI2Jacobian

private

Definition at line 218 of file TsCtx.hpp.

◆ MOFEM_EVENT_TsCtxIFunction

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxIFunction

private

Definition at line 214 of file TsCtx.hpp.

◆ MOFEM_EVENT_TsCtxIJacobian

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxIJacobian

private

Definition at line 215 of file TsCtx.hpp.

◆ MOFEM_EVENT_TsCtxMonitor

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxMonitor

private

Definition at line 216 of file TsCtx.hpp.

◆ MOFEM_EVENT_TsCtxRHSFunction

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxRHSFunction

private

Definition at line 212 of file TsCtx.hpp.

◆ MOFEM_EVENT_TsCtxRHSJacobian

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxRHSJacobian

private

Definition at line 213 of file TsCtx.hpp.

◆ postProcessIFunction

BasicMethodsSequence MoFEM::TsCtx::postProcessIFunction

Definition at line 37 of file TsCtx.hpp.

◆ postProcessIJacobian

BasicMethodsSequence MoFEM::TsCtx::postProcessIJacobian

Definition at line 35 of file TsCtx.hpp.

◆ postProcessMonitor

BasicMethodsSequence MoFEM::TsCtx::postProcessMonitor

Definition at line 39 of file TsCtx.hpp.

◆ postProcessRHSFunction

BasicMethodsSequence MoFEM::TsCtx::postProcessRHSFunction

Definition at line 43 of file TsCtx.hpp.

◆ postProcessRHSJacobian

BasicMethodsSequence MoFEM::TsCtx::postProcessRHSJacobian

Definition at line 42 of file TsCtx.hpp.

◆ preProcessIFunction

BasicMethodsSequence MoFEM::TsCtx::preProcessIFunction

Definition at line 36 of file TsCtx.hpp.

◆ preProcessIJacobian

BasicMethodsSequence MoFEM::TsCtx::preProcessIJacobian

Definition at line 34 of file TsCtx.hpp.

◆ preProcessMonitor

BasicMethodsSequence MoFEM::TsCtx::preProcessMonitor

Definition at line 38 of file TsCtx.hpp.

◆ preProcessRHSFunction

BasicMethodsSequence MoFEM::TsCtx::preProcessRHSFunction

Definition at line 41 of file TsCtx.hpp.

◆ preProcessRHSJacobian

BasicMethodsSequence MoFEM::TsCtx::preProcessRHSJacobian

Definition at line 40 of file TsCtx.hpp.

◆ problemName

std::string MoFEM::TsCtx::problemName

Definition at line 22 of file TsCtx.hpp.

◆ tsDebugHook

boost::function<MoFEMErrorCode(TS ts, PetscReal t, Vec u, Vec u_t, Vec u_tt, Vec F, void *ctx)> MoFEM::TsCtx::tsDebugHook

Definition at line 47 of file TsCtx.hpp.

◆ vecAssembleSwitch

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

private

Definition at line 220 of file TsCtx.hpp.

◆ zeroMatrix

bool MoFEM::TsCtx::zeroMatrix

Definition at line 49 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 Symbol 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

◆ tsDebugHook

◆ vecAssembleSwitch

◆ zeroMatrix