v0.15.0
Loading...
Searching...
No Matches
BitRefManager.cpp
Go to the documentation of this file.
1/** \file BitRefManager.cpp
2 * \brief Managing BitRefLevels
3 * \mofem_bit_ref
4 */
5
6namespace MoFEM {
7
9BitRefManager::query_interface(boost::typeindex::type_index type_index,
10 UnknownInterface **iface) const {
12 *iface = const_cast<BitRefManager *>(this);
14}
15
17 : cOre(const_cast<MoFEM::Core &>(core)), dEbug(false) {
18
19 if (!LogManager::checkIfChannelExist("BitRefSelf")) {
20 auto core_log = logging::core::get();
21 core_log->add_sink(
23 LogManager::setLog("BitRefSelf");
24 core_log->add_sink(
26 LogManager::setLog("BitRefWorld");
27 core_log->add_sink(
29 LogManager::setLog("BitRefSync");
30 MOFEM_LOG_TAG("BitRefSelf", "BitRefManager");
31 MOFEM_LOG_TAG("BitRefWorld", "BitRefManager");
32 MOFEM_LOG_TAG("BitRefSync", "BitRefManager");
33 }
34
36 MOFEM_LOG("BitRefWorld", Sev::noisy) << "BitRefManager interface created";
37}
38
39/// tool class with methods used more than twp times
41
43
44 const BitRefLevel &bIt; ///< bit to set
45 const RefEntity_multiIndex *refEntsPtr; ///< access to ents database
46 const RefElement_multiIndex *refElementPtr; ///< access to fe database
47
48 boost::shared_ptr<BasicEntityData> &baseEntData; ///< base entity data
49
50 /// constructor
52 const RefEntity_multiIndex *ref_ents_ptr,
53 const RefElement_multiIndex *ref_element_ptr)
54 : mField(m_field), bIt(bit), refEntsPtr(ref_ents_ptr),
55 refElementPtr(ref_element_ptr),
56 baseEntData(m_field.get_basic_entity_data_ptr()) {}
57
58 /// find entities and change entity bit if in database
60 Range &seed_ents_range) const {
61 // MoFEMFunctionBeginHot;
62
63 seed_ents_range.insert(f, s);
64 // get lower bound of multi-index
65 auto rit = refEntsPtr->lower_bound(f);
66 if (rit == refEntsPtr->end()) {
67 // all entities in range are added to database
68 // MoFEMFunctionReturnHot(0);
69 return 0;
70 } else {
71
72 // some entities from range are in database
73 auto hi_rit = refEntsPtr->upper_bound(s);
74
75 Range to_erase;
76 insertOrdered(to_erase, RefEntExtractor(), rit, hi_rit);
77 if (bIt.any())
78 for (; rit != hi_rit; ++rit)
79 const_cast<BitRefLevel &>((*rit)->getBitRefLevel()) |= bIt;
80
81 Range::iterator lo, hi = seed_ents_range.begin();
82 for (auto pt = to_erase.pair_begin(); pt != to_erase.pair_end(); ++pt) {
83 lo = seed_ents_range.lower_bound(hi, seed_ents_range.end(), pt->first);
84 if (lo != seed_ents_range.end()) {
85 hi = seed_ents_range.upper_bound(lo, seed_ents_range.end(),
86 pt->second);
87 seed_ents_range.erase(lo, hi);
88 } else
89 break;
90 }
91 }
92
93 // MoFEMFunctionReturnHot(0);
94 return 0;
95 }
96
97 /// add entities to database
98 template <int N>
99 MoFEMErrorCode addEntsToDatabaseImpl(const Range &seed_ents_range) const {
101 std::vector<boost::shared_ptr<RefEntity>> shared_ref_ents_vec;
102 shared_ref_ents_vec.reserve(seed_ents_range.size());
103 std::vector<const void *> tag_by_ptr;
104 for (Range::const_pair_iterator pit = seed_ents_range.pair_begin();
105 pit != seed_ents_range.pair_end(); pit++) {
106 // add entities to database
107 EntityHandle f = pit->first;
108 EntityHandle s = pit->second;
109
110 boost::shared_ptr<std::vector<RefEntityTmp<N>>> ref_ents_vec(
111 new std::vector<RefEntityTmp<N>>());
112 ref_ents_vec->reserve(s - f + 1);
113
114 tag_by_ptr.resize(s - f + 1);
115 CHKERR baseEntData->moab.tag_get_by_ptr(
116 baseEntData->th_RefParentHandle, Range(f, s), &*tag_by_ptr.begin());
117 auto tag_parent_it = tag_by_ptr.begin();
118 for (auto f : Range(f, s)) {
119 ref_ents_vec->emplace_back(
120 baseEntData, f,
121 const_cast<EntityHandle *>(
122 static_cast<const EntityHandle *>(*tag_parent_it)));
123 ++tag_parent_it;
124 }
125
126 // Set bits to range
127 if (bIt.any()) {
128 tag_by_ptr.resize(s - f + 1);
129 CHKERR baseEntData->moab.tag_get_by_ptr(
130 baseEntData->th_RefBitLevel, Range(f, s), &*tag_by_ptr.begin());
131 for (auto &v_bit_ptr : tag_by_ptr)
132 const_cast<BitRefLevel &>(
133 *(static_cast<const BitRefLevel *>(v_bit_ptr))) |= bIt;
134 }
135
136 for (auto &re : *ref_ents_vec)
137 shared_ref_ents_vec.emplace_back(ref_ents_vec,
138 static_cast<RefEntity *>(&re));
139 }
140 if (!shared_ref_ents_vec.empty()) {
141 int s0 = refEntsPtr->size();
142 const_cast<RefEntity_multiIndex *>(refEntsPtr)
143 ->insert(shared_ref_ents_vec.begin(), shared_ref_ents_vec.end());
144 if ((refEntsPtr->size() - s0) != shared_ref_ents_vec.size()) {
145 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
146 "Data inconsistency %ld != %ld", refEntsPtr->size() - s0,
147 shared_ref_ents_vec.size());
148 }
149 }
151 }
152
153 MoFEMErrorCode addEntsToDatabase(const Range &seed_ents_range) const {
155
156 switch (mField.getValue()) {
157 case -1:
159 case 0:
161 case 1:
163 default:
164 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
165 "Core index can vary from -1 to %d", MAX_CORE_TMP);
166 }
167
169 }
170
172 Range &seed_fe_range) const {
174 seed_fe_range.insert(f, s);
175 RefElement_multiIndex::iterator rit, hi_rit;
176 // get lower bound of multi-index
177 rit = refElementPtr->lower_bound(f);
178 if (rit == refElementPtr->end()) {
179 // all entities in range are added to database
181 } else {
182 // some entities from range are in database
183 hi_rit = refElementPtr->upper_bound(s);
184 for (; rit != hi_rit; ++rit) {
185 seed_fe_range.erase(rit->get()->getEnt());
186 }
187 }
189 }
190
193 std::vector<boost::shared_ptr<RefElement>> shared_ref_fe_vec;
194 shared_ref_fe_vec.reserve(seed_fe_range.size());
195 // create ref entity instances
196 for (Range::const_pair_iterator pit = seed_fe_range.const_pair_begin();
197 pit != seed_fe_range.const_pair_end(); ++pit) {
198 RefEntity_multiIndex::iterator rit, hi_rit;
199 rit = refEntsPtr->lower_bound(pit->first);
200 hi_rit = refEntsPtr->upper_bound(pit->second);
201 if (static_cast<int>(std::distance(rit, hi_rit)) !=
202 static_cast<int>(pit->second - pit->first + 1)) {
203 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
204 "data inconsistency %ld != %ld", std::distance(rit, hi_rit),
205 pit->second - pit->first + 1);
206 }
207 switch ((*rit)->getEntType()) {
208 case MBVERTEX: {
209 boost::shared_ptr<std::vector<RefElement_VERTEX>> ref_fe_vec =
210 boost::make_shared<std::vector<RefElement_VERTEX>>();
211 ref_fe_vec->reserve(pit->second - pit->first + 1);
212 for (; rit != hi_rit; ++rit) {
213 ref_fe_vec->push_back(RefElement_VERTEX(*rit));
214 shared_ref_fe_vec.push_back(
215 boost::shared_ptr<RefElement>(ref_fe_vec, &ref_fe_vec->back()));
216 }
217 } break;
218 case MBEDGE: {
219 boost::shared_ptr<std::vector<RefElement_EDGE>> ref_fe_vec =
220 boost::make_shared<std::vector<RefElement_EDGE>>();
221 ref_fe_vec->reserve(pit->second - pit->first + 1);
222 for (; rit != hi_rit; ++rit) {
223 ref_fe_vec->push_back(RefElement_EDGE(*rit));
224 shared_ref_fe_vec.push_back(
225 boost::shared_ptr<RefElement>(ref_fe_vec, &ref_fe_vec->back()));
226 }
227 } break;
228 case MBTRI:
229 case MBQUAD: {
230 boost::shared_ptr<std::vector<RefElementFace>> ref_fe_vec =
231 boost::make_shared<std::vector<RefElementFace>>();
232 ref_fe_vec->reserve(pit->second - pit->first + 1);
233 for (; rit != hi_rit; ++rit) {
234 ref_fe_vec->push_back(RefElementFace(*rit));
235 shared_ref_fe_vec.push_back(
236 boost::shared_ptr<RefElement>(ref_fe_vec, &ref_fe_vec->back()));
237 }
238 } break;
239 case MBTET:
240 case MBHEX: {
241 boost::shared_ptr<std::vector<RefElementVolume>> ref_fe_vec =
242 boost::make_shared<std::vector<RefElementVolume>>();
243 ref_fe_vec->reserve(pit->second - pit->first + 1);
244 for (; rit != hi_rit; ++rit) {
245 ref_fe_vec->push_back(RefElementVolume(*rit));
246 shared_ref_fe_vec.push_back(
247 boost::shared_ptr<RefElement>(ref_fe_vec, &ref_fe_vec->back()));
248 }
249 } break;
250 case MBPRISM: {
251 boost::shared_ptr<std::vector<RefElement_PRISM>> ref_fe_vec =
252 boost::make_shared<std::vector<RefElement_PRISM>>();
253 ref_fe_vec->reserve(pit->second - pit->first + 1);
254 for (; rit != hi_rit; ++rit) {
255 ref_fe_vec->push_back(RefElement_PRISM(*rit));
256 shared_ref_fe_vec.push_back(
257 boost::shared_ptr<RefElement>(ref_fe_vec, &ref_fe_vec->back()));
258 }
259 } break;
260 case MBENTITYSET: {
261 boost::shared_ptr<std::vector<RefElement_MESHSET>> ref_fe_vec =
262 boost::make_shared<std::vector<RefElement_MESHSET>>();
263 ref_fe_vec->reserve(pit->second - pit->first + 1);
264 for (; rit != hi_rit; ++rit) {
265 ref_fe_vec->push_back(RefElement_MESHSET(*rit));
266 shared_ref_fe_vec.push_back(
267 boost::shared_ptr<RefElement>(ref_fe_vec, &ref_fe_vec->back()));
268 }
269 } break;
270 default:
271 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED, "not implemented");
272 }
273 }
274 // add shared pointers to database
276 ->insert(shared_ref_fe_vec.begin(), shared_ref_fe_vec.end());
278 }
279};
280
282 const BitRefLevel bit,
283 const bool only_tets, int verb,
284 Range *adj_ents_ptr) const {
285 MoFEM::Interface &m_field = cOre;
286 auto ref_ents_ptr = m_field.get_ref_ents();
287 auto ref_fe_ptr = m_field.get_ref_finite_elements();
289
291 MOFEM_LOG_C("BitRefSelf", Sev::noisy, "Number of entities to add %d",
292 ents.size());
293
294 CHKERR setElementsBitRefLevel(ents, bit, verb);
295
296 if (!ents.empty()) {
297 for (int d = 3; d >= 1; --d) {
298 Range dim_ents;
299 if (only_tets && d == 3) {
300 dim_ents = ents.subset_by_type(MBTET);
301 } else {
302 dim_ents = ents.subset_by_dimension(d);
303 }
304
306 MOFEM_LOG_C("BitRefSelf", Sev::noisy,
307 " Number of dim %d entities to add %d", d,
308 dim_ents.size());
309
310 if (!dim_ents.empty()) {
311 for (int dd = 0; dd < d; ++dd) {
312 Range adj_ents;
313
314 if (dd == 0) {
315 rval = m_field.get_moab().get_connectivity(ents, adj_ents, true);
316
317 } else {
318 if (adj_ents_ptr) {
319 if (dd == 1) {
320 adj_ents = adj_ents_ptr->subset_by_dimension(MBEDGE);
321 } else if (dd == 2) {
322 adj_ents = adj_ents_ptr->subset_by_dimension(MBTRI);
323 }
324 } else {
325 rval = m_field.get_moab().get_adjacencies(
326 dim_ents, dd, true, adj_ents, moab::Interface::UNION);
327 }
328 }
329
330
332 MOFEM_LOG_C("BitRefSelf", Sev::noisy,
333 " Number of dim %d adj entities for dim %d to add %d",
334 d, dd, adj_ents.size());
335
336 if (rval == MB_MULTIPLE_ENTITIES_FOUND) {
337 auto log_message = [&](const auto sev) {
340 MOFEM_LOG("BitRefSelf", sev)
341 << "When get adjacencies moab return MB_MULTIPLE_ENTITIES_ "
342 "FOUND for dim = "
343 << dd << " and dim of entities " << d;
344 MOFEM_LOG_CHANNEL("BitRefSelf"); // reset channel
345 };
346
347 if (verb <= QUIET)
348 log_message(Sev::noisy);
349 else
350 log_message(Sev::warning);
351
352 rval = MB_SUCCESS;
353 }
355 for (Range::pair_iterator pit = adj_ents.pair_begin();
356 pit != adj_ents.pair_end(); ++pit) {
357 Range seed_ents_range;
358 // get first and last element of range
359 EntityHandle f = pit->first;
360 EntityHandle s = pit->second;
361 CHKERR SetBitRefLevelTool(m_field, bit, ref_ents_ptr, ref_fe_ptr)
362 .findEntsToAdd(f, s, seed_ents_range);
363 if (!seed_ents_range.empty())
364 CHKERR SetBitRefLevelTool(m_field, bit, ref_ents_ptr,
365 ref_fe_ptr)
366 .addEntsToDatabase(seed_ents_range);
367 }
368 }
369 }
370 }
371 }
372
374}
375
377 const BitRefLevel bit,
378 int verb) const {
379 MoFEM::Interface &m_field = cOre;
380 auto ref_ents_ptr = m_field.get_ref_ents();
381 auto ref_fe_ptr = m_field.get_ref_finite_elements();
382
384
385 for (Range::const_pair_iterator pit = ents.pair_begin();
386 pit != ents.pair_end(); pit++) {
387 // get first and last element of range
388 EntityHandle f = pit->first;
389 EntityHandle s = pit->second;
390 Range seed_ents_range; // entities seeded not in database
391 // find ents to add
392 CHKERR SetBitRefLevelTool(m_field, bit, ref_ents_ptr, ref_fe_ptr)
393 .findEntsToAdd(f, s, seed_ents_range);
394 // add elements
395 if (!seed_ents_range.empty())
396 CHKERR SetBitRefLevelTool(m_field, bit, ref_ents_ptr, ref_fe_ptr)
397 .addEntsToDatabase(seed_ents_range);
398
399 Range seed_fe_range;
400 CHKERR SetBitRefLevelTool(m_field, bit, ref_ents_ptr, ref_fe_ptr)
401 .findElementsToAdd(f, s, seed_fe_range);
402 if (!seed_fe_range.empty()) {
403 CHKERR SetBitRefLevelTool(m_field, bit, ref_ents_ptr, ref_fe_ptr)
404 .addElementsToDatabase(seed_fe_range);
405 }
406 }
407
409 MOFEM_LOG("BitRefSelf", Sev::noisy)
410 << "Number of entities in database " << ref_ents_ptr->size();
411 MOFEM_LOG("BitRefSelf", Sev::noisy)
412 << "Number of finite element entities in database " << ref_fe_ptr->size();
413
415}
416
418 const BitRefLevel bit,
419 int verb) const {
420 MoFEM::Interface &m_field = cOre;
421 auto ref_ents_ptr = m_field.get_ref_ents();
422 auto ref_fe_ptr = m_field.get_ref_finite_elements();
424
425 for (Range::const_pair_iterator pit = ents.pair_begin();
426 pit != ents.pair_end(); pit++) {
427 // get first and last element of range
428 EntityHandle f = pit->first;
429 EntityHandle s = pit->second;
430 Range seed_ents_range; // entities seeded not in database
431 // find ents to add
432 CHKERR SetBitRefLevelTool(m_field, bit, ref_ents_ptr, ref_fe_ptr)
433 .findEntsToAdd(f, s, seed_ents_range);
434 // add elements
435 if (!seed_ents_range.empty())
436 CHKERR SetBitRefLevelTool(m_field, bit, ref_ents_ptr, ref_fe_ptr)
437 .addEntsToDatabase(seed_ents_range);
438 }
440}
441
443 const std::string field_name, const BitRefLevel bit, int verb) const {
444 MoFEM::Interface &m_field = cOre;
446 EntityHandle field_meshset = m_field.get_field_meshset(field_name);
447 Range field_ents;
448 CHKERR m_field.get_moab().get_entities_by_handle(field_meshset, field_ents,
449 true);
450 CHKERR setEntitiesBitRefLevel(field_ents, bit, verb);
452}
453
455 const EntityType type, const BitRefLevel bit, const BitRefLevel mask,
456 int verb) const {
458 Range ents;
459 CHKERR getEntitiesByTypeAndRefLevel(bit, mask, type, ents);
460 CHKERR setBitRefLevel(ents, BitRefLevel(), false, verb);
462}
463
465 const int dim, const BitRefLevel bit, const BitRefLevel mask,
466 int verb) const {
468 Range ents;
469 CHKERR getEntitiesByDimAndRefLevel(bit, mask, dim, ents);
470 CHKERR setBitRefLevel(ents, BitRefLevel(), false, verb);
472}
473
475 const BitRefLevel bit,
476 int verb) const {
477 MoFEM::Interface &m_field = cOre;
478 auto ref_ents_ptr = m_field.get_ref_ents();
479 auto ref_fe_ptr = m_field.get_ref_finite_elements();
481 // Add ref entity
482 std::pair<RefEntity_multiIndex::iterator, bool> p_ent =
483 const_cast<RefEntity_multiIndex *>(ref_ents_ptr)
484 ->insert(boost::shared_ptr<RefEntity>(
485 new RefEntity(m_field.get_basic_entity_data_ptr(), meshset)));
486 *(const_cast<RefEntity *>(p_ent.first->get())->getBitRefLevelPtr()) |= bit;
487 // Add ref element
488 boost::shared_ptr<RefElement> fe_ptr =
489 boost::shared_ptr<RefElement>(new RefElement_MESHSET(*p_ent.first));
490 std::pair<RefElement_multiIndex::iterator, bool> p_fe =
491 const_cast<RefElement_multiIndex *>(ref_fe_ptr)->insert(fe_ptr);
492
494 MOFEM_LOG("BitRefSelf", Sev::noisy)
495 << "Add meshset as ref_ent " << **p_fe.first;
496
498}
499
501 const int dim,
502 const BitRefLevel bit,
503 int verb) const {
504 MoFEM::Interface &m_field = cOre;
506 Range ents;
507 CHKERR m_field.get_moab().get_entities_by_dimension(meshset, dim, ents,
508 false);
509 CHKERR setBitRefLevel(ents, bit, false, verb);
511}
512
514 const EntityType type,
515 const BitRefLevel bit,
516 int verb) const {
517 MoFEM::Interface &m_field = cOre;
519 Range ents;
520 CHKERR m_field.get_moab().get_entities_by_type(meshset, type, ents, false);
521 CHKERR setBitRefLevel(ents, bit, false, verb);
523}
524
526 boost::function<void(EntityHandle ent, BitRefLevel &bit)> fun) const {
527 MoFEM::Interface &m_field = cOre;
529 auto get_ents = [&]() {
530 Range ents;
531 CHKERR m_field.get_moab().get_entities_by_handle(
532 m_field.get_moab().get_root_set(), ents, true);
533 ents = subtract(ents, ents.subset_by_type(MBENTITYSET));
534 return ents;
535 };
536 CHKERR lambdaBitRefLevel(get_ents(), fun);
538}
539
541 const Range &ents,
542 boost::function<void(EntityHandle ent, BitRefLevel &bit)> fun) const {
543 MoFEM::Interface &m_field = cOre;
545 std::vector<const BitRefLevel *> ents_bits_vec;
546 CHKERR RefEntity::getBitRefLevel(m_field.get_moab(), ents, ents_bits_vec);
547 auto eit = ents.begin();
548 for (auto &it : ents_bits_vec) {
549 fun(*eit, const_cast<BitRefLevel &>(*it));
550 ++eit;
551 }
553};
554
556 const BitRefLevel &bit,
557 int verb) const {
558 return lambdaBitRefLevel(
559 ents, [&](EntityHandle ent, BitRefLevel &ent_bit) { ent_bit |= bit; });
560}
561
563 const int dim,
564 const BitRefLevel bit,
565 int verb) const {
566 MoFEM::Interface &m_field = cOre;
567 moab::Interface &moab = m_field.get_moab();
568 Range ents, adj;
570 CHKERR moab.get_entities_by_dimension(meshset, dim, ents, true);
571 for (int dd = dim - 1; dd >= 0; dd--)
572 CHKERR moab.get_adjacencies(ents, dd, false, adj, moab::Interface::UNION);
573 ents.merge(adj);
574 if (verb == VERY_NOISY)
575 MOFEM_LOG("BitRefSelf", Sev::noisy) << "Add add bit ref level by dim";
576 CHKERR addBitRefLevel(ents, bit, verb);
578}
579
581 const bool b, int verb) const {
582 if (verb == VERY_NOISY)
583 MOFEM_LOG("BitRefSelf", Sev::noisy) << "Set bit to " << ents;
584 return lambdaBitRefLevel(
585 ents, [&](EntityHandle ent, BitRefLevel &ent_bit) { ent_bit[n] = b; });
586}
587
589 int verb) const {
590 if (verb == VERY_NOISY)
591 MOFEM_LOG("BitRefSelf", Sev::noisy) << "Set bit to all entities";
592 return lambdaBitRefLevel(
593 [&](EntityHandle ent, BitRefLevel &ent_bit) { ent_bit[n] = b; });
594}
595
597 const BitRefLevel mask,
598 int verb) const {
600 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED, "not implemented");
602}
603
605 const BitRefLevel mask, int verb,
606 MoFEMTypes mf) const {
607 MoFEM::Interface &m_field = cOre;
608 auto ref_ents_ptr = m_field.get_ref_ents();
610 RefEntity_change_right_shift right_shift(1, mask);
611 for (int ii = 0; ii < shift; ii++) {
612 // delete bits on the right which are shifted to zero
613 BitRefLevel delete_bits = BitRefLevel().set(0) & mask;
614 if (delete_bits.any()) {
615 CHKERR m_field.delete_ents_by_bit_ref(delete_bits, delete_bits, true,
616 verb, mf);
617 }
618 for (RefEntity_multiIndex::iterator ent_it = ref_ents_ptr->begin();
619 ent_it != ref_ents_ptr->end(); ent_it++) {
620 if (verb >= NOISY) {
622 MOFEM_LOG("BitRefSelf", Sev::noisy)
623 << (*ent_it)->getBitRefLevel() << " : ";
624 }
625 right_shift(const_cast<boost::shared_ptr<RefEntity> &>(*ent_it));
626 if (verb == VERY_NOISY) {
628 MOFEM_LOG("BitRefSelf", Sev::noisy) << (*ent_it)->getBitRefLevel();
629 }
630 }
631 }
633}
634
636 const BitRefLevel mask,
637 const char *file_name,
638 const char *file_type,
639 const char *options,
640 const bool check_for_empty) const {
641 MoFEM::Interface &m_field = cOre;
642 moab::Interface &moab(m_field.get_moab());
644 EntityHandle meshset;
645 CHKERR moab.create_meshset(MESHSET_SET, meshset);
646 CHKERR getEntitiesByRefLevel(bit, mask, meshset);
647 int nb_ents;
648 CHKERR moab.get_number_entities_by_handle(meshset, nb_ents, true);
649 if (check_for_empty && !nb_ents) {
650 MOFEM_LOG("SELF", Sev::warning)
651 << "No entities to save < " << file_name << " > in writeBitLevel";
653 }
654
655 CHKERR moab.write_file(file_name, file_type, options, &meshset, 1);
656 CHKERR moab.delete_entities(&meshset, 1);
658}
659
662 const int dim, const char *file_name,
663 const char *file_type, const char *options,
664 const bool check_for_empty) const {
665 MoFEM::Interface &m_field = cOre;
666 moab::Interface &moab(m_field.get_moab());
668 Range ents;
669 CHKERR getEntitiesByDimAndRefLevel(bit, mask, dim, ents);
670 if (check_for_empty && ents.empty()) {
671 MOFEM_LOG("SELF", Sev::warning)
672 << "No entities to save < " << file_name << " > in writeBitLevelByDim";
674 }
675 EntityHandle meshset;
676 CHKERR moab.create_meshset(MESHSET_SET, meshset);
677 CHKERR moab.add_entities(meshset, ents);
678 CHKERR moab.write_file(file_name, file_type, options, &meshset, 1);
679 CHKERR moab.delete_entities(&meshset, 1);
681}
682
684 const BitRefLevel bit, const BitRefLevel mask, const EntityType type,
685 const char *file_name, const char *file_type, const char *options,
686 const bool check_for_empty) const {
687 MoFEM::Interface &m_field = cOre;
688 moab::Interface &moab(m_field.get_moab());
690 Range ents;
691 CHKERR getEntitiesByTypeAndRefLevel(bit, mask, type, ents);
692 if (check_for_empty && ents.empty()) {
693 MOFEM_LOG("SELF", Sev::warning)
694 << "No entities to save < " << file_name << " > in writeBitLevelByType";
696 }
697 EntityHandle meshset;
698 CHKERR moab.create_meshset(MESHSET_SET, meshset);
699 CHKERR moab.add_entities(meshset, ents);
700 CHKERR moab.write_file(file_name, file_type, options, &meshset, 1);
701 CHKERR moab.delete_entities(&meshset, 1);
703}
704
706 const char *file_name, const char *file_type, const char *options,
707 const bool check_for_empty) const {
708 MoFEM::Interface &m_field = cOre;
709 moab::Interface &moab(m_field.get_moab());
711 EntityHandle meshset;
712 Range ents;
714 if (check_for_empty && ents.empty())
716 CHKERR moab.create_meshset(MESHSET_SET, meshset);
717 CHKERR moab.add_entities(meshset, ents);
718 CHKERR moab.write_file(file_name, file_type, options, &meshset, 1);
719 CHKERR moab.delete_entities(&meshset, 1);
721}
722
724 const BitRefLevel mask, const EntityType type, const char *file_name,
725 const char *file_type, const char *options) {
727 for (int ll = 0; ll != BITREFLEVEL_SIZE; ++ll) {
728 std::string name = boost::lexical_cast<std::string>(ll) + "_" + file_name;
729 CHKERR writeBitLevelByType(BitRefLevel().set(ll), mask, type, name.c_str(),
730 file_type, options, true);
731 }
733}
734
736 const BitRefLevel bit, const BitRefLevel mask, const EntityType type,
737 const EntityHandle meshset, int verb) const {
738 MoFEM::Interface &m_field = cOre;
739 moab::Interface &moab(m_field.get_moab());
741 Range ents;
742 CHKERR getEntitiesByTypeAndRefLevel(bit, mask, type, ents, verb);
743 CHKERR moab.add_entities(meshset, ents);
745}
746
748 const BitRefLevel mask,
749 Range &ents,
750 int verb) const {
751 MoFEM::Interface &m_field = cOre;
752 moab::Interface &moab(m_field.get_moab());
754
755 std::vector<EntityHandle> ents_vec;
756 ents_vec.reserve(ents.size());
757
758 std::vector<BitRefLevel *> tags_bits_ptr_vec(ents.size());
759
760 Range swap_ents;
761 auto hint = swap_ents.begin();
762
763 for (Range::pair_iterator p_eit = ents.pair_begin(); p_eit != ents.pair_end();
764 ++p_eit) {
765
766 EntityHandle f = p_eit->first;
767 const EntityHandle s = p_eit->second;
768
769 // get bits on entities
770 rval = moab.tag_get_by_ptr(cOre.get_th_RefBitLevel(), Range(f, s),
771 (const void **)(&*tags_bits_ptr_vec.begin()));
772
773 if (rval == MB_SUCCESS) {
774
775 auto bit_it = tags_bits_ptr_vec.begin();
776
777 auto check = [&bit, &mask](const auto &entity_bit) -> bool {
778 return
779
780 (entity_bit & bit).any() &&
781
782 ((entity_bit & mask) == entity_bit);
783 };
784
785 while (f != s + 1) {
786
787 while (f != s + 1 && !check(**bit_it)) {
788 ++bit_it;
789 ++f;
790 }
791
792 if (f != s + 1) {
793
794 const EntityHandle start = f;
795
796 while (f != (s + 1) && check(**bit_it)) {
797 ++bit_it;
798 ++f;
799 };
800
801 hint = swap_ents.insert(hint, start, f - 1);
802 }
803 }
804 }
805 }
806
807 ents.swap(swap_ents);
808
810}
811
813 const BitRefLevel bit, const BitRefLevel mask, const EntityType type,
814 Range &ents, int verb) const {
815 MoFEM::Interface &m_field = cOre;
816 moab::Interface &moab(m_field.get_moab());
818 CHKERR moab.get_entities_by_type(0, type, ents, false);
819 CHKERR filterEntitiesByRefLevel(bit, mask, ents, verb);
821}
822
824 const BitRefLevel bit, const BitRefLevel mask, const int dim,
825 const EntityHandle meshset, int verb) const {
826 MoFEM::Interface &m_field = cOre;
827 moab::Interface &moab(m_field.get_moab());
829 Range ents;
830 CHKERR getEntitiesByDimAndRefLevel(bit, mask, dim, ents, verb);
831 CHKERR moab.add_entities(meshset, ents);
833}
834
836 const BitRefLevel bit, const BitRefLevel mask, const int dim, Range &ents,
837 int verb) const {
838 MoFEM::Interface &m_field = cOre;
839 moab::Interface &moab(m_field.get_moab());
841 CHKERR moab.get_entities_by_dimension(0, dim, ents, false);
842 CHKERR filterEntitiesByRefLevel(bit, mask, ents, verb);
844}
845
847 const BitRefLevel mask,
848 const EntityHandle meshset,
849 const int verb) const {
850 MoFEM::Interface &m_field = cOre;
851 moab::Interface &moab(m_field.get_moab());
853 Range ents;
854 CHKERR getEntitiesByRefLevel(bit, mask, ents, verb);
855 CHKERR moab.add_entities(meshset, ents);
857}
858
860 const BitRefLevel mask,
861 Range &ents,
862 const int verb) const {
863 MoFEM::Interface &m_field = cOre;
864 moab::Interface &moab(m_field.get_moab());
866 Range meshset_ents;
867 CHKERR moab.get_entities_by_type(0, MBENTITYSET, meshset_ents, false);
868 CHKERR moab.get_entities_by_handle(0, ents, false);
869 ents.merge(meshset_ents);
870 CHKERR filterEntitiesByRefLevel(bit, mask, ents, verb);
872}
873
875 const BitRefLevel mask,
876 const EntityType type,
877 Range &ents,
878 const int verb) const {
879 MoFEM::Interface &m_field = cOre;
880 auto ref_ents_ptr = m_field.get_ref_ents();
882 auto &ref_ents = ref_ents_ptr->get<Ent_Ent_mi_tag>();
883 auto it = ref_ents.lower_bound(get_id_for_min_type(type));
884 auto hi_it = ref_ents.upper_bound(get_id_for_max_type(type));
885 std::vector<EntityHandle> ents_vec;
886 ents_vec.reserve(std::distance(it, hi_it));
887 for (; it != hi_it; it++) {
888 const BitRefLevel &ent_bit = it->get()->getBitRefLevel();
889 if ((ent_bit & mask) == ent_bit && (ent_bit & bit).any())
890 ents_vec.emplace_back(it->get()->getEnt());
891 }
892 ents.insert_list(ents_vec.begin(), ents_vec.end());
893 if (verb > NOISY)
894 MOFEM_LOG("BitRefSelf", Sev::noisy)
895 << "getEntitiesByParentType: " << ents << endl;
897}
898
900 MoFEM::Interface &m_field = cOre;
901 moab::Interface &moab = m_field.get_moab();
903 CHKERR moab.get_entities_by_handle(0, ents, false);
904 ents = subtract(ents, ents.subset_by_type(MBENTITYSET));
907}
908
910 MoFEM::Interface &m_field = cOre;
911 auto ref_ents_ptr = m_field.get_ref_ents();
913 auto eit = ents.begin();
914 for (; eit != ents.end();) {
915 auto rit = ref_ents_ptr->get<Ent_mi_tag>().find(*eit);
916 if (rit != ref_ents_ptr->get<Ent_mi_tag>().end()) {
917 eit = ents.erase(eit);
918 } else {
919 eit++;
920 }
921 }
923}
924
927 const int to_dimension,
928 Range &adj_entities) const {
929 MoFEM::Interface &m_field = cOre;
930 moab::Interface &moab(m_field.get_moab());
932 BitRefLevel bit_from_entity;
933 CHKERR moab.tag_get_data(cOre.get_th_RefBitLevel(), &from_entity, 1,
934 &bit_from_entity);
935 CHKERR moab.get_adjacencies(&from_entity, 1, to_dimension, false,
936 adj_entities);
937 std::vector<BitRefLevel> bit_levels(adj_entities.size());
938 CHKERR moab.tag_get_data(cOre.get_th_RefBitLevel(), adj_entities,
939 &*bit_levels.begin());
940 auto b_it = bit_levels.begin();
941 auto eit = adj_entities.begin();
942 for (; eit != adj_entities.end(); b_it++) {
943 if (bit_from_entity != *b_it) {
944 eit = adj_entities.erase(eit);
945 } else {
946 eit++;
947 }
948 }
950}
951
953 const int to_dimension,
954 Range &adj_entities) const {
955 MoFEM::Interface &m_field = cOre;
956 moab::Interface &moab(m_field.get_moab());
958 BitRefLevel bit_from_entity;
959 CHKERR moab.tag_get_data(cOre.get_th_RefBitLevel(), &from_entity, 1,
960 &bit_from_entity);
961 CHKERR moab.get_adjacencies(&from_entity, 1, to_dimension, false,
962 adj_entities);
963 std::vector<BitRefLevel> bit_levels(adj_entities.size());
964 CHKERR moab.tag_get_data(cOre.get_th_RefBitLevel(), adj_entities,
965 &*bit_levels.begin());
966 std::vector<BitRefLevel>::iterator b_it = bit_levels.begin();
967 Range::iterator eit = adj_entities.begin();
968 for (; eit != adj_entities.end(); b_it++) {
969 if (!(bit_from_entity & (*b_it)).any()) {
970 eit = adj_entities.erase(eit);
971 } else {
972 eit++;
973 }
974 }
976}
977
979 const Problem *problem_ptr, const EntityHandle *from_entities,
980 const int num_entities, const int to_dimension, Range &adj_entities,
981 const int operation_type, const int verb) const {
983 BitRefLevel bit = problem_ptr->getBitRefLevel();
984 CHKERR getAdjacencies(bit, from_entities, num_entities, to_dimension,
985 adj_entities, operation_type);
987}
988
990 const BitRefLevel bit, const EntityHandle *from_entities,
991 const int num_entities, const int to_dimension, Range &adj_entities,
992 const int operation_type, const int verb) const {
993 MoFEM::Interface &m_field = cOre;
994 moab::Interface &moab(m_field.get_moab());
996
997 if (verb > VERBOSE) {
999 MOFEM_LOG("BitRef", Sev::noisy) << "from: " << bit;
1000 }
1001
1002 CHKERR moab.get_adjacencies(from_entities, num_entities, to_dimension, false,
1003 adj_entities, operation_type);
1004 std::vector<BitRefLevel> bit_levels(adj_entities.size());
1005 CHKERR moab.tag_get_data(cOre.get_th_RefBitLevel(), adj_entities,
1006 &*bit_levels.begin());
1007 std::vector<BitRefLevel>::iterator b_it = bit_levels.begin();
1008 for (Range::iterator eit = adj_entities.begin(); eit != adj_entities.end();
1009 b_it++) {
1010
1011 if (verb > VERBOSE) {
1012 RefEntity adj_entity(m_field.get_basic_entity_data_ptr(), *eit);
1014 MOFEM_LOG("BitRef", Sev::noisy)
1015 << "to: " << adj_entity.getBitRefLevel() << " : " << adj_entity;
1016 }
1017
1018 if (!((*b_it) & bit).any()) {
1019 eit = adj_entities.erase(eit);
1020 } else {
1021 eit++;
1022 }
1023 }
1024 if (b_it != bit_levels.end()) {
1025 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "Data inconsistency");
1026 }
1028}
1029
1031 const EntityHandle parent, const BitRefLevel &parent_bit,
1032 const BitRefLevel &parent_mask, const BitRefLevel &child_bit,
1033 const BitRefLevel &child_mask, const EntityHandle child,
1034 EntityType child_type, const bool recursive, int verb) {
1035 MoFEM::Interface &m_field = cOre;
1036 moab::Interface &moab = m_field.get_moab();
1038 Range parent_ents;
1039 CHKERR moab.get_entities_by_handle(parent, parent_ents, recursive);
1040 CHKERR filterEntitiesByRefLevel(parent_bit, parent_mask, parent_ents, verb);
1041 if (verb >= VERY_VERBOSE) {
1043 MOFEM_LOG("BitRefSelf", Sev::noisy) << "Parents: " << parent;
1044 }
1045 Range children_ents;
1046 CHKERR updateRangeByChildren(parent_ents, children_ents);
1047 if (child_type < MBMAXTYPE)
1048 children_ents = children_ents.subset_by_type(child_type);
1049 CHKERR filterEntitiesByRefLevel(child_bit, BitRefLevel().set(), children_ents,
1050 verb);
1051 CHKERR moab.add_entities(child, children_ents);
1053}
1054
1056 const EntityHandle parent, const BitRefLevel &child_bit,
1057 const EntityHandle child, EntityType child_type, const bool recursive,
1058 int verb) {
1061 parent, BitRefLevel().set(), BitRefLevel().set(), child_bit, child_bit,
1062 child, child_type, recursive, verb);
1064}
1065
1067 const BitRefLevel &child_bit, int verb) {
1068 MoFEM::Interface &m_field = cOre;
1069 moab::Interface &moab = m_field.get_moab();
1070 auto fields_ptr = m_field.get_fields();
1072
1073 for (auto &fit : (*fields_ptr)) {
1074
1075 const EntityHandle meshset = fit->getMeshset();
1076 Range parent_ents;
1077 CHKERR moab.get_entities_by_handle(meshset, parent_ents, true);
1078
1079 if (verb >= VERY_VERBOSE) {
1081 MOFEM_LOG("BitRefSelf", Sev::noisy) << "Parnets:" << std::endl
1082 << parent_ents << std::endl;
1083 }
1084
1085 Range children_ents;
1086 CHKERR updateRangeByChildren(parent_ents, children_ents);
1087 CHKERR filterEntitiesByRefLevel(child_bit, BitRefLevel().set(),
1088 children_ents, verb);
1089
1090 CHKERR moab.add_entities(meshset, children_ents);
1091
1092 if (verb >= VERY_VERBOSE) {
1094 MOFEM_LOG("BitRefSelf", Sev::noisy) << "Children: " << std::endl
1095 << children_ents << std::endl;
1096 }
1097 }
1099}
1100
1102 const std::string name, const BitRefLevel &child_bit, int verb) {
1103 MoFEM::Interface &m_field = cOre;
1104 moab::Interface &moab = m_field.get_moab();
1106
1107 EntityHandle field_meshset = m_field.get_field_structure(name)->getMeshset();
1108
1109 Range parent_ents;
1110 CHKERR moab.get_entities_by_handle(field_meshset, parent_ents, true);
1111
1112 if (verb >= VERBOSE) {
1114 MOFEM_LOG("BitRefSelf", Sev::noisy) << "Parnets:" << endl
1115 << parent_ents << std::endl;
1116 }
1117
1118 Range children_ents;
1119 CHKERR updateRangeByChildren(parent_ents, children_ents);
1120 CHKERR filterEntitiesByRefLevel(child_bit, BitRefLevel().set(), children_ents,
1121 verb);
1122
1123 CHKERR moab.add_entities(field_meshset, children_ents);
1124
1125 if (verb >= VERBOSE) {
1127 MOFEM_LOG("BitRefSelf", Sev::noisy) << "Children: " << endl
1128 << children_ents << std::endl;
1129 }
1130
1132}
1133
1135 const std::string name, const BitRefLevel &child_bit,
1136 const EntityType fe_ent_type, int verb) {
1137 MoFEM::Interface &m_field = cOre;
1139 EntityHandle meshset = m_field.get_finite_element_meshset(name);
1140 CHKERR updateMeshsetByEntitiesChildren(meshset, child_bit, meshset,
1141 fe_ent_type, false, verb);
1143}
1144
1146 Range &child_ents,
1147 MoFEMTypes bh) {
1148 MoFEM::Interface &m_field = cOre;
1149 auto ref_ents_ptr = m_field.get_ref_ents();
1151 auto &ref_ents =
1152 const_cast<RefEntity_multiIndex *>(ref_ents_ptr)->get<Ent_Ent_mi_tag>();
1153 std::vector<EntityHandle> child_ents_vec;
1154 child_ents_vec.reserve(ref_ents.size());
1155 for (Range::const_pair_iterator pit = parent_ents.const_pair_begin();
1156 pit != parent_ents.const_pair_end(); pit++) {
1157 const auto f = pit->first;
1158 auto it = ref_ents.lower_bound(f);
1159 if (it != ref_ents.end()) {
1160 const auto s = pit->second;
1161 auto hi_it = ref_ents.upper_bound(s);
1162 if (bh == MF_EXIST) {
1163 if (std::distance(it, hi_it) != (s - f) + 1) {
1164 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_FOUND,
1165 "Number of entities and entities parents is different %ld != "
1166 "%ld ",
1167 std::distance(it, hi_it), (s - f) + 1);
1168 }
1169 }
1170 for (; it != hi_it; it++) {
1171#ifndef NDEBUG
1172 if (it->get()->getEntType() == MBENTITYSET) {
1173 SETERRQ(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE,
1174 "This should not happen; Entity should not have part of the "
1175 "meshset. It has no children.");
1176 }
1177#endif
1178 child_ents_vec.emplace_back((*it)->getEnt());
1179 }
1180 } else if (bh == MF_EXIST) {
1181 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "Entities not found");
1182 }
1183 }
1184 child_ents.insert_list(child_ents_vec.begin(), child_ents_vec.end());
1186}
1187
1189 Range &parent_ents,
1190 MoFEMTypes bh) {
1191 MoFEM::Interface &m_field = cOre;
1192 auto ref_ents_ptr = m_field.get_ref_ents();
1194 auto &ref_ents =
1195 const_cast<RefEntity_multiIndex *>(ref_ents_ptr)->get<Ent_mi_tag>();
1196 std::vector<EntityHandle> parent_ents_vec;
1197 parent_ents_vec.reserve(ref_ents.size());
1198 for (Range::const_pair_iterator pit = child_ents.const_pair_begin();
1199 pit != child_ents.const_pair_end(); pit++) {
1200 const auto f = pit->first;
1201 auto it = ref_ents.lower_bound(f);
1202 if (it != ref_ents.end()) {
1203 const auto s = pit->second;
1204 auto hi_it = ref_ents.upper_bound(s);
1205 if (bh == MF_EXIST) {
1206 if (std::distance(it, hi_it) != (s - f) + 1) {
1207 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_FOUND,
1208 "Number of entities and entities parents is different %ld != "
1209 "%ld ",
1210 std::distance(it, hi_it), (s - f) + 1);
1211 }
1212 }
1213 for (; it != hi_it; it++) {
1214#ifndef NDEBUG
1215 if (it->get()->getEntType() == MBENTITYSET) {
1216 SETERRQ(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE,
1217 "This should not happen; Entity should not have part of the "
1218 "meshset. It has no children.");
1219 }
1220#endif
1221 auto parent = (*it)->getParentEnt();
1222 if (parent)
1223 parent_ents_vec.emplace_back(parent);
1224 }
1225 } else if (bh == MF_EXIST) {
1226 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "Entities not found");
1227 }
1228 }
1229 parent_ents.insert_list(parent_ents_vec.begin(), parent_ents_vec.end());
1231}
1232
1233MoFEMErrorCode BitRefManager::fixTagSize(moab::Interface &moab, bool *changes) {
1235 MOFEM_LOG_CHANNEL("WORLD");
1236
1237 if (changes)
1238 *changes = false;
1239
1240 if (Tag th = 0; moab.tag_get_handle("_RefBitLevel", th) == MB_SUCCESS) {
1241
1242 MOFEM_TAG_AND_LOG("WORLD", Sev::verbose, "BitRefManager") << "Tag found";
1243
1244 auto get_old_tag = [&](auto &&name) {
1245 Tag th;
1246 CHK_MOAB_THROW(moab.tag_get_handle(name, th),
1247 "bit ref level handle does not exist");
1248 return th;
1249 };
1250
1251 auto get_new_tag = [&](auto &&name, auto &&def_val) {
1252 Tag th;
1253 CHK_MOAB_THROW(moab.tag_get_handle(
1254 name, sizeof(BitRefLevel), MB_TYPE_OPAQUE, th,
1255 MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_SPARSE, &def_val),
1256 "can not create tag");
1257 return th;
1258 };
1259
1260 int length;
1261 CHKERR moab.tag_get_length(get_old_tag("_RefBitLevel"), length);
1262
1263 if (sizeof(BitRefLevel) != length) {
1264
1265 if(changes)
1266 *changes = true;
1267
1268 MOFEM_TAG_AND_LOG("WORLD", Sev::verbose, "BitRefManager")
1269 << "Fixing tag length";
1270
1271 Range all_ents;
1272 CHKERR moab.get_entities_by_type(0, MBENTITYSET, all_ents, true);
1273 CHKERR moab.get_entities_by_handle(0, all_ents, true);
1274
1275 auto process_tag = [&](auto &&name, auto &&def_val) {
1277 auto tag_old = get_old_tag(name);
1278 auto get_bits = [&]() {
1279 std::vector<BitRefLevel> bits;
1280 bits.reserve(all_ents.size());
1281 auto it_bit = bits.begin();
1282 for (auto e : all_ents) {
1283 const void *data;
1284 int data_size;
1285 CHKERR moab.tag_get_by_ptr(tag_old, &e, 1, (const void **)&data,
1286 &data_size);
1287 bcopy(
1288 data, &*it_bit,
1289 std::min(sizeof(BitRefLevel), static_cast<size_t>(data_size)));
1290 ++it_bit;
1291 }
1292 return bits;
1293 };
1294 auto bits = get_bits();
1295 CHKERR moab.tag_delete(tag_old);
1296 auto tag_new = get_new_tag(name, def_val);
1297 auto it_bit = bits.begin();
1298 for (auto e : all_ents) {
1299 if (it_bit->any()) {
1300 CHKERR moab.tag_set_data(tag_new, &e, 1, &*it_bit);
1301 }
1302 ++it_bit;
1303 }
1305 };
1306
1307 CHKERR process_tag("_RefBitLevel", BitRefLevel() = 0);
1308 CHKERR process_tag("_RefBitLevelMask", BitRefLevel().set());
1309 }
1310 }
1311
1312 MOFEM_LOG_CHANNEL("WORLD");
1314}
1315
1316} // namespace MoFEM
#define MOFEM_LOG_C(channel, severity, format,...)
#define MOFEM_TAG_AND_LOG(channel, severity, tag)
Tag and log in channel.
@ VERY_VERBOSE
@ QUIET
@ NOISY
@ VERBOSE
@ VERY_NOISY
MoFEMTypes
Those types control how functions respond on arguments, f.e. error handling.
@ MF_EXIST
#define BITREFLEVEL_SIZE
max number of refinements
#define MOAB_THROW(err)
Check error code of MoAB function and throw MoFEM exception.
#define MAX_CORE_TMP
maximal number of cores
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
#define CHK_MOAB_THROW(err, msg)
Check error code of MoAB function and throw MoFEM exception.
@ MOFEM_NOT_FOUND
Definition definitions.h:33
@ MOFEM_IMPOSSIBLE_CASE
Definition definitions.h:35
@ MOFEM_DATA_INCONSISTENCY
Definition definitions.h:31
@ MOFEM_NOT_IMPLEMENTED
Definition definitions.h:32
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
#define CHKERR
Inline error check.
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
auto fun
Function to approximate.
multi_index_container< boost::shared_ptr< RefEntity >, indexed_by< ordered_unique< tag< Ent_mi_tag >, const_mem_fun< RefEntity, EntityHandle, &RefEntity::getEnt > >, ordered_non_unique< tag< Ent_Ent_mi_tag >, const_mem_fun< RefEntity, EntityHandle, &RefEntity::getParentEnt > >, ordered_non_unique< tag< Composite_EntType_and_ParentEntType_mi_tag >, composite_key< RefEntity, const_mem_fun< RefEntity, EntityType, &RefEntity::getEntType >, const_mem_fun< RefEntity, EntityType, &RefEntity::getParentEntType > > >, ordered_non_unique< tag< Composite_ParentEnt_And_EntType_mi_tag >, composite_key< RefEntity, const_mem_fun< RefEntity, EntityType, &RefEntity::getEntType >, const_mem_fun< RefEntity, EntityHandle, &RefEntity::getParentEnt > > > > > RefEntity_multiIndex
multi_index_container< boost::shared_ptr< RefElement >, indexed_by< ordered_unique< tag< Ent_mi_tag >, const_mem_fun< RefElement::interface_type_RefEntity, EntityHandle, &RefElement::getEnt > > > > RefElement_multiIndex
virtual const RefEntity_multiIndex * get_ref_ents() const =0
Get the ref ents object.
virtual const Field_multiIndex * get_fields() const =0
Get the fields object.
virtual const RefElement_multiIndex * get_ref_finite_elements() const =0
Get the ref finite elements object.
virtual MoFEMErrorCode getAdjacenciesAny(const EntityHandle from_entity, const int to_dimension, Range &adj_entities) const
Get the adjacencies associated with a entity to entities of a specified dimension.
MoFEMErrorCode updateMeshsetByEntitiesChildren(const EntityHandle parent, const BitRefLevel &parent_bit, const BitRefLevel &parent_mask, const BitRefLevel &child_bit, const BitRefLevel &child_mask, const EntityHandle child, EntityType child_type, const bool recursive=false, int verb=0)
Get child entities form meshset containing parent entities.
MoFEMErrorCode shiftLeftBitRef(const int shift, const BitRefLevel mask=BitRefLevel().set(), int verb=DEFAULT_VERBOSITY) const
left shift bit ref levelthis results of deletion of entities on far left side
MoFEMErrorCode setElementsBitRefLevel(const Range &ents, const BitRefLevel bit=BitRefLevel(), int verb=QUIET) const
add entities to database and set bit ref level
MoFEMErrorCode shiftRightBitRef(const int shift, const BitRefLevel mask=BitRefLevel().set(), int verb=DEFAULT_VERBOSITY, MoFEMTypes mf=MF_ZERO) const
right shift bit ref level
MoFEMErrorCode setEntitiesBitRefLevel(const Range &ents, const BitRefLevel bit=BitRefLevel(), int verb=QUIET) const
add entities to database and set bit ref level
MoFEMErrorCode addBitRefLevel(const Range &ents, const BitRefLevel &bit, int verb=QUIET) const
add bit ref level to ref entity
MoFEMErrorCode getEntitiesByDimAndRefLevel(const BitRefLevel bit, const BitRefLevel mask, const int dim, const EntityHandle meshset, int verb=0) const
add all ents from ref level given by bit to meshset
MoFEMErrorCode setBitRefLevel(const Range &ents, const BitRefLevel bit, const bool only_tets=true, int verb=0, Range *adj_ents_ptr=nullptr) const
add entities to database and set bit ref level
MoFEMErrorCode setBitRefLevelByType(const EntityHandle meshset, const EntityType type, const BitRefLevel bit, int verb=QUIET) const
Set the Bit Ref Level By Type object.
MoFEMErrorCode addBitRefLevelByDim(const EntityHandle meshset, const int dim, const BitRefLevel bit, int verb=QUIET) const
add bit ref level by dimension
MoFEMErrorCode setBitLevelToMeshset(const EntityHandle meshset, const BitRefLevel bit, int verb=0) const
MoFEMErrorCode setNthBitRefLevel(const Range &ents, const int n, const bool b, int verb=QUIET) const
Set nth bit ref level.
MoFEMErrorCode addToDatabaseBitRefLevelByType(const EntityType type, const BitRefLevel bit, const BitRefLevel mask=BitRefLevel().set(), int verb=QUIET) const
Add entities which exist in MoAB database, and have set appropiate BitRef level tag,...
MoFEMErrorCode updateFiniteElementMeshsetByEntitiesChildren(const std::string name, const BitRefLevel &child_bit, const EntityType fe_ent_type, int verb=0)
update finite element meshset by child entities
MoFEMErrorCode addToDatabaseBitRefLevelByDim(const int dim, const BitRefLevel bit, const BitRefLevel mask=BitRefLevel().set(), int verb=QUIET) const
Add entities which exist in MoAB database, and have set appropiate BitRef level tag,...
virtual MoFEMErrorCode getAdjacencies(const Problem *problem_ptr, const EntityHandle *from_entities, const int num_entities, const int to_dimension, Range &adj_entities, const int operation_type=moab::Interface::INTERSECT, const int verb=0) const
Get the adjacencies associated with a entity to entities of a specified dimension.
MoFEMErrorCode setFieldEntitiesBitRefLevel(const std::string field_name, const BitRefLevel bit=BitRefLevel(), int verb=QUIET) const
Set the bit ref level to entities in the field meshset.
MoFEMErrorCode getEntitiesByTypeAndRefLevel(const BitRefLevel bit, const BitRefLevel mask, const EntityType type, const EntityHandle meshset, int verb=0) const
add all ents from ref level given by bit to meshset
MoFEMErrorCode updateRangeByParent(const Range &child_ents, Range &parent_ents, MoFEMTypes bh=MF_ZERO)
Update range by parents.
MoFEMErrorCode lambdaBitRefLevel(boost::function< void(EntityHandle ent, BitRefLevel &bit)> fun) const
Process bit ref level by lambda function.
MoFEMErrorCode getEntitiesByRefLevel(const BitRefLevel bit, const BitRefLevel mask, const EntityHandle meshset, const int verb=QUIET) const
add all ents from ref level given by bit to meshset
MoFEMErrorCode updateFieldMeshsetByEntitiesChildren(const BitRefLevel &child_bit, int verb=0)
update fields meshesets by child entities
virtual MoFEMErrorCode getAdjacenciesEquality(const EntityHandle from_entity, const int to_dimension, Range &adj_entities) const
Get the adjacencies associated with a entity to entities of a specified dimension.
MoFEMErrorCode setBitRefLevelByDim(const EntityHandle meshset, const int dim, const BitRefLevel bit, int verb=QUIET) const
Set the Bit Ref Level By Dim object.
MoFEMErrorCode updateRangeByChildren(const Range &parent, Range &child, MoFEMTypes bh=MF_ZERO)
Update range by childrens.
virtual EntityHandle get_finite_element_meshset(const std::string name) const =0
virtual const Field * get_field_structure(const std::string &name, enum MoFEMTypes bh=MF_EXIST) const =0
get field structure
static LoggerType & setLog(const std::string channel)
Set ans resset chanel logger.
#define MOFEM_LOG(channel, severity)
Log.
#define MOFEM_LOG_TAG(channel, tag)
Tag channel.
#define MOFEM_LOG_CHANNEL(channel)
Set and reset channel.
#define MOFEM_LOG_ATTRIBUTES(channel, bit)
Add attributes to channel.
#define MOFEM_LOG_FUNCTION()
Set scope.
auto bit
set bit
const double n
refractive index of diffusive medium
static MoFEMErrorCodeGeneric< moab::ErrorCode > rval
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
std::bitset< BITREFLEVEL_SIZE > BitRefLevel
Bit structure attached to each entity identifying to what mesh entity is attached.
Definition Types.hpp:40
implementation of Data Operators for Forces and Sources
Definition Common.hpp:10
EntityHandle get_id_for_max_type()
EntityHandle get_id_for_min_type()
RefEntityTmp< 0 > RefEntity
moab::Range::iterator insertOrdered(Range &r, Extractor, Iterator begin_iter, Iterator end_iter)
Insert ordered mofem multi-index into range.
constexpr auto field_name
Managing BitRefLevels.
MoFEMErrorCode getAllEntitiesNotInDatabase(Range &ents) const
Get all entities not in database.
MoFEMErrorCode writeBitLevelByDim(const BitRefLevel bit, const BitRefLevel mask, const int dim, const char *file_name, const char *file_type, const char *options, const bool check_for_empty=true) const
Write bit ref level to file.
static MoFEMErrorCode fixTagSize(moab::Interface &moab, bool *changed=nullptr)
Fix tag size when BITREFLEVEL_SIZE of core library is different than file BITREFLEVEL_SIZE.
MoFEMErrorCode writeBitLevelByType(const BitRefLevel bit, const BitRefLevel mask, const EntityType type, const char *file_name, const char *file_type, const char *options, const bool check_for_empty=true) const
Write bit ref level to file.
MoFEMErrorCode getEntitiesByParentType(const BitRefLevel bit, const BitRefLevel mask, const EntityType type, Range &ents, const int verb=QUIET) const
get entities by bit ref level and type of parent
MoFEMErrorCode filterEntitiesByRefLevel(const BitRefLevel bit, const BitRefLevel mask, Range &ents, int verb=QUIET) const
filter entities by bit ref level
BitRefManager(const MoFEM::Core &core)
MoFEMErrorCode filterEntitiesNotInDatabase(Range &ents) const
Get entities not in database.
MoFEMErrorCode query_interface(boost::typeindex::type_index type_index, UnknownInterface **iface) const
MoFEMErrorCode writeEntitiesAllBitLevelsByType(const BitRefLevel mask, const EntityType type, const char *file_name, const char *file_type, const char *options)
Write all entities by bit levels and type.
MoFEMErrorCode writeBitLevel(const BitRefLevel bit, const BitRefLevel mask, const char *file_name, const char *file_type, const char *options, const bool check_for_empty=true) const
Write bit ref level to file.
MoFEMErrorCode writeEntitiesNotInDatabase(const char *file_name, const char *file_type, const char *options, const bool check_for_empty=true) const
Write ents not in database.
virtual moab::Interface & get_moab()=0
virtual EntityHandle get_field_meshset(const std::string name) const =0
get field meshset
virtual const int getValue() const =0
Get the core.
virtual MoFEMErrorCode delete_ents_by_bit_ref(const BitRefLevel bit, const BitRefLevel mask, const bool remove_parent=false, int verb=DEFAULT_VERBOSITY, MoFEMTypes mf=MF_ZERO)=0
delete entities form mofem and moab database
virtual boost::shared_ptr< BasicEntityData > & get_basic_entity_data_ptr()=0
Get pointer to basic entity data.
Core (interface) class.
Definition Core.hpp:82
Tag get_th_RefBitLevel() const
Definition Core.hpp:198
Deprecated interface functions.
EntityHandle getMeshset() const
Get field meshset.
static boost::shared_ptr< SinkType > createSink(boost::shared_ptr< std::ostream > stream_ptr, std::string comm_filter)
Create a sink object.
static boost::shared_ptr< std::ostream > getStrmWorld()
Get the strm world object.
static boost::shared_ptr< std::ostream > getStrmSync()
Get the strm sync object.
static bool checkIfChannelExist(const std::string channel)
Check if channel exist.
static boost::shared_ptr< std::ostream > getStrmSelf()
Get the strm self object.
keeps basic data about problem
BitRefLevel getBitRefLevel() const
keeps data about abstract TRI finite element
keeps data about abstract TET finite element
keeps data about abstract EDGE finite element
keeps data about abstract MESHSET finite element
keeps data about abstract PRISM finite element
keeps data about abstract VERTEX finite element
Extract entity handle form multi-index container.
Struct keeps handle to refined handle.
const BitRefLevel & getBitRefLevel() const
Get entity ref bit refinement signature.
static MoFEMErrorCode getBitRefLevel(Interface &moab, Range ents, std::vector< BitRefLevel > &vec_bit_ref_level)
tool class with methods used more than twp times
boost::shared_ptr< BasicEntityData > & baseEntData
base entity data
MoFEM::Interface & mField
SetBitRefLevelTool(MoFEM::Interface &m_field, const BitRefLevel &bit, const RefEntity_multiIndex *ref_ents_ptr, const RefElement_multiIndex *ref_element_ptr)
constructor
const RefEntity_multiIndex * refEntsPtr
access to ents database
MoFEMErrorCode findEntsToAdd(EntityHandle f, EntityHandle s, Range &seed_ents_range) const
find entities and change entity bit if in database
MoFEMErrorCode addEntsToDatabase(const Range &seed_ents_range) const
const BitRefLevel & bIt
bit to set
MoFEMErrorCode addElementsToDatabase(Range &seed_fe_range) const
const RefElement_multiIndex * refElementPtr
access to fe database
MoFEMErrorCode addEntsToDatabaseImpl(const Range &seed_ents_range) const
add entities to database
MoFEMErrorCode findElementsToAdd(EntityHandle f, EntityHandle s, Range &seed_fe_range) const
base class for all interface classes