MoFEM::TsCtx Struct Reference

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

Detailed Description

Interface for Time Stepping (TS) solver.

Examples

level_set.cpp, nonlinear_dynamics.cpp, and 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

nonlinear_dynamics.cpp.

Definition at line 63 of file TsCtx.hpp.

{ 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.

{ 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

EshelbianPlasticity.cpp, and nonlinear_dynamics.cpp.

Definition at line 102 of file TsCtx.hpp.

{ 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.

{ 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.

{ return loopsRHSJacobian; }

getPostProcessIFunction()

BasicMethodsSequence& MoFEM::TsCtx::getPostProcessIFunction ( )

inline

Get the postProcess to do IFunction object.

Returns

BasicMethodsSequence&

Examples

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

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

Remodeling.cpp, and UnsaturatedFlow.hpp.

Definition at line 148 of file TsCtx.hpp.

{ 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

nonlinear_dynamics.cpp.

Definition at line 109 of file TsCtx.hpp.

{ return preProcessIFunction; }

getPreProcessIJacobian()

BasicMethodsSequence& MoFEM::TsCtx::getPreProcessIJacobian ( )

inline

Get the preProcess to do IJacobian object.

Returns

BasicMethodsSequence&

Examples

nonlinear_dynamics.cpp.

Definition at line 125 of file TsCtx.hpp.

{ 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.

{ 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 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 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_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;
 
    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+v*U,W'+a*U), equivalent to dF/dU + v*dF/dU_t + a*dF/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_NULL, 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_NULL, PETSC_NULL, 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