v0.15.0
Loading...
Searching...
No Matches
Namespaces | Macros
DeleteCore.cpp File Reference

Core interface methods for managing deletions and insertion dofs. More...

#include <MoFEM.hpp>

Go to the source code of this file.

Namespaces

namespace  MoFEM
 implementation of Data Operators for Forces and Sources
 

Macros

#define DeleteCoreFunctionBegin
 

Detailed Description

Core interface methods for managing deletions and insertion dofs.

Note
If entity/dof/finite element is cleared it mean that is erased from multi-index database
If entity/dof/finite element is removed is is clearded and removed from field or finite element meshset
If entity if deleted is cleated, removed and deleted from MoAB database.
Todo:
Implement tag_field_delete, tag_field_delete_by_bit_ref to remove field tags from entities. This is for entities which are as well removed, thus cleared as well.

Definition in file DeleteCore.cpp.

Macro Definition Documentation

◆ DeleteCoreFunctionBegin

#define DeleteCoreFunctionBegin
Value:
MoFEMFunctionBegin; \
MOFEM_LOG_CHANNEL("WORLD"); \
MOFEM_LOG_FUNCTION(); \
MOFEM_LOG_TAG("WORLD", "DeleteCore");
MoFEMFunctionBegin
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition definitions.h:359

Definition at line 21 of file DeleteCore.cpp.

26 {
27
28MoFEMErrorCode Core::clear_inactive_dofs(int verb) {
29 MoFEMFunctionBegin;
30 if (verb == -1)
31 verb = verbose;
32 Range ents;
33 for (DofEntity_multiIndex::iterator dit = dofsField.begin();
34 dit != dofsField.end();) {
35 if (!dit->get()->getActive()) {
36 dit = dofsField.erase(dit);
37 } else {
38 ++dit;
39 }
40 }
41 MoFEMFunctionReturn(0);
42}
43
44MoFEMErrorCode Core::clear_dofs_fields_by_bit_ref(const BitRefLevel bit,
45 const BitRefLevel mask,
46 int verb) {
47 MoFEMFunctionBeginHot;
48 if (verb == -1)
49 verb = verbose;
50 Range ents;
51 CHKERR BitRefManager(*this).getEntitiesByRefLevel(bit, mask, ents, verb);
52 CHKERR clear_dofs_fields(ents, verb);
53 MoFEMFunctionReturnHot(0);
54}
55
56MoFEMErrorCode Core::clear_dofs_fields(const Range ents, int verb) {
57 MoFEMFunctionBeginHot;
58 if (verb == -1)
59 verb = verbose;
60
61 for (Range::const_pair_iterator p_eit = ents.pair_begin();
62 p_eit != ents.pair_end(); p_eit++) {
63 EntityHandle first = p_eit->first;
64 EntityHandle second = p_eit->second;
65 // get dofs range
66 DofEntityByEnt::iterator dit, hi_dit;
67 dit = dofsField.get<Ent_mi_tag>().lower_bound(first);
68 if (dit == dofsField.get<Ent_mi_tag>().end())
69 continue;
70 hi_dit = dofsField.get<Ent_mi_tag>().upper_bound(second);
71 // finally clear dofs
72 dofsField.get<Ent_mi_tag>().erase(dit, hi_dit);
73 }
74 MoFEMFunctionReturnHot(0);
75}
76
77MoFEMErrorCode Core::clear_dofs_fields(const std::string name, const Range ents,
78 int verb) {
79 MoFEMFunctionBeginHot;
80 if (verb == -1)
81 verb = verbose;
82
83 const auto bit_number = get_field_bit_number(name);
84
85 for (Range::const_pair_iterator p_eit = ents.pair_begin();
86 p_eit != ents.pair_end(); p_eit++) {
87 const auto first = p_eit->first;
88 const auto second = p_eit->second;
89 const auto lo_uid = DofEntity::getLoFieldEntityUId(bit_number, first);
90 const auto hi_uid = DofEntity::getHiFieldEntityUId(bit_number, second);
91 auto dit = dofsField.get<Unique_mi_tag>().lower_bound(lo_uid);
92 auto hi_dit = dofsField.get<Unique_mi_tag>().upper_bound(hi_uid);
93 dofsField.get<Unique_mi_tag>().erase(dit, hi_dit);
94 }
95 MoFEMFunctionReturnHot(0);
96}
97
98MoFEMErrorCode Core::clear_ents_fields_by_bit_ref(const BitRefLevel bit,
99 const BitRefLevel mask,
100 int verb) {
101 MoFEMFunctionBegin;
102 if (verb == -1)
103 verb = verbose;
104 Range ents;
105 CHKERR BitRefManager(*this).getEntitiesByRefLevel(bit, mask, ents, verb);
106 CHKERR clear_dofs_fields(ents, verb);
107 CHKERR clear_adjacencies_entities(ents, verb);
108 CHKERR clear_ents_fields(ents, verb);
109 MoFEMFunctionReturn(0);
110}
111
112MoFEMErrorCode Core::clear_ents_fields(const Range ents, int verb) {
113 MoFEMFunctionBegin;
114 if (verb == -1)
115 verb = verbose;
116 CHKERR clear_dofs_fields(ents, verb);
117 CHKERR clear_adjacencies_entities(ents, verb);
118 for (Range::const_pair_iterator p_eit = ents.pair_begin();
119 p_eit != ents.pair_end(); p_eit++) {
120 EntityHandle first = p_eit->first;
121 EntityHandle second = p_eit->second;
122 FieldEntity_multiIndex::index<Ent_mi_tag>::type::iterator dit, hi_dit;
123 dit = entsFields.get<Ent_mi_tag>().lower_bound(first);
124 hi_dit = entsFields.get<Ent_mi_tag>().upper_bound(second);
125 entsFields.get<Ent_mi_tag>().erase(dit, hi_dit);
126 }
127 MoFEMFunctionReturn(0);
128}
129
130MoFEMErrorCode Core::clear_ents_fields(const std::string name, const Range ents,
131 int verb) {
132 MoFEMFunctionBegin;
133 if (verb == -1)
134 verb = verbose;
135 const auto bit_number = get_field_bit_number(name);
136 CHKERR clear_dofs_fields(name, ents, verb);
137 CHKERR clear_adjacencies_entities(name, ents, verb);
138 for (Range::const_pair_iterator p_eit = ents.pair_begin();
139 p_eit != ents.pair_end(); p_eit++) {
140 const auto first = p_eit->first;
141 const auto second = p_eit->second;
142 auto dit = entsFields.get<Unique_mi_tag>().lower_bound(
143 FieldEntity::getLocalUniqueIdCalculate(bit_number, first));
144 auto hi_dit = entsFields.get<Unique_mi_tag>().upper_bound(
145 FieldEntity::getLocalUniqueIdCalculate(bit_number, second));
146 entsFields.get<Unique_mi_tag>().erase(dit, hi_dit);
147 }
148 MoFEMFunctionReturn(0);
149}
150
151MoFEMErrorCode Core::remove_ents_from_field(const std::string name,
152 const EntityHandle meshset,
153 const EntityType type, int verb) {
154 MoFEMFunctionBegin;
155 if (verb == -1)
156 verb = verbose;
157 Range ents;
158 CHKERR get_moab().get_entities_by_type(meshset, type, ents);
159 CHKERR remove_ents_from_field(name, ents, verb);
160 MoFEMFunctionReturn(0);
161}
162
163MoFEMErrorCode Core::remove_ents_from_field(const std::string name,
164 const Range ents, int verb) {
165 MoFEMFunctionBegin;
166 if (verb == -1)
167 verb = verbose;
168 EntityHandle meshset;
169 meshset = get_field_meshset(name);
170 CHKERR clear_ents_fields(name, ents, verb);
171 CHKERR get_moab().remove_entities(meshset, ents);
172 MoFEMFunctionReturn(0);
173}
174
175MoFEMErrorCode Core::remove_ents_from_field(const Range ents, int verb) {
176 MoFEMFunctionBegin;
177 if (verb == -1)
178 verb = verbose;
179 CHKERR clear_ents_fields(ents, verb);
180 for (Field_multiIndex::iterator fit = fIelds.begin(); fit != fIelds.end();
181 fit++) {
182 EntityHandle meshset = fit->get()->getMeshset();
183 CHKERR get_moab().remove_entities(meshset, ents);
184 }
185 MoFEMFunctionReturn(0);
186}
187
188MoFEMErrorCode Core::remove_ents_from_field_by_bit_ref(const BitRefLevel bit,
189 const BitRefLevel mask,
190 int verb) {
191 MoFEMFunctionBegin;
192 if (verb == -1)
193 verb = verbose;
194 Range ents;
195 CHKERR BitRefManager(*this).getEntitiesByRefLevel(bit, mask, ents, verb);
196 CHKERR remove_ents_from_field(ents, verb);
197 MoFEMFunctionReturn(0);
198}
199
200MoFEMErrorCode Core::clear_adjacencies_entities(const BitRefLevel bit,
201 const BitRefLevel mask,
202 int verb) {
203 MoFEMFunctionBegin;
204 if (verb == -1)
205 verb = verbose;
206 Range ents;
207 CHKERR BitRefManager(*this).getEntitiesByRefLevel(bit, mask, ents, verb);
208 CHKERR clear_adjacencies_entities(ents, verb);
209 MoFEMFunctionReturn(0);
210}
211
212MoFEMErrorCode Core::clear_adjacencies_entities(const Range ents, int verb) {
213 MoFEMFunctionBeginHot;
214 if (verb == -1)
215 verb = verbose;
216 for (Range::const_pair_iterator p_eit = ents.pair_begin();
217 p_eit != ents.pair_end(); ++p_eit) {
218 const EntityHandle first = p_eit->first;
219 const EntityHandle second = p_eit->second;
220 FieldEntityEntFiniteElementAdjacencyMap_multiIndex::index<
221 Ent_mi_tag>::type::iterator ait,
222 hi_ait;
223 ait = entFEAdjacencies.get<Ent_mi_tag>().lower_bound(first);
224 hi_ait = entFEAdjacencies.get<Ent_mi_tag>().upper_bound(second);
225 entFEAdjacencies.get<Ent_mi_tag>().erase(ait, hi_ait);
226 }
227 MoFEMFunctionReturnHot(0);
228}
229
230MoFEMErrorCode Core::clear_adjacencies_entities(const std::string name,
231 const Range ents, int verb) {
232 MoFEMFunctionBeginHot;
233 if (verb == -1)
234 verb = verbose;
235
236 const Field *field_ptr = get_field_structure(name);
237 int field_bit_number = field_ptr->getBitNumber();
238
239 for (Range::const_pair_iterator p_eit = ents.pair_begin();
240 p_eit != ents.pair_end(); p_eit++) {
241
242 // First and last handle
243 const EntityHandle first = p_eit->first;
244 const EntityHandle second = p_eit->second;
245
246 // Get UId
247 UId first_uid =
248 FieldEntity::getLocalUniqueIdCalculate(field_bit_number, first);
249 UId second_uid =
250 FieldEntity::getLocalUniqueIdCalculate(field_bit_number, second);
251
252 // Find adjacencies
253 auto ait = entFEAdjacencies.get<Unique_mi_tag>().lower_bound(first_uid);
254 auto hi_ait = entFEAdjacencies.get<Unique_mi_tag>().upper_bound(second_uid);
255 entFEAdjacencies.get<Unique_mi_tag>().erase(ait, hi_ait);
256 }
257 MoFEMFunctionReturnHot(0);
258}
259
260MoFEMErrorCode Core::clear_finite_elements_by_bit_ref(const BitRefLevel bit,
261 const BitRefLevel mask,
262 int verb) {
263 MoFEMFunctionBegin;
264 if (verb == -1)
265 verb = verbose;
266 Range ents;
267 CHKERR BitRefManager(*this).getEntitiesByRefLevel(bit, mask, ents, verb);
268 CHKERR clear_finite_elements(ents, verb);
269 MoFEMFunctionReturn(0);
270}
271
272MoFEMErrorCode Core::clear_finite_elements(const Range &ents, int verb) {
273 MoFEMFunctionBegin;
274 if (verb == -1)
275 verb = verbose;
276 CHKERR clear_adjacencies_finite_elements(ents, verb);
277 for (Range::const_pair_iterator p_eit = ents.pair_begin();
278 p_eit != ents.pair_end(); p_eit++) {
279 EntityHandle first = p_eit->first;
280 EntityHandle second = p_eit->second;
281 EntFiniteElement_multiIndex::index<Ent_mi_tag>::type::iterator fit, hi_fit;
282 fit = entsFiniteElements.get<Ent_mi_tag>().lower_bound(first);
283 hi_fit = entsFiniteElements.get<Ent_mi_tag>().upper_bound(second);
284 entsFiniteElements.get<Ent_mi_tag>().erase(fit, hi_fit);
285 }
286 MoFEMFunctionReturn(0);
287}
288
289MoFEMErrorCode Core::clear_finite_elements(const std::string &fe_name,
290 const Range &ents, int verb) {
291 MoFEMFunctionBegin;
292 if (verb == -1)
293 verb = verbose;
294 CHKERR clear_adjacencies_finite_elements(fe_name, ents, verb);
295 auto fe_miit = finiteElements.get<FiniteElement_name_mi_tag>().find(fe_name);
296 if (fe_miit == finiteElements.get<FiniteElement_name_mi_tag>().end()) {
297 for (Range::const_pair_iterator p_eit = ents.pair_begin();
298 p_eit != ents.pair_end(); p_eit++) {
299 auto fit = entsFiniteElements.get<Unique_mi_tag>().lower_bound(
300 EntFiniteElement::getLocalUniqueIdCalculate(p_eit->first,
301 (*fe_miit)->getFEUId()));
302 auto hi_fit = entsFiniteElements.get<Unique_mi_tag>().upper_bound(
303 EntFiniteElement::getLocalUniqueIdCalculate(p_eit->second,
304 (*fe_miit)->getFEUId()));
305 fit = entsFiniteElements.get<Unique_mi_tag>().erase(fit, hi_fit);
306 }
307 }
308 MoFEMFunctionReturn(0);
309}
310
311MoFEMErrorCode Core::clear_adjacencies_finite_elements(const BitRefLevel bit,
312 const BitRefLevel mask,
313 int verb) {
314 MoFEMFunctionBegin;
315 Range ents;
316 CHKERR BitRefManager(*this).getEntitiesByRefLevel(bit, mask, ents, verb);
317 CHKERR clear_adjacencies_finite_elements(ents, verb);
318 MoFEMFunctionReturn(0);
319}
320
321MoFEMErrorCode Core::clear_adjacencies_finite_elements(const Range ents,
322 int verb) {
323 MoFEMFunctionBeginHot;
324 if (verb == -1)
325 verb = verbose;
326 for (Range::const_pair_iterator p_eit = ents.pair_begin();
327 p_eit != ents.pair_end(); p_eit++) {
328 EntityHandle first = p_eit->first;
329 EntityHandle second = p_eit->second;
330 FieldEntityEntFiniteElementAdjacencyMap_multiIndex::index<
331 FEEnt_mi_tag>::type::iterator ait,
332 hi_ait;
333 ait = entFEAdjacencies.get<FEEnt_mi_tag>().lower_bound(first);
334 hi_ait = entFEAdjacencies.get<FEEnt_mi_tag>().upper_bound(second);
335 entFEAdjacencies.get<FEEnt_mi_tag>().erase(ait, hi_ait);
336 }
337 MoFEMFunctionReturnHot(0);
338}
339
340MoFEMErrorCode Core::clear_adjacencies_finite_elements(const std::string name,
341 const Range ents,
342 int verb) {
343 MoFEMFunctionBeginHot;
344 if (verb == -1)
345 verb = verbose;
346
347 FiniteElement_multiIndex::index<FiniteElement_name_mi_tag>::type::iterator
348 it_fe = finiteElements.get<FiniteElement_name_mi_tag>().find(name);
349 if (it_fe != finiteElements.get<FiniteElement_name_mi_tag>().end()) {
350
351 const auto fe_uid = (*it_fe)->getFEUId();
352
353 for (Range::const_pair_iterator p_eit = ents.pair_begin();
354 p_eit != ents.pair_end(); p_eit++) {
355
356 // First and last handle
357 const EntityHandle first = p_eit->first;
358 const EntityHandle second = p_eit->second;
359
360 // Get UId
361 UId first_uid =
362 EntFiniteElement::getLocalUniqueIdCalculate(first, fe_uid);
363 UId second_uid =
364 EntFiniteElement::getLocalUniqueIdCalculate(second, fe_uid);
365
366 // Find and remove adjacencies
367 FieldEntityEntFiniteElementAdjacencyMap_multiIndex::index<
368 FE_Unique_mi_tag>::type::iterator ait,
369 hi_ait;
370 ait = entFEAdjacencies.get<FE_Unique_mi_tag>().lower_bound(first_uid);
371 hi_ait = entFEAdjacencies.get<FE_Unique_mi_tag>().upper_bound(second_uid);
372 entFEAdjacencies.get<FE_Unique_mi_tag>().erase(ait, hi_ait);
373 }
374 }
375 MoFEMFunctionReturnHot(0);
376}
377
378MoFEMErrorCode Core::remove_ents_from_finite_element(const std::string name,
379 const EntityHandle meshset,
380 const EntityType type,
381 int verb) {
382 MoFEMFunctionBegin;
383 if (verb == -1)
384 verb = verbose;
385 Range ents;
386 CHKERR get_moab().get_entities_by_type(meshset, type, ents, false);
387 CHKERR remove_ents_from_finite_element(name, ents, verb);
388 MoFEMFunctionReturn(0);
389}
390
391MoFEMErrorCode Core::remove_ents_from_finite_element(const std::string name,
392 const Range ents,
393 int verb) {
394 MoFEMFunctionBegin;
395 if (verb == -1)
396 verb = verbose;
397 CHKERR clear_finite_elements(name, ents, verb);
398 const EntityHandle idm = get_finite_element_meshset(name);
399 CHKERR get_moab().remove_entities(idm, ents);
400 MoFEMFunctionReturn(0);
401}
402
403MoFEMErrorCode Core::remove_ents_from_finite_element(const Range ents,
404 int verb) {
405 MoFEMFunctionBegin;
406 if (verb == -1)
407 verb = verbose;
408 CHKERR clear_finite_elements(ents, verb);
409 for (FiniteElement_multiIndex::iterator fe_it = finiteElements.begin();
410 fe_it != finiteElements.end(); fe_it++) {
411 EntityHandle meshset = fe_it->get()->getMeshset();
412 CHKERR get_moab().remove_entities(meshset, ents);
413 }
414 MoFEMFunctionReturn(0);
415}
416
417MoFEMErrorCode Core::remove_ents_from_finite_element_by_bit_ref(
418 const BitRefLevel bit, const BitRefLevel mask, int verb) {
419 MoFEMFunctionBegin;
420 if (verb == -1)
421 verb = verbose;
422 Range ents;
423 CHKERR BitRefManager(*this).getEntitiesByRefLevel(bit, mask, ents, verb);
424 CHKERR remove_ents_from_finite_element(ents, verb);
425 MoFEMFunctionReturn(0);
426}
427
428MoFEMErrorCode Core::remove_ents(const Range ents, int verb) {
429 MoFEMFunctionBegin;
430 if (verb == -1)
431 verb = verbose;
432 CHKERR remove_ents_from_finite_element(ents, verb);
433 CHKERR remove_ents_from_field(ents, verb);
434
435 for (Range::const_pair_iterator p_eit = ents.pair_begin();
436 p_eit != ents.pair_end(); ++p_eit) {
437
438 RefElement_multiIndex::index<Ent_mi_tag>::type::iterator frit, hi_frit;
439 frit = refinedFiniteElements.get<Ent_mi_tag>().lower_bound(p_eit->first);
440 hi_frit =
441 refinedFiniteElements.get<Ent_mi_tag>().upper_bound(p_eit->second);
442 refinedFiniteElements.get<Ent_mi_tag>().erase(frit, hi_frit);
443
444 RefEntity_multiIndex::index<Ent_mi_tag>::type::iterator rit, hi_rit;
445 rit = refinedEntities.get<Ent_mi_tag>().lower_bound(p_eit->first);
446 hi_rit = refinedEntities.get<Ent_mi_tag>().upper_bound(p_eit->second);
447 refinedEntities.get<Ent_mi_tag>().erase(rit, hi_rit);
448 }
449
450 MoFEMFunctionReturn(0);
451}
452
453MoFEMErrorCode Core::remove_ents_by_bit_ref(const BitRefLevel bit,
454 const BitRefLevel mask, int verb) {
455 MoFEMFunctionBegin;
456 if (verb == -1)
457 verb = verbose;
458 Range ents;
459 CHKERR BitRefManager(*this).getEntitiesByRefLevel(bit, mask, ents, verb);
460 CHKERR remove_ents(ents, verb);
461 MoFEMFunctionReturn(0);
462}
463
464MoFEMErrorCode Core::remove_parents_by_bit_ref(const BitRefLevel bit,
465 const BitRefLevel mask,
466 int verb) {
467 MoFEMFunctionBegin;
468 if (verb == -1)
469 verb = verbose;
470 Range ents;
471 CHKERR BitRefManager(*this).getEntitiesByRefLevel(bit, mask, ents, verb);
472 CHKERR remove_parents_by_ents(ents, verb);
473 MoFEMFunctionReturn(0);
474}
475
476MoFEMErrorCode Core::remove_parents_by_ents(const Range &ents, int verb) {
477 MoFEMFunctionBegin;
478
479 std::vector<EntityHandle> leftovers_ents;
480 leftovers_ents.reserve(ents.size());
481
482 for (auto pit = ents.pair_begin(); pit != ents.pair_end(); ++pit) {
483
484 EntityHandle f = pit->first;
485 const EntityHandle s = pit->second;
486 auto lo = refinedEntities.lower_bound(f);
487 for (; f <= s; ++f) {
488
489 auto check = [this](auto lo, auto f) {
490 if (lo == refinedEntities.end())
491 return false;
492 if ((*lo)->getEnt() == f)
493 return true;
494 return false;
495 };
496
497 if (check(lo, f)) {
498 bool success = refinedEntities.modify(lo, RefEntity_change_parent(0));
499 if (!success)
500 SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
501 "Operation of removing parent unsuccessful");
502 ++lo;
503 } else
504 leftovers_ents.emplace_back(f);
505 }
506 }
507
508 if (!leftovers_ents.empty()) {
509 std::vector<EntityHandle> zero_parents(leftovers_ents.size());
510 CHKERR get_moab().tag_set_data(th_RefParentHandle, &leftovers_ents[0],
511 leftovers_ents.size(),
512 &*zero_parents.begin());
513 }
514 MoFEMFunctionReturn(0);
515}
516
517MoFEMErrorCode Core::remove_parents_by_parents(const Range &ents, int verb) {
518 MoFEMFunctionBegin;
519 for (Range::iterator eit = ents.begin(); eit != ents.end(); ++eit) {
520 RefEntity_multiIndex::index<Ent_Ent_mi_tag>::type::iterator it;
521 while ((it = refinedEntities.get<Ent_Ent_mi_tag>().find(*eit)) !=
522 refinedEntities.get<Ent_Ent_mi_tag>().end()) {
523 bool success = refinedEntities.get<Ent_Ent_mi_tag>().modify(
524 it, RefEntity_change_parent(0));
525 if (!success) {
526 SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
527 "Operation of removing parent unsuccessful");
528 }
529 }
530 }
531 MoFEMFunctionReturn(0);
532}
533
534MoFEMErrorCode Core::delete_ents_by_bit_ref(const BitRefLevel bit,
535 const BitRefLevel mask,
536 const bool remove_parent, int verb,
537 MoFEMTypes mf) {
538 DeleteCoreFunctionBegin;
539 if (verb == -1)
540 verb = verbose;
541
542 Range ents;
543 CHKERR BitRefManager(*this).getEntitiesByRefLevel(bit, mask, ents, verb);
544 Range ents_meshsets = ents.subset_by_type(MBENTITYSET);
545 ents = subtract(ents, ents_meshsets);
546 if(ents.empty()) {
547 if (verb >= VERBOSE)
548 MOFEM_LOG("WORLD", Sev::verbose) << "Nb. of deleted entities 0";
549 MoFEMFunctionReturnHot(0);
550 }
551
552 if (verb >= VERBOSE)
553 MOFEM_LOG("WORLD", Sev::noisy) << "Deleted ents:\n" << ents;
554
555 CHKERR remove_ents(ents, verb);
556
557 // remove parent
558 if (remove_parent) {
559 CHKERR remove_parents_by_parents(ents);
560 }
561
562 Range meshsets;
563 CHKERR get_moab().get_entities_by_type(0, MBENTITYSET, meshsets, true);
564 for (auto m : meshsets) {
565 CHKERR get_moab().remove_entities(m, ents);
566
567 }
568
569 rval = get_moab().delete_entities(ents);
570 if (rval != MB_SUCCESS) {
571 MOFEM_LOG_ATTRIBUTES("SELF", LogManager::BitScope);
572 if (verb == QUIET) {
573 MOFEM_LOG("SELF", Sev::noisy) << "Problem deleting:\n" << ents;
574 } else {
575 MOFEM_LOG("SELF", Sev::warning) << "Problem deleting:\n" << ents;
576 }
577 MOFEM_LOG_CHANNEL("WORLD");
578 MOFEM_LOG_TAG("WORLD", "DeleteCore");
579 if (!(mf & MF_NOT_THROW)) {
580 CHK_MOAB_THROW(rval, "Can not delete entities");
581 } else {
582 rval = MB_SUCCESS;
583 }
584 }
585
586 MOFEM_LOG_C("SELF", Sev::noisy, "Nb. of deleted entities %d", ents.size());
587
588 MoFEMFunctionReturn(0);
589}
590
591MoFEMErrorCode Core::delete_finite_element(const std::string name, int verb) {
592 MoFEMFunctionBegin;
593 auto &fe = finiteElements.get<FiniteElement_name_mi_tag>();
594 auto mit = fe.find(name);
595 if (mit == fe.end()) {
596 SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
597 "Finite element <%s> not found", name.c_str());
598 }
599 EntityHandle meshset = mit->get()->getMeshset();
600 Range ents;
601 CHKERR get_moab().get_entities_by_handle(meshset, ents, false);
602 CHKERR remove_ents_from_finite_element(name, ents, verb);
603 fe.erase(mit);
604 CHKERR get_moab().delete_entities(&meshset, 1);
605 MoFEMFunctionReturn(0);
606}
607
608MoFEMErrorCode Core::delete_field(const std::string name, int verb) {
609 MoFEMFunctionBegin;
610 auto &f = fIelds.get<FieldName_mi_tag>();
611 auto mit = f.find(name);
612 if (mit == f.end()) {
613 SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
614 "Finite element <%s> not found", name.c_str());
615 }
616 EntityHandle meshset = mit->get()->getMeshset();
617 Range ents;
618 CHKERR get_moab().get_entities_by_handle(meshset, ents, false);
619 CHKERR remove_ents_from_field(name, ents, verb);
620 CHKERR get_moab().tag_delete((*mit)->th_FieldDataVerts);
621 CHKERR get_moab().tag_delete((*mit)->th_FieldData);
622 CHKERR get_moab().tag_delete((*mit)->th_AppOrder);
623 f.erase(mit);
624 CHKERR get_moab().delete_entities(&meshset, 1);
625 MoFEMFunctionReturn(0);
626}
627} // namespace MoFEM
DeleteCoreFunctionBegin
#define DeleteCoreFunctionBegin
Definition DeleteCore.cpp:21
MOFEM_LOG_C
#define MOFEM_LOG_C(channel, severity, format,...)
Definition LogManager.hpp:319
QUIET
@ QUIET
Definition definitions.h:221
VERBOSE
@ VERBOSE
Definition definitions.h:222
MoFEMTypes
MoFEMTypes
Those types control how functions respond on arguments, f.e. error handling.
Definition definitions.h:110
MF_NOT_THROW
@ MF_NOT_THROW
Definition definitions.h:114
MoFEMFunctionReturnHot
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition definitions.h:463
CHK_MOAB_THROW
#define CHK_MOAB_THROW(err, msg)
Check error code of MoAB function and throw MoFEM exception.
Definition definitions.h:592
MOFEM_OPERATION_UNSUCCESSFUL
@ MOFEM_OPERATION_UNSUCCESSFUL
Definition definitions.h:34
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_LOG
#define MOFEM_LOG(channel, severity)
Log.
Definition LogManager.hpp:316
MOFEM_LOG_TAG
#define MOFEM_LOG_TAG(channel, tag)
Tag channel.
Definition LogManager.hpp:347
MOFEM_LOG_CHANNEL
#define MOFEM_LOG_CHANNEL(channel)
Set and reset channel.
Definition LogManager.hpp:292
MOFEM_LOG_ATTRIBUTES
#define MOFEM_LOG_ATTRIBUTES(channel, bit)
Add attributes to channel.
Definition LogManager.hpp:304
bit
auto bit
set bit
Definition hanging_node_approx.cpp:75
MoFEM::Exceptions::MoFEMErrorCode
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
Definition Exceptions.hpp:56
MoFEM::Types::UId
uint128_t UId
Unique Id.
Definition Types.hpp:31
m
FTensor::Index< 'm', 3 > m
Definition shallow_wave.cpp:80
Generated by Doxygen 1.9.8 and hosted at University of Glasgow