v0.16.3
Loading...
Searching...
No Matches
TaoCtx.cpp
Go to the documentation of this file.
1/**
2 * @brief Context for Tao optimization routines
3 * @author Anonymous author(s) committing under MIT license
4 */
5
6namespace MoFEM {
7
8namespace {
9
10PetscErrorCode zeroTaoOutputVector(Vec v) {
11 MoFEMFunctionBegin;
12 Vec local = PETSC_NULLPTR;
13 CHKERR VecGhostGetLocalForm(v, &local);
14 if (local) {
15 CHKERR VecZeroEntries(local);
16 CHKERR VecGhostRestoreLocalForm(v, &local);
17 } else {
18 CHKERR VecZeroEntries(v);
19 }
20 MoFEMFunctionReturn(0);
21}
22
23PetscErrorCode assembleTaoOutputVector(Vec v) {
24 MoFEMFunctionBegin;
25 Vec local = PETSC_NULLPTR;
26 CHKERR VecGhostGetLocalForm(v, &local);
27 const bool has_local_form = local != PETSC_NULLPTR;
28 if (local)
29 CHKERR VecGhostRestoreLocalForm(v, &local);
30 if (has_local_form) {
31 CHKERR VecGhostUpdateBegin(v, ADD_VALUES, SCATTER_REVERSE);
32 CHKERR VecGhostUpdateEnd(v, ADD_VALUES, SCATTER_REVERSE);
33 }
34 CHKERR VecAssemblyBegin(v);
35 CHKERR VecAssemblyEnd(v);
36 MoFEMFunctionReturn(0);
37}
38
39} // namespace
40
66
92
93PetscErrorCode TaoCtx::evaluateConstraint(
94 Tao tao, Vec x, Vec c, FEMethodsSequence &loops,
95 BasicMethodsSequence &pre_process, BasicMethodsSequence &post_process,
96 TaoMethod::TAOContext evaluation_context, PetscLogEvent log_event) {
97 MoFEMFunctionBegin;
98 PetscLogEventBegin(log_event, 0, 0, 0, 0);
99
100 CHKERR VecGhostUpdateBegin(x, INSERT_VALUES, SCATTER_FORWARD);
101 CHKERR VecGhostUpdateEnd(x, INSERT_VALUES, SCATTER_FORWARD);
102 CHKERR mField.getInterface<VecManager>()->setLocalGhostVector(
103 problemName, COL, x, INSERT_VALUES, SCATTER_REVERSE);
104 CHKERR zeroTaoOutputVector(c);
105
106 vecAssembleSwitch = boost::movelib::make_unique<bool>(true);
107 auto cache_ptr = boost::make_shared<CacheTuple>();
108 CHKERR mField.cache_problem_entities(problemName, cache_ptr);
109
110 auto set = [&](auto &fe) {
111 fe.tao = tao;
112 fe.tao_x = x;
113 fe.tao_c = c;
114 fe.snes_ctx = SnesMethod::CTX_SNESSETFUNCTION;
115 fe.ksp_ctx = KspMethod::CTX_SETFUNCTION;
116 fe.tao_ctx = evaluation_context;
117 fe.data_ctx = PetscData::CtxSetF | PetscData::CtxSetX;
118 fe.cacheWeakPtr = cache_ptr;
119 };
120
121 auto unset = [&](auto &fe) {
122 fe.snes_ctx = SnesMethod::CTX_SNESNONE;
123 fe.ksp_ctx = KspMethod::CTX_KSPNONE;
124 fe.tao_ctx = TaoMethod::CTX_TAO_NONE;
125 fe.data_ctx = PetscData::CtxSetNone;
126 };
127
128 for (auto &method : pre_process) {
129 method->vecAssembleSwitch = boost::move(vecAssembleSwitch);
130 set(*method);
131 CHKERR mField.problem_basic_method_preProcess(problemName, *method);
132 unset(*method);
133 vecAssembleSwitch = boost::move(method->vecAssembleSwitch);
134 }
135
136 for (auto &loop : loops) {
137 loop.second->vecAssembleSwitch = boost::move(vecAssembleSwitch);
138 set(*loop.second);
139 CHKERR mField.loop_finite_elements(problemName, loop.first, *loop.second,
140 nullptr, MF_EXIST, cache_ptr);
141 unset(*loop.second);
142 vecAssembleSwitch = boost::move(loop.second->vecAssembleSwitch);
143 }
144
145 for (auto &method : post_process) {
146 method->vecAssembleSwitch = boost::move(vecAssembleSwitch);
147 set(*method);
148 CHKERR mField.problem_basic_method_postProcess(problemName, *method);
149 unset(*method);
150 vecAssembleSwitch = boost::move(method->vecAssembleSwitch);
151 }
152
153 if (*vecAssembleSwitch)
154 CHKERR assembleTaoOutputVector(c);
155
156 PetscLogEventEnd(log_event, 0, 0, 0, 0);
157 MoFEMFunctionReturn(0);
158}
159
160PetscErrorCode TaoCtx::evaluateConstraintJacobian(
161 Tao tao, Vec x, Mat J, Mat Jpre, FEMethodsSequence &loops,
162 BasicMethodsSequence &pre_process, BasicMethodsSequence &post_process,
163 TaoMethod::TAOContext evaluation_context, PetscLogEvent log_event) {
164 MoFEMFunctionBegin;
165 PetscLogEventBegin(log_event, 0, 0, 0, 0);
166
167 CHKERR VecGhostUpdateBegin(x, INSERT_VALUES, SCATTER_FORWARD);
168 CHKERR VecGhostUpdateEnd(x, INSERT_VALUES, SCATTER_FORWARD);
169 CHKERR mField.getInterface<VecManager>()->setLocalGhostVector(
170 problemName, COL, x, INSERT_VALUES, SCATTER_REVERSE);
171
172 matAssembleSwitch = boost::movelib::make_unique<bool>(true);
173 CHKERR MatZeroEntries(Jpre);
174 if (J != Jpre)
175 CHKERR MatZeroEntries(J);
176
177 auto cache_ptr = boost::make_shared<CacheTuple>();
178 CHKERR mField.cache_problem_entities(problemName, cache_ptr);
179
180 auto set = [&](auto &fe) {
181 fe.tao = tao;
182 fe.tao_x = x;
183 fe.tao_J = J;
184 fe.tao_Jpre = Jpre;
185 fe.ksp_ctx = KspMethod::CTX_OPERATORS;
186 fe.snes_ctx = SnesMethod::CTX_SNESSETJACOBIAN;
187 fe.tao_ctx = evaluation_context;
188 fe.data_ctx = PetscData::CtxSetA | PetscData::CtxSetB | PetscData::CtxSetX;
189 fe.cacheWeakPtr = cache_ptr;
190 };
191
192 auto unset = [&](auto &fe) {
193 fe.snes_ctx = SnesMethod::CTX_SNESNONE;
194 fe.ksp_ctx = KspMethod::CTX_KSPNONE;
195 fe.tao_ctx = TaoMethod::CTX_TAO_NONE;
196 fe.data_ctx = PetscData::CtxSetNone;
197 };
198
199 for (auto &method : pre_process) {
200 method->matAssembleSwitch = boost::move(matAssembleSwitch);
201 set(*method);
202 CHKERR mField.problem_basic_method_preProcess(problemName, *method);
203 unset(*method);
204 matAssembleSwitch = boost::move(method->matAssembleSwitch);
205 }
206
207 for (auto &loop : loops) {
208 loop.second->matAssembleSwitch = boost::move(matAssembleSwitch);
209 set(*loop.second);
210 CHKERR mField.loop_finite_elements(problemName, loop.first, *loop.second,
211 nullptr, MF_EXIST, cache_ptr);
212 unset(*loop.second);
213 matAssembleSwitch = boost::move(loop.second->matAssembleSwitch);
214 }
215
216 for (auto &method : post_process) {
217 method->matAssembleSwitch = boost::move(matAssembleSwitch);
218 set(*method);
219 CHKERR mField.problem_basic_method_postProcess(problemName, *method);
220 unset(*method);
221 matAssembleSwitch = boost::move(method->matAssembleSwitch);
222 }
223
224 if (*matAssembleSwitch) {
225 CHKERR MatAssemblyBegin(Jpre, MAT_FINAL_ASSEMBLY);
226 CHKERR MatAssemblyEnd(Jpre, MAT_FINAL_ASSEMBLY);
227 if (J != Jpre) {
228 CHKERR MatAssemblyBegin(J, MAT_FINAL_ASSEMBLY);
229 CHKERR MatAssemblyEnd(J, MAT_FINAL_ASSEMBLY);
230 }
231 }
232
233 PetscLogEventEnd(log_event, 0, 0, 0, 0);
234 MoFEMFunctionReturn(0);
235}
236
237PetscErrorCode TaoSetObjective(Tao tao, Vec x, PetscReal *f, void *ctx) {
238 auto *tao_ctx = static_cast<TaoCtx *>(ctx);
239 MoFEMFunctionBegin;
240 if (tao_ctx->objectiveHook) {
241 CHKERR tao_ctx->objectiveHook(tao, x, f);
242 MoFEMFunctionReturnHot(0);
243 }
244 PetscLogEventBegin(tao_ctx->MOFEM_EVENT_TaoObjective, 0, 0, 0, 0);
245 CHKERR VecGhostUpdateBegin(x, INSERT_VALUES, SCATTER_FORWARD);
246 CHKERR VecGhostUpdateEnd(x, INSERT_VALUES, SCATTER_FORWARD);
247 CHKERR tao_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
248 tao_ctx->problemName, COL, x, INSERT_VALUES, SCATTER_REVERSE);
249
250 auto cache_ptr = boost::make_shared<CacheTuple>();
251 CHKERR tao_ctx->mField.cache_problem_entities(tao_ctx->problemName,
252 cache_ptr);
253
254 auto set = [&](auto &fe) {
255 fe.tao = tao;
256 fe.tao_x = x;
257 fe.tao_ctx = TaoMethod::CTX_TAO_OBJECTIVE;
258 fe.data_ctx = PetscData::CtxSetX;
259 fe.cacheWeakPtr = cache_ptr;
260 };
261
262 auto unset = [&](auto &fe) {
263 fe.tao_ctx = TaoMethod::CTX_TAO_NONE;
264 fe.data_ctx = PetscData::CtxSetNone;
265 };
266
267 for (auto &bit : tao_ctx->preObjective) {
268 bit->vecAssembleSwitch = boost::move(tao_ctx->vecAssembleSwitch);
269 set(*bit);
270 CHKERR tao_ctx->mField.problem_basic_method_preProcess(tao_ctx->problemName,
271 *bit);
272 unset(*bit);
273 }
274
275 for (auto &lit : tao_ctx->loopsObjective) {
276 set(*lit.second);
277 CHKERR tao_ctx->mField.loop_finite_elements(tao_ctx->problemName, lit.first,
278 *lit.second, nullptr, MF_EXIST,
279 cache_ptr);
280 unset(*lit.second);
281 }
282
283 for (auto &bit : tao_ctx->postObjective) {
284 bit->vecAssembleSwitch = boost::move(tao_ctx->vecAssembleSwitch);
285 set(*bit);
286 CHKERR tao_ctx->mField.problem_basic_method_postProcess(
287 tao_ctx->problemName, *bit);
288 unset(*bit);
289 tao_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
290 }
291
292 PetscLogEventEnd(tao_ctx->MOFEM_EVENT_TaoObjective, 0, 0, 0, 0);
293 MoFEMFunctionReturn(0);
294}
295
296PetscErrorCode TaoSetGradient(Tao tao, Vec x, Vec f, void *ctx) {
297 auto *tao_ctx = static_cast<TaoCtx *>(ctx);
298 MoFEMFunctionBegin;
299 if (tao_ctx->gradientHook) {
300 CHKERR tao_ctx->gradientHook(tao, x, f);
301 MoFEMFunctionReturnHot(0);
302 }
303 PetscLogEventBegin(tao_ctx->MOFEM_EVENT_TaoGradient, 0, 0, 0, 0);
304 CHKERR VecGhostUpdateBegin(x, INSERT_VALUES, SCATTER_FORWARD);
305 CHKERR VecGhostUpdateEnd(x, INSERT_VALUES, SCATTER_FORWARD);
306 CHKERR tao_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
307 tao_ctx->problemName, COL, x, INSERT_VALUES, SCATTER_REVERSE);
308
309 auto zero_ghost_vec = [](Vec g) {
310 MoFEMFunctionBegin;
311 Vec l;
312 CHKERR VecGhostGetLocalForm(g, &l);
313 double *a;
314 CHKERR VecGetArray(l, &a);
315 int s;
316 CHKERR VecGetLocalSize(l, &s);
317 for (int i = 0; i != s; ++i)
318 a[i] = 0;
319 CHKERR VecRestoreArray(l, &a);
320 CHKERR VecGhostRestoreLocalForm(g, &l);
321 MoFEMFunctionReturn(0);
322 };
323 CHKERR zero_ghost_vec(f);
324
325 tao_ctx->vecAssembleSwitch = boost::movelib::make_unique<bool>(true);
326 auto cache_ptr = boost::make_shared<CacheTuple>();
327 CHKERR tao_ctx->mField.cache_problem_entities(tao_ctx->problemName,
328 cache_ptr);
329
330 auto set = [&](auto &fe) {
331 fe.tao = tao;
332 fe.tao_x = x;
333 fe.tao_f = f;
334 fe.snes_ctx = SnesMethod::CTX_SNESSETFUNCTION;
335 fe.ksp_ctx = KspMethod::CTX_SETFUNCTION;
336 fe.tao_ctx = TaoMethod::CTX_TAO_GRADIENT;
337 fe.data_ctx = PetscData::CtxSetF | PetscData::CtxSetX;
338 fe.cacheWeakPtr = cache_ptr;
339 };
340
341 auto unset = [&](auto &fe) {
342 fe.snes_ctx = SnesMethod::CTX_SNESNONE;
343 fe.ksp_ctx = KspMethod::CTX_KSPNONE;
344 fe.tao_ctx = TaoMethod::CTX_TAO_NONE;
345 fe.data_ctx = PetscData::CtxSetNone;
346 };
347
348 for (auto &bit : tao_ctx->preGradient) {
349 bit->vecAssembleSwitch = boost::move(tao_ctx->vecAssembleSwitch);
350 set(*bit);
351 CHKERR tao_ctx->mField.problem_basic_method_preProcess(tao_ctx->problemName,
352 *bit);
353 unset(*bit);
354 tao_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
355 }
356
357 for (auto &lit : tao_ctx->loopsGradient) {
358 lit.second->vecAssembleSwitch = boost::move(tao_ctx->vecAssembleSwitch);
359 set(*lit.second);
360 CHKERR tao_ctx->mField.loop_finite_elements(tao_ctx->problemName, lit.first,
361 *lit.second, nullptr, MF_EXIST,
362 cache_ptr);
363 unset(*lit.second);
364 tao_ctx->vecAssembleSwitch = boost::move(lit.second->vecAssembleSwitch);
365 }
366
367 for (auto &bit : tao_ctx->postGradient) {
368 bit->vecAssembleSwitch = boost::move(tao_ctx->vecAssembleSwitch);
369 set(*bit);
370 CHKERR tao_ctx->mField.problem_basic_method_postProcess(
371 tao_ctx->problemName, *bit);
372 unset(*bit);
373 tao_ctx->vecAssembleSwitch = boost::move(bit->vecAssembleSwitch);
374 }
375
376 if (*(tao_ctx->vecAssembleSwitch)) {
377 CHKERR VecGhostUpdateBegin(f, ADD_VALUES, SCATTER_REVERSE);
378 CHKERR VecGhostUpdateEnd(f, ADD_VALUES, SCATTER_REVERSE);
379 CHKERR VecAssemblyBegin(f);
380 CHKERR VecAssemblyEnd(f);
381 }
382 PetscLogEventEnd(tao_ctx->MOFEM_EVENT_TaoGradient, 0, 0, 0, 0);
383 MoFEMFunctionReturn(0);
384}
385
386PetscErrorCode TaoSetObjectiveAndGradient(Tao tao, Vec x, PetscReal *f, Vec g,
387 void *ctx) {
388 MoFEMFunctionBegin;
389 TaoCtx *tao_ctx = (TaoCtx *)ctx;
390 if (tao_ctx->objectiveAndGradientHook) {
391 CHKERR tao_ctx->objectiveAndGradientHook(tao, x, f, g);
392 MoFEMFunctionReturnHot(0);
393 }
394 CHKERR TaoSetObjective(tao, x, f, ctx);
395 CHKERR TaoSetGradient(tao, x, g, ctx);
396 MoFEMFunctionReturn(0);
397}
398
399PetscErrorCode TaoSetHessian(Tao tao, Vec x, Mat H, Mat Hpre, void *ctx) {
400 TaoCtx *tao_ctx = (TaoCtx *)ctx;
401 MoFEMFunctionBegin;
402 PetscLogEventBegin(tao_ctx->MOFEM_EVENT_TaoHessian, 0, 0, 0, 0);
403
404 tao_ctx->matAssembleSwitch = boost::movelib::make_unique<bool>(true);
405 auto cache_ptr = boost::make_shared<CacheTuple>();
406 CHKERR tao_ctx->mField.cache_problem_entities(tao_ctx->problemName,
407 cache_ptr);
408
409 auto set = [&](auto &fe) {
410 fe.tao = tao;
411 fe.tao_A = H;
412 fe.tao_B = Hpre;
413 fe.ksp_ctx = KspMethod::CTX_OPERATORS;
414 fe.snes_ctx = SnesMethod::CTX_SNESSETJACOBIAN;
415 fe.tao_ctx = TaoMethod::CTX_TAO_HESSIAN;
416 fe.data_ctx = PetscData::CtxSetA | PetscData::CtxSetB | PetscData::CtxSetX;
417 fe.cacheWeakPtr = cache_ptr;
418 };
419
420 auto unset = [&](auto &fe) {
421 fe.snes_ctx = SnesMethod::CTX_SNESNONE;
422 fe.ksp_ctx = KspMethod::CTX_KSPNONE;
423 fe.tao_ctx = TaoMethod::CTX_TAO_NONE;
424 fe.data_ctx = PetscData::CtxSetNone;
425 };
426
427 CHKERR VecGhostUpdateBegin(x, INSERT_VALUES, SCATTER_FORWARD);
428 CHKERR VecGhostUpdateEnd(x, INSERT_VALUES, SCATTER_FORWARD);
429 CHKERR tao_ctx->mField.getInterface<VecManager>()->setLocalGhostVector(
430 tao_ctx->problemName, COL, x, INSERT_VALUES, SCATTER_REVERSE);
431
432 for (auto &bit : tao_ctx->preHessian) {
433 bit->matAssembleSwitch = boost::move(tao_ctx->matAssembleSwitch);
434 set(*bit);
435 CHKERR tao_ctx->mField.problem_basic_method_preProcess(tao_ctx->problemName,
436 *bit);
437 unset(*bit);
438 tao_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
439 }
440
441 for (auto &lit : tao_ctx->loopsHessian) {
442 lit.second->matAssembleSwitch = boost::move(tao_ctx->matAssembleSwitch);
443 set(*lit.second);
444 CHKERR tao_ctx->mField.loop_finite_elements(tao_ctx->problemName, lit.first,
445 *(lit.second), nullptr,
446 MF_EXIST, cache_ptr);
447 unset(*lit.second);
448 tao_ctx->matAssembleSwitch = boost::move(lit.second->matAssembleSwitch);
449 }
450
451 for (auto &bit : tao_ctx->postHessian) {
452 bit->matAssembleSwitch = boost::move(tao_ctx->matAssembleSwitch);
453 set(*bit);
454 CHKERR tao_ctx->mField.problem_basic_method_postProcess(
455 tao_ctx->problemName, *bit);
456 unset(*bit);
457 tao_ctx->matAssembleSwitch = boost::move(bit->matAssembleSwitch);
458 }
459
460 if (*tao_ctx->matAssembleSwitch) {
461 CHKERR MatAssemblyBegin(Hpre, MAT_FINAL_ASSEMBLY);
462 CHKERR MatAssemblyEnd(Hpre, MAT_FINAL_ASSEMBLY);
463 }
464 PetscLogEventEnd(tao_ctx->MOFEM_EVENT_TaoHessian, 0, 0, 0, 0);
465 MoFEMFunctionReturn(0);
466}
467
468PetscErrorCode TaoSetEqualityConstraints(Tao tao, Vec x, Vec c, void *ctx) {
469 MoFEMFunctionBegin;
470 auto *tao_ctx = static_cast<TaoCtx *>(ctx);
471 CHKERR tao_ctx->evaluateConstraint(
472 tao, x, c, tao_ctx->loopsEqualityConstraint,
473 tao_ctx->preEqualityConstraint, tao_ctx->postEqualityConstraint,
474 TaoMethod::CTX_TAO_EQUALITY_CONSTRAINT,
475 tao_ctx->MOFEM_EVENT_TaoEqualityConstraint);
476 MoFEMFunctionReturn(0);
477}
478
479PetscErrorCode TaoSetInequalityConstraints(Tao tao, Vec x, Vec c, void *ctx) {
480 MoFEMFunctionBegin;
481 auto *tao_ctx = static_cast<TaoCtx *>(ctx);
482 CHKERR tao_ctx->evaluateConstraint(
483 tao, x, c, tao_ctx->loopsInequalityConstraint,
484 tao_ctx->preInequalityConstraint, tao_ctx->postInequalityConstraint,
485 TaoMethod::CTX_TAO_INEQUALITY_CONSTRAINT,
486 tao_ctx->MOFEM_EVENT_TaoInequalityConstraint);
487 MoFEMFunctionReturn(0);
488}
489
490PetscErrorCode TaoSetJacobianEquality(Tao tao, Vec x, Mat J, Mat Jpre,
491 void *ctx) {
492 MoFEMFunctionBegin;
493 auto *tao_ctx = static_cast<TaoCtx *>(ctx);
494 CHKERR tao_ctx->evaluateConstraintJacobian(
495 tao, x, J, Jpre, tao_ctx->loopsEqualityJacobian,
496 tao_ctx->preEqualityJacobian, tao_ctx->postEqualityJacobian,
497 TaoMethod::CTX_TAO_EQUALITY_JACOBIAN,
498 tao_ctx->MOFEM_EVENT_TaoEqualityJacobian);
499 MoFEMFunctionReturn(0);
500}
501
502PetscErrorCode TaoSetJacobianInequality(Tao tao, Vec x, Mat J, Mat Jpre,
503 void *ctx) {
504 MoFEMFunctionBegin;
505 auto *tao_ctx = static_cast<TaoCtx *>(ctx);
506 CHKERR tao_ctx->evaluateConstraintJacobian(
507 tao, x, J, Jpre, tao_ctx->loopsInequalityJacobian,
508 tao_ctx->preInequalityJacobian, tao_ctx->postInequalityJacobian,
509 TaoMethod::CTX_TAO_INEQUALITY_JACOBIAN,
510 tao_ctx->MOFEM_EVENT_TaoInequalityJacobian);
511 MoFEMFunctionReturn(0);
512}
513
514} // namespace MoFEM
a
constexpr double a
Definition approx_sphere.cpp:30
COL
@ COL
Definition definitions.h:136
MF_EXIST
@ MF_EXIST
Definition definitions.h:113
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
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
c
const double c
speed of light (cm/ns)
Definition initial_diffusion.cpp:40
v
const double v
phase velocity of light in medium (cm/ns)
Definition initial_diffusion.cpp:41
J
FTensor::Index< 'J', DIM1 > J
Definition level_set.cpp:30
l
FTensor::Index< 'l', 3 > l
Definition matrix_function.cpp:23
EigenMatrix::Vec
const FTensor::Tensor2< T, Dim, Dim > Vec
Definition MatrixFunction.hpp:64
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::TaoSetObjective
PetscErrorCode TaoSetObjective(Tao tao, Vec x, PetscReal *f, void *ctx)
Sets the objective function value for a TAO optimization context.
Definition TaoCtx.cpp:237
MoFEM::TaoSetJacobianInequality
PetscErrorCode TaoSetJacobianInequality(Tao tao, Vec x, Mat J, Mat Jpre, void *ctx)
Assemble the inequality constraint Jacobian.
Definition TaoCtx.cpp:502
MoFEM::TaoSetEqualityConstraints
PetscErrorCode TaoSetEqualityConstraints(Tao tao, Vec x, Vec c, void *ctx)
Evaluate equality constraints for a TAO optimization context.
Definition TaoCtx.cpp:468
MoFEM::TaoSetInequalityConstraints
PetscErrorCode TaoSetInequalityConstraints(Tao tao, Vec x, Vec c, void *ctx)
Evaluate inequality constraints for a TAO optimization context.
Definition TaoCtx.cpp:479
MoFEM::TaoSetJacobianEquality
PetscErrorCode TaoSetJacobianEquality(Tao tao, Vec x, Mat J, Mat Jpre, void *ctx)
Assemble the equality constraint Jacobian.
Definition TaoCtx.cpp:490
MoFEM::TaoSetObjectiveAndGradient
PetscErrorCode TaoSetObjectiveAndGradient(Tao tao, Vec x, PetscReal *f, Vec g, void *ctx)
Sets the objective function value and gradient for a TAO optimization solver.
Definition TaoCtx.cpp:386
MoFEM::TaoSetGradient
PetscErrorCode TaoSetGradient(Tao tao, Vec x, Vec f, void *ctx)
Sets the gradient vector for a TAO optimization context.
Definition TaoCtx.cpp:296
MoFEM::TaoSetHessian
PetscErrorCode TaoSetHessian(Tao tao, Vec x, Mat H, Mat Hpre, void *ctx)
Sets the Hessian matrix for a TAO optimization context.
Definition TaoCtx.cpp:399
H
double H
Hardening.
Definition plastic.cpp:129
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::KspMethod::CTX_KSPNONE
@ CTX_KSPNONE
No specific KSP context.
Definition LoopMethods.hpp:158
MoFEM::KspMethod::CTX_SETFUNCTION
@ CTX_SETFUNCTION
Setting up the linear system function.
Definition LoopMethods.hpp:156
MoFEM::KspMethod::CTX_OPERATORS
@ CTX_OPERATORS
Setting up linear operators.
Definition LoopMethods.hpp:157
MoFEM::PetscData::CtxSetA
static constexpr Switches CtxSetA
Jacobian matrix switch.
Definition LoopMethods.hpp:103
MoFEM::PetscData::CtxSetX
static constexpr Switches CtxSetX
Solution vector switch.
Definition LoopMethods.hpp:105
MoFEM::PetscData::CtxSetNone
static constexpr Switches CtxSetNone
No data switch.
Definition LoopMethods.hpp:101
MoFEM::PetscData::CtxSetF
static constexpr Switches CtxSetF
Residual vector switch.
Definition LoopMethods.hpp:102
MoFEM::PetscData::CtxSetB
static constexpr Switches CtxSetB
Preconditioner matrix switch.
Definition LoopMethods.hpp:104
MoFEM::SnesMethod::CTX_SNESSETJACOBIAN
@ CTX_SNESSETJACOBIAN
Setting up Jacobian matrix computation.
Definition LoopMethods.hpp:214
MoFEM::SnesMethod::CTX_SNESSETFUNCTION
@ CTX_SNESSETFUNCTION
Setting up nonlinear function evaluation.
Definition LoopMethods.hpp:213
MoFEM::SnesMethod::CTX_SNESNONE
@ CTX_SNESNONE
No specific SNES context.
Definition LoopMethods.hpp:215
MoFEM::TaoCtx
Interface for TAO solvers.
Definition TaoCtx.hpp:14
MoFEM::TaoCtx::copyLoops
MoFEMErrorCode copyLoops(const TaoCtx &tao_ctx)
Copy sequences from another TaoCtx.
Definition TaoCtx.cpp:41
MoFEM::TaoCtx::loopsInequalityJacobian
FEMethodsSequence loopsInequalityJacobian
Definition TaoCtx.hpp:49
MoFEM::TaoCtx::vecAssembleSwitch
boost::movelib::unique_ptr< bool > vecAssembleSwitch
Definition TaoCtx.hpp:256
MoFEM::TaoCtx::FEMethodsSequence
MoFEM::FEMethodsSequence FEMethodsSequence
Definition TaoCtx.hpp:22
MoFEM::TaoCtx::mField
MoFEM::Interface & mField
database Interface
Definition TaoCtx.hpp:16
MoFEM::TaoCtx::postInequalityConstraint
BasicMethodsSequence postInequalityConstraint
Definition TaoCtx.hpp:77
MoFEM::TaoCtx::evaluateConstraint
PetscErrorCode evaluateConstraint(Tao tao, Vec x, Vec c, FEMethodsSequence &loops, BasicMethodsSequence &pre_process, BasicMethodsSequence &post_process, TaoMethod::TAOContext evaluation_context, PetscLogEvent log_event)
Definition TaoCtx.cpp:93
MoFEM::TaoCtx::preEqualityJacobian
BasicMethodsSequence preEqualityJacobian
Definition TaoCtx.hpp:80
MoFEM::TaoCtx::postObjective
BasicMethodsSequence postObjective
Sequence of methods run after objective is evaluated.
Definition TaoCtx.hpp:61
MoFEM::TaoCtx::preEqualityConstraint
BasicMethodsSequence preEqualityConstraint
Definition TaoCtx.hpp:68
MoFEM::TaoCtx::problemName
std::string problemName
problem name
Definition TaoCtx.hpp:18
MoFEM::TaoCtx::preInequalityConstraint
BasicMethodsSequence preInequalityConstraint
Definition TaoCtx.hpp:74
MoFEM::TaoCtx::postEqualityConstraint
BasicMethodsSequence postEqualityConstraint
Definition TaoCtx.hpp:71
MoFEM::TaoCtx::postGradient
BasicMethodsSequence postGradient
Sequence of methods run after gradient is assembled.
Definition TaoCtx.hpp:66
MoFEM::TaoCtx::MOFEM_EVENT_TaoHessian
PetscLogEvent MOFEM_EVENT_TaoHessian
Log event for TAO Hessian.
Definition TaoCtx.hpp:258
MoFEM::TaoCtx::evaluateConstraintJacobian
PetscErrorCode evaluateConstraintJacobian(Tao tao, Vec x, Mat J, Mat Jpre, FEMethodsSequence &loops, BasicMethodsSequence &pre_process, BasicMethodsSequence &post_process, TaoMethod::TAOContext evaluation_context, PetscLogEvent log_event)
Definition TaoCtx.cpp:160
MoFEM::TaoCtx::matAssembleSwitch
boost::movelib::unique_ptr< bool > matAssembleSwitch
Definition TaoCtx.hpp:257
MoFEM::TaoCtx::loopsInequalityConstraint
FEMethodsSequence loopsInequalityConstraint
Definition TaoCtx.hpp:43
MoFEM::TaoCtx::preObjective
BasicMethodsSequence preObjective
Sequence of methods run before objective is evaluated.
Definition TaoCtx.hpp:59
MoFEM::TaoCtx::loopsObjective
FEMethodsSequence loopsObjective
Definition TaoCtx.hpp:35
MoFEM::TaoCtx::preGradient
BasicMethodsSequence preGradient
Sequence of methods run before gradient is assembled.
Definition TaoCtx.hpp:64
MoFEM::TaoCtx::gradientHook
GradientHook gradientHook
Definition TaoCtx.hpp:254
MoFEM::TaoCtx::postEqualityJacobian
BasicMethodsSequence postEqualityJacobian
Definition TaoCtx.hpp:83
MoFEM::TaoCtx::loopsEqualityConstraint
FEMethodsSequence loopsEqualityConstraint
Definition TaoCtx.hpp:40
MoFEM::TaoCtx::objectiveAndGradientHook
ObjectiveAndGradientHook objectiveAndGradientHook
Definition TaoCtx.hpp:255
MoFEM::TaoCtx::clearLoops
MoFEMErrorCode clearLoops()
Clear loops.
Definition TaoCtx.cpp:67
MoFEM::TaoCtx::preInequalityJacobian
BasicMethodsSequence preInequalityJacobian
Definition TaoCtx.hpp:86
MoFEM::TaoCtx::postHessian
BasicMethodsSequence postHessian
Sequence of methods run after Hessian is assembled.
Definition TaoCtx.hpp:56
MoFEM::TaoCtx::objectiveHook
ObjectiveHook objectiveHook
Definition TaoCtx.hpp:253
MoFEM::TaoCtx::preHessian
BasicMethodsSequence preHessian
Sequence of methods run before Hessian is assembled.
Definition TaoCtx.hpp:54
MoFEM::TaoCtx::loopsEqualityJacobian
FEMethodsSequence loopsEqualityJacobian
Definition TaoCtx.hpp:46
MoFEM::TaoCtx::postInequalityJacobian
BasicMethodsSequence postInequalityJacobian
Definition TaoCtx.hpp:89
MoFEM::TaoCtx::loopsGradient
FEMethodsSequence loopsGradient
Definition TaoCtx.hpp:38
MoFEM::TaoCtx::BasicMethodsSequence
MoFEM::BasicMethodsSequence BasicMethodsSequence
Definition TaoCtx.hpp:23
MoFEM::TaoCtx::loopsHessian
FEMethodsSequence loopsHessian
Definition TaoCtx.hpp:32
MoFEM::TaoMethod::TAOContext
TAOContext
Context enumeration for TAO solver phases.
Definition LoopMethods.hpp:343
MoFEM::TaoMethod::CTX_TAO_EQUALITY_CONSTRAINT
@ CTX_TAO_EQUALITY_CONSTRAINT
Evaluating equality constraints.
Definition LoopMethods.hpp:347
MoFEM::TaoMethod::CTX_TAO_EQUALITY_JACOBIAN
@ CTX_TAO_EQUALITY_JACOBIAN
Assembling equality Jacobian.
Definition LoopMethods.hpp:349
MoFEM::TaoMethod::CTX_TAO_HESSIAN
@ CTX_TAO_HESSIAN
Assembling Hessian matrix.
Definition LoopMethods.hpp:346
MoFEM::TaoMethod::CTX_TAO_NONE
@ CTX_TAO_NONE
No specific TAO context.
Definition LoopMethods.hpp:351
MoFEM::TaoMethod::CTX_TAO_INEQUALITY_JACOBIAN
@ CTX_TAO_INEQUALITY_JACOBIAN
Assembling inequality Jacobian.
Definition LoopMethods.hpp:350
MoFEM::TaoMethod::CTX_TAO_INEQUALITY_CONSTRAINT
@ CTX_TAO_INEQUALITY_CONSTRAINT
Evaluating inequality constraints.
Definition LoopMethods.hpp:348
MoFEM::TaoMethod::CTX_TAO_GRADIENT
@ CTX_TAO_GRADIENT
Computing gradient vector.
Definition LoopMethods.hpp:345
MoFEM::TaoMethod::CTX_TAO_OBJECTIVE
@ CTX_TAO_OBJECTIVE
Evaluating objective function.
Definition LoopMethods.hpp:344
MoFEM::UnknownInterface::getInterface
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface reference to pointer of interface.
Definition UnknownInterface.hpp:103
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