v0.8.20
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 175 of file TsCtx.cpp.

176  {
177  // PetscValidHeaderSpecific(ts,TS_CLASSID,1);
179  TsCtx *ts_ctx = (TsCtx *)ctx;
180  PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxRHSFunction, 0, 0, 0, 0);
181  CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
182  CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
183  CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
184  ts_ctx->problemName, COL, u, INSERT_VALUES, SCATTER_REVERSE);
185 
186  // preproces
187  for (auto &bit : ts_ctx->preProcess_Monitor) {
188  bit->ts_u = u;
189  bit->ts_t = t;
190  bit->ts_step = step;
191  bit->ts_F = PETSC_NULL;
192  CHKERR bit->setTsCtx(TSMethod::CTX_TSSETIJACOBIAN);
193  CHKERR bit->setTs(ts);
194  CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
195  *bit);
196  CHKERR bit->setTsCtx(TSMethod::CTX_TSNONE);
197  }
198 
199  for (auto &lit : ts_ctx->loops_to_do_Monitor) {
200  lit.second->ts_u = u;
201  lit.second->ts_t = t;
202  lit.second->ts_step = step;
203  lit.second->ts_F = PETSC_NULL;
204  CHKERR lit.second->setTsCtx(TSMethod::CTX_TSTSMONITORSET);
205  CHKERR lit.second->setTs(ts);
206  CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
207  *(lit.second), ts_ctx->bH);
208  CHKERR lit.second->setTsCtx(TSMethod::CTX_TSNONE);
209  }
210 
211  // post process
212  for (auto &bit : ts_ctx->postProcess_Monitor) {
213  bit->ts_u = u;
214  bit->ts_t = t;
215  bit->ts_step = step;
216  bit->ts_F = PETSC_NULL;
217  CHKERR bit->setTsCtx(TSMethod::CTX_TSSETIJACOBIAN);
218  CHKERR bit->setTs(ts);
219  CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
220  *bit);
221  CHKERR bit->setTsCtx(TSMethod::CTX_TSNONE);
222  }
223  PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxRHSFunction, 0, 0, 0, 0);
225 }
#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 23 of file TsCtx.cpp.

24  {
25  // PetscValidHeaderSpecific(ts,TS_CLASSID,1);
27  TsCtx *ts_ctx = (TsCtx *)ctx;
28  PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxIFunction, 0, 0, 0, 0);
29  CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
30  CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
31  CHKERR VecGhostUpdateBegin(u_t, INSERT_VALUES, SCATTER_FORWARD);
32  CHKERR VecGhostUpdateEnd(u_t, INSERT_VALUES, SCATTER_FORWARD);
33  CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
34  ts_ctx->problemName, COL, u, INSERT_VALUES, SCATTER_REVERSE);
35 
36  auto zero_ghost_vec = [](Vec g) {
38  Vec l;
39  CHKERR VecGhostGetLocalForm(g, &l);
40  double *a;
41  CHKERR VecGetArray(l, &a);
42  int s;
43  CHKERR VecGetLocalSize(l, &s);
44  for (int i = 0; i != s; ++i)
45  a[i] = 0;
46  CHKERR VecRestoreArray(l, &a);
47  CHKERR VecGhostRestoreLocalForm(g, &l);
49  };
50  CHKERR zero_ghost_vec(F);
51 
52  int step;
53  CHKERR TSGetTimeStepNumber(ts, &step);
54  // preprocess
55  for (auto &bit : ts_ctx->preProcess_IFunction) {
56  bit->ts_u = u;
57  bit->ts_u_t = u_t;
58  bit->ts_F = F;
59  bit->ts_t = t;
60  bit->ts_step = step;
61  CHKERR bit->setTsCtx(TSMethod::CTX_TSSETIFUNCTION);
62  CHKERR bit->setTs(ts);
63  CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
64  *bit);
65  CHKERR bit->setTsCtx(TSMethod::CTX_TSNONE);
66  }
67 
68  // fe loops
69  for (auto &lit : ts_ctx->loops_to_do_IFunction) {
70  lit.second->ts_u = u;
71  lit.second->ts_u_t = u_t;
72  lit.second->ts_F = F;
73  lit.second->ts_t = t;
74  lit.second->ts_step = step;
75  CHKERR lit.second->setTsCtx(TSMethod::CTX_TSSETIFUNCTION);
76  CHKERR lit.second->setTs(ts);
77  CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
78  *(lit.second), ts_ctx->bH);
79  CHKERR lit.second->setTsCtx(TSMethod::CTX_TSNONE);
80  }
81 
82  // post process
83  for (auto &bit : ts_ctx->postProcess_IFunction) {
84  bit->ts_u = u;
85  bit->ts_u_t = u_t;
86  bit->ts_F = F;
87  bit->ts_t = t;
88  bit->ts_step = step;
89  CHKERR bit->setTsCtx(TSMethod::CTX_TSSETIFUNCTION);
90  CHKERR bit->setTs(ts);
91  CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
92  *bit);
93  CHKERR bit->setTsCtx(TSMethod::CTX_TSNONE);
94  }
95 
96  CHKERR VecGhostUpdateBegin(F, ADD_VALUES, SCATTER_REVERSE);
97  CHKERR VecGhostUpdateEnd(F, ADD_VALUES, SCATTER_REVERSE);
98  CHKERR VecAssemblyBegin(F);
99  CHKERR VecAssemblyEnd(F);
100  PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxIFunction, 0, 0, 0, 0);
102 }
#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 103 of file TsCtx.cpp.

104  {
105  // PetscValidHeaderSpecific(ts,TS_CLASSID,1);
107  TsCtx *ts_ctx = (TsCtx *)ctx;
108  PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxIFunction, 0, 0, 0, 0);
109  CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
110  CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
111  CHKERR VecGhostUpdateBegin(u_t, INSERT_VALUES, SCATTER_FORWARD);
112  CHKERR VecGhostUpdateEnd(u_t, INSERT_VALUES, SCATTER_FORWARD);
113  CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
114  ts_ctx->problemName, COL, u, INSERT_VALUES, SCATTER_REVERSE);
115  if (ts_ctx->zeroMatrix) {
116  CHKERR MatZeroEntries(B);
117  }
118  int step;
119  CHKERR TSGetTimeStepNumber(ts, &step);
120 
121  // preproces
122  for (auto &bit : ts_ctx->preProcess_IJacobian) {
123  bit->ts_u = u;
124  bit->ts_u_t = u_t;
125  bit->ts_A = A;
126  bit->ts_B = B;
127  bit->ts_t = t;
128  bit->ts_a = a;
129  bit->ts_step = step;
130  CHKERR bit->setTsCtx(TSMethod::CTX_TSSETIJACOBIAN);
131  CHKERR bit->setTs(ts);
132  CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
133  *bit);
134  CHKERR bit->setTsCtx(TSMethod::CTX_TSNONE);
135  }
136 
137  for (auto &lit : ts_ctx->loops_to_do_IJacobian) {
138  lit.second->ts_u = u;
139  lit.second->ts_u_t = u_t;
140  lit.second->ts_A = A;
141  lit.second->ts_B = B;
142  lit.second->ts_t = t;
143  lit.second->ts_a = a;
144  lit.second->ts_step = step;
145  CHKERR lit.second->setTsCtx(TSMethod::CTX_TSSETIJACOBIAN);
146  CHKERR lit.second->setTs(ts);
147  CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
148  *(lit.second), ts_ctx->bH);
149  CHKERR lit.second->setTsCtx(TSMethod::CTX_TSNONE);
150  }
151 
152  // post process
153  for (auto &bit : ts_ctx->postProcess_IJacobian) {
154  bit->ts_u = u;
155  bit->ts_u_t = u_t;
156  bit->ts_A = A;
157  bit->ts_B = B;
158  bit->ts_t = t;
159  bit->ts_a = a;
160  bit->ts_step = step;
161  CHKERR bit->setTsCtx(TSMethod::CTX_TSSETIJACOBIAN);
162  CHKERR bit->setTs(ts);
163  CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
164  *bit);
165  CHKERR bit->setTsCtx(TSMethod::CTX_TSNONE);
166  }
167 
168  if (ts_ctx->zeroMatrix) {
169  CHKERR MatAssemblyBegin(B, MAT_FINAL_ASSEMBLY);
170  CHKERR MatAssemblyEnd(B, MAT_FINAL_ASSEMBLY);
171  }
172  PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxIFunction, 0, 0, 0, 0);
174 }
#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: