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)
FEMethodsSequence &	get_loops_to_do_IFunction ()
	Get the loops to do IFunction object. More...
FEMethodsSequence &	get_loops_to_do_RHSFunction ()
	Get the loops to do RHSFunction object. More...
FEMethodsSequence &	get_loops_to_do_IJacobian ()
	Get the loops to do IJacobian object. More...
FEMethodsSequence &	get_loops_to_do_RHSJacobian ()
	Get the loops to do RHSJacobian object. More...
FEMethodsSequence &	get_loops_to_do_Monitor ()
	Get the loops to do Monitor object. More...
BasicMethodsSequence &	get_preProcess_to_do_IFunction ()
	Get the preProcess to do IFunction object. More...
BasicMethodsSequence &	get_postProcess_to_do_IFunction ()
	Get the postProcess to do IFunction object. More...
BasicMethodsSequence &	get_preProcess_to_do_IJacobian ()
	Get the preProcess to do IJacobian object. More...
BasicMethodsSequence &	get_postProcess_to_do_IJacobian ()
	Get the postProcess to do IJacobian object. More...
BasicMethodsSequence &	get_preProcess_to_do_Monitor ()
	Get the preProcess to do Monitor object. More...
BasicMethodsSequence &	get_postProcess_to_do_Monitor ()
	Get the postProcess to do Monitor object. More...
BasicMethodsSequence &	get_preProcess_to_do_RHSJacobian ()
	Get the preProcess to do RHSJacobian object. More...
BasicMethodsSequence &	get_postProcess_to_do_RHSJacobian ()
	Get the postProcess to do RHSJacobian object. More...
BasicMethodsSequence &	get_preProcess_to_do_RHSFunction ()
	Get the preProcess to do RHSFunction object. More...
BasicMethodsSequence &	get_postProcess_to_do_RHSFunction ()
	Get the postProcess to do RHSFunction object. More...

Public Attributes
DEPRECATED typedef MoFEM::PairNameFEMethodPtr	loop_pair_type
DEPRECATED typedef MoFEM::FEMethodsSequence	loops_to_do_type
DEPRECATED typedef MoFEM::BasicMethodsSequence	basic_method_to_do
MoFEM::Interface &	mField
moab::Interface &	moab
std::string	problemName
MoFEMTypes	bH
	If set to MF_EXIST check if element exist. More...
FEMethodsSequence	loops_to_do_IJacobian
FEMethodsSequence	loops_to_do_IFunction
FEMethodsSequence	loops_to_do_Monitor
FEMethodsSequence	loops_to_do_RHSJacobian
FEMethodsSequence	loops_to_do_RHSFunction
BasicMethodsSequence	preProcess_IJacobian
BasicMethodsSequence	postProcess_IJacobian
BasicMethodsSequence	preProcess_IFunction
BasicMethodsSequence	postProcess_IFunction
BasicMethodsSequence	preProcess_Monitor
BasicMethodsSequence	postProcess_Monitor
BasicMethodsSequence	preProcess_RHSJacobian
BasicMethodsSequence	preProcess_RHSFunction
BasicMethodsSequence	postProcess_RHSJacobian
BasicMethodsSequence	postProcess_RHSFunction
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.

Examples

Remodeling.cpp.

Definition at line 27 of file TsCtx.hpp.

Member Typedef Documentation

BasicMethodsSequence

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

Definition at line 46 of file TsCtx.hpp.

FEMethodsSequence

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

Definition at line 45 of file TsCtx.hpp.

PairNameFEMethodPtr

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

Definition at line 44 of file TsCtx.hpp.

Constructor & Destructor Documentation

TsCtx()

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

Definition at line 66 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);
  }

Member Function Documentation

get_loops_to_do_IFunction()

FEMethodsSequence& MoFEM::TsCtx::get_loops_to_do_IFunction

(

)

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

                                                 {
    return loops_to_do_IFunction;
  }

get_loops_to_do_IJacobian()

FEMethodsSequence& MoFEM::TsCtx::get_loops_to_do_IJacobian

(

)

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

                                                 {
    return loops_to_do_IJacobian;
  }

get_loops_to_do_Monitor()

FEMethodsSequence& MoFEM::TsCtx::get_loops_to_do_Monitor

(

)

Get the loops to do Monitor object.

It is sequence used to monitor solution of time solver.

Returns

FEMethodsSequence&

Definition at line 135 of file TsCtx.hpp.

{ return loops_to_do_Monitor; }

get_loops_to_do_RHSFunction()

FEMethodsSequence& MoFEM::TsCtx::get_loops_to_do_RHSFunction

(

)

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

                                                   {
    return loops_to_do_RHSFunction;
  }

get_loops_to_do_RHSJacobian()

FEMethodsSequence& MoFEM::TsCtx::get_loops_to_do_RHSJacobian

(

)

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

                                                   {
    return loops_to_do_RHSJacobian;
  }

get_postProcess_to_do_IFunction()

BasicMethodsSequence& MoFEM::TsCtx::get_postProcess_to_do_IFunction

(

)

Get the postProcess to do IFunction object.

Returns

BasicMethodsSequence&

Definition at line 151 of file TsCtx.hpp.

                                                          {
    return postProcess_IFunction;
  }

get_postProcess_to_do_IJacobian()

BasicMethodsSequence& MoFEM::TsCtx::get_postProcess_to_do_IJacobian

(

)

Get the postProcess to do IJacobian object.

Returns

BasicMethodsSequence&

Definition at line 169 of file TsCtx.hpp.

                                                          {
    return postProcess_IJacobian;
  }

get_postProcess_to_do_Monitor()

BasicMethodsSequence& MoFEM::TsCtx::get_postProcess_to_do_Monitor

(

)

Get the postProcess to do Monitor object.

Returns

BasicMethodsSequence&

Examples

Remodeling.cpp.

Definition at line 187 of file TsCtx.hpp.

                                                        {
    return postProcess_Monitor;
  }

get_postProcess_to_do_RHSFunction()

BasicMethodsSequence& MoFEM::TsCtx::get_postProcess_to_do_RHSFunction

(

)

Get the postProcess to do RHSFunction object.

Returns

BasicMethodsSequence&

Definition at line 223 of file TsCtx.hpp.

                                                            {
    return postProcess_RHSFunction;
  }

get_postProcess_to_do_RHSJacobian()

BasicMethodsSequence& MoFEM::TsCtx::get_postProcess_to_do_RHSJacobian

(

)

Get the postProcess to do RHSJacobian object.

Returns

BasicMethodsSequence&

Definition at line 205 of file TsCtx.hpp.

                                                            {
    return postProcess_RHSJacobian;
  }

get_preProcess_to_do_IFunction()

BasicMethodsSequence& MoFEM::TsCtx::get_preProcess_to_do_IFunction

(

)

Get the preProcess to do IFunction object.

Returns

BasicMethodsSequence&

Definition at line 142 of file TsCtx.hpp.

                                                         {
    return preProcess_IFunction;
  }

get_preProcess_to_do_IJacobian()

BasicMethodsSequence& MoFEM::TsCtx::get_preProcess_to_do_IJacobian

(

)

Get the preProcess to do IJacobian object.

Returns

BasicMethodsSequence&

Definition at line 160 of file TsCtx.hpp.

                                                         {
    return preProcess_IJacobian;
  }

get_preProcess_to_do_Monitor()

BasicMethodsSequence& MoFEM::TsCtx::get_preProcess_to_do_Monitor

(

)

Get the preProcess to do Monitor object.

Returns

BasicMethodsSequence&

Definition at line 178 of file TsCtx.hpp.

                                                       {
    return preProcess_Monitor;
  }

get_preProcess_to_do_RHSFunction()

BasicMethodsSequence& MoFEM::TsCtx::get_preProcess_to_do_RHSFunction

(

)

Get the preProcess to do RHSFunction object.

Returns

BasicMethodsSequence&

Definition at line 214 of file TsCtx.hpp.

                                                           {
    return preProcess_RHSFunction;
  }

get_preProcess_to_do_RHSJacobian()

BasicMethodsSequence& MoFEM::TsCtx::get_preProcess_to_do_RHSJacobian

(

)

Get the preProcess to do RHSJacobian object.

Returns

BasicMethodsSequence&

Definition at line 196 of file TsCtx.hpp.

                                                           {
    return preProcess_RHSJacobian;
  }

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 190 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);

  // preproces
  for (auto &bit : ts_ctx->preProcess_Monitor) {
    bit->ts_u = u;
    bit->ts_t = t;
    bit->ts_step = step;
    bit->ts_F = PETSC_NULL;
    CHKERR bit->setTsCtx(TSMethod::CTX_TSTSMONITORSET);
    CHKERR bit->setTs(ts);
    CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
                                                          *bit);
    CHKERR bit->setTsCtx(TSMethod::CTX_TSNONE);
  }

  for (auto &lit : ts_ctx->loops_to_do_Monitor) {
    lit.second->ts_u = u;
    lit.second->ts_t = t;
    lit.second->ts_step = step;
    lit.second->ts_F = PETSC_NULL;
    CHKERR lit.second->setTsCtx(TSMethod::CTX_TSTSMONITORSET);
    CHKERR lit.second->setTs(ts);
    CHKERR ts_ctx->mField.loop_finite_elements(
        ts_ctx->problemName, lit.first, *(lit.second), nullptr, ts_ctx->bH);
    CHKERR lit.second->setTsCtx(TSMethod::CTX_TSNONE);
  }

  // post process
  for (auto &bit : ts_ctx->postProcess_Monitor) {
    bit->ts_u = u;
    bit->ts_t = t;
    bit->ts_step = step;
    bit->ts_F = PETSC_NULL;
    CHKERR bit->setTsCtx(TSMethod::CTX_TSTSMONITORSET);
    CHKERR bit->setTs(ts);
    CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
                                                           *bit);
    CHKERR bit->setTsCtx(TSMethod::CTX_TSNONE);
  }
  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
F
fun
ctx

Returns

PetscErrorCode

Definition at line 492 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;
  CHKERR TSGetTimeStepNumber(ts, &step);
  // preprocess
  for (auto &bit : ts_ctx->preProcess_IFunction) {
    bit->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
    bit->ts_u = u;
    bit->ts_u_t = u_t;
    bit->ts_u_tt = u_tt;
    bit->ts_F = F;
    bit->ts_t = t;
    bit->ts_step = step;
    CHKERR bit->setTsCtx(TSMethod::CTX_TSSETIFUNCTION);
    CHKERR bit->setTs(ts);
    CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
                                                          *bit);
    CHKERR bit->setTsCtx(TSMethod::CTX_TSNONE);
    ts_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
  }

  // fe loops
  for (auto &lit : ts_ctx->loops_to_do_IFunction) {
    lit.second->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
    lit.second->ts_u = u;
    lit.second->ts_u_t = u_t;
    lit.second->ts_u_tt = u_tt;
    lit.second->ts_F = F;
    lit.second->ts_t = t;
    lit.second->ts_step = step;
    CHKERR lit.second->setTsCtx(TSMethod::CTX_TSSETIFUNCTION);
    CHKERR lit.second->setTs(ts);
    CHKERR ts_ctx->mField.loop_finite_elements(
        ts_ctx->problemName, lit.first, *(lit.second), nullptr, ts_ctx->bH);
    CHKERR lit.second->setTsCtx(TSMethod::CTX_TSNONE);
    ts_ctx->vecAssembleSwitch = boost::move(lit.second->vecAssembleSwitch);
  }

  // post process
  for (auto &bit : ts_ctx->postProcess_IFunction) {
    bit->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
    bit->ts_u = u;
    bit->ts_u_t = u_t;
    bit->ts_u_tt = u_tt;
    bit->ts_F = F;
    bit->ts_t = t;
    bit->ts_step = step;
    CHKERR bit->setTsCtx(TSMethod::CTX_TSSETIFUNCTION);
    CHKERR bit->setTs(ts);
    CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
                                                           *bit);
    CHKERR bit->setTsCtx(TSMethod::CTX_TSNONE);
    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.

PETSc for details

Parameters

ts
J
P
jac
ctx

Returns

PetscErrorCode

Definition at line 401 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;
  CHKERR TSGetTimeStepNumber(ts, &step);

  ts_ctx->matAssembleSwitch =
      boost::movelib::make_unique<bool>(ts_ctx->zeroMatrix);

  // preproces
  for (auto &bit : ts_ctx->preProcess_IJacobian) {
    bit->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
    bit->ts_u = u;
    bit->ts_u_t = u_t;
    bit->ts_u_tt = u_tt;
    bit->ts_A = A;
    bit->ts_B = B;
    bit->ts_t = t;
    bit->ts_a = a;
    bit->ts_step = step;

    CHKERR bit->setTsCtx(TSMethod::CTX_TSSETIJACOBIAN);
    CHKERR bit->setTs(ts);
    CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
                                                          *bit);
    CHKERR bit->setTsCtx(TSMethod::CTX_TSNONE);
    ts_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
  }

  for (auto &lit : ts_ctx->loops_to_do_IJacobian) {
    lit.second->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
    lit.second->ts_u = u;
    lit.second->ts_u_t = u_t;
    lit.second->ts_u_tt = u_tt;
    lit.second->ts_A = A;
    lit.second->ts_B = B;
    lit.second->ts_t = t;
    lit.second->ts_v = v;
    lit.second->ts_a = a;
    lit.second->ts_step = step;
    CHKERR lit.second->setTsCtx(TSMethod::CTX_TSSETIJACOBIAN);
    CHKERR lit.second->setTs(ts);
    CHKERR ts_ctx->mField.loop_finite_elements(
        ts_ctx->problemName, lit.first, *(lit.second), nullptr, ts_ctx->bH);
    CHKERR lit.second->setTsCtx(TSMethod::CTX_TSNONE);
    ts_ctx->matAssembleSwitch = boost::move(lit.second->matAssembleSwitch);
  }

  // post process
  for (auto &bit : ts_ctx->postProcess_IJacobian) {
    bit->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
    bit->ts_u = u;
    bit->ts_u_t = u_t;
    bit->ts_u_tt = u_tt;
    bit->ts_A = A;
    bit->ts_B = B;
    bit->ts_t = t;
    bit->ts_v = v;
    bit->ts_a = a;
    bit->ts_step = step;
    CHKERR bit->setTsCtx(TSMethod::CTX_TSSETIJACOBIAN);
    CHKERR bit->setTs(ts);
    CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
                                                           *bit);
    CHKERR bit->setTsCtx(TSMethod::CTX_TSNONE);
    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 17 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;
  CHKERR TSGetTimeStepNumber(ts, &step);
  // preprocess
  for (auto &bit : ts_ctx->preProcess_IFunction) {
    bit->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
    bit->ts_u = u;
    bit->ts_u_t = u_t;
    bit->ts_F = F;
    bit->ts_t = t;
    bit->ts_step = step;
    CHKERR bit->setTsCtx(TSMethod::CTX_TSSETIFUNCTION);
    CHKERR bit->setTs(ts);
    CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
                                                          *bit);
    CHKERR bit->setTsCtx(TSMethod::CTX_TSNONE);
    ts_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
  }

  // fe loops
  for (auto &lit : ts_ctx->loops_to_do_IFunction) {
    lit.second->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
    lit.second->ts_u = u;
    lit.second->ts_u_t = u_t;
    lit.second->ts_F = F;
    lit.second->ts_t = t;
    lit.second->ts_step = step;
    CHKERR lit.second->setTsCtx(TSMethod::CTX_TSSETIFUNCTION);
    CHKERR lit.second->setTs(ts);
    CHKERR ts_ctx->mField.loop_finite_elements(
        ts_ctx->problemName, lit.first, *(lit.second), nullptr, ts_ctx->bH);
    CHKERR lit.second->setTsCtx(TSMethod::CTX_TSNONE);
    ts_ctx->vecAssembleSwitch = boost::move(lit.second->vecAssembleSwitch);
  }

  // post process
  for (auto &bit : ts_ctx->postProcess_IFunction) {
    bit->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
    bit->ts_u = u;
    bit->ts_u_t = u_t;
    bit->ts_F = F;
    bit->ts_t = t;
    bit->ts_step = step;
    CHKERR bit->setTsCtx(TSMethod::CTX_TSSETIFUNCTION);
    CHKERR bit->setTs(ts);
    CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
                                                           *bit);
    CHKERR bit->setTsCtx(TSMethod::CTX_TSNONE);
    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 108 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;
  CHKERR TSGetTimeStepNumber(ts, &step);

  ts_ctx->matAssembleSwitch =
      boost::movelib::make_unique<bool>(ts_ctx->zeroMatrix);

  // preproces
  for (auto &bit : ts_ctx->preProcess_IJacobian) {
    bit->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
    bit->ts_u = u;
    bit->ts_u_t = u_t;
    bit->ts_A = A;
    bit->ts_B = B;
    bit->ts_t = t;
    bit->ts_a = a;
    bit->ts_step = step;
    CHKERR bit->setTsCtx(TSMethod::CTX_TSSETIJACOBIAN);
    CHKERR bit->setTs(ts);
    CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
                                                          *bit);
    CHKERR bit->setTsCtx(TSMethod::CTX_TSNONE);
    ts_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
  }

  for (auto &lit : ts_ctx->loops_to_do_IJacobian) {
    lit.second->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
    lit.second->ts_u = u;
    lit.second->ts_u_t = u_t;
    lit.second->ts_A = A;
    lit.second->ts_B = B;
    lit.second->ts_t = t;
    lit.second->ts_a = a;
    lit.second->ts_step = step;
    CHKERR lit.second->setTsCtx(TSMethod::CTX_TSSETIJACOBIAN);
    CHKERR lit.second->setTs(ts);
    CHKERR ts_ctx->mField.loop_finite_elements(
        ts_ctx->problemName, lit.first, *(lit.second), nullptr, ts_ctx->bH);
    CHKERR lit.second->setTsCtx(TSMethod::CTX_TSNONE);
    ts_ctx->matAssembleSwitch = boost::move(lit.second->matAssembleSwitch);
  }

  // post process
  for (auto &bit : ts_ctx->postProcess_IJacobian) {
    bit->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
    bit->ts_u = u;
    bit->ts_u_t = u_t;
    bit->ts_A = A;
    bit->ts_B = B;
    bit->ts_t = t;
    bit->ts_a = a;
    bit->ts_step = step;
    CHKERR bit->setTsCtx(TSMethod::CTX_TSSETIJACOBIAN);
    CHKERR bit->setTs(ts);
    CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
                                                           *bit);
    CHKERR bit->setTsCtx(TSMethod::CTX_TSNONE);
    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 241 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;
  CHKERR TSGetTimeStepNumber(ts, &step);
  for (auto &bit : ts_ctx->preProcess_RHSJacobian) {
    bit->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
    bit->ts_u = u;
    bit->ts_F = F;
    bit->ts_t = t;
    bit->ts_step = step;
    CHKERR bit->setTsCtx(TSMethod::CTX_TSSETRHSFUNCTION);
    CHKERR bit->setTs(ts);
    CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
                                                          *bit);
    CHKERR bit->setTsCtx(TSMethod::CTX_TSNONE);
    ts_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
  }

  // fe loops
  for (auto &lit : ts_ctx->loops_to_do_RHSFunction) {
    lit.second->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
    lit.second->ts_u = u;
    lit.second->ts_F = F;
    lit.second->ts_t = t;
    lit.second->ts_step = step;
    CHKERR lit.second->setTsCtx(TSMethod::CTX_TSSETRHSFUNCTION);
    CHKERR lit.second->setTs(ts);
    CHKERR ts_ctx->mField.loop_finite_elements(
        ts_ctx->problemName, lit.first, *(lit.second), nullptr, ts_ctx->bH);
    CHKERR lit.second->setTsCtx(TSMethod::CTX_TSNONE);
    ts_ctx->vecAssembleSwitch = boost::move(lit.second->vecAssembleSwitch);
  }

  // post process
  for (auto &bit : ts_ctx->postProcess_RHSJacobian) {
    bit->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
    bit->ts_u = u;
    bit->ts_F = F;
    bit->ts_t = t;
    bit->ts_step = step;
    CHKERR bit->setTsCtx(TSMethod::CTX_TSSETRHSFUNCTION);
    CHKERR bit->setTs(ts);
    CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
                                                           *bit);
    CHKERR bit->setTsCtx(TSMethod::CTX_TSNONE);
    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 325 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;
  CHKERR TSGetTimeStepNumber(ts, &step);
  // preprocess
  for (auto &bit : ts_ctx->preProcess_RHSJacobian) {
    bit->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
    bit->ts_u = u;
    bit->ts_A = A;
    bit->ts_B = B;
    bit->ts_t = t;
    bit->ts_step = step;
    CHKERR bit->setTsCtx(TSMethod::CTX_TSSETRHSJACOBIAN);
    CHKERR bit->setTs(ts);
    CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
                                                          *bit);
    CHKERR bit->setTsCtx(TSMethod::CTX_TSNONE);
    ts_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
  }

  // fe loops
  for (auto &lit : ts_ctx->loops_to_do_RHSJacobian) {
    lit.second->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
    lit.second->ts_u = u;
    lit.second->ts_A = A;
    lit.second->ts_B = B;
    lit.second->ts_t = t;
    lit.second->ts_step = step;
    CHKERR lit.second->setTsCtx(TSMethod::CTX_TSSETRHSJACOBIAN);
    CHKERR lit.second->setTs(ts);
    CHKERR ts_ctx->mField.loop_finite_elements(
        ts_ctx->problemName, lit.first, *(lit.second), nullptr, ts_ctx->bH);
    CHKERR lit.second->setTsCtx(TSMethod::CTX_TSNONE);
    ts_ctx->matAssembleSwitch = boost::move(lit.second->matAssembleSwitch);
  }

  // post process
  for (auto &bit : ts_ctx->postProcess_RHSJacobian) {
    bit->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
    bit->ts_u = u;
    bit->ts_A = A;
    bit->ts_B = B;
    bit->ts_t = t;
    bit->ts_step = step;
    CHKERR bit->setTsCtx(TSMethod::CTX_TSSETRHSJACOBIAN);
    CHKERR bit->setTs(ts);
    CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
                                                           *bit);
    CHKERR bit->setTsCtx(TSMethod::CTX_TSNONE);
    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

basic_method_to_do

DEPRECATED typedef MoFEM::BasicMethodsSequence MoFEM::TsCtx::basic_method_to_do

Deprecated:

use BasicMethodsSequence

Definition at line 42 of file TsCtx.hpp.

bH

MoFEMTypes MoFEM::TsCtx::bH

If set to MF_EXIST check if element exist.

Definition at line 33 of file TsCtx.hpp.

loop_pair_type

DEPRECATED typedef MoFEM::PairNameFEMethodPtr MoFEM::TsCtx::loop_pair_type

Deprecated:

use PairNameFEMethodPtr

Definition at line 36 of file TsCtx.hpp.

loops_to_do_IFunction

FEMethodsSequence MoFEM::TsCtx::loops_to_do_IFunction

Definition at line 49 of file TsCtx.hpp.

loops_to_do_IJacobian

FEMethodsSequence MoFEM::TsCtx::loops_to_do_IJacobian

Definition at line 48 of file TsCtx.hpp.

loops_to_do_Monitor

FEMethodsSequence MoFEM::TsCtx::loops_to_do_Monitor

Definition at line 50 of file TsCtx.hpp.

loops_to_do_RHSFunction

FEMethodsSequence MoFEM::TsCtx::loops_to_do_RHSFunction

Definition at line 52 of file TsCtx.hpp.

loops_to_do_RHSJacobian

FEMethodsSequence MoFEM::TsCtx::loops_to_do_RHSJacobian

Definition at line 51 of file TsCtx.hpp.

loops_to_do_type

DEPRECATED typedef MoFEM::FEMethodsSequence MoFEM::TsCtx::loops_to_do_type

Deprecated:

use FEMethodsSequence

Definition at line 39 of file TsCtx.hpp.

matAssembleSwitch

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

private

Definition at line 255 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 251 of file TsCtx.hpp.

MOFEM_EVENT_TsCtxI2Jacobian

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxI2Jacobian

private

Definition at line 252 of file TsCtx.hpp.

MOFEM_EVENT_TsCtxIFunction

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxIFunction

private

Definition at line 248 of file TsCtx.hpp.

MOFEM_EVENT_TsCtxIJacobian

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxIJacobian

private

Definition at line 249 of file TsCtx.hpp.

MOFEM_EVENT_TsCtxMonitor

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxMonitor

private

Definition at line 250 of file TsCtx.hpp.

MOFEM_EVENT_TsCtxRHSFunction

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxRHSFunction

private

Definition at line 246 of file TsCtx.hpp.

MOFEM_EVENT_TsCtxRHSJacobian

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxRHSJacobian

private

Definition at line 247 of file TsCtx.hpp.

postProcess_IFunction

BasicMethodsSequence MoFEM::TsCtx::postProcess_IFunction

Definition at line 56 of file TsCtx.hpp.

postProcess_IJacobian

BasicMethodsSequence MoFEM::TsCtx::postProcess_IJacobian

Definition at line 54 of file TsCtx.hpp.

postProcess_Monitor

BasicMethodsSequence MoFEM::TsCtx::postProcess_Monitor

Definition at line 58 of file TsCtx.hpp.

postProcess_RHSFunction

BasicMethodsSequence MoFEM::TsCtx::postProcess_RHSFunction

Definition at line 62 of file TsCtx.hpp.

postProcess_RHSJacobian

BasicMethodsSequence MoFEM::TsCtx::postProcess_RHSJacobian

Definition at line 61 of file TsCtx.hpp.

preProcess_IFunction

BasicMethodsSequence MoFEM::TsCtx::preProcess_IFunction

Definition at line 55 of file TsCtx.hpp.

preProcess_IJacobian

BasicMethodsSequence MoFEM::TsCtx::preProcess_IJacobian

Definition at line 53 of file TsCtx.hpp.

preProcess_Monitor

BasicMethodsSequence MoFEM::TsCtx::preProcess_Monitor

Definition at line 57 of file TsCtx.hpp.

preProcess_RHSFunction

BasicMethodsSequence MoFEM::TsCtx::preProcess_RHSFunction

Definition at line 60 of file TsCtx.hpp.

preProcess_RHSJacobian

BasicMethodsSequence MoFEM::TsCtx::preProcess_RHSJacobian

Definition at line 59 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 254 of file TsCtx.hpp.

zeroMatrix

bool MoFEM::TsCtx::zeroMatrix

Definition at line 64 of file TsCtx.hpp.

---

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

• src/petsc/TsCtx.hpp