v0.15.0
Loading...
Searching...
No Matches
TsCtx.cpp
Go to the documentation of this file.
1
2
3namespace MoFEM {
4
5TsCtx::TsCtx(MoFEM::Interface &m_field, const std::string &problem_name)
6 : mField(m_field), moab(m_field.get_moab()), problemName(problem_name),
7 bH(MF_EXIST), zeroMatrix(true) {
8 PetscLogEventRegister("LoopTsIFunction", 0, &MOFEM_EVENT_TsCtxIFunction);
9 PetscLogEventRegister("LoopTsIJacobian", 0, &MOFEM_EVENT_TsCtxIJacobian);
10 PetscLogEventRegister("LoopTsRHSFunction", 0, &MOFEM_EVENT_TsCtxRHSFunction);
11 PetscLogEventRegister("LoopTsRHSJacobian", 0, &MOFEM_EVENT_TsCtxRHSJacobian);
12 PetscLogEventRegister("LoopTsMonitor", 0, &MOFEM_EVENT_TsCtxMonitor);
13 PetscLogEventRegister("LoopTsI2Function", 0, &MOFEM_EVENT_TsCtxI2Function);
14 PetscLogEventRegister("LoopTsI2Jacobian", 0, &MOFEM_EVENT_TsCtxI2Jacobian);
15
16 if (!LogManager::checkIfChannelExist("TSWORLD")) {
17 auto core_log = logging::core::get();
18
19 core_log->add_sink(
20 LogManager::createSink(LogManager::getStrmWorld(), "TSWORLD"));
21 core_log->add_sink(
22 LogManager::createSink(LogManager::getStrmSync(), "TSSYNC"));
23 core_log->add_sink(
24 LogManager::createSink(LogManager::getStrmSelf(), "TSSELF"));
25
26 LogManager::setLog("TSWORLD");
27 LogManager::setLog("TSSYNC");
28 LogManager::setLog("TSSELF");
29
30 MOFEM_LOG_TAG("TSWORLD", "TS");
31 MOFEM_LOG_TAG("TSSYNC", "TS");
32 MOFEM_LOG_TAG("TSSELF", "TS");
33 }
34}
35
55
56PetscErrorCode TsSetIFunction(TS ts, PetscReal t, Vec u, Vec u_t, Vec F,
57 void *ctx) {
58 MoFEMFunctionBegin;
59 TsCtx *ts_ctx = static_cast<TsCtx *>(ctx);
60 PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxIFunction, 0, 0, 0, 0);
61 CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
62 CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
63 CHKERR VecGhostUpdateBegin(u_t, INSERT_VALUES, SCATTER_FORWARD);
64 CHKERR VecGhostUpdateEnd(u_t, INSERT_VALUES, SCATTER_FORWARD);
65 CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
66 ts_ctx->problemName, COL, u, INSERT_VALUES, SCATTER_REVERSE);
67
68 auto zero_ghost_vec = [](Vec g) {
69 MoFEMFunctionBegin;
70 Vec l;
71 CHKERR VecGhostGetLocalForm(g, &l);
72 double *a;
73 CHKERR VecGetArray(l, &a);
74 int s;
75 CHKERR VecGetLocalSize(l, &s);
76 for (int i = 0; i != s; ++i)
77 a[i] = 0;
78 CHKERR VecRestoreArray(l, &a);
79 CHKERR VecGhostRestoreLocalForm(g, &l);
80 MoFEMFunctionReturn(0);
81 };
82 CHKERR zero_ghost_vec(F);
83
84 ts_ctx->vecAssembleSwitch = boost::movelib::make_unique<bool>(true);
85
86 int step;
87#if PETSC_VERSION_GE(3, 8, 0)
88 CHKERR TSGetStepNumber(ts, &step);
89#else
90 CHKERR TSGetTimeStepNumber(ts, &step);
91#endif
92
93 auto cache_ptr = boost::make_shared<CacheTuple>();
94 CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
95
96 auto set = [&](auto &fe) {
97 fe.ts = ts;
98 fe.ts_u = u;
99 fe.ts_u_t = u_t;
100 fe.ts_F = F;
101 fe.ts_t = t;
102 fe.ts_step = step;
103 fe.ts_ctx = TSMethod::CTX_TSSETIFUNCTION;
104 fe.snes_ctx = SnesMethod::CTX_SNESSETFUNCTION;
105 fe.ksp_ctx = KspMethod::CTX_SETFUNCTION;
106 fe.data_ctx = PetscData::CtxSetF | PetscData::CtxSetX |
107 PetscData::CtxSetX_T | PetscData::CtxSetTime;
108
109 CHKERR TSGetSNES(ts, &fe.snes);
110 CHKERR SNESGetKSP(fe.snes, &fe.ksp);
111
112 fe.cacheWeakPtr = cache_ptr;
113 CHK_THROW_MESSAGE(TSGetTimeStep(ts, &fe.ts_dt), "get time step failed");
114 };
115
116 auto unset = [&](auto &fe) {
117 fe.ts_ctx = TSMethod::CTX_TSNONE;
118 fe.snes_ctx = SnesMethod::CTX_SNESNONE;
119 fe.ksp_ctx = KspMethod::CTX_KSPNONE;
120 fe.data_ctx = PetscData::CtxSetNone;
121 };
122
123 // preprocess
124 for (auto &bit : ts_ctx->preProcessIFunction) {
125 bit->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
126 set(*bit);
127 CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
128 *bit);
129 unset(*bit);
130 ts_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
131 }
132
133 // fe loops
134 for (auto &lit : ts_ctx->loopsIFunction) {
135 lit.second->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
136 set(*lit.second);
137 CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
138 *(lit.second), nullptr,
139 ts_ctx->bH, cache_ptr);
140 unset(*lit.second);
141 ts_ctx->vecAssembleSwitch = boost::move(lit.second->vecAssembleSwitch);
142 }
143
144 // post process
145 for (auto &bit : ts_ctx->postProcessIFunction) {
146 bit->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
147 set(*bit);
148 CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
149 *bit);
150 unset(*bit);
151 ts_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
152 }
153
154 if (*ts_ctx->vecAssembleSwitch) {
155 CHKERR VecGhostUpdateBegin(F, ADD_VALUES, SCATTER_REVERSE);
156 CHKERR VecGhostUpdateEnd(F, ADD_VALUES, SCATTER_REVERSE);
157 CHKERR VecAssemblyBegin(F);
158 CHKERR VecAssemblyEnd(F);
159 }
160
161 if(ts_ctx->tsDebugHook) {
162 CHKERR ts_ctx->tsDebugHook(ts, t, u, u_t, PETSC_NULLPTR, F, ctx);
163 }
164
165 PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxIFunction, 0, 0, 0, 0);
166 MoFEMFunctionReturn(0);
167}
168
169PetscErrorCode TsSetIJacobian(TS ts, PetscReal t, Vec u, Vec u_t, PetscReal a,
170 Mat A, Mat B, void *ctx) {
171 MoFEMFunctionBegin;
172
173 TsCtx *ts_ctx = static_cast<TsCtx *>(ctx);
174 PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxIFunction, 0, 0, 0, 0);
175 CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
176 CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
177 CHKERR VecGhostUpdateBegin(u_t, INSERT_VALUES, SCATTER_FORWARD);
178 CHKERR VecGhostUpdateEnd(u_t, INSERT_VALUES, SCATTER_FORWARD);
179 CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
180 ts_ctx->problemName, COL, u, INSERT_VALUES, SCATTER_REVERSE);
181 if (ts_ctx->zeroMatrix) {
182 CHKERR MatZeroEntries(B);
183 }
184 int step;
185#if PETSC_VERSION_GE(3, 8, 0)
186 CHKERR TSGetStepNumber(ts, &step);
187#else
188 CHKERR TSGetTimeStepNumber(ts, &step);
189#endif
190
191 ts_ctx->matAssembleSwitch =
192 boost::movelib::make_unique<bool>(ts_ctx->zeroMatrix);
193 auto cache_ptr = boost::make_shared<CacheTuple>();
194 CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
195
196 auto set = [&](auto &fe) {
197 fe.ts = ts;
198 fe.ts_u = u;
199 fe.ts_u_t = u_t;
200 fe.ts_A = A;
201 fe.ts_B = B;
202 fe.ts_t = t;
203 fe.ts_a = a;
204 fe.ts_step = step;
205 fe.ts_ctx = TSMethod::CTX_TSSETIJACOBIAN;
206 fe.snes_ctx = SnesMethod::CTX_SNESSETJACOBIAN;
207 fe.ksp_ctx = KspMethod::CTX_OPERATORS;
208 fe.data_ctx = PetscData::CtxSetA | PetscData::CtxSetB | PetscData::CtxSetX |
209 PetscData::CtxSetX_T | PetscData::CtxSetTime;
210
211 CHKERR TSGetSNES(ts, &fe.snes);
212 CHKERR SNESGetKSP(fe.snes, &fe.ksp);
213
214 fe.cacheWeakPtr = cache_ptr;
215 CHK_THROW_MESSAGE(TSGetTimeStep(ts, &fe.ts_dt), "get time step failed");
216 };
217
218 auto unset = [&](auto &fe) {
219 fe.ts_ctx = TSMethod::CTX_TSNONE;
220 fe.snes_ctx = SnesMethod::CTX_SNESNONE;
221 fe.ksp_ctx = KspMethod::CTX_KSPNONE;
222 fe.data_ctx = PetscData::CtxSetNone;
223 };
224
225 // preproces
226 for (auto &bit : ts_ctx->preProcessIJacobian) {
227 bit->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
228 set(*bit);
229 CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
230 *bit);
231 unset(*bit);
232 ts_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
233 }
234
235 for (auto &lit : ts_ctx->loopsIJacobian) {
236 lit.second->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
237 set(*lit.second);
238 CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
239 *(lit.second), nullptr,
240 ts_ctx->bH, cache_ptr);
241 unset(*lit.second);
242 ts_ctx->matAssembleSwitch = boost::move(lit.second->matAssembleSwitch);
243 }
244
245 // post process
246 for (auto &bit : ts_ctx->postProcessIJacobian) {
247 bit->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
248 set(*bit);
249 CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
250 *bit);
251 unset(*bit);
252 ts_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
253 }
254
255 if (*(ts_ctx->matAssembleSwitch)) {
256 CHKERR MatAssemblyBegin(B, MAT_FINAL_ASSEMBLY);
257 CHKERR MatAssemblyEnd(B, MAT_FINAL_ASSEMBLY);
258 }
259 PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxIFunction, 0, 0, 0, 0);
260 MoFEMFunctionReturn(0);
261}
262
263PetscErrorCode TsMonitorSet(TS ts, PetscInt step, PetscReal t, Vec u,
264 void *ctx) {
265 MoFEMFunctionBegin;
266 TsCtx *ts_ctx = static_cast<TsCtx *>(ctx);
267 PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxMonitor, 0, 0, 0, 0);
268 CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
269 CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
270 CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
271 ts_ctx->problemName, COL, u, INSERT_VALUES, SCATTER_REVERSE);
272
273 auto cache_ptr = boost::make_shared<CacheTuple>();
274 CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
275
276 auto set = [&](auto &fe) {
277 fe.ts = ts;
278 fe.ts_u = u;
279 fe.ts_t = t;
280 fe.ts_step = step;
281 fe.ts_F = PETSC_NULLPTR;
282 fe.ts_ctx = TSMethod::CTX_TSTSMONITORSET;
283 fe.snes_ctx = SnesMethod::CTX_SNESNONE;
284 fe.ksp_ctx = KspMethod::CTX_KSPNONE;
285 fe.data_ctx = PetscData::CtxSetX | PetscData::CtxSetTime;
286
287 CHKERR TSGetSNES(ts, &fe.snes);
288 CHKERR SNESGetKSP(fe.snes, &fe.ksp);
289
290 fe.cacheWeakPtr = cache_ptr;
291 CHK_THROW_MESSAGE(TSGetTimeStep(ts, &fe.ts_dt), "get time step failed");
292 };
293
294 auto unset = [&](auto &fe) {
295 fe.ts_ctx = TSMethod::CTX_TSNONE;
296 fe.data_ctx = PetscData::CtxSetNone;
297 };
298
299 // preprocess
300 for (auto &bit : ts_ctx->preProcessMonitor) {
301 set(*bit);
302 CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
303 *bit);
304 unset(*bit);
305 }
306
307 for (auto &lit : ts_ctx->loopsMonitor) {
308 set(*lit.second);
309 CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
310 *(lit.second), nullptr,
311 ts_ctx->bH, cache_ptr);
312 unset(*lit.second);
313 }
314
315 // post process
316 for (auto &bit : ts_ctx->postProcessMonitor) {
317 set(*bit);
318 CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
319 *bit);
320 unset(*bit);
321 }
322
323 PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxMonitor, 0, 0, 0, 0);
324 MoFEMFunctionReturn(0);
325}
326
327PetscErrorCode TsSetRHSFunction(TS ts, PetscReal t, Vec u, Vec F, void *ctx) {
328 MoFEMFunctionBegin;
329 TsCtx *ts_ctx = static_cast<TsCtx *>(ctx);
330 PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxRHSFunction, 0, 0, 0, 0);
331 CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
332 CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
333 CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
334 ts_ctx->problemName, COL, u, INSERT_VALUES, SCATTER_REVERSE);
335
336 auto zero_ghost_vec = [](Vec g) {
337 MoFEMFunctionBegin;
338 Vec l;
339 CHKERR VecGhostGetLocalForm(g, &l);
340 double *a;
341 CHKERR VecGetArray(l, &a);
342 int s;
343 CHKERR VecGetLocalSize(l, &s);
344 for (int i = 0; i != s; ++i)
345 a[i] = 0;
346 CHKERR VecRestoreArray(l, &a);
347 CHKERR VecGhostRestoreLocalForm(g, &l);
348 MoFEMFunctionReturn(0);
349 };
350 CHKERR zero_ghost_vec(F);
351
352 ts_ctx->vecAssembleSwitch = boost::movelib::make_unique<bool>(true);
353 auto cache_ptr = boost::make_shared<CacheTuple>();
354 CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
355
356 int step;
357#if PETSC_VERSION_GE(3, 8, 0)
358 CHKERR TSGetStepNumber(ts, &step);
359#else
360 CHKERR TSGetTimeStepNumber(ts, &step);
361#endif
362
363 auto set = [&](auto &fe) {
364 fe.ts_u = u;
365 fe.ts_F = F;
366 fe.ts_t = t;
367 fe.ts = ts;
368 fe.ts_step = step;
369 fe.ts_ctx = TSMethod::CTX_TSSETRHSFUNCTION;
370 fe.snes_ctx = SnesMethod::CTX_SNESSETFUNCTION;
371 fe.ksp_ctx = KspMethod::CTX_SETFUNCTION;
372 fe.data_ctx =
373 PetscData::CtxSetF | PetscData::CtxSetX | PetscData::CtxSetTime;
374 fe.cacheWeakPtr = cache_ptr;
375 CHK_THROW_MESSAGE(TSGetTimeStep(ts, &fe.ts_dt), "get time step failed");
376 };
377
378 auto unset = [&](auto &fe) {
379 fe.ts_ctx = TSMethod::CTX_TSNONE;
380 fe.snes_ctx = SnesMethod::CTX_SNESNONE;
381 fe.ksp_ctx = KspMethod::CTX_KSPNONE;
382 fe.data_ctx = PetscData::CtxSetNone;
383 };
384
385 for (auto &bit : ts_ctx->preProcessRHSFunction) {
386 bit->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
387 set(*bit);
388 CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
389 *bit);
390 unset(*bit);
391 ts_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
392 }
393
394 // fe loops
395 for (auto &lit : ts_ctx->loopsRHSFunction) {
396 lit.second->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
397 set(*lit.second);
398 CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
399 *(lit.second), nullptr,
400 ts_ctx->bH, cache_ptr);
401 unset(*lit.second);
402 ts_ctx->vecAssembleSwitch = boost::move(lit.second->vecAssembleSwitch);
403 }
404
405 // post process
406 for (auto &bit : ts_ctx->postProcessRHSFunction) {
407 bit->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
408 set(*bit);
409 CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
410 *bit);
411 unset(*bit);
412 ts_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
413 }
414
415 if (*ts_ctx->vecAssembleSwitch) {
416 CHKERR VecGhostUpdateBegin(F, ADD_VALUES, SCATTER_REVERSE);
417 CHKERR VecGhostUpdateEnd(F, ADD_VALUES, SCATTER_REVERSE);
418 CHKERR VecAssemblyBegin(F);
419 CHKERR VecAssemblyEnd(F);
420 }
421
422 if (ts_ctx->tsDebugHook) {
423 CHKERR ts_ctx->tsDebugHook(ts, t, u, PETSC_NULLPTR, PETSC_NULLPTR, F, ctx);
424 }
425
426 PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxRHSFunction, 0, 0, 0, 0);
427 MoFEMFunctionReturn(0);
428}
429
430PetscErrorCode TsSetRHSJacobian(TS ts, PetscReal t, Vec u, Mat A, Mat B,
431 void *ctx) {
432 MoFEMFunctionBegin;
433 TsCtx *ts_ctx = static_cast<TsCtx *>(ctx);
434 PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxRHSJacobian, 0, 0, 0, 0);
435 CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
436 CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
437 CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
438 ts_ctx->problemName, COL, u, INSERT_VALUES, SCATTER_REVERSE);
439
440 if (ts_ctx->zeroMatrix) {
441 CHKERR MatZeroEntries(B);
442 }
443
444 ts_ctx->matAssembleSwitch =
445 boost::movelib::make_unique<bool>(ts_ctx->zeroMatrix);
446 auto cache_ptr = boost::make_shared<CacheTuple>();
447 CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
448
449 int step;
450#if PETSC_VERSION_GE(3, 8, 0)
451 CHKERR TSGetStepNumber(ts, &step);
452#else
453 CHKERR TSGetTimeStepNumber(ts, &step);
454#endif
455
456 auto set = [&](auto &fe) {
457 fe.ts_u = u;
458 fe.ts_A = A;
459 fe.ts_B = B;
460 fe.ts_t = t;
461 fe.ts_step = step;
462 fe.ts_ctx = TSMethod::CTX_TSSETRHSJACOBIAN;
463 fe.snes_ctx = SnesMethod::CTX_SNESSETJACOBIAN;
464 fe.ksp_ctx = KspMethod::CTX_OPERATORS;
465 fe.data_ctx = PetscData::CtxSetA | PetscData::CtxSetB | PetscData::CtxSetX |
466 PetscData::CtxSetTime;
467 fe.ts = ts;
468 fe.cacheWeakPtr = cache_ptr;
469 CHK_THROW_MESSAGE(TSGetTimeStep(ts, &fe.ts_dt), "get time step failed");
470 };
471
472 auto unset = [&](auto &fe) {
473 fe.ts_ctx = TSMethod::CTX_TSNONE;
474 fe.snes_ctx = SnesMethod::CTX_SNESNONE;
475 fe.ksp_ctx = KspMethod::CTX_KSPNONE;
476 fe.data_ctx = PetscData::CtxSetNone;
477 };
478
479 // preprocess
480 for (auto &bit : ts_ctx->preProcessRHSJacobian) {
481 bit->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
482 set(*bit);
483 CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
484 *bit);
485 unset(*bit);
486 ts_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
487 }
488
489 // fe loops
490 for (auto &lit : ts_ctx->loopsRHSJacobian) {
491 lit.second->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
492 set(*lit.second);
493 CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
494 *(lit.second), nullptr,
495 ts_ctx->bH, cache_ptr);
496 unset(*lit.second);
497 ts_ctx->matAssembleSwitch = boost::move(lit.second->matAssembleSwitch);
498 }
499
500 // post process
501 for (auto &bit : ts_ctx->postProcessRHSJacobian) {
502 bit->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
503 set(*bit);
504 CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
505 *bit);
506 unset(*bit);
507 ts_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
508 }
509
510 if (*(ts_ctx->matAssembleSwitch)) {
511 CHKERR MatAssemblyBegin(B, MAT_FINAL_ASSEMBLY);
512 CHKERR MatAssemblyEnd(B, MAT_FINAL_ASSEMBLY);
513 }
514
515 PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxRHSJacobian, 0, 0, 0, 0);
516 MoFEMFunctionReturn(0);
517}
518
519PetscErrorCode TsSetI2Jacobian(TS ts, PetscReal t, Vec u, Vec u_t, Vec u_tt,
520 PetscReal a, PetscReal aa, Mat A, Mat B,
521 void *ctx) {
522 MoFEMFunctionBegin;
523
524 TsCtx *ts_ctx = static_cast<TsCtx *>(ctx);
525 PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxI2Function, 0, 0, 0, 0);
526 CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
527 CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
528 CHKERR VecGhostUpdateBegin(u_t, INSERT_VALUES, SCATTER_FORWARD);
529 CHKERR VecGhostUpdateEnd(u_t, INSERT_VALUES, SCATTER_FORWARD);
530 CHKERR VecGhostUpdateBegin(u_tt, INSERT_VALUES, SCATTER_FORWARD);
531 CHKERR VecGhostUpdateEnd(u_tt, INSERT_VALUES, SCATTER_FORWARD);
532 CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
533 ts_ctx->problemName, COL, u, INSERT_VALUES, SCATTER_REVERSE);
534 if (ts_ctx->zeroMatrix) {
535 CHKERR MatZeroEntries(B);
536 }
537 int step;
538#if PETSC_VERSION_GE(3, 8, 0)
539 CHKERR TSGetStepNumber(ts, &step);
540#else
541 CHKERR TSGetTimeStepNumber(ts, &step);
542#endif
543
544 ts_ctx->matAssembleSwitch =
545 boost::movelib::make_unique<bool>(ts_ctx->zeroMatrix);
546 auto cache_ptr = boost::make_shared<CacheTuple>();
547 CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
548
549 auto set = [&](auto &fe) {
550 fe.ts_u = u;
551 fe.ts_u_t = u_t;
552 fe.ts_u_tt = u_tt;
553 fe.ts_A = A;
554 fe.ts_B = B;
555 fe.ts_t = t;
556 fe.ts_a = a;
557 fe.ts_aa = aa;
558 fe.ts_step = step;
559
560 fe.ts_ctx = TSMethod::CTX_TSSETIJACOBIAN;
561 fe.snes_ctx = SnesMethod::CTX_SNESSETJACOBIAN;
562 fe.ksp_ctx = KspMethod::CTX_OPERATORS;
563 fe.data_ctx = PetscData::CtxSetA | PetscData::CtxSetB | PetscData::CtxSetX |
564 PetscData::CtxSetX_T | PetscData::CtxSetX_TT |
565 PetscData::CtxSetTime;
566
567 CHKERR TSGetSNES(ts, &fe.snes);
568 CHKERR SNESGetKSP(fe.snes, &fe.ksp);
569
570 fe.ts = ts;
571 fe.cacheWeakPtr = cache_ptr;
572 CHK_THROW_MESSAGE(TSGetTimeStep(ts, &fe.ts_dt), "get time step failed");
573 };
574
575 auto unset = [&](auto &fe) {
576 fe.ts_ctx = TSMethod::CTX_TSNONE;
577 fe.snes_ctx = SnesMethod::CTX_SNESNONE;
578 fe.ksp_ctx = KspMethod::CTX_KSPNONE;
579 fe.data_ctx = PetscData::CtxSetNone;
580 };
581
582 // preprocess
583 for (auto &bit : ts_ctx->preProcessIJacobian) {
584 bit->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
585 set(*bit);
586 CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
587 *bit);
588 unset(*bit);
589 ts_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
590 }
591
592 for (auto &lit : ts_ctx->loopsIJacobian) {
593 lit.second->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
594 set(*lit.second);
595 CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
596 *(lit.second), nullptr,
597 ts_ctx->bH, cache_ptr);
598 unset(*lit.second);
599 ts_ctx->matAssembleSwitch = boost::move(lit.second->matAssembleSwitch);
600 }
601
602 // post process
603 for (auto &bit : ts_ctx->postProcessIJacobian) {
604 bit->matAssembleSwitch = boost::move(ts_ctx->matAssembleSwitch);
605 set(*bit);
606 CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
607 *bit);
608 unset(*bit);
609 ts_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
610 }
611
612 if (*(ts_ctx->matAssembleSwitch)) {
613 CHKERR MatAssemblyBegin(B, MAT_FINAL_ASSEMBLY);
614 CHKERR MatAssemblyEnd(B, MAT_FINAL_ASSEMBLY);
615 }
616 PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxI2Function, 0, 0, 0, 0);
617 MoFEMFunctionReturn(0);
618}
619
620PetscErrorCode TsSetI2Function(TS ts, PetscReal t, Vec u, Vec u_t, Vec u_tt,
621 Vec F, void *ctx) {
622 MoFEMFunctionBegin;
623 TsCtx *ts_ctx = static_cast<TsCtx *>(ctx);
624 PetscLogEventBegin(ts_ctx->MOFEM_EVENT_TsCtxIFunction, 0, 0, 0, 0);
625 CHKERR VecGhostUpdateBegin(u, INSERT_VALUES, SCATTER_FORWARD);
626 CHKERR VecGhostUpdateEnd(u, INSERT_VALUES, SCATTER_FORWARD);
627 CHKERR VecGhostUpdateBegin(u_t, INSERT_VALUES, SCATTER_FORWARD);
628 CHKERR VecGhostUpdateEnd(u_t, INSERT_VALUES, SCATTER_FORWARD);
629 CHKERR VecGhostUpdateBegin(u_tt, INSERT_VALUES, SCATTER_FORWARD);
630 CHKERR VecGhostUpdateEnd(u_tt, INSERT_VALUES, SCATTER_FORWARD);
631 CHKERR ts_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
632 ts_ctx->problemName, COL, u, INSERT_VALUES, SCATTER_REVERSE);
633
634 auto zero_ghost_vec = [](Vec g) {
635 MoFEMFunctionBegin;
636 Vec l;
637 CHKERR VecGhostGetLocalForm(g, &l);
638 double *a;
639 CHKERR VecGetArray(l, &a);
640 int s;
641 CHKERR VecGetLocalSize(l, &s);
642 for (int i = 0; i != s; ++i)
643 a[i] = 0;
644 CHKERR VecRestoreArray(l, &a);
645 CHKERR VecGhostRestoreLocalForm(g, &l);
646 MoFEMFunctionReturn(0);
647 };
648 CHKERR zero_ghost_vec(F);
649
650 ts_ctx->vecAssembleSwitch = boost::movelib::make_unique<bool>(true);
651 auto cache_ptr = boost::make_shared<CacheTuple>();
652 CHKERR ts_ctx->mField.cache_problem_entities(ts_ctx->problemName, cache_ptr);
653
654 int step;
655#if PETSC_VERSION_GE(3, 8, 0)
656 CHKERR TSGetStepNumber(ts, &step);
657#else
658 CHKERR TSGetTimeStepNumber(ts, &step);
659#endif
660
661 auto set = [&](auto &fe) {
662 fe.ts_u = u;
663 fe.ts_u_t = u_t;
664 fe.ts_u_tt = u_tt;
665 fe.ts_F = F;
666 fe.ts_t = t;
667 fe.ts_step = step;
668 fe.ts_ctx = TSMethod::CTX_TSSETIFUNCTION;
669 fe.snes_ctx = SnesMethod::CTX_SNESSETFUNCTION;
670 fe.ksp_ctx = KspMethod::CTX_SETFUNCTION;
671 fe.data_ctx = PetscData::CtxSetF | PetscData::CtxSetX |
672 PetscData::CtxSetX_T | PetscData::CtxSetX_TT |
673 PetscData::CtxSetTime;
674
675 CHKERR TSGetSNES(ts, &fe.snes);
676 CHKERR SNESGetKSP(fe.snes, &fe.ksp);
677
678 fe.ts = ts;
679 fe.cacheWeakPtr = cache_ptr;
680 CHK_THROW_MESSAGE(TSGetTimeStep(ts, &fe.ts_dt), "get time step failed");
681 };
682
683 auto unset = [&](auto &fe) {
684 fe.ts_ctx = TSMethod::CTX_TSNONE;
685 fe.snes_ctx = SnesMethod::CTX_SNESNONE;
686 fe.ksp_ctx = KspMethod::CTX_KSPNONE;
687 fe.data_ctx = PetscData::CtxSetNone;
688 };
689
690 // preprocess
691 for (auto &bit : ts_ctx->preProcessIFunction) {
692 bit->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
693 set(*bit);
694 CHKERR ts_ctx->mField.problem_basic_method_preProcess(ts_ctx->problemName,
695 *bit);
696 unset(*bit);
697 ts_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
698 }
699
700 // fe loops
701 for (auto &lit : ts_ctx->loopsIFunction) {
702 lit.second->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
703 set(*lit.second);
704 CHKERR ts_ctx->mField.loop_finite_elements(ts_ctx->problemName, lit.first,
705 *(lit.second), nullptr,
706 ts_ctx->bH, cache_ptr);
707 unset(*lit.second);
708 ts_ctx->vecAssembleSwitch = boost::move(lit.second->vecAssembleSwitch);
709 }
710
711 // post process
712 for (auto &bit : ts_ctx->postProcessIFunction) {
713 bit->vecAssembleSwitch = boost::move(ts_ctx->vecAssembleSwitch);
714 set(*bit);
715 CHKERR ts_ctx->mField.problem_basic_method_postProcess(ts_ctx->problemName,
716 *bit);
717 unset(*bit);
718 ts_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
719 }
720
721 if (*ts_ctx->vecAssembleSwitch) {
722 CHKERR VecGhostUpdateBegin(F, ADD_VALUES, SCATTER_REVERSE);
723 CHKERR VecGhostUpdateEnd(F, ADD_VALUES, SCATTER_REVERSE);
724 CHKERR VecAssemblyBegin(F);
725 CHKERR VecAssemblyEnd(F);
726 }
727
728 if (ts_ctx->tsDebugHook) {
729 CHKERR ts_ctx->tsDebugHook(ts, t, u, u_t, u_tt, F, ctx);
730 }
731
732 PetscLogEventEnd(ts_ctx->MOFEM_EVENT_TsCtxIFunction, 0, 0, 0, 0);
733 MoFEMFunctionReturn(0);
734}
735
736/** \brief Custom TSAdaptivity in MoFEM
737 *
738 * \code
739 * CHKERR TSAdaptRegister(TSADAPTMOFEM, TSAdaptCreateMoFEM);
740 * TSAdapt adapt;
741 * CHKERR TSGetAdapt(solver, &adapt);
742 * CHKERR TSAdaptSetType(adapt, TSADAPTMOFEM);
743 * \endcode
744 *
745 */
746struct TSAdaptMoFEM {
747
748 TSAdaptMoFEM();
749
750 double alpha; //< step reduction if divergence
751 double gamma; //< adaptivity exponent
752 int desiredIt; //< desired number of iterations
753 PetscBool offApat; //< off adaptivity
754};
755
756TSAdaptMoFEM::TSAdaptMoFEM()
757 : alpha(0.75), gamma(0.5), desiredIt(6), offApat(PETSC_FALSE) {
758 CHKERR PetscOptionsGetScalar("", "-ts_mofem_adapt_alpha", &alpha, PETSC_NULLPTR);
759 CHKERR PetscOptionsGetScalar("", "-ts_mofem_adapt_gamma", &gamma, PETSC_NULLPTR);
760 CHKERR PetscOptionsGetInt("", "-ts_mofem_adapt_desired_it", &desiredIt,
761 PETSC_NULLPTR);
762 CHKERR PetscOptionsGetBool("", "-ts_mofem_adapt_off", &offApat, PETSC_NULLPTR);
763
764 MOFEM_LOG("TSWORLD", Sev::inform)
765 << "TS adaptivity: alpha = " << alpha << ", gamma = " << gamma
766 << ", desiredIt = " << desiredIt << ", offAdapt = " << offApat;
767}
768
769PetscErrorCode TSAdaptChooseMoFEM(TSAdapt adapt, TS ts, PetscReal h,
770 PetscInt *next_sc, PetscReal *next_h,
771 PetscBool *accept, PetscReal *wlte,
772 PetscReal *wltea, PetscReal *wlter) {
773 MoFEMFunctionBegin;
774
775 auto ts_adapt_mofem = boost::make_shared<TSAdaptMoFEM>();
776
777 *next_sc = 0; /* Reuse the same order scheme */
778 *wlte = -1; /* Weighted local truncation error was not evaluated */
779 *wltea = -1; /* Weighted absolute local truncation error is not used */
780 *wlter = -1; /* Weighted relative local truncation error is not used */
781
782 *accept = PETSC_TRUE;
783 *next_h = h; /* Reuse the old step */
784
785 if (!ts_adapt_mofem->offApat) {
786
787 SNES snes;
788 CHKERR TSGetSNES(ts, &snes);
789
790 SNESConvergedReason reason;
791 CHKERR SNESGetConvergedReason(snes, &reason);
792
793 int it;
794 CHKERR SNESGetIterationNumber(snes, &it);
795
796 if (reason < 0) {
797 h *= ts_adapt_mofem->alpha;
798 *next_h = h;
799 MOFEM_LOG_C(
800 "TSWORLD", Sev::warning,
801 "\tDiverged set step length: it = %d, h = %3.4g set h = %3.4g \n", it,
802 h, *next_h);
803 } else if (reason > 0) {
804 h *= pow((static_cast<double>(ts_adapt_mofem->desiredIt) /
805 static_cast<double>(it + 1)),
806 static_cast<double>(ts_adapt_mofem->gamma));
807 *next_h = PetscClipInterval(h, adapt->dt_min, adapt->dt_max);
808 MOFEM_LOG_C(
809 "TSWORLD", Sev::inform,
810 "\tConverged set step length: it = %d, h = %3.4g set h = %3.4g \n",
811 it, h, *next_h);
812 }
813 }
814
815 MoFEMFunctionReturn(0);
816}
817
818PetscErrorCode TSAdaptResetMoFEM(TSAdapt adapt) {
819 PetscFunctionBegin;
820 PetscFunctionReturn(0);
821}
822
823PetscErrorCode TSAdaptDestroyMoFEM(TSAdapt adapt) {
824 MoFEMFunctionBegin;
825 CHKERR TSAdaptResetMoFEM(adapt);
826 MoFEMFunctionReturn(0);
827}
828
829PetscErrorCode TSAdaptCreateMoFEM(TSAdapt adapt) {
830 PetscFunctionBegin;
831 adapt->ops->choose = TSAdaptChooseMoFEM;
832 adapt->ops->reset = TSAdaptResetMoFEM;
833 adapt->ops->destroy = TSAdaptDestroyMoFEM;
834 PetscFunctionReturn(0);
835}
836
837} // namespace MoFEM
MOFEM_LOG_C
#define MOFEM_LOG_C(channel, severity, format,...)
Definition LogManager.hpp:319
a
constexpr double a
Definition approx_sphere.cpp:30
COL
@ COL
Definition definitions.h:136
MF_EXIST
@ MF_EXIST
Definition definitions.h:113
CHK_THROW_MESSAGE
#define CHK_THROW_MESSAGE(err, msg)
Check and throw MoFEM exception.
Definition definitions.h:612
MoFEMFunctionReturnHot
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition definitions.h:463
MoFEMFunctionBegin
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition definitions.h:359
MoFEMFunctionReturn
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition definitions.h:432
CHKERR
#define CHKERR
Inline error check.
Definition definitions.h:551
MoFEMFunctionBeginHot
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition definitions.h:456
F
@ F
Definition free_surface.cpp:624
MoFEM::LogManager::setLog
static LoggerType & setLog(const std::string channel)
Set ans resset chanel logger.
Definition LogManager.cpp:392
MOFEM_LOG
#define MOFEM_LOG(channel, severity)
Log.
Definition LogManager.hpp:316
MOFEM_LOG_TAG
#define MOFEM_LOG_TAG(channel, tag)
Tag channel.
Definition LogManager.hpp:347
MoFEM::CoreInterface::problem_basic_method_postProcess
virtual MoFEMErrorCode problem_basic_method_postProcess(const Problem *problem_ptr, BasicMethod &method, int verb=DEFAULT_VERBOSITY)=0
Set data for BasicMethod.
MoFEM::CoreInterface::loop_finite_elements
virtual MoFEMErrorCode loop_finite_elements(const std::string problem_name, const std::string &fe_name, FEMethod &method, boost::shared_ptr< NumeredEntFiniteElement_multiIndex > fe_ptr=nullptr, MoFEMTypes bh=MF_EXIST, CacheTupleWeakPtr cache_ptr=CacheTupleSharedPtr(), int verb=DEFAULT_VERBOSITY)=0
Make a loop over finite elements.
bit
auto bit
set bit
Definition hanging_node_approx.cpp:75
i
FTensor::Index< 'i', SPACE_DIM > i
Definition hcurl_divergence_operator_2d.cpp:27
ts_ctx
MoFEM::TsCtx * ts_ctx
Definition level_set.cpp:1932
l
FTensor::Index< 'l', 3 > l
Definition matrix_function.cpp:21
MoFEM::Exceptions::MoFEMErrorCode
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
Definition Exceptions.hpp:56
MoFEM
implementation of Data Operators for Forces and Sources
Definition Common.hpp:10
MoFEM::TsSetIJacobian
PetscErrorCode TsSetIJacobian(TS ts, PetscReal t, Vec u, Vec u_t, PetscReal a, Mat A, Mat B, void *ctx)
Set function evaluating jacobian in TS solver.
Definition TsCtx.cpp:169
MoFEM::TsMonitorSet
PetscErrorCode TsMonitorSet(TS ts, PetscInt step, PetscReal t, Vec u, void *ctx)
Set monitor for TS solver.
Definition TsCtx.cpp:263
MoFEM::PetscOptionsGetInt
PetscErrorCode PetscOptionsGetInt(PetscOptions *, const char pre[], const char name[], PetscInt *ivalue, PetscBool *set)
Definition DeprecatedPetsc.hpp:142
MoFEM::TsSetI2Function
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.
Definition TsCtx.cpp:620
MoFEM::TsSetRHSFunction
PetscErrorCode TsSetRHSFunction(TS ts, PetscReal t, Vec u, Vec F, void *ctx)
TS solver function.
Definition TsCtx.cpp:327
MoFEM::TSAdaptChooseMoFEM
PetscErrorCode TSAdaptChooseMoFEM(TSAdapt adapt, TS ts, PetscReal h, PetscInt *next_sc, PetscReal *next_h, PetscBool *accept, PetscReal *wlte, PetscReal *wltea, PetscReal *wlter)
Definition TsCtx.cpp:769
MoFEM::PetscOptionsGetBool
PetscErrorCode PetscOptionsGetBool(PetscOptions *, const char pre[], const char name[], PetscBool *bval, PetscBool *set)
Definition DeprecatedPetsc.hpp:182
MoFEM::PetscOptionsGetScalar
PetscErrorCode PetscOptionsGetScalar(PetscOptions *, const char pre[], const char name[], PetscScalar *dval, PetscBool *set)
Definition DeprecatedPetsc.hpp:162
MoFEM::TsSetIFunction
PetscErrorCode TsSetIFunction(TS ts, PetscReal t, Vec u, Vec u_t, Vec F, void *ctx)
Set IFunction for TS solver.
Definition TsCtx.cpp:56
MoFEM::TSAdaptDestroyMoFEM
PetscErrorCode TSAdaptDestroyMoFEM(TSAdapt adapt)
Definition TsCtx.cpp:823
MoFEM::TsSetI2Jacobian
PetscErrorCode TsSetI2Jacobian(TS ts, PetscReal t, Vec u, Vec u_t, Vec u_tt, PetscReal a, PetscReal aa, Mat A, Mat B, void *ctx)
Calculation Jacobian for second order PDE in time.
Definition TsCtx.cpp:519
MoFEM::TSAdaptResetMoFEM
PetscErrorCode TSAdaptResetMoFEM(TSAdapt adapt)
Definition TsCtx.cpp:818
MoFEM::TsSetRHSJacobian
PetscErrorCode TsSetRHSJacobian(TS ts, PetscReal t, Vec u, Mat A, Mat B, void *ctx)
TS solver function.
Definition TsCtx.cpp:430
MoFEM::TSAdaptCreateMoFEM
PetscErrorCode TSAdaptCreateMoFEM(TSAdapt adapt)
Craete MOFEM adapt.
Definition TsCtx.cpp:829
A
constexpr AssemblyType A
Definition operators_tests.cpp:30
h
double h
Definition photon_diffusion.cpp:60
t
constexpr double t
plate stiffness
Definition plate.cpp:58
g
constexpr double g
Definition shallow_wave.cpp:63
MoFEM::CoreInterface::cache_problem_entities
virtual MoFEMErrorCode cache_problem_entities(const std::string prb_name, CacheTupleWeakPtr cache_ptr)=0
Cache variables.
MoFEM::CoreInterface::problem_basic_method_preProcess
virtual MoFEMErrorCode problem_basic_method_preProcess(const Problem *problem_ptr, BasicMethod &method, int verb=DEFAULT_VERBOSITY)=0
Set data for BasicMethod.
MoFEM::DeprecatedCoreInterface
Deprecated interface functions.
Definition DeprecatedCoreInterface.hpp:16
MoFEM::KspMethod::CTX_KSPNONE
@ CTX_KSPNONE
No specific KSP context.
Definition LoopMethods.hpp:165
MoFEM::KspMethod::CTX_SETFUNCTION
@ CTX_SETFUNCTION
Setting up the linear system function.
Definition LoopMethods.hpp:163
MoFEM::KspMethod::CTX_OPERATORS
@ CTX_OPERATORS
Setting up linear operators.
Definition LoopMethods.hpp:164
MoFEM::LogManager::createSink
static boost::shared_ptr< SinkType > createSink(boost::shared_ptr< std::ostream > stream_ptr, std::string comm_filter)
Create a sink object.
Definition LogManager.cpp:293
MoFEM::LogManager::getStrmWorld
static boost::shared_ptr< std::ostream > getStrmWorld()
Get the strm world object.
Definition LogManager.cpp:339
MoFEM::LogManager::getStrmSync
static boost::shared_ptr< std::ostream > getStrmSync()
Get the strm sync object.
Definition LogManager.cpp:343
MoFEM::LogManager::checkIfChannelExist
static bool checkIfChannelExist(const std::string channel)
Check if channel exist.
Definition LogManager.cpp:407
MoFEM::LogManager::getStrmSelf
static boost::shared_ptr< std::ostream > getStrmSelf()
Get the strm self object.
Definition LogManager.cpp:335
MoFEM::PetscData::CtxSetA
static constexpr Switches CtxSetA
Jacobian matrix switch.
Definition LoopMethods.hpp:110
MoFEM::PetscData::CtxSetX
static constexpr Switches CtxSetX
Solution vector switch.
Definition LoopMethods.hpp:112
MoFEM::PetscData::CtxSetX_TT
static constexpr Switches CtxSetX_TT
Second time derivative switch.
Definition LoopMethods.hpp:115
MoFEM::PetscData::CtxSetNone
static constexpr Switches CtxSetNone
No data switch.
Definition LoopMethods.hpp:108
MoFEM::PetscData::CtxSetF
static constexpr Switches CtxSetF
Residual vector switch.
Definition LoopMethods.hpp:109
MoFEM::PetscData::CtxSetX_T
static constexpr Switches CtxSetX_T
First time derivative switch.
Definition LoopMethods.hpp:114
MoFEM::PetscData::CtxSetB
static constexpr Switches CtxSetB
Preconditioner matrix switch.
Definition LoopMethods.hpp:111
MoFEM::PetscData::CtxSetTime
static constexpr Switches CtxSetTime
Time value switch.
Definition LoopMethods.hpp:116
MoFEM::SnesMethod::CTX_SNESSETJACOBIAN
@ CTX_SNESSETJACOBIAN
Setting up Jacobian matrix computation.
Definition LoopMethods.hpp:221
MoFEM::SnesMethod::CTX_SNESSETFUNCTION
@ CTX_SNESSETFUNCTION
Setting up nonlinear function evaluation.
Definition LoopMethods.hpp:220
MoFEM::SnesMethod::CTX_SNESNONE
@ CTX_SNESNONE
No specific SNES context.
Definition LoopMethods.hpp:222
MoFEM::TSAdaptMoFEM
Custom TSAdaptivity in MoFEM.
Definition TsCtx.cpp:746
MoFEM::TSAdaptMoFEM::offApat
PetscBool offApat
Definition TsCtx.cpp:753
MoFEM::TSMethod::CTX_TSSETIFUNCTION
@ CTX_TSSETIFUNCTION
Setting up implicit function.
Definition LoopMethods.hpp:281
MoFEM::TSMethod::CTX_TSSETRHSFUNCTION
@ CTX_TSSETRHSFUNCTION
Setting up right-hand side function.
Definition LoopMethods.hpp:279
MoFEM::TSMethod::CTX_TSSETRHSJACOBIAN
@ CTX_TSSETRHSJACOBIAN
Setting up right-hand side Jacobian.
Definition LoopMethods.hpp:280
MoFEM::TSMethod::CTX_TSTSMONITORSET
@ CTX_TSTSMONITORSET
Setting up time step monitoring.
Definition LoopMethods.hpp:283
MoFEM::TSMethod::CTX_TSSETIJACOBIAN
@ CTX_TSSETIJACOBIAN
Setting up implicit Jacobian.
Definition LoopMethods.hpp:282
MoFEM::TSMethod::CTX_TSNONE
@ CTX_TSNONE
No specific TS context.
Definition LoopMethods.hpp:284
MoFEM::TsCtx
Interface for Time Stepping (TS) solver.
Definition TsCtx.hpp:17
MoFEM::TsCtx::MOFEM_EVENT_TsCtxI2Jacobian
PetscLogEvent MOFEM_EVENT_TsCtxI2Jacobian
Definition TsCtx.hpp:218
MoFEM::TsCtx::loopsIJacobian
FEMethodsSequence loopsIJacobian
Definition TsCtx.hpp:29
MoFEM::TsCtx::zeroMatrix
bool zeroMatrix
Definition TsCtx.hpp:49
MoFEM::TsCtx::bH
MoFEMTypes bH
If set to MF_EXIST check if element exist.
Definition TsCtx.hpp:23
MoFEM::TsCtx::MOFEM_EVENT_TsCtxRHSJacobian
PetscLogEvent MOFEM_EVENT_TsCtxRHSJacobian
Definition TsCtx.hpp:213
MoFEM::TsCtx::loopsRHSFunction
FEMethodsSequence loopsRHSFunction
Definition TsCtx.hpp:33
MoFEM::TsCtx::MOFEM_EVENT_TsCtxMonitor
PetscLogEvent MOFEM_EVENT_TsCtxMonitor
Definition TsCtx.hpp:216
MoFEM::TsCtx::postProcessRHSFunction
BasicMethodsSequence postProcessRHSFunction
Definition TsCtx.hpp:43
MoFEM::TsCtx::preProcessMonitor
BasicMethodsSequence preProcessMonitor
Definition TsCtx.hpp:38
MoFEM::TsCtx::MOFEM_EVENT_TsCtxRHSFunction
PetscLogEvent MOFEM_EVENT_TsCtxRHSFunction
Definition TsCtx.hpp:212
MoFEM::TsCtx::preProcessIJacobian
BasicMethodsSequence preProcessIJacobian
Definition TsCtx.hpp:34
MoFEM::TsCtx::postProcessIFunction
BasicMethodsSequence postProcessIFunction
Definition TsCtx.hpp:37
MoFEM::TsCtx::loopsIFunction
FEMethodsSequence loopsIFunction
Definition TsCtx.hpp:30
MoFEM::TsCtx::loopsRHSJacobian
FEMethodsSequence loopsRHSJacobian
Definition TsCtx.hpp:32
MoFEM::TsCtx::preProcessIFunction
BasicMethodsSequence preProcessIFunction
Definition TsCtx.hpp:36
MoFEM::TsCtx::loopsMonitor
FEMethodsSequence loopsMonitor
Definition TsCtx.hpp:31
MoFEM::TsCtx::postProcessMonitor
BasicMethodsSequence postProcessMonitor
Definition TsCtx.hpp:39
MoFEM::TsCtx::preProcessRHSJacobian
BasicMethodsSequence preProcessRHSJacobian
Definition TsCtx.hpp:40
MoFEM::TsCtx::vecAssembleSwitch
boost::movelib::unique_ptr< bool > vecAssembleSwitch
Definition TsCtx.hpp:220
MoFEM::TsCtx::MOFEM_EVENT_TsCtxIJacobian
PetscLogEvent MOFEM_EVENT_TsCtxIJacobian
Definition TsCtx.hpp:215
MoFEM::TsCtx::matAssembleSwitch
boost::movelib::unique_ptr< bool > matAssembleSwitch
Definition TsCtx.hpp:221
MoFEM::TsCtx::clearLoops
MoFEMErrorCode clearLoops()
Clear loops.
Definition TsCtx.cpp:36
MoFEM::TsCtx::problemName
std::string problemName
Definition TsCtx.hpp:22
MoFEM::TsCtx::TsCtx
TsCtx(MoFEM::Interface &m_field, const std::string &problem_name)
Definition TsCtx.cpp:5
MoFEM::TsCtx::mField
MoFEM::Interface & mField
Definition TsCtx.hpp:19
MoFEM::TsCtx::tsDebugHook
boost::function< MoFEMErrorCode(TS ts, PetscReal t, Vec u, Vec u_t, Vec u_tt, Vec F, void *ctx)> tsDebugHook
Definition TsCtx.hpp:47
MoFEM::TsCtx::preProcessRHSFunction
BasicMethodsSequence preProcessRHSFunction
Definition TsCtx.hpp:41
MoFEM::TsCtx::postProcessIJacobian
BasicMethodsSequence postProcessIJacobian
Definition TsCtx.hpp:35
MoFEM::TsCtx::MOFEM_EVENT_TsCtxIFunction
PetscLogEvent MOFEM_EVENT_TsCtxIFunction
Definition TsCtx.hpp:214
MoFEM::TsCtx::postProcessRHSJacobian
BasicMethodsSequence postProcessRHSJacobian
Definition TsCtx.hpp:42
MoFEM::TsCtx::MOFEM_EVENT_TsCtxI2Function
PetscLogEvent MOFEM_EVENT_TsCtxI2Function
Definition TsCtx.hpp:217
MoFEM::UnknownInterface::getInterface
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface reference to pointer of interface.
Definition UnknownInterface.hpp:93
MoFEM::VecManager
Vector manager is used to create vectors \mofem_vectors.
Definition VecManager.hpp:23
Generated by Doxygen 1.9.8 and hosted at University of Glasgow