v0.8.19
Public Types | Public Member Functions | Public Attributes | Friends | List of all members
MoFEM::TsCtx Struct Reference

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

#include <src/petsc/TsCtx.hpp>

Collaboration diagram for MoFEM::TsCtx:
[legend]

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)
 
FEMethodsSequenceget_loops_to_do_IFunction ()
 Get the loops to do IFunction object. More...
 
FEMethodsSequenceget_loops_to_do_IJacobian ()
 Get the loops to do IJacobian object. More...
 
FEMethodsSequenceget_loops_to_do_Monitor ()
 Get the loops to do Monitor object. More...
 
BasicMethodsSequenceget_preProcess_to_do_IFunction ()
 Get the preProcess to do IFunction object. More...
 
BasicMethodsSequenceget_postProcess_to_do_IFunction ()
 Get the postProcess to do IFunction object. More...
 
BasicMethodsSequenceget_preProcess_to_do_IJacobian ()
 Get the preProcess to do IJacobian object. More...
 
BasicMethodsSequenceget_postProcess_to_do_IJacobian ()
 Get the postProcess to do IJacobian object. More...
 
BasicMethodsSequenceget_preProcess_to_do_Monitor ()
 Get the preProcess to do Monitor object. More...
 
BasicMethodsSequenceget_postProcess_to_do_Monitor ()
 Get the postProcess to do Monitor 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::InterfacemField
 
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
 
BasicMethodsSequence preProcess_IJacobian
 
BasicMethodsSequence postProcess_IJacobian
 
BasicMethodsSequence preProcess_IFunction
 
BasicMethodsSequence postProcess_IFunction
 
BasicMethodsSequence preProcess_Monitor
 
BasicMethodsSequence postProcess_Monitor
 
PetscLogEvent MOFEM_EVENT_TsCtxRHSFunction
 
PetscLogEvent MOFEM_EVENT_TsCtxRHSJacobian
 
PetscLogEvent MOFEM_EVENT_TsCtxIFunction
 
PetscLogEvent MOFEM_EVENT_TsCtxIJacobian
 
PetscLogEvent MOFEM_EVENT_TsCtxMonitor
 
bool zeroMatrix
 

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

Detailed Description

Interface for Time Stepping (TS) solver.

Examples:
Remodeling.cpp.

Definition at line 27 of file TsCtx.hpp.

Member Typedef Documentation

◆ BasicMethodsSequence

Definition at line 46 of file TsCtx.hpp.

◆ FEMethodsSequence

Definition at line 45 of file TsCtx.hpp.

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

66  : mField(m_field), moab(m_field.get_moab()), problemName(problem_name),
67  bH(MF_EXIST), zeroMatrix(true) {
68  PetscLogEventRegister("LoopTsIFunction", 0, &MOFEM_EVENT_TsCtxIFunction);
69  PetscLogEventRegister("LoopTsIJacobian", 0, &MOFEM_EVENT_TsCtxIJacobian);
70  PetscLogEventRegister("LoopTsRHSFunction", 0,
72  PetscLogEventRegister("LoopTsRHSJacobian", 0,
74  PetscLogEventRegister("LoopTsMonitor", 0, &MOFEM_EVENT_TsCtxMonitor);
75  }
PetscLogEvent MOFEM_EVENT_TsCtxIFunction
Definition: TsCtx.hpp:60
bool zeroMatrix
Definition: TsCtx.hpp:64
virtual moab::Interface & get_moab()=0
PetscLogEvent MOFEM_EVENT_TsCtxIJacobian
Definition: TsCtx.hpp:61
MoFEMTypes bH
If set to MF_EXIST check if element exist.
Definition: TsCtx.hpp:33
std::string problemName
Definition: TsCtx.hpp:32
moab::Interface & moab
Definition: TsCtx.hpp:30
PetscLogEvent MOFEM_EVENT_TsCtxRHSFunction
Definition: TsCtx.hpp:58
PetscLogEvent MOFEM_EVENT_TsCtxMonitor
Definition: TsCtx.hpp:62
MoFEM::Interface & mField
Definition: TsCtx.hpp:29
PetscLogEvent MOFEM_EVENT_TsCtxRHSJacobian
Definition: TsCtx.hpp:59

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

85  {
86  return loops_to_do_IFunction;
87  }
FEMethodsSequence loops_to_do_IFunction
Definition: TsCtx.hpp:49

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

97  {
98  return loops_to_do_IJacobian;
99  }
FEMethodsSequence loops_to_do_IJacobian
Definition: TsCtx.hpp:48

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

108 { return loops_to_do_Monitor; }
FEMethodsSequence loops_to_do_Monitor
Definition: TsCtx.hpp:50

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

124  {
125  return postProcess_IFunction;
126  }
BasicMethodsSequence postProcess_IFunction
Definition: TsCtx.hpp:54

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

142  {
143  return postProcess_IJacobian;
144  }
BasicMethodsSequence postProcess_IJacobian
Definition: TsCtx.hpp:52

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

160  {
161  return postProcess_Monitor;
162  }
BasicMethodsSequence postProcess_Monitor
Definition: TsCtx.hpp:56

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

115  {
116  return preProcess_IFunction;
117  }
BasicMethodsSequence preProcess_IFunction
Definition: TsCtx.hpp:53

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

133  {
134  return preProcess_IJacobian;
135  }
BasicMethodsSequence preProcess_IJacobian
Definition: TsCtx.hpp:51

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

151  {
152  return preProcess_Monitor;
153  }
BasicMethodsSequence preProcess_Monitor
Definition: TsCtx.hpp:55

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 208 of file TsCtx.cpp.

209  {
210  // PetscValidHeaderSpecific(ts,TS_CLASSID,1);
212  TsCtx *ts_ctx = (TsCtx *)ctx;
213  PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxRHSFunction, 0, 0, 0, 0);
214  CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
215  CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
216  CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
217  ts_ctx->problemName, COL, u, INSERT_VALUES, SCATTER_REVERSE);
218 
219  // preproces
220  for (auto &bit : ts_ctx->preProcess_Monitor) {
221  bit->ts_u = u;
222  bit->ts_t = t;
223  bit->ts_step = step;
224  bit->ts_F = PETSC_NULL;
225  CHKERR bit->setTsCtx(TSMethod::CTX_TSSETIJACOBIAN);
226  CHKERR bit->setTs(ts);
227  CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
228  *bit);
229  CHKERR bit->setTsCtx(TSMethod::CTX_TSNONE);
230  }
231 
232  for (auto &lit : ts_ctx->loops_to_do_Monitor) {
233  lit.second->ts_u = u;
234  lit.second->ts_t = t;
235  lit.second->ts_step = step;
236  lit.second->ts_F = PETSC_NULL;
237  CHKERR lit.second->setTsCtx(TSMethod::CTX_TSTSMONITORSET);
238  CHKERR lit.second->setTs(ts);
239  CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
240  *(lit.second), ts_ctx->bH);
241  CHKERR lit.second->setTsCtx(TSMethod::CTX_TSNONE);
242  }
243 
244  // post process
245  for (auto &bit : ts_ctx->postProcess_Monitor) {
246  bit->ts_u = u;
247  bit->ts_t = t;
248  bit->ts_step = step;
249  bit->ts_F = PETSC_NULL;
250  CHKERR bit->setTsCtx(TSMethod::CTX_TSSETIJACOBIAN);
251  CHKERR bit->setTs(ts);
252  CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
253  *bit);
254  CHKERR bit->setTsCtx(TSMethod::CTX_TSNONE);
255  }
256  PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxRHSFunction, 0, 0, 0, 0);
258 }
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return() ...
Definition: definitions.h:475
TsCtx(MoFEM::Interface &m_field, const std::string &problem_name)
Definition: TsCtx.hpp:65
#define CHKERR
Inline error check.
Definition: definitions.h:594
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:405

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

57  {
58  // PetscValidHeaderSpecific(ts,TS_CLASSID,1);
60  TsCtx *ts_ctx = (TsCtx *)ctx;
61  PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxIFunction, 0, 0, 0, 0);
62  CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
63  CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
64  CHKERR VecGhostUpdateBegin(u_t, INSERT_VALUES, SCATTER_FORWARD);
65  CHKERR VecGhostUpdateEnd(u_t, INSERT_VALUES, SCATTER_FORWARD);
66  CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
67  ts_ctx->problemName, COL, u, INSERT_VALUES, SCATTER_REVERSE);
68 
69  auto zero_ghost_vec = [](Vec g) {
71  Vec l;
72  CHKERR VecGhostGetLocalForm(g, &l);
73  double *a;
74  CHKERR VecGetArray(l, &a);
75  int s;
76  CHKERR VecGetLocalSize(l, &s);
77  for (int i = 0; i != s; ++i)
78  a[i] = 0;
79  CHKERR VecRestoreArray(l, &a);
80  CHKERR VecGhostRestoreLocalForm(g, &l);
82  };
83  CHKERR zero_ghost_vec(F);
84 
85  int step;
86  CHKERR TSGetTimeStepNumber(ts, &step);
87  // preprocess
88  for (auto &bit : ts_ctx->preProcess_IFunction) {
89  bit->ts_u = u;
90  bit->ts_u_t = u_t;
91  bit->ts_F = F;
92  bit->ts_t = t;
93  bit->ts_step = step;
94  CHKERR bit->setTsCtx(TSMethod::CTX_TSSETIFUNCTION);
95  CHKERR bit->setTs(ts);
96  CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
97  *bit);
98  CHKERR bit->setTsCtx(TSMethod::CTX_TSNONE);
99  }
100 
101  // fe loops
102  for (auto &lit : ts_ctx->loops_to_do_IFunction) {
103  lit.second->ts_u = u;
104  lit.second->ts_u_t = u_t;
105  lit.second->ts_F = F;
106  lit.second->ts_t = t;
107  lit.second->ts_step = step;
108  CHKERR lit.second->setTsCtx(TSMethod::CTX_TSSETIFUNCTION);
109  CHKERR lit.second->setTs(ts);
110  CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
111  *(lit.second), ts_ctx->bH);
112  CHKERR lit.second->setTsCtx(TSMethod::CTX_TSNONE);
113  }
114 
115  // post process
116  for (auto &bit : ts_ctx->postProcess_IFunction) {
117  bit->ts_u = u;
118  bit->ts_u_t = u_t;
119  bit->ts_F = F;
120  bit->ts_t = t;
121  bit->ts_step = step;
122  CHKERR bit->setTsCtx(TSMethod::CTX_TSSETIFUNCTION);
123  CHKERR bit->setTs(ts);
124  CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
125  *bit);
126  CHKERR bit->setTsCtx(TSMethod::CTX_TSNONE);
127  }
128 
129  CHKERR VecGhostUpdateBegin(F, ADD_VALUES, SCATTER_REVERSE);
130  CHKERR VecGhostUpdateEnd(F, ADD_VALUES, SCATTER_REVERSE);
131  CHKERR VecAssemblyBegin(F);
132  CHKERR VecAssemblyEnd(F);
133  PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxIFunction, 0, 0, 0, 0);
135 }
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return() ...
Definition: definitions.h:475
TsCtx(MoFEM::Interface &m_field, const std::string &problem_name)
Definition: TsCtx.hpp:65
#define CHKERR
Inline error check.
Definition: definitions.h:594
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:405

◆ 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 136 of file TsCtx.cpp.

137  {
138  // PetscValidHeaderSpecific(ts,TS_CLASSID,1);
140  TsCtx *ts_ctx = (TsCtx *)ctx;
141  PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxIFunction, 0, 0, 0, 0);
142  CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
143  CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
144  CHKERR VecGhostUpdateBegin(u_t, INSERT_VALUES, SCATTER_FORWARD);
145  CHKERR VecGhostUpdateEnd(u_t, INSERT_VALUES, SCATTER_FORWARD);
146  CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
147  ts_ctx->problemName, COL, u, INSERT_VALUES, SCATTER_REVERSE);
148  if (ts_ctx->zeroMatrix) {
149  CHKERR MatZeroEntries(B);
150  }
151  int step;
152  CHKERR TSGetTimeStepNumber(ts, &step);
153 
154  // preproces
155  for (auto &bit : ts_ctx->preProcess_IJacobian) {
156  bit->ts_u = u;
157  bit->ts_u_t = u_t;
158  bit->ts_A = A;
159  bit->ts_B = B;
160  bit->ts_t = t;
161  bit->ts_a = a;
162  bit->ts_step = step;
163  CHKERR bit->setTsCtx(TSMethod::CTX_TSSETIJACOBIAN);
164  CHKERR bit->setTs(ts);
165  CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
166  *bit);
167  CHKERR bit->setTsCtx(TSMethod::CTX_TSNONE);
168  }
169 
170  for (auto &lit : ts_ctx->loops_to_do_IJacobian) {
171  lit.second->ts_u = u;
172  lit.second->ts_u_t = u_t;
173  lit.second->ts_A = A;
174  lit.second->ts_B = B;
175  lit.second->ts_t = t;
176  lit.second->ts_a = a;
177  lit.second->ts_step = step;
178  CHKERR lit.second->setTsCtx(TSMethod::CTX_TSSETIJACOBIAN);
179  CHKERR lit.second->setTs(ts);
180  CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
181  *(lit.second), ts_ctx->bH);
182  CHKERR lit.second->setTsCtx(TSMethod::CTX_TSNONE);
183  }
184 
185  // post process
186  for (auto &bit : ts_ctx->postProcess_IJacobian) {
187  bit->ts_u = u;
188  bit->ts_u_t = u_t;
189  bit->ts_A = A;
190  bit->ts_B = B;
191  bit->ts_t = t;
192  bit->ts_a = a;
193  bit->ts_step = step;
194  CHKERR bit->setTsCtx(TSMethod::CTX_TSSETIJACOBIAN);
195  CHKERR bit->setTs(ts);
196  CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
197  *bit);
198  CHKERR bit->setTsCtx(TSMethod::CTX_TSNONE);
199  }
200 
201  if (ts_ctx->zeroMatrix) {
202  CHKERR MatAssemblyBegin(B, MAT_FINAL_ASSEMBLY);
203  CHKERR MatAssemblyEnd(B, MAT_FINAL_ASSEMBLY);
204  }
205  PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxIFunction, 0, 0, 0, 0);
207 }
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return() ...
Definition: definitions.h:475
TsCtx(MoFEM::Interface &m_field, const std::string &problem_name)
Definition: TsCtx.hpp:65
#define CHKERR
Inline error check.
Definition: definitions.h:594
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:405

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_type

DEPRECATED typedef MoFEM::FEMethodsSequence MoFEM::TsCtx::loops_to_do_type
Deprecated:
use FEMethodsSequence

Definition at line 39 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

Definition at line 60 of file TsCtx.hpp.

◆ MOFEM_EVENT_TsCtxIJacobian

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxIJacobian

Definition at line 61 of file TsCtx.hpp.

◆ MOFEM_EVENT_TsCtxMonitor

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxMonitor

Definition at line 62 of file TsCtx.hpp.

◆ MOFEM_EVENT_TsCtxRHSFunction

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxRHSFunction

Definition at line 58 of file TsCtx.hpp.

◆ MOFEM_EVENT_TsCtxRHSJacobian

PetscLogEvent MoFEM::TsCtx::MOFEM_EVENT_TsCtxRHSJacobian

Definition at line 59 of file TsCtx.hpp.

◆ postProcess_IFunction

BasicMethodsSequence MoFEM::TsCtx::postProcess_IFunction

Definition at line 54 of file TsCtx.hpp.

◆ postProcess_IJacobian

BasicMethodsSequence MoFEM::TsCtx::postProcess_IJacobian

Definition at line 52 of file TsCtx.hpp.

◆ postProcess_Monitor

BasicMethodsSequence MoFEM::TsCtx::postProcess_Monitor

Definition at line 56 of file TsCtx.hpp.

◆ preProcess_IFunction

BasicMethodsSequence MoFEM::TsCtx::preProcess_IFunction

Definition at line 53 of file TsCtx.hpp.

◆ preProcess_IJacobian

BasicMethodsSequence MoFEM::TsCtx::preProcess_IJacobian

Definition at line 51 of file TsCtx.hpp.

◆ preProcess_Monitor

BasicMethodsSequence MoFEM::TsCtx::preProcess_Monitor

Definition at line 55 of file TsCtx.hpp.

◆ problemName

std::string MoFEM::TsCtx::problemName

Definition at line 32 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: