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

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

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 87 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 111 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 99 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);
}

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 247 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_TsCtxIFunction

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxIFunction

private

Definition at line 242 of file TsCtx.hpp.

MOFEM_EVENT_TsCtxIJacobian

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxIJacobian

private

Definition at line 243 of file TsCtx.hpp.

MOFEM_EVENT_TsCtxMonitor

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxMonitor

private

Definition at line 244 of file TsCtx.hpp.

MOFEM_EVENT_TsCtxRHSFunction

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxRHSFunction

private

Definition at line 240 of file TsCtx.hpp.

MOFEM_EVENT_TsCtxRHSJacobian

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxRHSJacobian

private

Definition at line 241 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 246 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