v0.13.2
Loading...
Searching...
No Matches
DMMoFEM.cpp
Go to the documentation of this file.
1
2
3// #undef PETSC_VERSION_RELEASE
4// #define PETSC_VERSION_RELEASE 1
5
6#if PETSC_VERSION_GE(3, 6, 0)
7#include <petsc/private/dmimpl.h> /*I "petscdm.h" I*/
8// #include <petsc/private/vecimpl.h> /*I "petscdm.h" I*/
9#else
10#include <petsc-private/dmimpl.h> /*I "petscdm.h" I*/
11#include <petsc-private/vecimpl.h> /*I "petscdm.h" I*/
12#endif
13
14#include <DMMoFEM.hpp>
15
16namespace MoFEM {
17
18DMCtx::DMCtx()
19 : mField_ptr(PETSC_NULL), isProblemBuild(PETSC_FALSE),
20 isPartitioned(PETSC_FALSE), isSquareMatrix(PETSC_TRUE),
21 isSubDM(PETSC_FALSE), isCompDM(PETSC_FALSE), destroyProblem(PETSC_FALSE),
22 verbosity(VERBOSE), referenceNumber(0) {
23
24 if (!LogManager::checkIfChannelExist("DMWORLD")) {
25 auto core_log = logging::core::get();
26 core_log->add_sink(
27 LogManager::createSink(LogManager::getStrmWorld(), "DMWORLD"));
28 core_log->add_sink(
29 LogManager::createSink(LogManager::getStrmSync(), "DMSYNC"));
30 core_log->add_sink(
31 LogManager::createSink(LogManager::getStrmSelf(), "DMSELF"));
32 LogManager::setLog("DMWORLD");
33 LogManager::setLog("DMSYNC");
34 LogManager::setLog("DMSELF");
35 MOFEM_LOG_TAG("DMWORLD", "DM");
36 MOFEM_LOG_TAG("DMSYNC", "DM");
37 MOFEM_LOG_TAG("DMSELF", "DM");
38 }
39}
40
41MoFEMErrorCode DMCtx::query_interface(boost::typeindex::type_index type_index,
42 UnknownInterface **iface) const {
43 *iface = const_cast<DMCtx *>(this);
44 return 0;
45}
46
47PetscErrorCode DMRegister_MoFEM(const char sname[]) {
48 MoFEMFunctionBegin;
49 CHKERR DMRegister(sname, DMCreate_MoFEM);
50 MoFEMFunctionReturn(0);
51}
52
53PetscErrorCode DMSetOperators_MoFEM(DM dm) {
54 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
55 MoFEMFunctionBegin;
56
57 dm->ops->createglobalvector = DMCreateGlobalVector_MoFEM;
58 dm->ops->createlocalvector = DMCreateLocalVector_MoFEM;
59 dm->ops->creatematrix = DMCreateMatrix_MoFEM;
60 dm->ops->setup = DMSetUp_MoFEM;
61 dm->ops->destroy = DMDestroy_MoFEM;
62 dm->ops->setfromoptions = DMSetFromOptions_MoFEM;
63 dm->ops->globaltolocalbegin = DMGlobalToLocalBegin_MoFEM;
64 dm->ops->globaltolocalend = DMGlobalToLocalEnd_MoFEM;
65 dm->ops->localtoglobalbegin = DMLocalToGlobalBegin_MoFEM;
66 dm->ops->localtoglobalend = DMLocalToGlobalEnd_MoFEM;
67 dm->ops->createfieldis = DMCreateFieldIS_MoFEM;
68
69 // Default matrix type
70 CHKERR DMSetMatType(dm, MATMPIAIJ);
71
72 MoFEMFunctionReturn(0);
73}
74
75PetscErrorCode DMCreate_MoFEM(DM dm) {
76 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
77 MoFEMFunctionBegin;
78 dm->data = new DMCtx();
79 CHKERR DMSetOperators_MoFEM(dm);
80 MoFEMFunctionReturn(0);
81}
82
83PetscErrorCode DMDestroy_MoFEM(DM dm) {
84 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
85 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
86 MoFEMFunctionBeginHot;
87
88 MPI_Comm comm;
89 CHKERR PetscObjectGetComm((PetscObject)dm, &comm);
90
91 int result;
92 MPI_Comm_compare(comm, PETSC_COMM_SELF, &result);
93 if (result == MPI_IDENT)
94 MOFEM_LOG("DMSELF", Sev::noisy)
95 << "MoFEM DM destroy for problem " << dm_field->problemName
96 << " referenceNumber " << dm_field->referenceNumber;
97 else
98 MOFEM_LOG("DMWORLD", Sev::noisy)
99 << "MoFEM DM destroy for problem " << dm_field->problemName
100 << " referenceNumber " << dm_field->referenceNumber;
101
102 if (dm_field->referenceNumber == 0) {
103 if (dm_field->destroyProblem) {
104
105 if (dm_field->mField_ptr->check_problem(dm_field->problemName)) {
106 dm_field->mField_ptr->delete_problem(dm_field->problemName);
107 } // else problem has to be deleted by the user
108 }
109
110 delete static_cast<DMCtx *>(dm->data);
111
112 } else
113 --dm_field->referenceNumber;
114
115 MoFEMFunctionReturnHot(0);
116}
117
118PetscErrorCode DMMoFEMCreateMoFEM(DM dm, MoFEM::Interface *m_field_ptr,
119 const char problem_name[],
120 const MoFEM::BitRefLevel bit_level,
121 const MoFEM::BitRefLevel bit_mask) {
122 MoFEMFunctionBegin;
123
124 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
125 if (!dm->data) {
126 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
127 "data structure for MoFEM not yet created");
128 }
129 if (!m_field_ptr) {
130 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
131 "DM function not implemented into MoFEM");
132 }
133 dm_field->mField_ptr = m_field_ptr;
134 dm_field->problemName = problem_name;
135 if (!m_field_ptr->check_problem(dm_field->problemName)) {
136 // problem is not defined, declare problem internally set bool to
137 // destroyProblem problem with DM
138 dm_field->destroyProblem = PETSC_TRUE;
139 CHKERR dm_field->mField_ptr->add_problem(dm_field->problemName, MF_EXCL,
140 dm_field->verbosity);
141 } else {
142 dm_field->destroyProblem = PETSC_FALSE;
143 }
144 CHKERR dm_field->mField_ptr->modify_problem_ref_level_add_bit(
145 dm_field->problemName, bit_level);
146 CHKERR dm_field->mField_ptr->modify_problem_mask_ref_level_add_bit(
147 dm_field->problemName, bit_mask);
148 dm_field->kspCtx =
149 boost::shared_ptr<KspCtx>(new KspCtx(*m_field_ptr, problem_name));
150 dm_field->snesCtx =
151 boost::shared_ptr<SnesCtx>(new SnesCtx(*m_field_ptr, problem_name));
152 dm_field->tsCtx =
153 boost::shared_ptr<TsCtx>(new TsCtx(*m_field_ptr, problem_name));
154
155 MPI_Comm comm;
156 CHKERR PetscObjectGetComm((PetscObject)dm, &comm);
157 int result = 0;
158 MPI_Comm_compare(comm, m_field_ptr->get_comm(), &result);
159 if (result > MPI_CONGRUENT) {
160 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
161 "MoFEM and DM using different communicators");
162 }
163 MPI_Comm_size(comm, &dm_field->sIze);
164 MPI_Comm_rank(comm, &dm_field->rAnk);
165
166 // problem structure
167 CHKERR dm_field->mField_ptr->get_problem(dm_field->problemName,
168 &dm_field->problemPtr);
169
170 MPI_Comm_compare(comm, PETSC_COMM_SELF, &result);
171 if (result == MPI_IDENT) {
172 MOFEM_LOG("DMSELF", Sev::noisy)
173 << "MoFEM DM created for problem " << dm_field->problemName;
174 MOFEM_LOG("DMSELF", Sev::noisy) << *dm_field->problemPtr;
175 } else {
176 MOFEM_LOG("DMWORLD", Sev::noisy)
177 << "MoFEM DM created for problem " << dm_field->problemName;
178 MOFEM_LOG("DMWORLD", Sev::noisy) << *dm_field->problemPtr;
179 }
180
181 MoFEMFunctionReturn(0);
182}
183
184PetscErrorCode DMMoFEMDuplicateDMCtx(DM dm, DM dm_duplicate) {
185 MoFEMFunctionBegin;
186
187 if (!dm->data)
188 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
189 "data structure for MoFEM not yet created");
190
191 auto *dm_field = static_cast<DMCtx *>(dm->data);
192
193 if (static_cast<DMCtx *>(dm_duplicate->data)->referenceNumber == 0)
194 delete static_cast<DMCtx *>(dm_duplicate->data);
195
196 dm_duplicate->data = dm->data;
197 ++(static_cast<DMCtx *>(dm_duplicate->data)->referenceNumber);
198
199 MoFEMFunctionReturn(0);
200}
201
202PetscErrorCode DMMoFEMSwapDMCtx(DM dm, DM dm_swap) {
203 MoFEMFunctionBegin;
204 if (!dm->data)
205 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
206 "data structure for MoFEM not yet created on dm");
207 if (!dm_swap->data)
208 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
209 "data structure for MoFEM not yet created on swap dm");
210
211 auto *dm_field = static_cast<DMCtx *>(dm->data);
212 auto *dm_field_swap = static_cast<DMCtx *>(dm_swap->data);
213
214 auto tmp_field = dm_field;
215 dm_field = dm_field_swap;
216 dm_field_swap = tmp_field;
217
218 MoFEMFunctionReturn(0);
219}
220
221PetscErrorCode DMMoFEMCreateSubDM(DM subdm, DM dm, const char problem_name[]) {
222 MoFEMFunctionBegin;
223
224 if (!dm->data) {
225 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
226 "data structure for MoFEM not yet created");
227 }
228 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
229
230 CHKERR DMMoFEMCreateMoFEM(subdm, dm_field->mField_ptr, problem_name,
231 dm_field->problemPtr->getBitRefLevel(),
232 dm_field->problemPtr->getBitRefLevelMask());
233
234 DMCtx *subdm_field = (DMCtx *)subdm->data;
235 subdm_field->isSubDM = PETSC_TRUE;
236 subdm_field->problemMainOfSubPtr = dm_field->problemPtr;
237 subdm_field->isPartitioned = dm_field->isPartitioned;
238 subdm_field->isSquareMatrix = PETSC_FALSE;
239 subdm->ops->setup = DMSubDMSetUp_MoFEM;
240
241 MoFEMFunctionReturn(0);
242}
243
244PetscErrorCode DMMoFEMAddSubFieldRow(DM dm, const char field_name[]) {
245 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
246 MoFEMFunctionBeginHot;
247 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
248 if (!dm->data) {
249 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
250 "data structure for MoFEM not yet created");
251 }
252 if (!dm_field->isSubDM) {
253 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "this is not sub-dm");
254 }
255 dm_field->rowFields.push_back(field_name);
256 dm_field->mapTypeRow.erase(field_name);
257 MoFEMFunctionReturnHot(0);
258}
259
260PetscErrorCode DMMoFEMAddSubFieldRow(DM dm, const char field_name[],
261 boost::shared_ptr<Range> r_ptr) {
262 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
263 MoFEMFunctionBeginHot;
264 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
265 if (!dm->data) {
266 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
267 "data structure for MoFEM not yet created");
268 }
269 if (!dm_field->isSubDM) {
270 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "this is not sub-dm");
271 }
272 dm_field->rowFields.push_back(field_name);
273 dm_field->mapTypeRow[field_name] = r_ptr;
274 MoFEMFunctionReturnHot(0);
275}
276
277PetscErrorCode DMMoFEMAddSubFieldCol(DM dm, const char field_name[]) {
278 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
279 MoFEMFunctionBeginHot;
280 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
281 if (!dm->data) {
282 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
283 "data structure for MoFEM not yet created");
284 }
285 if (!dm_field->isSubDM) {
286 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "this is not sub-dm");
287 }
288 dm_field->colFields.push_back(field_name);
289 dm_field->mapTypeCol.erase(field_name);
290 MoFEMFunctionReturnHot(0);
291}
292
293PetscErrorCode DMMoFEMAddSubFieldCol(DM dm, const char field_name[],
294 boost::shared_ptr<Range> r_ptr) {
295 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
296 MoFEMFunctionBeginHot;
297 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
298 if (!dm->data) {
299 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
300 "data structure for MoFEM not yet created");
301 }
302 if (!dm_field->isSubDM) {
303 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "this is not sub-dm");
304 }
305 dm_field->colFields.push_back(field_name);
306 dm_field->mapTypeCol[field_name] = r_ptr;
307 MoFEMFunctionReturnHot(0);
308}
309
310PetscErrorCode DMMoFEMGetIsSubDM(DM dm, PetscBool *is_sub_dm) {
311 MoFEMFunctionBeginHot;
312 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
313 MoFEMFunctionBeginHot;
314 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
315 *is_sub_dm = dm_field->isSubDM;
316 MoFEMFunctionReturnHot(0);
317}
318
319PetscErrorCode DMMoFEMGetSubRowIS(DM dm, IS *is) {
320 MoFEMFunctionBegin;
321 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
322 MoFEMFunctionBeginHot;
323 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
324 if (dm_field->isSubDM != PETSC_TRUE) {
325 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
326 "This DM is not created as a SubDM");
327 }
328 if (dm_field->isProblemBuild != PETSC_TRUE) {
329 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED, "Problem is not build");
330 }
331 boost::shared_ptr<Problem::SubProblemData> sub_data =
332 dm_field->problemPtr->getSubData();
333 CHKERR sub_data->getRowIs(is);
334 MoFEMFunctionReturn(0);
335}
336
337PetscErrorCode DMMoFEMGetSubColIS(DM dm, IS *is) {
338 MoFEMFunctionBegin;
339 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
340 MoFEMFunctionBeginHot;
341 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
342 if (dm_field->isSubDM != PETSC_TRUE) {
343 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
344 "This DM is not created as a SubDM");
345 }
346 if (dm_field->isProblemBuild != PETSC_TRUE) {
347 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED, "Problem is not build");
348 }
349 boost::shared_ptr<Problem::SubProblemData> sub_data =
350 dm_field->problemPtr->getSubData();
351 CHKERR sub_data->getColIs(is);
352 MoFEMFunctionReturn(0);
353}
354
355PetscErrorCode DMMoFEMAddRowCompositeProblem(DM dm, const char prb_name[]) {
356 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
357 MoFEMFunctionBegin;
358 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
359 if (!dm->data) {
360 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
361 "data structure for MoFEM not yet created");
362 }
363 if (!dm_field->isCompDM) {
364 dm_field->isCompDM = PETSC_TRUE;
365 }
366 dm_field->rowCompPrb.push_back(prb_name);
367 if (dm_field->isSquareMatrix) {
368 dm_field->colCompPrb.push_back(prb_name);
369 }
370 MoFEMFunctionReturn(0);
371}
372
373PetscErrorCode DMMoFEMAddColCompositeProblem(DM dm, const char prb_name[]) {
374 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
375 MoFEMFunctionBegin;
376 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
377 if (!dm->data) {
378 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
379 "data structure for MoFEM not yet created");
380 }
381 if (!dm_field->isCompDM) {
382 dm_field->isCompDM = PETSC_TRUE;
383 }
384 if (dm_field->isSquareMatrix) {
385 SETERRQ(PETSC_COMM_SELF, MOFEM_INVALID_DATA,
386 "No need to add problem on column when problem block structurally "
387 "symmetric");
388 }
389 dm_field->colCompPrb.push_back(prb_name);
390 MoFEMFunctionReturn(0);
391}
392
393PetscErrorCode DMMoFEMGetIsCompDM(DM dm, PetscBool *is_comp_dm) {
394 MoFEMFunctionBeginHot;
395 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
396 MoFEMFunctionBeginHot;
397 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
398 *is_comp_dm = dm_field->isCompDM;
399 MoFEMFunctionReturnHot(0);
400}
401
402PetscErrorCode DMoFEMGetInterfacePtr(DM dm, MoFEM::Interface **m_field_ptr) {
403 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
404 MoFEMFunctionBeginHot;
405 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
406 if (!dm->data) {
407 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
408 "data structure for MoFEM not yet created");
409 }
410 *m_field_ptr = dm_field->mField_ptr;
411 MoFEMFunctionReturnHot(0);
412}
413
414PetscErrorCode DMMoFEMGetProblemPtr(DM dm, const MoFEM::Problem **problem_ptr) {
415 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
416 MoFEMFunctionBeginHot;
417 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
418 if (!dm->data) {
419 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
420 "data structure for MoFEM not yet created");
421 }
422 *problem_ptr = dm_field->problemPtr;
423 MoFEMFunctionReturnHot(0);
424}
425
426PetscErrorCode DMMoFEMSetDestroyProblem(DM dm, PetscBool destroy_problem) {
427 MoFEMFunctionBeginHot;
428 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
429 MoFEMFunctionBeginHot;
430 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
431 dm_field->destroyProblem = destroy_problem;
432 MoFEMFunctionReturnHot(0);
433}
434
435PetscErrorCode DMMoFEMGetDestroyProblem(DM dm, PetscBool *destroy_problem) {
436 MoFEMFunctionBeginHot;
437 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
438 MoFEMFunctionBeginHot;
439 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
440 *destroy_problem = dm_field->destroyProblem;
441 MoFEMFunctionReturnHot(0);
442}
443
444PetscErrorCode DMMoFEMSetSquareProblem(DM dm, PetscBool square_problem) {
445 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
446 MoFEMFunctionBeginHot;
447 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
448 dm_field->isSquareMatrix = square_problem;
449 MoFEMFunctionReturnHot(0);
450}
451
452PetscErrorCode DMMoFEMResolveSharedFiniteElements(DM dm, std::string fe_name) {
453 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
454 MoFEMFunctionBegin;
455 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
456 CHKERR dm_field->mField_ptr->getInterface<CommInterface>()
457 ->resolveSharedFiniteElements(dm_field->problemPtr, fe_name);
458 MoFEMFunctionReturn(0);
459}
460
461PetscErrorCode DMMoFEMGetProblemFiniteElementLayout(DM dm, std::string fe_name,
462 PetscLayout *layout) {
463 MoFEMFunctionBeginHot;
464 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
465 MoFEMFunctionBegin;
466 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
467
468 MPI_Comm comm;
469 CHKERR PetscObjectGetComm((PetscObject)dm, &comm);
470 CHKERR dm_field->problemPtr->getNumberOfElementsByNameAndPart(comm, fe_name,
471 layout);
472 MoFEMFunctionReturn(0);
473}
474
475PetscErrorCode DMMoFEMGetSquareProblem(DM dm, PetscBool *square_problem) {
476 MoFEMFunctionBeginHot;
477 MoFEMFunctionBeginHot;
478 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
479 MoFEMFunctionBeginHot;
480 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
481 *square_problem = dm_field->isSquareMatrix;
482 MoFEMFunctionReturnHot(0);
483}
484
485PetscErrorCode DMMoFEMAddElement(DM dm, std::string fe_name) {
486 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
487 MoFEMFunctionBegin;
488 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
489 CHKERR dm_field->mField_ptr->modify_problem_add_finite_element(
490 dm_field->problemName, fe_name);
491 MoFEMFunctionReturn(0);
492}
493
494PetscErrorCode DMMoFEMAddElement(DM dm, std::vector<std::string> fe_name) {
495 MoFEMFunctionBegin;
496 for (auto fe : fe_name) {
497 CHKERR DMMoFEMAddElement(dm, fe);
498 }
499 MoFEMFunctionReturn(0);
500}
501
502PetscErrorCode DMMoFEMUnSetElement(DM dm, std::string fe_name) {
503 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
504 MoFEMFunctionBegin;
505 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
506 CHKERR dm_field->mField_ptr->modify_problem_unset_finite_element(
507 dm_field->problemName, fe_name);
508 MoFEMFunctionReturn(0);
509}
510
511PetscErrorCode DMoFEMMeshToLocalVector(DM dm, Vec l, InsertMode mode,
512 ScatterMode scatter_mode) {
513 MoFEMFunctionBeginHot;
514 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
515 MoFEMFunctionBeginHot;
516 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
517 ierr = dm_field->mField_ptr->getInterface<VecManager>()->setLocalGhostVector(
518 dm_field->problemPtr, COL, l, mode, scatter_mode);
519 CHKERRG(ierr);
520 MoFEMFunctionReturnHot(0);
521}
522
523PetscErrorCode DMoFEMMeshToGlobalVector(DM dm, Vec g, InsertMode mode,
524 ScatterMode scatter_mode) {
525 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
526 MoFEMFunctionBeginHot;
527 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
528 ierr = dm_field->mField_ptr->getInterface<VecManager>()->setGlobalGhostVector(
529 dm_field->problemPtr, COL, g, mode, scatter_mode);
530 CHKERRG(ierr);
531 MoFEMFunctionReturnHot(0);
532}
533
534PetscErrorCode DMoFEMPreProcessFiniteElements(DM dm, MoFEM::FEMethod *method) {
535 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
536 MoFEMFunctionBeginHot;
537 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
538 ierr = dm_field->mField_ptr->problem_basic_method_preProcess(
539 dm_field->problemPtr, *method);
540 CHKERRG(ierr);
541 MoFEMFunctionReturnHot(0);
542}
543
544PetscErrorCode DMoFEMPostProcessFiniteElements(DM dm, MoFEM::FEMethod *method) {
545 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
546 MoFEMFunctionBeginHot;
547 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
548 ierr = dm_field->mField_ptr->problem_basic_method_postProcess(
549 dm_field->problemPtr, *method);
550 CHKERRG(ierr);
551 MoFEMFunctionReturnHot(0);
552}
553
554PetscErrorCode
555DMoFEMLoopFiniteElementsUpAndLowRank(DM dm, const char fe_name[],
556 MoFEM::FEMethod *method, int low_rank,
557 int up_rank, CacheTupleWeakPtr cache_ptr) {
558 MoFEMFunctionBeginHot;
559 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
560 ierr = dm_field->mField_ptr->loop_finite_elements(
561 dm_field->problemPtr, fe_name, *method, low_rank, up_rank, nullptr,
562 MF_EXIST, cache_ptr);
563 CHKERRG(ierr);
564 MoFEMFunctionReturnHot(0);
565}
566
567PetscErrorCode DMoFEMLoopFiniteElementsUpAndLowRank(
568 DM dm, const std::string fe_name, boost::shared_ptr<MoFEM::FEMethod> method,
569 int low_rank, int up_rank, CacheTupleWeakPtr cache_ptr) {
570 return DMoFEMLoopFiniteElementsUpAndLowRank(dm, fe_name.c_str(), method.get(),
571 low_rank, up_rank, cache_ptr);
572}
573
574PetscErrorCode DMoFEMLoopFiniteElements(DM dm, const char fe_name[],
575 MoFEM::FEMethod *method,
576 CacheTupleWeakPtr cache_ptr) {
577 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
578 MoFEMFunctionBeginHot;
579 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
580 ierr = DMoFEMLoopFiniteElementsUpAndLowRank(
581 dm, fe_name, method, dm_field->rAnk, dm_field->rAnk, cache_ptr);
582 CHKERRG(ierr);
583 MoFEMFunctionReturnHot(0);
584}
585
586PetscErrorCode
587DMoFEMLoopFiniteElements(DM dm, const std::string fe_name,
588 boost::shared_ptr<MoFEM::FEMethod> method,
589 CacheTupleWeakPtr cache_ptr) {
590 return DMoFEMLoopFiniteElements(dm, fe_name.c_str(), method.get(), cache_ptr);
591}
592
593PetscErrorCode DMoFEMLoopDofs(DM dm, const char field_name[],
594 MoFEM::DofMethod *method) {
595 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
596 MoFEMFunctionBeginHot;
597 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
598 ierr =
599 dm_field->mField_ptr->loop_dofs(dm_field->problemPtr, field_name, COL,
600 *method, dm_field->rAnk, dm_field->rAnk);
601 CHKERRG(ierr);
602 MoFEMFunctionReturnHot(0);
603}
604
605template <class S, class T0, class T1, class T2>
606static PetscErrorCode DMMoFEMKSPSetComputeRHS(DM dm, S fe_name, T0 method,
607 T1 pre_only, T2 post_only) {
608 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
609 MoFEMFunctionBegin;
610 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
611 if (pre_only) {
612 dm_field->kspCtx->get_preProcess_to_do_Rhs().push_back(pre_only);
613 }
614 if (method) {
615 dm_field->kspCtx->get_loops_to_do_Rhs().push_back(
616 PairNameFEMethodPtr(fe_name, method));
617 }
618 if (post_only) {
619 dm_field->kspCtx->get_postProcess_to_do_Rhs().push_back(post_only);
620 }
621 CHKERR DMKSPSetComputeRHS(dm, KspRhs, dm_field->kspCtx.get());
622 MoFEMFunctionReturn(0);
623}
624
625PetscErrorCode DMMoFEMKSPSetComputeRHS(DM dm, const char fe_name[],
626 MoFEM::FEMethod *method,
627 MoFEM::BasicMethod *pre_only,
628 MoFEM::BasicMethod *post_only) {
629 return DMMoFEMKSPSetComputeRHS<const char *, MoFEM::FEMethod *,
630 MoFEM::BasicMethod *, MoFEM::BasicMethod *>(
631 dm, fe_name, method, pre_only, post_only);
632}
633
634PetscErrorCode
635DMMoFEMKSPSetComputeRHS(DM dm, const std::string fe_name,
636 boost::shared_ptr<MoFEM::FEMethod> method,
637 boost::shared_ptr<MoFEM::BasicMethod> pre_only,
638 boost::shared_ptr<MoFEM::BasicMethod> post_only) {
639 return DMMoFEMKSPSetComputeRHS<const std::string,
640 boost::shared_ptr<MoFEM::FEMethod>,
641 boost::shared_ptr<MoFEM::BasicMethod>,
642 boost::shared_ptr<MoFEM::BasicMethod>>(
643 dm, fe_name, method, pre_only, post_only);
644}
645
646template <class S, class T0, class T1, class T2>
647static PetscErrorCode DMMoFEMKSPSetComputeOperators(DM dm, S fe_name, T0 method,
648 T1 pre_only, T2 post_only) {
649 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
650 MoFEMFunctionBegin;
651 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
652 if (pre_only) {
653 dm_field->kspCtx->get_preProcess_to_do_Mat().push_back(pre_only);
654 }
655 if (method) {
656 dm_field->kspCtx->get_loops_to_do_Mat().push_back(
657 PairNameFEMethodPtr(fe_name, method));
658 }
659 if (post_only) {
660 dm_field->kspCtx->get_postProcess_to_do_Mat().push_back(post_only);
661 }
662 CHKERR DMKSPSetComputeOperators(dm, KspMat, dm_field->kspCtx.get());
663 MoFEMFunctionReturn(0);
664}
665
666PetscErrorCode DMMoFEMKSPSetComputeOperators(DM dm, const char fe_name[],
667 MoFEM::FEMethod *method,
668 MoFEM::BasicMethod *pre_only,
669 MoFEM::BasicMethod *post_only) {
670 return DMMoFEMKSPSetComputeOperators<const char *, MoFEM::FEMethod *,
671 MoFEM::BasicMethod *,
672 MoFEM::BasicMethod *>(
673 dm, fe_name, method, pre_only, post_only);
674}
675
676PetscErrorCode
677DMMoFEMKSPSetComputeOperators(DM dm, const std::string fe_name,
678 boost::shared_ptr<MoFEM::FEMethod> method,
679 boost::shared_ptr<MoFEM::BasicMethod> pre_only,
680 boost::shared_ptr<MoFEM::BasicMethod> post_only) {
681 return DMMoFEMKSPSetComputeOperators<const std::string,
682 boost::shared_ptr<MoFEM::FEMethod>>(
683 dm, fe_name, method, pre_only, post_only);
684}
685
686template <class S, class T0, class T1, class T2>
687static PetscErrorCode DMMoFEMSNESSetFunction(DM dm, S fe_name, T0 method,
688 T1 pre_only, T2 post_only) {
689 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
690 MoFEMFunctionBegin;
691 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
692 if (pre_only) {
693 dm_field->snesCtx->get_preProcess_to_do_Rhs().push_back(pre_only);
694 }
695 if (method) {
696 dm_field->snesCtx->get_loops_to_do_Rhs().push_back(
697 PairNameFEMethodPtr(fe_name, method));
698 }
699 if (post_only) {
700 dm_field->snesCtx->get_postProcess_to_do_Rhs().push_back(post_only);
701 }
702 CHKERR DMSNESSetFunction(dm, SnesRhs, dm_field->snesCtx.get());
703 MoFEMFunctionReturn(0);
704}
705
706PetscErrorCode DMMoFEMSNESSetFunction(DM dm, const char fe_name[],
707 MoFEM::FEMethod *method,
708 MoFEM::BasicMethod *pre_only,
709 MoFEM::BasicMethod *post_only) {
710 return DMMoFEMSNESSetFunction<const char *, MoFEM::FEMethod *,
711 MoFEM::BasicMethod *, MoFEM::BasicMethod *>(
712 dm, fe_name, method, pre_only, post_only);
713}
714
715PetscErrorCode
716DMMoFEMSNESSetFunction(DM dm, const std::string fe_name,
717 boost::shared_ptr<MoFEM::FEMethod> method,
718 boost::shared_ptr<MoFEM::BasicMethod> pre_only,
719 boost::shared_ptr<MoFEM::BasicMethod> post_only) {
720 return DMMoFEMSNESSetFunction<const std::string,
721 boost::shared_ptr<MoFEM::FEMethod>,
722 boost::shared_ptr<MoFEM::BasicMethod>,
723 boost::shared_ptr<MoFEM::BasicMethod>>(
724 dm, fe_name, method, pre_only, post_only);
725}
726
727template <class S, class T0, class T1, class T2>
728static PetscErrorCode DMMoFEMSNESSetJacobian(DM dm, S fe_name, T0 method,
729 T1 pre_only, T2 post_only) {
730 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
731 MoFEMFunctionBegin;
732 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
733 if (pre_only) {
734 dm_field->snesCtx->get_preProcess_to_do_Mat().push_back(pre_only);
735 }
736 if (method) {
737 dm_field->snesCtx->get_loops_to_do_Mat().push_back(
738 PairNameFEMethodPtr(fe_name, method));
739 }
740 if (post_only) {
741 dm_field->snesCtx->get_postProcess_to_do_Mat().push_back(post_only);
742 }
743 CHKERR DMSNESSetJacobian(dm, SnesMat, dm_field->snesCtx.get());
744 MoFEMFunctionReturn(0);
745}
746
747PetscErrorCode DMMoFEMSNESSetJacobian(DM dm, const char fe_name[],
748 MoFEM::FEMethod *method,
749 MoFEM::BasicMethod *pre_only,
750 MoFEM::BasicMethod *post_only) {
751 return DMMoFEMSNESSetJacobian<const char *, MoFEM::FEMethod *,
752 MoFEM::BasicMethod *, MoFEM::BasicMethod *>(
753 dm, fe_name, method, pre_only, post_only);
754}
755
756PetscErrorCode
757DMMoFEMSNESSetJacobian(DM dm, const std::string fe_name,
758 boost::shared_ptr<MoFEM::FEMethod> method,
759 boost::shared_ptr<MoFEM::BasicMethod> pre_only,
760 boost::shared_ptr<MoFEM::BasicMethod> post_only) {
761 return DMMoFEMSNESSetJacobian<const std::string,
762 boost::shared_ptr<MoFEM::FEMethod>,
763 boost::shared_ptr<MoFEM::BasicMethod>,
764 boost::shared_ptr<MoFEM::BasicMethod>>(
765 dm, fe_name, method, pre_only, post_only);
766}
767
768template <class S, class T0, class T1, class T2>
769static PetscErrorCode DMMoFEMTSSetIFunction(DM dm, S fe_name, T0 method,
770 T1 pre_only, T2 post_only) {
771 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
772 MoFEMFunctionBegin;
773 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
774 if (pre_only) {
775 dm_field->tsCtx->getPreProcessIFunction().push_back(pre_only);
776 }
777 if (method) {
778 dm_field->tsCtx->getLoopsIFunction().push_back(
779 PairNameFEMethodPtr(fe_name, method));
780 }
781 if (post_only) {
782 dm_field->tsCtx->getPostProcessIFunction().push_back(post_only);
783 }
784 CHKERR DMTSSetIFunction(dm, TsSetIFunction, dm_field->tsCtx.get());
785 MoFEMFunctionReturn(0);
786}
787
788PetscErrorCode DMMoFEMTSSetIFunction(DM dm, const char fe_name[],
789 MoFEM::FEMethod *method,
790 MoFEM::BasicMethod *pre_only,
791 MoFEM::BasicMethod *post_only) {
792 return DMMoFEMTSSetIFunction<const char *, MoFEM::FEMethod *,
793 MoFEM::BasicMethod *, MoFEM::BasicMethod *>(
794 dm, fe_name, method, pre_only, post_only);
795 MoFEMFunctionReturnHot(0);
796}
797
798PetscErrorCode
799DMMoFEMTSSetIFunction(DM dm, const std::string fe_name,
800 boost::shared_ptr<MoFEM::FEMethod> method,
801 boost::shared_ptr<MoFEM::BasicMethod> pre_only,
802 boost::shared_ptr<MoFEM::BasicMethod> post_only) {
803 return DMMoFEMTSSetIFunction<const std::string,
804 boost::shared_ptr<MoFEM::FEMethod>,
805 boost::shared_ptr<MoFEM::BasicMethod>,
806 boost::shared_ptr<MoFEM::BasicMethod>>(
807 dm, fe_name, method, pre_only, post_only);
808 MoFEMFunctionReturnHot(0);
809}
810
811template <class S, class T0, class T1, class T2>
812static PetscErrorCode DMMoFEMTSSetIJacobian(DM dm, S fe_name, T0 method,
813 T1 pre_only, T2 post_only) {
814 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
815 MoFEMFunctionBegin;
816 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
817 if (pre_only) {
818 dm_field->tsCtx->getPreProcessIJacobian().push_back(pre_only);
819 }
820 if (method) {
821 dm_field->tsCtx->getLoopsIJacobian().push_back(
822 PairNameFEMethodPtr(fe_name, method));
823 }
824 if (post_only) {
825 dm_field->tsCtx->getPostProcessIJacobian().push_back(post_only);
826 }
827 CHKERR DMTSSetIJacobian(dm, TsSetIJacobian, dm_field->tsCtx.get());
828 MoFEMFunctionReturn(0);
829}
830
831PetscErrorCode DMMoFEMTSSetIJacobian(DM dm, const char fe_name[],
832 MoFEM::FEMethod *method,
833 MoFEM::BasicMethod *pre_only,
834 MoFEM::BasicMethod *post_only) {
835 return DMMoFEMTSSetIJacobian<const char *, FEMethod *, MoFEM::BasicMethod *,
836 MoFEM::BasicMethod *>(dm, fe_name, method,
837 pre_only, post_only);
838}
839
840PetscErrorCode
841DMMoFEMTSSetIJacobian(DM dm, const std::string fe_name,
842 boost::shared_ptr<MoFEM::FEMethod> method,
843 boost::shared_ptr<MoFEM::BasicMethod> pre_only,
844 boost::shared_ptr<MoFEM::BasicMethod> post_only) {
845 return DMMoFEMTSSetIJacobian<const std::string,
846 boost::shared_ptr<MoFEM::FEMethod>,
847 boost::shared_ptr<MoFEM::BasicMethod>,
848 boost::shared_ptr<MoFEM::BasicMethod>>(
849 dm, fe_name, method, pre_only, post_only);
850}
851
852template <class S, class T0, class T1, class T2>
853static PetscErrorCode DMMoFEMTSSetRHSFunction(DM dm, S fe_name, T0 method,
854 T1 pre_only, T2 post_only) {
855 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
856 MoFEMFunctionBegin;
857 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
858 if (pre_only)
859 dm_field->tsCtx->getPreProcessRHSFunction().push_back(pre_only);
860 if (method)
861 dm_field->tsCtx->getLoopsRHSFunction().push_back(
862 PairNameFEMethodPtr(fe_name, method));
863 if (post_only)
864 dm_field->tsCtx->getPostProcessRHSFunction().push_back(post_only);
865 CHKERR DMTSSetRHSFunction(dm, TsSetRHSFunction, dm_field->tsCtx.get());
866 MoFEMFunctionReturn(0);
867}
868
869PetscErrorCode
870DMMoFEMTSSetRHSFunction(DM dm, const std::string fe_name,
871 boost::shared_ptr<MoFEM::FEMethod> method,
872 boost::shared_ptr<MoFEM::BasicMethod> pre_only,
873 boost::shared_ptr<MoFEM::BasicMethod> post_only) {
874 return DMMoFEMTSSetRHSFunction<const std::string,
875 boost::shared_ptr<MoFEM::FEMethod>,
876 boost::shared_ptr<MoFEM::BasicMethod>,
877 boost::shared_ptr<MoFEM::BasicMethod>>(
878 dm, fe_name, method, pre_only, post_only);
879 MoFEMFunctionReturnHot(0);
880}
881
882PetscErrorCode DMMoFEMTSSetRHSFunction(DM dm, const char fe_name[],
883 MoFEM::FEMethod *method,
884 MoFEM::BasicMethod *pre_only,
885 MoFEM::BasicMethod *post_only) {
886 return DMMoFEMTSSetRHSFunction<const char *, MoFEM::FEMethod *,
887 MoFEM::BasicMethod *, MoFEM::BasicMethod *>(
888 dm, fe_name, method, pre_only, post_only);
889 MoFEMFunctionReturnHot(0);
890}
891
892template <class S, class T0, class T1, class T2>
893static PetscErrorCode DMMoFEMTSSetRHSJacobian(DM dm, S fe_name, T0 method,
894 T1 pre_only, T2 post_only) {
895 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
896 MoFEMFunctionBegin;
897 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
898 if (pre_only)
899 dm_field->tsCtx->getPreProcessRHSFunction().push_back(pre_only);
900 if (method)
901 dm_field->tsCtx->getLoopsRHSFunction().push_back(
902 PairNameFEMethodPtr(fe_name, method));
903 if (post_only)
904 dm_field->tsCtx->getPostProcessRHSFunction().push_back(post_only);
905 CHKERR DMTSSetRHSJacobian(dm, TsSetRHSJacobian, dm_field->tsCtx.get());
906 MoFEMFunctionReturn(0);
907}
908
909PetscErrorCode
910DMMoFEMTSSetRHSJacobian(DM dm, const std::string fe_name,
911 boost::shared_ptr<MoFEM::FEMethod> method,
912 boost::shared_ptr<MoFEM::BasicMethod> pre_only,
913 boost::shared_ptr<MoFEM::BasicMethod> post_only) {
914 return DMMoFEMTSSetRHSJacobian<const std::string,
915 boost::shared_ptr<MoFEM::FEMethod>,
916 boost::shared_ptr<MoFEM::BasicMethod>,
917 boost::shared_ptr<MoFEM::BasicMethod>>(
918 dm, fe_name, method, pre_only, post_only);
919 MoFEMFunctionReturnHot(0);
920}
921
922PetscErrorCode DMMoFEMTSSetRHSJacobian(DM dm, const char fe_name[],
923 MoFEM::FEMethod *method,
924 MoFEM::BasicMethod *pre_only,
925 MoFEM::BasicMethod *post_only) {
926 return DMMoFEMTSSetRHSJacobian<const char *, MoFEM::FEMethod *,
927 MoFEM::BasicMethod *, MoFEM::BasicMethod *>(
928 dm, fe_name, method, pre_only, post_only);
929 MoFEMFunctionReturnHot(0);
930}
931
932template <class S, class T0, class T1, class T2>
933static PetscErrorCode DMMoFEMTSSetI2Function(DM dm, S fe_name, T0 method,
934 T1 pre_only, T2 post_only) {
935 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
936 MoFEMFunctionBegin;
937 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
938 if (pre_only) {
939 dm_field->tsCtx->getPreProcessIFunction().push_back(pre_only);
940 }
941 if (method) {
942 dm_field->tsCtx->getLoopsIFunction().push_back(
943 PairNameFEMethodPtr(fe_name, method));
944 }
945 if (post_only) {
946 dm_field->tsCtx->getPostProcessIFunction().push_back(post_only);
947 }
948 CHKERR DMTSSetI2Function(dm, TsSetI2Function, dm_field->tsCtx.get());
949 MoFEMFunctionReturn(0);
950}
951
952PetscErrorCode DMMoFEMTSSetI2Function(DM dm, const char fe_name[],
953 MoFEM::FEMethod *method,
954 MoFEM::BasicMethod *pre_only,
955 MoFEM::BasicMethod *post_only) {
956 return DMMoFEMTSSetI2Function<const char *, MoFEM::FEMethod *,
957 MoFEM::BasicMethod *, MoFEM::BasicMethod *>(
958 dm, fe_name, method, pre_only, post_only);
959 MoFEMFunctionReturnHot(0);
960}
961
962PetscErrorCode
963DMMoFEMTSSetI2Function(DM dm, const std::string fe_name,
964 boost::shared_ptr<MoFEM::FEMethod> method,
965 boost::shared_ptr<MoFEM::BasicMethod> pre_only,
966 boost::shared_ptr<MoFEM::BasicMethod> post_only) {
967 return DMMoFEMTSSetI2Function<const std::string,
968 boost::shared_ptr<MoFEM::FEMethod>,
969 boost::shared_ptr<MoFEM::BasicMethod>,
970 boost::shared_ptr<MoFEM::BasicMethod>>(
971 dm, fe_name, method, pre_only, post_only);
972 MoFEMFunctionReturnHot(0);
973}
974
975template <class S, class T0, class T1, class T2>
976static PetscErrorCode DMMoFEMTSSetI2Jacobian(DM dm, S fe_name, T0 method,
977 T1 pre_only, T2 post_only) {
978 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
979 MoFEMFunctionBegin;
980 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
981 if (pre_only) {
982 dm_field->tsCtx->getPreProcessIJacobian().push_back(pre_only);
983 }
984 if (method) {
985 dm_field->tsCtx->getLoopsIJacobian().push_back(
986 PairNameFEMethodPtr(fe_name, method));
987 }
988 if (post_only) {
989 dm_field->tsCtx->getPostProcessIJacobian().push_back(post_only);
990 }
991 CHKERR DMTSSetI2Jacobian(dm, TsSetI2Jacobian, dm_field->tsCtx.get());
992 MoFEMFunctionReturn(0);
993}
994
995PetscErrorCode DMMoFEMTSSetI2Jacobian(DM dm, const char fe_name[],
996 MoFEM::FEMethod *method,
997 MoFEM::BasicMethod *pre_only,
998 MoFEM::BasicMethod *post_only) {
999 return DMMoFEMTSSetI2Jacobian<const char *, FEMethod *, MoFEM::BasicMethod *,
1000 MoFEM::BasicMethod *>(dm, fe_name, method,
1001 pre_only, post_only);
1002}
1003
1004PetscErrorCode
1005DMMoFEMTSSetI2Jacobian(DM dm, const std::string fe_name,
1006 boost::shared_ptr<MoFEM::FEMethod> method,
1007 boost::shared_ptr<MoFEM::BasicMethod> pre_only,
1008 boost::shared_ptr<MoFEM::BasicMethod> post_only) {
1009 return DMMoFEMTSSetI2Jacobian<const std::string,
1010 boost::shared_ptr<MoFEM::FEMethod>,
1011 boost::shared_ptr<MoFEM::BasicMethod>,
1012 boost::shared_ptr<MoFEM::BasicMethod>>(
1013 dm, fe_name, method, pre_only, post_only);
1014}
1015
1016template <class S, class T0, class T1, class T2>
1017static PetscErrorCode DMMoFEMTSSetMonitor(DM dm, TS ts, S fe_name, T0 method,
1018 T1 pre_only, T2 post_only) {
1019 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
1020 MoFEMFunctionBegin;
1021 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
1022 if (pre_only)
1023 dm_field->tsCtx->getPreProcessMonitor().push_back(pre_only);
1024 if (method)
1025 dm_field->tsCtx->getLoopsMonitor().push_back(
1026 PairNameFEMethodPtr(fe_name, method));
1027 if (post_only)
1028 dm_field->tsCtx->getPostProcessMonitor().push_back(post_only);
1029 CHKERR TSMonitorSet(ts, TsMonitorSet, dm_field->tsCtx.get(), PETSC_NULL);
1030 MoFEMFunctionReturn(0);
1031}
1032
1033PetscErrorCode DMMoFEMTSSetMonitor(DM dm, TS ts, const char fe_name[],
1034 MoFEM::FEMethod *method,
1035 MoFEM::BasicMethod *pre_only,
1036 MoFEM::BasicMethod *post_only) {
1037 return DMMoFEMTSSetMonitor<const char *, MoFEM::FEMethod *,
1038 MoFEM::BasicMethod *, MoFEM::BasicMethod *>(
1039 dm, ts, fe_name, method, pre_only, post_only);
1040 MoFEMFunctionReturnHot(0);
1041}
1042
1043PetscErrorCode
1044DMMoFEMTSSetMonitor(DM dm, TS ts, const std::string fe_name,
1045 boost::shared_ptr<MoFEM::FEMethod> method,
1046 boost::shared_ptr<MoFEM::BasicMethod> pre_only,
1047 boost::shared_ptr<MoFEM::BasicMethod> post_only) {
1048 return DMMoFEMTSSetMonitor<const std::string,
1049 boost::shared_ptr<MoFEM::FEMethod>,
1050 boost::shared_ptr<MoFEM::BasicMethod>,
1051 boost::shared_ptr<MoFEM::BasicMethod>>(
1052 dm, ts, fe_name, method, pre_only, post_only);
1053 MoFEMFunctionReturnHot(0);
1054}
1055
1056PetscErrorCode DMMoFEMGetKspCtx(DM dm, MoFEM::KspCtx **ksp_ctx) {
1057 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
1058 MoFEMFunctionBeginHot;
1059 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
1060 *ksp_ctx = dm_field->kspCtx.get();
1061 MoFEMFunctionReturnHot(0);
1062}
1063
1064PetscErrorCode
1065DMMoFEMGetKspCtx(DM dm, const boost::shared_ptr<MoFEM::KspCtx> &ksp_ctx) {
1066 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
1067 MoFEMFunctionBeginHot;
1068 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
1069 const_cast<boost::shared_ptr<MoFEM::KspCtx> &>(ksp_ctx) = dm_field->kspCtx;
1070 MoFEMFunctionReturnHot(0);
1071}
1072
1073PetscErrorCode DMMoFEMSetKspCtx(DM dm,
1074 boost::shared_ptr<MoFEM::KspCtx> ksp_ctx) {
1075 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
1076 MoFEMFunctionBeginHot;
1077 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
1078 dm_field->kspCtx = ksp_ctx;
1079 MoFEMFunctionReturnHot(0);
1080}
1081
1082PetscErrorCode DMMoFEMGetSnesCtx(DM dm, MoFEM::SnesCtx **snes_ctx) {
1083 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
1084 MoFEMFunctionBeginHot;
1085 DMCtx *dm_field = (DMCtx *)dm->data;
1086 *snes_ctx = dm_field->snesCtx.get();
1087 MoFEMFunctionReturnHot(0);
1088}
1089
1090PetscErrorCode
1091DMMoFEMGetSnesCtx(DM dm, const boost::shared_ptr<MoFEM::SnesCtx> &snes_ctx) {
1092 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
1093 MoFEMFunctionBeginHot;
1094 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
1095 const_cast<boost::shared_ptr<MoFEM::SnesCtx> &>(snes_ctx) = dm_field->snesCtx;
1096 MoFEMFunctionReturnHot(0);
1097}
1098
1099PetscErrorCode DMMoFEMSetSnesCtx(DM dm,
1100 boost::shared_ptr<MoFEM::SnesCtx> snes_ctx) {
1101 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
1102 MoFEMFunctionBeginHot;
1103 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
1104 dm_field->snesCtx = snes_ctx;
1105 MoFEMFunctionReturnHot(0);
1106}
1107
1108/** get if read mesh is partitioned
1109 * \ingroup dm
1110 */
1111PetscErrorCode DMMoFEMSetIsPartitioned(DM dm, PetscBool is_partitioned) {
1112 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
1113 MoFEMFunctionBeginHot;
1114 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
1115 dm_field->isPartitioned = is_partitioned;
1116 MoFEMFunctionReturnHot(0);
1117}
1118
1119/** get if read mesh is partitioned
1120 * \ingroup dm
1121 */
1122PetscErrorCode DMMoFEMGetIsPartitioned(DM dm, PetscBool *is_partitioned) {
1123 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
1124 MoFEMFunctionBeginHot;
1125 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
1126 *is_partitioned = dm_field->isPartitioned;
1127 MoFEMFunctionReturnHot(0);
1128}
1129
1130PetscErrorCode DMMoFEMGetTsCtx(DM dm, MoFEM::TsCtx **ts_ctx) {
1131 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
1132 MoFEMFunctionBeginHot;
1133 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
1134 *ts_ctx = dm_field->tsCtx.get();
1135 MoFEMFunctionReturnHot(0);
1136}
1137
1138PetscErrorCode DMMoFEMGetTsCtx(DM dm,
1139 const boost::shared_ptr<MoFEM::TsCtx> &ts_ctx) {
1140 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
1141 MoFEMFunctionBeginHot;
1142 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
1143 const_cast<boost::shared_ptr<MoFEM::TsCtx> &>(ts_ctx) = dm_field->tsCtx;
1144 MoFEMFunctionReturnHot(0);
1145}
1146
1147PetscErrorCode DMMoFEMSetTsCtx(DM dm, boost::shared_ptr<MoFEM::TsCtx> ts_ctx) {
1148 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
1149 MoFEMFunctionBeginHot;
1150 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
1151 dm_field->tsCtx = ts_ctx;
1152 MoFEMFunctionReturnHot(0);
1153}
1154
1155PetscErrorCode DMCreateGlobalVector_MoFEM(DM dm, Vec *g) {
1156 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
1157 MoFEMFunctionBegin;
1158 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
1159 CHKERR dm_field->mField_ptr->getInterface<VecManager>()->vecCreateGhost(
1160 dm_field->problemName, COL, g);
1161 CHKERR VecSetDM(*g, dm);
1162 MoFEMFunctionReturn(0);
1163}
1164
1165PetscErrorCode DMCreateGlobalVector_MoFEM(DM dm, SmartPetscObj<Vec> &g_ptr) {
1166 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
1167 MoFEMFunctionBegin;
1168 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
1169 CHKERR dm_field->mField_ptr->getInterface<VecManager>()->vecCreateGhost(
1170 dm_field->problemName, COL, g_ptr);
1171 CHKERR VecSetDM(g_ptr, dm);
1172 MoFEMFunctionReturn(0);
1173}
1174
1175PetscErrorCode DMCreateLocalVector_MoFEM(DM dm, Vec *l) {
1176 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
1177 MoFEMFunctionBegin;
1178 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
1179 CHKERR dm_field->mField_ptr->getInterface<VecManager>()->vecCreateSeq(
1180 dm_field->problemName, COL, l);
1181 CHKERR VecSetDM(*l, dm);
1182 MoFEMFunctionReturn(0);
1183}
1184
1185PetscErrorCode DMCreateMatrix_MoFEM(DM dm, Mat *M) {
1186 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
1187 MoFEMFunctionBegin;
1188 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
1189 if (strcmp(dm->mattype, MATMPIAIJ) == 0) {
1190 CHKERR dm_field->mField_ptr->getInterface<MatrixManager>()
1191 ->createMPIAIJWithArrays<PetscGlobalIdx_mi_tag>(dm_field->problemName,
1192 M);
1193 } else if (strcmp(dm->mattype, MATAIJ) == 0) {
1194 CHKERR dm_field->mField_ptr->getInterface<MatrixManager>()
1195 ->createSeqAIJWithArrays<PetscLocalIdx_mi_tag>(dm_field->problemName,
1196 M);
1197 } else if (strcmp(dm->mattype, MATAIJCUSPARSE) == 0) {
1198 CHKERR dm_field->mField_ptr->getInterface<MatrixManager>()
1199 ->createMPIAIJCUSPARSEWithArrays<PetscGlobalIdx_mi_tag>(
1200 dm_field->problemName, M);
1201 } else if (strcmp(dm->mattype, MATSEQAIJCUSPARSE) == 0) {
1202 CHKERR dm_field->mField_ptr->getInterface<MatrixManager>()
1203 ->createSeqAIJCUSPARSEWithArrays<PetscLocalIdx_mi_tag>(
1204 dm_field->problemName, M);
1205 } else {
1206 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
1207 "Matrix type not implemented");
1208 }
1209 CHKERR MatSetDM(*M, dm);
1210 MoFEMFunctionReturn(0);
1211}
1212
1213PetscErrorCode DMCreateMatrix_MoFEM(DM dm, SmartPetscObj<Mat> &M) {
1214 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
1215 MoFEMFunctionBegin;
1216 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
1217 if (strcmp(dm->mattype, MATMPIAIJ) == 0) {
1218 CHKERR dm_field->mField_ptr->getInterface<MatrixManager>()
1219 ->createMPIAIJWithArrays<PetscGlobalIdx_mi_tag>(dm_field->problemName,
1220 M);
1221 } else if (strcmp(dm->mattype, MATAIJ) == 0) {
1222 CHKERR dm_field->mField_ptr->getInterface<MatrixManager>()
1223 ->createSeqAIJWithArrays<PetscLocalIdx_mi_tag>(dm_field->problemName,
1224 M);
1225 } else if (strcmp(dm->mattype, MATAIJCUSPARSE) == 0) {
1226 CHKERR dm_field->mField_ptr->getInterface<MatrixManager>()
1227 ->createMPIAIJCUSPARSEWithArrays<PetscGlobalIdx_mi_tag>(
1228 dm_field->problemName, M);
1229 } else if (strcmp(dm->mattype, MATSEQAIJCUSPARSE) == 0) {
1230 CHKERR dm_field->mField_ptr->getInterface<MatrixManager>()
1231 ->createSeqAIJCUSPARSEWithArrays<PetscLocalIdx_mi_tag>(
1232 dm_field->problemName, M);
1233 } else {
1234 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
1235 "Matrix type not implemented");
1236 }
1237 CHKERR MatSetDM(M, dm);
1238 MoFEMFunctionReturn(0);
1239}
1240
1241#if PETSC_VERSION_GE(3, 7, 0)
1242PetscErrorCode DMSetFromOptions_MoFEM(PetscOptionItems *PetscOptionsObject,
1243 DM dm) {
1244#elif PETSC_VERSION_GE(3, 5, 3)
1245PetscErrorCode DMSetFromOptions_MoFEM(PetscOptions *PetscOptionsObject, DM dm) {
1246#else
1247PetscErrorCode DMSetFromOptions_MoFEM(DM dm) {
1248#endif
1249
1250 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
1251 MoFEMFunctionBeginHot;
1252 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
1253#if PETSC_VERSION_GE(3, 5, 3)
1254 ierr = PetscOptionsHead(PetscOptionsObject, "DMMoFEM Options");
1255 CHKERRG(ierr);
1256#else
1257 ierr = PetscOptionsHead("DMMoFEM Options");
1258 CHKERRG(ierr);
1259#endif
1260 ierr = PetscOptionsBool("-dm_is_partitioned",
1261 "set if mesh is partitioned (works which native MOAB "
1262 "file format, i.e. h5m",
1263 "DMSetUp", dm_field->isPartitioned,
1264 &dm_field->isPartitioned, NULL);
1265 CHKERRG(ierr);
1266 MoFEMFunctionReturnHot(0);
1267}
1268
1269PetscErrorCode DMSetUp_MoFEM(DM dm) {
1270 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
1271 ProblemsManager *prb_mng_ptr;
1272 MoFEMFunctionBegin;
1273 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
1274 CHKERR dm_field->mField_ptr->getInterface(prb_mng_ptr);
1275
1276 if (dm_field->isCompDM) {
1277 // It is composite probelm
1278 CHKERR prb_mng_ptr->buildComposedProblem(
1279 dm_field->problemName, dm_field->rowCompPrb, dm_field->colCompPrb,
1280 dm_field->isSquareMatrix == PETSC_TRUE, dm_field->verbosity);
1281 } else {
1282 if (dm_field->isPartitioned) {
1283 CHKERR prb_mng_ptr->buildProblemOnDistributedMesh(
1284 dm_field->problemName, dm_field->isSquareMatrix == PETSC_TRUE,
1285 dm_field->verbosity);
1286 } else {
1287 CHKERR prb_mng_ptr->buildProblem(dm_field->problemName,
1288 dm_field->isSquareMatrix == PETSC_TRUE,
1289 dm_field->verbosity);
1290 CHKERR prb_mng_ptr->partitionProblem(dm_field->problemName,
1291 dm_field->verbosity);
1292 }
1293 }
1294
1295 // Partition finite elements
1296 if (dm_field->isPartitioned) {
1297 CHKERR prb_mng_ptr->partitionFiniteElements(
1298 dm_field->problemName, true, 0, dm_field->sIze, dm_field->verbosity);
1299 CHKERR prb_mng_ptr->partitionGhostDofsOnDistributedMesh(
1300 dm_field->problemName, dm_field->verbosity);
1301 } else {
1302 // partition finite elemnets
1303 CHKERR prb_mng_ptr->partitionFiniteElements(dm_field->problemName, false,
1304 -1, -1, dm_field->verbosity);
1305 // Get ghost DOFs
1306 CHKERR prb_mng_ptr->partitionGhostDofs(dm_field->problemName,
1307 dm_field->verbosity);
1308 }
1309
1310 // Set flag that problem is build and partitioned
1311 dm_field->isProblemBuild = PETSC_TRUE;
1312
1313 MoFEMFunctionReturn(0);
1314}
1315
1316PetscErrorCode DMSubDMSetUp_MoFEM(DM subdm) {
1317 PetscValidHeaderSpecific(subdm, DM_CLASSID, 1);
1318 ProblemsManager *prb_mng_ptr;
1319 MoFEMFunctionBegin;
1320
1321 DMCtx *subdm_field = static_cast<DMCtx *>(subdm->data);
1322
1323 // build sub dm problem
1324 CHKERR subdm_field->mField_ptr->getInterface(prb_mng_ptr);
1325
1326 map<std::string, boost::shared_ptr<Range>> *entity_map_row = nullptr;
1327 map<std::string, boost::shared_ptr<Range>> *entity_map_col = nullptr;
1328
1329 if (subdm_field->mapTypeRow.size())
1330 entity_map_row = &subdm_field->mapTypeRow;
1331 if (subdm_field->mapTypeCol.size())
1332 entity_map_col = &subdm_field->mapTypeCol;
1333
1334 CHKERR prb_mng_ptr->buildSubProblem(
1335 subdm_field->problemName, subdm_field->rowFields, subdm_field->colFields,
1336 subdm_field->problemMainOfSubPtr->getName(),
1337 subdm_field->isSquareMatrix == PETSC_TRUE, entity_map_row, entity_map_col,
1338 subdm_field->verbosity);
1339
1340 // partition problem
1341 subdm_field->isPartitioned = subdm_field->isPartitioned;
1342 if (subdm_field->isPartitioned) {
1343 CHKERR prb_mng_ptr->partitionFiniteElements(subdm_field->problemName, true,
1344 0, subdm_field->sIze,
1345 subdm_field->verbosity);
1346 // set ghost nodes
1347 CHKERR prb_mng_ptr->partitionGhostDofsOnDistributedMesh(
1348 subdm_field->problemName, subdm_field->verbosity);
1349 } else {
1350 // partition finite elements
1351 CHKERR prb_mng_ptr->partitionFiniteElements(subdm_field->problemName, false,
1352 -1, -1, subdm_field->verbosity);
1353 // set ghost nodes
1354 CHKERR prb_mng_ptr->partitionGhostDofs(subdm_field->problemName,
1355 subdm_field->verbosity);
1356 }
1357
1358 subdm_field->isProblemBuild = PETSC_TRUE;
1359
1360 MoFEMFunctionReturn(0);
1361}
1362
1363PetscErrorCode DMGlobalToLocalBegin_MoFEM(DM dm, Vec g, InsertMode mode,
1364 Vec l) {
1365 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
1366 MoFEMFunctionBegin;
1367 CHKERR VecGhostUpdateBegin(g, INSERT_VALUES, SCATTER_FORWARD);
1368 MoFEMFunctionReturn(0);
1369}
1370
1371PetscErrorCode DMGlobalToLocalEnd_MoFEM(DM dm, Vec g, InsertMode mode, Vec l) {
1372 MoFEMFunctionBeginHot;
1373 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
1374 MoFEMFunctionBegin;
1375
1376 CHKERR VecGhostUpdateEnd(g, INSERT_VALUES, SCATTER_FORWARD);
1377
1378 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
1379 int nb_dofs = dm_field->problemPtr->getNbLocalDofsRow();
1380 int nb_ghost = dm_field->problemPtr->getNbGhostDofsRow();
1381
1382 double *array_loc, *array_glob;
1383 CHKERR VecGetArray(l, &array_loc);
1384 CHKERR VecGetArray(g, &array_glob);
1385 switch (mode) {
1386 case INSERT_VALUES:
1387 cblas_dcopy(nb_dofs + nb_ghost, array_glob, 1, array_loc, 1);
1388 break;
1389 case ADD_VALUES:
1390 cblas_daxpy(nb_dofs + nb_ghost, 1, array_glob, 1, array_loc, 1);
1391 break;
1392 default:
1393 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED, "not implemented");
1394 }
1395 CHKERR VecRestoreArray(l, &array_loc);
1396 CHKERR VecRestoreArray(g, &array_glob);
1397 MoFEMFunctionReturn(0);
1398}
1399
1400PetscErrorCode DMLocalToGlobalBegin_MoFEM(DM dm, Vec l, InsertMode mode,
1401 Vec g) {
1402
1403 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
1404 MoFEMFunctionBegin;
1405
1406 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
1407 int nb_dofs = dm_field->problemPtr->getNbLocalDofsRow();
1408 int nb_ghost = dm_field->problemPtr->getNbGhostDofsRow();
1409
1410 double *array_loc, *array_glob;
1411 CHKERR VecGetArray(l, &array_loc);
1412 CHKERR VecGetArray(g, &array_glob);
1413 switch (mode) {
1414 case INSERT_VALUES:
1415 cblas_dcopy(nb_dofs + nb_ghost, array_loc, 1, array_glob, 1);
1416 break;
1417 case ADD_VALUES:
1418 cblas_daxpy(nb_dofs + nb_ghost, 1, array_loc, 1, array_glob, 1);
1419 break;
1420 default:
1421 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED, "not implemented");
1422 }
1423 CHKERR VecRestoreArray(l, &array_loc);
1424 CHKERR VecRestoreArray(g, &array_glob);
1425
1426 MoFEMFunctionReturn(0);
1427}
1428
1429PetscErrorCode DMLocalToGlobalEnd_MoFEM(DM, Vec l, InsertMode mode, Vec g) {
1430 //
1431 MoFEMFunctionBeginHot;
1432 MoFEMFunctionReturnHot(0);
1433}
1434
1435PetscErrorCode DMCreateFieldIS_MoFEM(DM dm, PetscInt *numFields,
1436 char ***fieldNames, IS **fields) {
1437 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
1438 MoFEMFunctionBegin;
1439
1440 if (numFields) {
1441 *numFields = 0;
1442 }
1443 if (fieldNames) {
1444 *fieldNames = NULL;
1445 }
1446 if (fields) {
1447 *fields = NULL;
1448 }
1449
1450 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
1451 auto fields_ptr = dm_field->mField_ptr->get_fields();
1452 Field_multiIndex::iterator fit, hi_fit;
1453 fit = fields_ptr->begin();
1454 hi_fit = fields_ptr->end();
1455 *numFields = std::distance(fit, hi_fit);
1456
1457 if (fieldNames) {
1458 CHKERR PetscMalloc1(*numFields, fieldNames);
1459 }
1460 if (fields) {
1461 CHKERR PetscMalloc1(*numFields, fields);
1462 }
1463
1464 for (int f = 0; fit != hi_fit; fit++, f++) {
1465 if (fieldNames) {
1466 CHKERR PetscStrallocpy(fit->get()->getName().c_str(),
1467 (char **)&(*fieldNames)[f]);
1468 }
1469 if (fields) {
1470 CHKERR dm_field->mField_ptr->getInterface<ISManager>()
1471 ->isCreateProblemFieldAndRank(
1472 dm_field->problemPtr->getName(), ROW, fit->get()->getName(), 0,
1473 fit->get()->getNbOfCoeffs(), &(*fields)[f]);
1474 }
1475 }
1476
1477 MoFEMFunctionReturn(0);
1478}
1479
1480PetscErrorCode DMMoFEMGetFieldIS(DM dm, RowColData rc, const char field_name[],
1481 IS *is) {
1482 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
1483 MoFEMFunctionBegin;
1484 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
1485 CHKERR dm_field->mField_ptr->getInterface<ISManager>()
1486 ->isCreateProblemFieldAndRank(dm_field->problemPtr->getName(), ROW,
1487 field_name, 0, 1000, is);
1488 MoFEMFunctionReturn(0);
1489}
1490
1491PetscErrorCode DMMoFEMSetVerbosity(DM dm, const int verb) {
1492 PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
1493 MoFEMFunctionBeginHot;
1494 DMCtx *dm_field = static_cast<DMCtx *>(dm->data);
1495 dm_field->verbosity = verb;
1496 MoFEMFunctionReturnHot(0);
1497}
1498
1499} // namespace MoFEM
M
static Index< 'M', 3 > M
Definition: BasicFeTools.hpp:96
DMMoFEM.hpp
Discrete manager interface for MoFEM.
if
if(!static_cast< bool >(ifstream(param_file)))
Definition: DefaultParams.hpp:115
VERBOSE
@ VERBOSE
Definition: definitions.h:209
RowColData
RowColData
RowColData.
Definition: definitions.h:123
COL
@ COL
Definition: definitions.h:123
ROW
@ ROW
Definition: definitions.h:123
MF_EXIST
@ MF_EXIST
Definition: definitions.h:100
MF_EXCL
@ MF_EXCL
Definition: definitions.h:99
MoFEMFunctionReturnHot
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:447
MoFEMFunctionBegin
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:346
CHKERRG
#define CHKERRG(n)
Check error code of MoFEM/MOAB/PETSc function.
Definition: definitions.h:483
MOFEM_DATA_INCONSISTENCY
@ MOFEM_DATA_INCONSISTENCY
Definition: definitions.h:31
MOFEM_INVALID_DATA
@ MOFEM_INVALID_DATA
Definition: definitions.h:36
MOFEM_NOT_IMPLEMENTED
@ MOFEM_NOT_IMPLEMENTED
Definition: definitions.h:32
MoFEMFunctionReturn
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:416
CHKERR
#define CHKERR
Inline error check.
Definition: definitions.h:535
MoFEMFunctionBeginHot
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:440
MoFEM::DMGlobalToLocalBegin_MoFEM
PetscErrorCode DMGlobalToLocalBegin_MoFEM(DM dm, Vec, InsertMode, Vec)
Definition: DMMoFEM.cpp:1363
MoFEM::DMGlobalToLocalEnd_MoFEM
PetscErrorCode DMGlobalToLocalEnd_MoFEM(DM dm, Vec, InsertMode, Vec)
Definition: DMMoFEM.cpp:1371
MoFEM::DMMoFEMSetIsPartitioned
PetscErrorCode DMMoFEMSetIsPartitioned(DM dm, PetscBool is_partitioned)
Definition: DMMoFEM.cpp:1111
MoFEM::DMMoFEMCreateSubDM
PetscErrorCode DMMoFEMCreateSubDM(DM subdm, DM dm, const char problem_name[])
Must be called by user to set Sub DM MoFEM data structures.
Definition: DMMoFEM.cpp:221
MoFEM::DMMoFEMGetIsPartitioned
PetscErrorCode DMMoFEMGetIsPartitioned(DM dm, PetscBool *is_partitioned)
Definition: DMMoFEM.cpp:1122
MoFEM::DMMoFEMAddElement
PetscErrorCode DMMoFEMAddElement(DM dm, std::string fe_name)
add element to dm
Definition: DMMoFEM.cpp:485
MoFEM::DMMoFEMSNESSetFunction
PetscErrorCode DMMoFEMSNESSetFunction(DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
set SNES residual evaluation function
Definition: DMMoFEM.cpp:706
MoFEM::DMMoFEMGetProblemFiniteElementLayout
PetscErrorCode DMMoFEMGetProblemFiniteElementLayout(DM dm, std::string fe_name, PetscLayout *layout)
Get finite elements layout in the problem.
Definition: DMMoFEM.cpp:461
MoFEM::DMCreateLocalVector_MoFEM
PetscErrorCode DMCreateLocalVector_MoFEM(DM dm, Vec *l)
DMShellSetCreateLocalVector.
Definition: DMMoFEM.cpp:1175
MoFEM::DMMoFEMSetSquareProblem
PetscErrorCode DMMoFEMSetSquareProblem(DM dm, PetscBool square_problem)
set squared problem
Definition: DMMoFEM.cpp:444
MoFEM::DMMoFEMTSSetIFunction
PetscErrorCode DMMoFEMTSSetIFunction(DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
set TS implicit function evaluation function
Definition: DMMoFEM.cpp:788
MoFEM::DMDestroy_MoFEM
PetscErrorCode DMDestroy_MoFEM(DM dm)
Destroys dm with MoFEM data structure.
Definition: DMMoFEM.cpp:83
MoFEM::DMMoFEMCreateMoFEM
PetscErrorCode DMMoFEMCreateMoFEM(DM dm, MoFEM::Interface *m_field_ptr, const char problem_name[], const MoFEM::BitRefLevel bit_level, const MoFEM::BitRefLevel bit_mask=MoFEM::BitRefLevel().set())
Must be called by user to set MoFEM data structures.
Definition: DMMoFEM.cpp:118
MoFEM::DMoFEMPostProcessFiniteElements
PetscErrorCode DMoFEMPostProcessFiniteElements(DM dm, MoFEM::FEMethod *method)
execute finite element method for each element in dm (problem)
Definition: DMMoFEM.cpp:544
MoFEM::DMoFEMMeshToLocalVector
PetscErrorCode DMoFEMMeshToLocalVector(DM dm, Vec l, InsertMode mode, ScatterMode scatter_mode)
set local (or ghosted) vector values on mesh for partition only
Definition: DMMoFEM.cpp:511
MoFEM::DMMoFEMAddColCompositeProblem
PetscErrorCode DMMoFEMAddColCompositeProblem(DM dm, const char prb_name[])
Add problem to composite DM on col.
Definition: DMMoFEM.cpp:373
MoFEM::DMLocalToGlobalBegin_MoFEM
PetscErrorCode DMLocalToGlobalBegin_MoFEM(DM, Vec, InsertMode, Vec)
Definition: DMMoFEM.cpp:1400
MoFEM::DMMoFEMGetProblemPtr
PetscErrorCode DMMoFEMGetProblemPtr(DM dm, const MoFEM::Problem **problem_ptr)
Get pointer to problem data structure.
Definition: DMMoFEM.cpp:414
MoFEM::DMCreate_MoFEM
PetscErrorCode DMCreate_MoFEM(DM dm)
Create dm data structure with MoFEM data structure.
Definition: DMMoFEM.cpp:75
MoFEM::DMMoFEMSetSnesCtx
PetscErrorCode DMMoFEMSetSnesCtx(DM dm, boost::shared_ptr< MoFEM::SnesCtx > snes_ctx)
Set MoFEM::SnesCtx data structure.
Definition: DMMoFEM.cpp:1099
MoFEM::DMMoFEMSetKspCtx
PetscErrorCode DMMoFEMSetKspCtx(DM dm, boost::shared_ptr< MoFEM::KspCtx > ksp_ctx)
set MoFEM::KspCtx data structure
Definition: DMMoFEM.cpp:1073
MoFEM::DMMoFEMAddSubFieldRow
PetscErrorCode DMMoFEMAddSubFieldRow(DM dm, const char field_name[])
Definition: DMMoFEM.cpp:244
MoFEM::DMMoFEMGetIsSubDM
PetscErrorCode DMMoFEMGetIsSubDM(DM dm, PetscBool *is_sub_dm)
Definition: DMMoFEM.cpp:310
MoFEM::DMMoFEMAddRowCompositeProblem
PetscErrorCode DMMoFEMAddRowCompositeProblem(DM dm, const char prb_name[])
Add problem to composite DM on row.
Definition: DMMoFEM.cpp:355
MoFEM::DMMoFEMSNESSetJacobian
PetscErrorCode DMMoFEMSNESSetJacobian(DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
set SNES Jacobian evaluation function
Definition: DMMoFEM.cpp:747
MoFEM::DMCreateMatrix_MoFEM
PetscErrorCode DMCreateMatrix_MoFEM(DM dm, Mat *M)
Definition: DMMoFEM.cpp:1185
MoFEM::DMSetFromOptions_MoFEM
PetscErrorCode DMSetFromOptions_MoFEM(DM dm)
Definition: DMMoFEM.cpp:1247
MoFEM::DMMoFEMGetTsCtx
PetscErrorCode DMMoFEMGetTsCtx(DM dm, MoFEM::TsCtx **ts_ctx)
get MoFEM::TsCtx data structure
Definition: DMMoFEM.cpp:1130
MoFEM::DMRegister_MoFEM
PetscErrorCode DMRegister_MoFEM(const char sname[])
Register MoFEM problem.
Definition: DMMoFEM.cpp:47
MoFEM::DMMoFEMGetKspCtx
PetscErrorCode DMMoFEMGetKspCtx(DM dm, MoFEM::KspCtx **ksp_ctx)
get MoFEM::KspCtx data structure
Definition: DMMoFEM.cpp:1056
MoFEM::DMMoFEMGetSquareProblem
PetscErrorCode DMMoFEMGetSquareProblem(DM dm, PetscBool *square_problem)
get squared problem
Definition: DMMoFEM.cpp:475
MoFEM::DMoFEMLoopDofs
PetscErrorCode DMoFEMLoopDofs(DM dm, const char field_name[], MoFEM::DofMethod *method)
execute method for dofs on field in problem
Definition: DMMoFEM.cpp:593
MoFEM::DMMoFEMKSPSetComputeRHS
PetscErrorCode DMMoFEMKSPSetComputeRHS(DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
set KSP right hand side evaluation function
Definition: DMMoFEM.cpp:625
MoFEM::DMMoFEMResolveSharedFiniteElements
PetscErrorCode DMMoFEMResolveSharedFiniteElements(DM dm, std::string fe_name)
Resolve shared entities.
Definition: DMMoFEM.cpp:452
MoFEM::DMMoFEMSetTsCtx
PetscErrorCode DMMoFEMSetTsCtx(DM dm, boost::shared_ptr< MoFEM::TsCtx > ts_ctx)
Set MoFEM::TsCtx data structure.
Definition: DMMoFEM.cpp:1147
MoFEM::DMoFEMLoopFiniteElements
PetscErrorCode DMoFEMLoopFiniteElements(DM dm, const char fe_name[], MoFEM::FEMethod *method, CacheTupleWeakPtr cache_ptr=CacheTupleSharedPtr())
Executes FEMethod for finite elements in DM.
Definition: DMMoFEM.cpp:574
MoFEM::DMMoFEMGetFieldIS
PetscErrorCode DMMoFEMGetFieldIS(DM dm, RowColData rc, const char field_name[], IS *is)
get field is in the problem
Definition: DMMoFEM.cpp:1480
MoFEM::DMMoFEMTSSetIJacobian
PetscErrorCode DMMoFEMTSSetIJacobian(DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
set TS Jacobian evaluation function
Definition: DMMoFEM.cpp:841
MoFEM::DMoFEMGetInterfacePtr
PetscErrorCode DMoFEMGetInterfacePtr(DM dm, MoFEM::Interface **m_field_ptr)
Get pointer to MoFEM::Interface.
Definition: DMMoFEM.cpp:402
MoFEM::DMMoFEMAddSubFieldCol
PetscErrorCode DMMoFEMAddSubFieldCol(DM dm, const char field_name[])
Definition: DMMoFEM.cpp:277
MoFEM::DMMoFEMTSSetI2Jacobian
PetscErrorCode DMMoFEMTSSetI2Jacobian(DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
set TS Jacobian evaluation function
Definition: DMMoFEM.cpp:1005
MoFEM::DMMoFEMTSSetI2Function
PetscErrorCode DMMoFEMTSSetI2Function(DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
set TS implicit function evaluation function
Definition: DMMoFEM.cpp:963
MoFEM::DMCreateGlobalVector_MoFEM
PetscErrorCode DMCreateGlobalVector_MoFEM(DM dm, Vec *g)
DMShellSetCreateGlobalVector.
Definition: DMMoFEM.cpp:1155
MoFEM::DMMoFEMGetSnesCtx
PetscErrorCode DMMoFEMGetSnesCtx(DM dm, MoFEM::SnesCtx **snes_ctx)
get MoFEM::SnesCtx data structure
Definition: DMMoFEM.cpp:1082
MoFEM::DMoFEMMeshToGlobalVector
PetscErrorCode DMoFEMMeshToGlobalVector(DM dm, Vec g, InsertMode mode, ScatterMode scatter_mode)
set ghosted vector values on all existing mesh entities
Definition: DMMoFEM.cpp:523
MoFEM::DMMoFEMGetIsCompDM
PetscErrorCode DMMoFEMGetIsCompDM(DM dm, PetscBool *is_comp_dm)
Get if this DM is composite DM.
Definition: DMMoFEM.cpp:393
MoFEM::DMSubDMSetUp_MoFEM
PetscErrorCode DMSubDMSetUp_MoFEM(DM subdm)
Definition: DMMoFEM.cpp:1316
MoFEM::DMMoFEMKSPSetComputeOperators
PetscErrorCode DMMoFEMKSPSetComputeOperators(DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
Set KSP operators and push mofem finite element methods.
Definition: DMMoFEM.cpp:666
MoFEM::DMCreateFieldIS_MoFEM
PetscErrorCode DMCreateFieldIS_MoFEM(DM dm, PetscInt *numFields, char ***fieldNames, IS **fields)
Definition: DMMoFEM.cpp:1435
MoFEM::DMMoFEMUnSetElement
PetscErrorCode DMMoFEMUnSetElement(DM dm, std::string fe_name)
unset element from dm
Definition: DMMoFEM.cpp:502
MoFEM::DMSetUp_MoFEM
PetscErrorCode DMSetUp_MoFEM(DM dm)
Definition: DMMoFEM.cpp:1269
MoFEM::DMLocalToGlobalEnd_MoFEM
PetscErrorCode DMLocalToGlobalEnd_MoFEM(DM, Vec, InsertMode, Vec)
Definition: DMMoFEM.cpp:1429
MoFEM::DMoFEMLoopFiniteElementsUpAndLowRank
PetscErrorCode DMoFEMLoopFiniteElementsUpAndLowRank(DM dm, const char fe_name[], MoFEM::FEMethod *method, int low_rank, int up_rank, CacheTupleWeakPtr cache_ptr=CacheTupleSharedPtr())
Executes FEMethod for finite elements in DM.
Definition: DMMoFEM.cpp:555
MoFEM::DMoFEMPreProcessFiniteElements
PetscErrorCode DMoFEMPreProcessFiniteElements(DM dm, MoFEM::FEMethod *method)
execute finite element method for each element in dm (problem)
Definition: DMMoFEM.cpp:534
MoFEM::DMSetOperators_MoFEM
PetscErrorCode DMSetOperators_MoFEM(DM dm)
Set operators for MoFEM dm.
Definition: DMMoFEM.cpp:53
MoFEM::CoreInterface::get_problem
virtual const Problem * get_problem(const std::string problem_name) const =0
Get the problem object.
MoFEM::CoreInterface::get_fields
virtual const Field_multiIndex * get_fields() const =0
Get the fields object.
MoFEM::LogManager::setLog
static LoggerType & setLog(const std::string channel)
Set ans resset chanel logger.
Definition: LogManager.cpp:391
MOFEM_LOG
#define MOFEM_LOG(channel, severity)
Log.
Definition: LogManager.hpp:308
MOFEM_LOG_TAG
#define MOFEM_LOG_TAG(channel, tag)
Tag channel.
Definition: LogManager.hpp:339
MoFEM::CoreInterface::loop_dofs
virtual MoFEMErrorCode loop_dofs(const Problem *problem_ptr, const std::string &field_name, RowColData rc, DofMethod &method, int lower_rank, int upper_rank, int verb=DEFAULT_VERBOSITY)=0
Make a loop over dofs.
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.
MoFEM::ProblemsManager::buildProblemOnDistributedMesh
MoFEMErrorCode buildProblemOnDistributedMesh(const std::string name, const bool square_matrix, int verb=VERBOSE)
build problem data structures, assuming that mesh is distributed (collective)
Definition: ProblemsManager.cpp:290
MoFEM::ProblemsManager::partitionGhostDofs
MoFEMErrorCode partitionGhostDofs(const std::string name, int verb=VERBOSE)
determine ghost nodes
Definition: ProblemsManager.cpp:2341
MoFEM::ProblemsManager::buildComposedProblem
MoFEMErrorCode buildComposedProblem(const std::string out_name, const std::vector< std::string > add_row_problems, const std::vector< std::string > add_col_problems, const bool square_matrix=true, int verb=1)
build composite problem
Definition: ProblemsManager.cpp:1250
MoFEM::ProblemsManager::buildProblem
MoFEMErrorCode buildProblem(const std::string name, const bool square_matrix, int verb=VERBOSE)
build problem data structures
Definition: ProblemsManager.cpp:87
MoFEM::ProblemsManager::buildSubProblem
MoFEMErrorCode buildSubProblem(const std::string out_name, const std::vector< std::string > &fields_row, const std::vector< std::string > &fields_col, const std::string main_problem, const bool square_matrix=true, const map< std::string, boost::shared_ptr< Range > > *entityMapRow=nullptr, const map< std::string, boost::shared_ptr< Range > > *entityMapCol=nullptr, int verb=VERBOSE)
build sub problem
Definition: ProblemsManager.cpp:983
MoFEM::ProblemsManager::partitionProblem
MoFEMErrorCode partitionProblem(const std::string name, int verb=VERBOSE)
partition problem dofs (collective)
Definition: ProblemsManager.cpp:1685
MoFEM::ProblemsManager::partitionGhostDofsOnDistributedMesh
MoFEMErrorCode partitionGhostDofsOnDistributedMesh(const std::string name, int verb=VERBOSE)
determine ghost nodes on distributed meshes
Definition: ProblemsManager.cpp:2475
MoFEM::ProblemsManager::partitionFiniteElements
MoFEMErrorCode partitionFiniteElements(const std::string name, bool part_from_moab=false, int low_proc=-1, int hi_proc=-1, int verb=VERBOSE)
partition finite elements
Definition: ProblemsManager.cpp:2169
MoFEM::CoreInterface::add_problem
virtual MoFEMErrorCode add_problem(const std::string &name, enum MoFEMTypes bh=MF_EXCL, int verb=DEFAULT_VERBOSITY)=0
Add problem.
MoFEM::CoreInterface::modify_problem_unset_finite_element
virtual MoFEMErrorCode modify_problem_unset_finite_element(const std::string name_problem, const std::string &fe_name)=0
unset finite element from problem, this remove entities assigned to finite element to a particular pr...
MoFEM::CoreInterface::delete_problem
virtual MoFEMErrorCode delete_problem(const std::string name)=0
Delete problem.
MoFEM::CoreInterface::modify_problem_ref_level_add_bit
virtual MoFEMErrorCode modify_problem_ref_level_add_bit(const std::string &name_problem, const BitRefLevel &bit)=0
add ref level to problem
MoFEM::CoreInterface::check_problem
virtual bool check_problem(const std::string name)=0
check if problem exist
MoFEM::CoreInterface::modify_problem_mask_ref_level_add_bit
virtual MoFEMErrorCode modify_problem_mask_ref_level_add_bit(const std::string &name_problem, const BitRefLevel &bit)=0
set dof mask ref level for problem
MoFEM::CoreInterface::modify_problem_add_finite_element
virtual MoFEMErrorCode modify_problem_add_finite_element(const std::string name_problem, const std::string &fe_name)=0
add finite element to problem, this add entities assigned to finite element to a particular problem
ts_ctx
MoFEM::TsCtx * ts_ctx
Definition: level_set.cpp:1876
l
FTensor::Index< 'l', 3 > l
Definition: matrix_function.cpp:21
MoFEM::Exceptions::ierr
static MoFEMErrorCodeGeneric< PetscErrorCode > ierr
Definition: Exceptions.hpp:76
MoFEM::Exceptions::MoFEMErrorCode
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
Definition: Exceptions.hpp:56
MoFEM::Types::BitRefLevel
std::bitset< BITREFLEVEL_SIZE > BitRefLevel
Bit structure attached to each entity identifying to what mesh entity is attached.
Definition: Types.hpp:40
MoFEM
implementation of Data Operators for Forces and Sources
Definition: Common.hpp:10
MoFEM::DMMoFEMTSSetMonitor
PetscErrorCode DMMoFEMTSSetMonitor(DM dm, TS ts, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
Set Monitor To TS solver.
Definition: DMMoFEM.cpp:1044
MoFEM::TsSetIJacobian
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.
Definition: TsCtx.cpp:129
MoFEM::TsMonitorSet
PetscErrorCode TsMonitorSet(TS ts, PetscInt step, PetscReal t, Vec u, void *ctx)
Set monitor for TS solver.
Definition: TsCtx.cpp:219
MoFEM::DMMoFEMTSSetRHSFunction
PetscErrorCode DMMoFEMTSSetRHSFunction(DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
set TS the right hand side function
Definition: DMMoFEM.cpp:870
MoFEM::SnesMat
PetscErrorCode SnesMat(SNES snes, Vec x, Mat A, Mat B, void *ctx)
This is MoFEM implementation for the left hand side (tangent matrix) evaluation in SNES solver.
Definition: SnesCtx.cpp:136
MoFEM::DMMoFEMSetDestroyProblem
PetscErrorCode DMMoFEMSetDestroyProblem(DM dm, PetscBool destroy_problem)
Definition: DMMoFEM.cpp:426
MoFEM::DMMoFEMGetDestroyProblem
PetscErrorCode DMMoFEMGetDestroyProblem(DM dm, PetscBool *destroy_problem)
Definition: DMMoFEM.cpp:435
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:563
MoFEM::TsSetRHSFunction
PetscErrorCode TsSetRHSFunction(TS ts, PetscReal t, Vec u, Vec F, void *ctx)
TS solver function.
Definition: TsCtx.cpp:278
MoFEM::SnesRhs
PetscErrorCode SnesRhs(SNES snes, Vec x, Vec f, void *ctx)
This is MoFEM implementation for the right hand side (residual vector) evaluation in SNES solver.
Definition: SnesCtx.cpp:27
MoFEM::DMMoFEMGetSubRowIS
PetscErrorCode DMMoFEMGetSubRowIS(DM dm, IS *is)
get sub problem is
Definition: DMMoFEM.cpp:319
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:25
MoFEM::DMMoFEMGetSubColIS
PetscErrorCode DMMoFEMGetSubColIS(DM dm, IS *is)
get sub problem is
Definition: DMMoFEM.cpp:337
MoFEM::KspRhs
PetscErrorCode KspRhs(KSP ksp, Vec f, void *ctx)
Run over elements in the lists.
Definition: KspCtx.cpp:21
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 Jaconian for second order PDE in time.
Definition: TsCtx.cpp:466
MoFEM::KspMat
PetscErrorCode KspMat(KSP ksp, Mat A, Mat B, void *ctx)
Run over elenents in the list.
Definition: KspCtx.cpp:85
MoFEM::TsSetRHSJacobian
PetscErrorCode TsSetRHSJacobian(TS ts, PetscReal t, Vec u, Mat A, Mat B, void *ctx)
TS solver function.
Definition: TsCtx.cpp:377
MoFEM::DMMoFEMTSSetRHSJacobian
PetscErrorCode DMMoFEMTSSetRHSJacobian(DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
set TS the right hand side jacobian
Definition: DMMoFEM.cpp:910
MoFEM::DMMoFEMSetVerbosity
PetscErrorCode DMMoFEMSetVerbosity(DM dm, const int verb)
Set verbosity level.
Definition: DMMoFEM.cpp:1491
MoFEM::DMMoFEMSwapDMCtx
PetscErrorCode DMMoFEMSwapDMCtx(DM dm, DM dm_swap)
Swap internal data struture.
Definition: DMMoFEM.cpp:202
MoFEM::DMMoFEMDuplicateDMCtx
PetscErrorCode DMMoFEMDuplicateDMCtx(DM dm, DM dm_duplicate)
Duplicate internal data struture.
Definition: DMMoFEM.cpp:184
MoFEM::CacheTupleWeakPtr
boost::weak_ptr< CacheTuple > CacheTupleWeakPtr
Definition: FEMultiIndices.hpp:494
field_name
constexpr auto field_name
Definition: poisson_2d_homogeneous.cpp:13
g
constexpr double g
Definition: shallow_wave.cpp:63
MoFEM::BasicMethod
Data structure to exchange data between mofem and User Loop Methods.
Definition: LoopMethods.hpp:183
MoFEM::CommInterface
Managing BitRefLevels.
Definition: CommInterface.hpp:21
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::CoreInterface::get_comm
virtual MPI_Comm & get_comm() const =0
MoFEM::DMCtx
PETSc Discrete Manager data structure.
Definition: DMMoFEM.hpp:924
MoFEM::DMCtx::isCompDM
PetscBool isCompDM
Definition: DMMoFEM.hpp:948
MoFEM::DMCtx::problemName
std::string problemName
Problem name.
Definition: DMMoFEM.hpp:931
MoFEM::DMCtx::problemPtr
const Problem * problemPtr
pinter to problem data structure
Definition: DMMoFEM.hpp:940
MoFEM::DMCtx::rowCompPrb
std::vector< std::string > rowCompPrb
Definition: DMMoFEM.hpp:949
MoFEM::DMCtx::snesCtx
boost::shared_ptr< SnesCtx > snesCtx
data structure SNES
Definition: DMMoFEM.hpp:963
MoFEM::DMCtx::tsCtx
boost::shared_ptr< TsCtx > tsCtx
data structure for TS solver
Definition: DMMoFEM.hpp:964
MoFEM::DMCtx::isSquareMatrix
PetscBool isSquareMatrix
true if rows equals to cols
Definition: DMMoFEM.hpp:935
MoFEM::DMCtx::isPartitioned
PetscBool isPartitioned
true if read mesh is on parts
Definition: DMMoFEM.hpp:934
MoFEM::DMCtx::isSubDM
PetscBool isSubDM
Definition: DMMoFEM.hpp:943
MoFEM::DMCtx::referenceNumber
int referenceNumber
Definition: DMMoFEM.hpp:960
MoFEM::DMCtx::verbosity
int verbosity
verbosity
Definition: DMMoFEM.hpp:959
MoFEM::DMCtx::isProblemBuild
PetscBool isProblemBuild
True if problem is build.
Definition: DMMoFEM.hpp:930
MoFEM::DMCtx::mField_ptr
Interface * mField_ptr
MoFEM interface.
Definition: DMMoFEM.hpp:929
MoFEM::DMCtx::kspCtx
boost::shared_ptr< KspCtx > kspCtx
data structure KSP
Definition: DMMoFEM.hpp:962
MoFEM::DMCtx::colCompPrb
std::vector< std::string > colCompPrb
Definition: DMMoFEM.hpp:950
MoFEM::DMCtx::query_interface
MoFEMErrorCode query_interface(boost::typeindex::type_index type_index, UnknownInterface **iface) const
Definition: DMMoFEM.cpp:41
MoFEM::DMCtx::colFields
std::vector< std::string > colFields
Definition: DMMoFEM.hpp:945
MoFEM::DMCtx::destroyProblem
PetscBool destroyProblem
If true destroy problem with DM.
Definition: DMMoFEM.hpp:954
MoFEM::DMCtx::rowFields
std::vector< std::string > rowFields
Definition: DMMoFEM.hpp:944
MoFEM::DMCtx::mapTypeRow
std::map< std::string, boost::shared_ptr< Range > > mapTypeRow
Definition: DMMoFEM.hpp:951
MoFEM::DMCtx::problemMainOfSubPtr
const Problem * problemMainOfSubPtr
pinter to main problem to sub-problem
Definition: DMMoFEM.hpp:946
MoFEM::DMCtx::mapTypeCol
std::map< std::string, boost::shared_ptr< Range > > mapTypeCol
Definition: DMMoFEM.hpp:952
MoFEM::DeprecatedCoreInterface
Deprecated interface functions.
Definition: DeprecatedCoreInterface.hpp:16
MoFEM::DofMethod
Data structure to exchange data between mofem and User Loop Methods on entities.
Definition: LoopMethods.hpp:493
MoFEM::FEMethod
structure for User Loop Methods on finite elements
Definition: LoopMethods.hpp:369
MoFEM::ISManager
Section manager is used to create indexes and sections.
Definition: ISManager.hpp:23
MoFEM::KspCtx
Interface for linear (KSP) solver.
Definition: KspCtx.hpp:15
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:300
MoFEM::LogManager::getStrmWorld
static boost::shared_ptr< std::ostream > getStrmWorld()
Get the strm world object.
Definition: LogManager.cpp:346
MoFEM::LogManager::getStrmSync
static boost::shared_ptr< std::ostream > getStrmSync()
Get the strm sync object.
Definition: LogManager.cpp:350
MoFEM::LogManager::checkIfChannelExist
static bool checkIfChannelExist(const std::string channel)
Check if channel exist.
Definition: LogManager.cpp:401
MoFEM::LogManager::getStrmSelf
static boost::shared_ptr< std::ostream > getStrmSelf()
Get the strm self object.
Definition: LogManager.cpp:342
MoFEM::MatrixManager
Matrix manager is used to build and partition problems.
Definition: MatrixManager.hpp:21
MoFEM::Problem
keeps basic data about problem
Definition: ProblemsMultiIndices.hpp:40
MoFEM::Problem::getNbLocalDofsRow
DofIdx getNbLocalDofsRow() const
Definition: ProblemsMultiIndices.hpp:356
MoFEM::Problem::getNumberOfElementsByNameAndPart
MoFEMErrorCode getNumberOfElementsByNameAndPart(MPI_Comm comm, const std::string name, PetscLayout *layout) const
Get number of finite elements by name on processors.
Definition: ProblemsMultiIndices.cpp:117
MoFEM::Problem::getBitRefLevel
BitRefLevel getBitRefLevel() const
Definition: ProblemsMultiIndices.hpp:361
MoFEM::Problem::getBitRefLevelMask
BitRefLevel getBitRefLevelMask() const
Definition: ProblemsMultiIndices.hpp:362
MoFEM::Problem::getSubData
boost::shared_ptr< SubProblemData > & getSubData() const
Get main problem of sub-problem is.
Definition: ProblemsMultiIndices.hpp:97
MoFEM::Problem::getNbGhostDofsRow
DofIdx getNbGhostDofsRow() const
Definition: ProblemsMultiIndices.hpp:358
MoFEM::ProblemsManager
Problem manager is used to build and partition problems.
Definition: ProblemsManager.hpp:21
MoFEM::SmartPetscObj
intrusive_ptr for managing petsc objects
Definition: PetscSmartObj.hpp:81
MoFEM::SnesCtx
Interface for nonlinear (SNES) solver.
Definition: SnesCtx.hpp:13
MoFEM::TsCtx
Interface for Time Stepping (TS) solver.
Definition: TsCtx.hpp:15
MoFEM::UnknownInterface
base class for all interface classes
Definition: UnknownInterface.hpp:34
MoFEM::UnknownInterface::getInterface
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface refernce 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.5 and hosted at University of Glasgow