v0.15.0
Loading...
Searching...
No Matches
MeshsetsManager.cpp
Go to the documentation of this file.
1/** \file MeshsetsManager.cpp
2 * \brief Interface to manage meshsets which carrying information about boundary
3 * conditions and material blocks
4 *
5 */
6
7using namespace std;
8namespace po = boost::program_options;
9
10namespace MoFEM {
11
13 std::vector<const CubitMeshSets *> &vec_ptr) {
14 std::sort(vec_ptr.begin(), vec_ptr.end(),
15 [](const CubitMeshSets *a, const CubitMeshSets *b) {
16 if (a->getBcType().to_ullong() < b->getBcType().to_ullong())
17 return true;
18 if (a->getBcType().to_ullong() > b->getBcType().to_ullong())
19 return false;
20 else
21 return a->getMeshsetId() < b->getMeshsetId();
22 });
23}
24
26
28MeshsetsManager::query_interface(boost::typeindex::type_index type_index,
29 UnknownInterface **iface) const {
30 *iface = const_cast<MeshsetsManager *>(this);
31 return 0;
32}
33
35 : cOre(const_cast<Core &>(core)) {
36
37 if (!LogManager::checkIfChannelExist("MeshsetMngWorld")) {
38 auto core_log = logging::core::get();
39
40 core_log->add_sink(
42 core_log->add_sink(
44 core_log->add_sink(
46
47 LogManager::setLog("MeshsetMngWorld");
48 LogManager::setLog("MeshsetMngSync");
49 LogManager::setLog("MeshsetMngSelf");
50
51 MOFEM_LOG_TAG("MeshsetMngWorld", "MeshsetMng");
52 MOFEM_LOG_TAG("MeshsetMngSync", "MeshsetMng");
53 MOFEM_LOG_TAG("MeshsetMngSelf", "MeshsetMng");
54 }
55
56 MOFEM_LOG("MeshsetMngWorld", Sev::noisy) << "Mashset manager created";
57}
58
64
66 Interface &m_field = cOre;
68 CHKERR readMeshsets(verb);
71
72 std::vector<const CubitMeshSets *> vec_ptr;
73 for (auto &m : cubitMeshsets) {
74 vec_ptr.push_back(&m);
75 }
76 sortMeshsets(vec_ptr);
77
78 for (auto m_ptr : vec_ptr) {
79 MOFEM_LOG("MeshsetMngWorld", Sev::inform)
80 << "meshset in database " << *m_ptr;
81 }
82 // Verbose synchronised print
83 for (auto m_ptr : vec_ptr) {
84 MOFEM_LOG("MeshsetMngSync", Sev::verbose)
85 << "meshset in database " << *m_ptr;
86 }
87 MOFEM_LOG_SEVERITY_SYNC(m_field.get_comm(), Sev::verbose);
88
90}
91
93 Interface &m_field = cOre;
94 moab::Interface &moab = m_field.get_moab();
96
97 Range meshsets;
98 CHKERR moab.get_entities_by_type(0, MBENTITYSET, meshsets, false);
99 for (auto m : meshsets) {
100 // check if meshset is cubit meshset
101 CubitMeshSets block(moab, m);
102 if ((block.cubitBcType & CubitBCType(NODESET | SIDESET | BLOCKSET)).any()) {
103 auto p = cubitMeshsets.insert(block);
104 if (!p.second) {
105 // blockset/nodeset/sideset set exist, could be created on other
106 // processor.
107 Range ents;
108 CHKERR m_field.get_moab().get_entities_by_handle(m, ents, true);
109 CHKERR m_field.get_moab().add_entities(p.first->getMeshset(), ents);
110 CHKERR m_field.get_moab().delete_entities(&m, 1);
111 }
112 }
113 }
114
115 std::vector<const CubitMeshSets *> vec_ptr;
116 for (auto &m : cubitMeshsets) {
117 vec_ptr.push_back(&m);
118 }
119 sortMeshsets(vec_ptr);
120
121 for (auto m_ptr : vec_ptr) {
122 MOFEM_LOG("MeshsetMngSync", Sev::verbose) << "read " << *m_ptr;
123 }
124 MOFEM_LOG_SEVERITY_SYNC(m_field.get_comm(), Sev::verbose);
125
127}
128
130 Interface &m_field = cOre;
131 moab::Interface &moab = m_field.get_moab();
133
134 ParallelComm *pcomm = ParallelComm::get_pcomm(&moab, MYPCOMM_INDEX);
135 if (pcomm == NULL)
136 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
137 "MOAB communicator not set");
138
139 const double coords[] = {0, 0, 0};
140
141 auto set_tags_dummy_node = [&](const EntityHandle dummy_node,
142 const EntityHandle meshset) {
144 std::vector<Tag> tag_handles;
145 CHKERR moab.tag_get_tags_on_entity(meshset, tag_handles);
146 for (auto th : tag_handles) {
147 void *data[1];
148 int tag_size;
149 CHKERR moab.tag_get_by_ptr(th, &meshset, 1, (const void **)data,
150 &tag_size);
151 if (tag_size > 0)
152 CHKERR moab.tag_set_by_ptr(th, &dummy_node, 1, data, &tag_size);
153 }
155 };
156
157 for (auto t : {NODESET, SIDESET, BLOCKSET}) {
158 std::vector<const CubitMeshSets *> vec_ptr;
159 for (auto &m : cubitMeshsets) {
160 if ((m.getBcType() & CubitBCType(t)).any()) {
161 vec_ptr.push_back(&m);
162 }
163 }
164 sortMeshsets(vec_ptr);
165
166 std::vector<EntityHandle> vec_meshsets;
167 vec_meshsets.reserve(vec_ptr.size());
168 for (auto m_ptr : vec_ptr) {
169 vec_meshsets.push_back(m_ptr->getMeshset());
170 }
171
172 switch (t) {
173 case NODESET:
174 MOFEM_LOG("MeshsetMngSync", Sev::verbose)
175 << "broadcast NODESET " << vec_meshsets.size();
176 break;
177 case SIDESET:
178 MOFEM_LOG("MeshsetMngSync", Sev::verbose)
179 << "broadcast SIDESET " << vec_meshsets.size();
180 break;
181 case BLOCKSET:
182 MOFEM_LOG("MeshsetMngSync", Sev::verbose)
183 << "broadcast BLOCKSET " << vec_meshsets.size();
184 break;
185 default:
186 MOFEM_LOG("MeshsetMngSync", Sev::verbose)
187 << "broadcast Unknown " << vec_meshsets.size();
188 }
189
190 for (int from_proc = 0; from_proc < pcomm->size(); ++from_proc) {
191
192 Range r_dummy_nodes;
193
194 if (from_proc == pcomm->rank()) {
195 std::vector<EntityHandle> dummy_nodes(vec_meshsets.size(), 0);
196 int i = 0;
197 for (auto m : vec_meshsets) {
198 CHKERR moab.create_vertex(coords, dummy_nodes[i]);
199 CHKERR set_tags_dummy_node(dummy_nodes[i], m);
200 ++i;
201 }
202 r_dummy_nodes.insert_list(dummy_nodes.begin(), dummy_nodes.end());
203 }
204
205 CHKERR pcomm->broadcast_entities(from_proc, r_dummy_nodes, false, true);
206
207 if (from_proc != pcomm->rank()) {
208
209 for (auto dummy_node : r_dummy_nodes) {
210 CubitMeshSets broadcast_block(moab, dummy_node);
211 auto id = broadcast_block.getMeshsetId();
212 if (id != -1) {
213 auto mit =
215 .find(boost::make_tuple(
216 id, broadcast_block.getMaskedBcTypeULong()));
217 if (mit ==
219 .end()) {
221 CHKERR moab.create_meshset(MESHSET_SET, m);
222 CHKERR set_tags_dummy_node(m, dummy_node);
223 auto hint = cubitMeshsets.end();
224 /*auto p = */ cubitMeshsets.emplace_hint(hint, moab, m);
225 }
226 } else {
227 MOFEM_LOG("MeshsetMngSync", Sev::warning)
228 << "broadcasted vertex " << dummy_node << " has negative id";
229 }
230
231 }
232
233 } else {
234 MOFEM_LOG("MeshsetMngSync", Sev::verbose)
235 << "broadcast send from " << from_proc;
236 }
237
238 CHKERR moab.delete_entities(r_dummy_nodes);
239 }
240
241 MOFEM_LOG_SEVERITY_SYNC(m_field.get_comm(), Sev::verbose);
242 }
243
245}
246
249 Interface &m_field = cOre;
250 moab::Interface &moab = m_field.get_moab();
252 bhTag_header, verb);
254}
255
256MoFEMErrorCode MeshsetsManager::getTags(moab::Interface &moab, Tag &nsTag,
257 Tag &ssTag, Tag &nsTag_data,
258 Tag &ssTag_data, Tag &bhTag,
259 Tag &bhTag_header, int verb) {
261
262 int default_val = -1;
263 CHKERR moab.tag_get_handle(DIRICHLET_SET_TAG_NAME, 1, MB_TYPE_INTEGER, nsTag,
264 MB_TAG_SPARSE | MB_TAG_CREAT, &default_val);
265
266 CHKERR moab.tag_get_handle(NEUMANN_SET_TAG_NAME, 1, MB_TYPE_INTEGER, ssTag,
267 MB_TAG_SPARSE | MB_TAG_CREAT, &default_val);
268
269 const int def_bc_data_len = 0;
270 std::string tag_name = std::string(DIRICHLET_SET_TAG_NAME) + "__BC_DATA";
271 CHKERR moab.tag_get_handle(
272 tag_name.c_str(), def_bc_data_len, MB_TYPE_OPAQUE, nsTag_data,
273 MB_TAG_CREAT | MB_TAG_SPARSE | MB_TAG_BYTES | MB_TAG_VARLEN, NULL);
274
275 tag_name = std::string(NEUMANN_SET_TAG_NAME) + "__BC_DATA";
276 CHKERR moab.tag_get_handle(
277 tag_name.c_str(), def_bc_data_len, MB_TYPE_OPAQUE, ssTag_data,
278 MB_TAG_CREAT | MB_TAG_SPARSE | MB_TAG_BYTES | MB_TAG_VARLEN, NULL);
279
280 CHKERR moab.tag_get_handle(MATERIAL_SET_TAG_NAME, 1, MB_TYPE_INTEGER, bhTag,
281 MB_TAG_SPARSE | MB_TAG_CREAT, &default_val);
282
283 std::vector<unsigned int> def_uint_zero(3, 0);
284 CHKERR moab.tag_get_handle(
285 BLOCK_HEADER, 3 * sizeof(unsigned int), MB_TYPE_INTEGER, bhTag_header,
286 MB_TAG_CREAT | MB_TAG_SPARSE | MB_TAG_BYTES, &def_uint_zero[0]);
287
288 Tag block_attribs;
289 int def_Block_Attributes_length = 0;
290 CHKERR moab.tag_get_handle(
291 BLOCK_ATTRIBUTES, def_Block_Attributes_length, MB_TYPE_DOUBLE,
292 block_attribs, MB_TAG_CREAT | MB_TAG_SPARSE | MB_TAG_VARLEN, NULL);
293
294 Tag entity_name_tag;
295 CHKERR moab.tag_get_handle(NAME_TAG_NAME, NAME_TAG_SIZE, MB_TYPE_OPAQUE,
296 entity_name_tag, MB_TAG_SPARSE | MB_TAG_CREAT);
297
299}
300
307
314
321
328
335
338 const Interface &m_field = cOre;
339 const moab::Interface &moab = m_field.get_moab();
341 (*this), BLOCKSET | MAT_ELASTICSET, it)) {
342 Mat_Elastic data;
343 CHKERR it->getAttributeDataStructure(data);
344 MOFEM_LOG("MeshsetMngWorld", Sev::inform) << *it;
345 MOFEM_LOG("MeshsetMngWorld", Sev::inform) << data;
346 Range tets;
347 CHKERR moab.get_entities_by_dimension(it->meshset, 3, tets, true);
348 MOFEM_LOG("MeshsetMngWorld", Sev::inform)
349 << "MAT_ELATIC msId " << it->getMeshsetId() << " nb. volumes "
350 << tets.size();
351 }
352
354 m_field, BLOCKSET | MAT_THERMALSET, it)) {
355 Mat_Thermal data;
356 CHKERR it->getAttributeDataStructure(data);
357 MOFEM_LOG("MeshsetMngWorld", Sev::inform) << *it;
358 MOFEM_LOG("MeshsetMngWorld", Sev::inform) << data;
359 }
360
362 m_field, BLOCKSET | MAT_MOISTURESET, it)) {
363 Mat_Moisture data;
364 CHKERR it->getAttributeDataStructure(data);
365 MOFEM_LOG("MeshsetMngWorld", Sev::inform) << *it;
366 MOFEM_LOG("MeshsetMngWorld", Sev::inform) << data;
367 }
369}
370
371bool MeshsetsManager::checkMeshset(const int ms_id,
372 const CubitBCType cubit_bc_type) const {
373 auto miit =
375 boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
376 if (miit !=
378 return true;
379 }
380 return false;
381}
382
383bool MeshsetsManager::checkMeshset(const string name,
384 int *const number_of_meshsets_ptr) const {
385 auto miit = cubitMeshsets.get<CubitMeshsets_name>().lower_bound(name);
386 auto hi_miit = cubitMeshsets.get<CubitMeshsets_name>().upper_bound(name);
387 if (std::distance(miit, hi_miit) == 0) {
388 return false;
389 }
390 if (number_of_meshsets_ptr) {
391 *number_of_meshsets_ptr = std::distance(miit, hi_miit);
392 }
393 return true;
394}
395
397 const int ms_id,
398 const std::string name) {
399 Interface &m_field = cOre;
400 moab::Interface &moab = m_field.get_moab();
402 if (checkMeshset(ms_id, cubit_bc_type)) {
403 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
404 "such cubit meshset is already there id = %d", ms_id);
405 }
406
407 CubitMeshSets cmeshset(moab, cubit_bc_type, ms_id);
408 if ((cmeshset.cubitBcType & CubitBCType(NODESET | SIDESET | BLOCKSET))
409 .any()) {
410 auto p = cubitMeshsets.insert(cmeshset);
411 if (!p.second) {
412 SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
413 "meshset not inserted");
414 }
415 if (name.size() > 0) {
416 bool success =
417 cubitMeshsets.modify(p.first, CubitMeshSets_change_name(moab, name));
418 if (!success) {
419 SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
420 "name to cubit meshset can not be set");
421 }
422 }
423 }
424
426}
427
430 const int ms_id, const Range &ents) {
431 Interface &m_field = cOre;
432 moab::Interface &moab = m_field.get_moab();
434 auto cit =
436 boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
437 if (cit ==
439 SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
440 "Cannot find Cubit meshset with id: %d", ms_id);
441 }
442 EntityHandle meshset = cit->getMeshset();
443 CHKERR moab.add_entities(meshset, ents);
444
446}
447
450 const int ms_id, const EntityHandle *ents,
451 const int nb_ents) {
452 Interface &m_field = cOre;
453 moab::Interface &moab = m_field.get_moab();
455 auto cit =
457 boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
458 if (cit ==
460 SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
461 "Cannot find Cubit meshset with id: %d", ms_id);
462 }
463 EntityHandle meshset = cit->getMeshset();
464 CHKERR moab.add_entities(meshset, ents, nb_ents);
465
467}
468
470MeshsetsManager::setAtributes(const CubitBCType cubit_bc_type, const int ms_id,
471 const std::vector<double> &attributes,
472 const std::string name) {
473 Interface &m_field = cOre;
474 moab::Interface &moab = m_field.get_moab();
476 auto cit =
478 boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
479 if (cit ==
481 SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
482 "Cannot find Cubit meshset with id: %d", ms_id);
483 }
484 if (name.size() > 0) {
485 bool success = cubitMeshsets.modify(cubitMeshsets.project<0>(cit),
486 CubitMeshSets_change_name(moab, name));
487 if (!success) {
488 SETERRQ(m_field.get_comm(), MOFEM_OPERATION_UNSUCCESSFUL,
489 "name to cubit meshset can not be set");
490 }
491 }
492 bool success =
493 cubitMeshsets.modify(cubitMeshsets.project<0>(cit),
494 CubitMeshSets_change_attributes(moab, attributes));
495 if (!success)
496 SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
497 "modification unsuccessful");
498
499 std::ostringstream ss;
500 ss << "Block " << cit->getName();
501 ss << " Add attr: ";
502 for (unsigned int ii = 0; ii != attributes.size(); ii++) {
503 ss << attributes[ii] << " ";
504 }
505 MOFEM_LOG("MeshsetMngSelf", Sev::noisy) << ss.str();
506
508}
509
511 const CubitBCType cubit_bc_type, const int ms_id,
512 const GenericAttributeData &data, const std::string name) {
513 Interface &m_field = cOre;
514 moab::Interface &moab = m_field.get_moab();
516 auto cit =
518 boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
519 if (cit ==
521 SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
522 "Cannot find Cubit meshset with id: %d", ms_id);
523 }
524 if (name.size() > 0) {
525 bool success = cubitMeshsets.modify(cubitMeshsets.project<0>(cit),
526 CubitMeshSets_change_name(moab, name));
527 if (!success) {
528 SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
529 "name to cubit meshset can not be set");
530 }
531 }
532 bool success = cubitMeshsets.modify(
533 cubitMeshsets.project<0>(cit),
535 if (!success)
536 SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
537 "modification unsuccessful");
539}
540
542 const int ms_id,
543 const GenericCubitBcData &data) {
544 Interface &m_field = cOre;
545 moab::Interface &moab = m_field.get_moab();
547 auto cit =
549 boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
550 if (cit ==
552 SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
553 "Cubit meshset with id is already there id = %d", ms_id);
554 }
555 bool success =
556 cubitMeshsets.modify(cubitMeshsets.project<0>(cit),
558 if (!success)
559 SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
560 "modification unsuccessful");
562}
563
565 const int ms_id,
566 const MoFEMTypes bh) {
567 Interface &m_field = cOre;
568 moab::Interface &moab = m_field.get_moab();
570 auto miit =
572 boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
573 if (miit ==
575 if (bh & MF_EXIST) {
576 SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
577 "meshset not found id = %d", ms_id);
578 } else {
580 }
581 }
582 EntityHandle meshset = miit->getMeshset();
584 CHKERR moab.delete_entities(&meshset, 1);
585
587}
588
590 const int ms_id, const CubitBCType cubit_bc_type,
591 const CubitMeshSets **cubit_meshset_ptr) const {
592 Interface &m_field = cOre;
594 auto miit =
596 boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
597 if (miit !=
599 *cubit_meshset_ptr = &*miit;
600 } else {
601 SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
602 "msId = %d is not there", ms_id);
603 }
605}
606
607const CubitMeshSets *
609 const CubitBCType cubit_bc_type) const {
610 const CubitMeshSets *cubit_meshset_ptr;
612 getCubitMeshsetPtr(ms_id, cubit_bc_type, &cubit_meshset_ptr),
613 "Get not get meshset");
614 return cubit_meshset_ptr;
615}
616
618 const string name, const CubitMeshSets **cubit_meshset_ptr) const {
619 Interface &m_field = cOre;
621 auto miit = cubitMeshsets.get<CubitMeshsets_name>().lower_bound(name);
622 auto hi_miit = cubitMeshsets.get<CubitMeshsets_name>().upper_bound(name);
623 if (std::distance(miit, hi_miit) == 0) {
624 SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
625 "meshset name <%s> is not there", name.c_str());
626 }
627 if (std::distance(miit, hi_miit) > 1) {
628 SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
629 "more that one meshser of that name <%s>", name.c_str());
630 }
631 *cubit_meshset_ptr = &*miit;
633}
634
636 const CubitBCType cubit_bc_type,
637 std::vector<const CubitMeshSets *> &vec_ptr) const {
639 auto r = cubitMeshsets.get<CubitMeshsetType_mi_tag>().equal_range(
640 cubit_bc_type.to_ulong());
641 for (auto it = r.first; it != r.second; ++it) {
642 vec_ptr.push_back(&*it);
643 }
644 sortMeshsets(vec_ptr);
646}
647
648std::vector<const CubitMeshSets *>
650 std::vector<const CubitMeshSets *> vec_ptr;
651 CHK_MOAB_THROW(getCubitMeshsetPtr(cubit_bc_type, vec_ptr),
652 "Error in getting meshsets by name");
653 return vec_ptr;
654}
655
657 const std::regex reg_exp_name,
658 std::vector<const CubitMeshSets *> &vec_ptr) const {
660 auto r =
662 for (; r.first != r.second; ++r.first) {
663 const auto name = r.first->getName();
664 if (std::regex_match(name, reg_exp_name)) {
665 vec_ptr.push_back(&*r.first);
666 }
667 }
668 sortMeshsets(vec_ptr);
670}
671
672std::vector<const CubitMeshSets *>
673MeshsetsManager::getCubitMeshsetPtr(const std::regex reg_exp_name) const {
674 std::vector<const CubitMeshSets *> vec_ptr;
675 CHK_MOAB_THROW(getCubitMeshsetPtr(reg_exp_name, vec_ptr),
676 "Error in getting meshsets by name");
677 return vec_ptr;
678}
679
681 const int msId, const unsigned int cubit_bc_type, const int dimension,
682 Range &entities, const bool recursive) const {
683 Interface &m_field = cOre;
684 moab::Interface &moab = m_field.get_moab();
686 auto miit =
688 boost::make_tuple(msId, cubit_bc_type));
689 if (miit !=
691 CHKERR miit->getMeshsetIdEntitiesByDimension(moab, dimension, entities,
692 recursive);
693 } else {
694 SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
695 "msId = %d is not there", msId);
696 }
698}
699
701 const int ms_id, const unsigned int cubit_bc_type, Range &entities,
702 const bool recursive) const {
703 Interface &m_field = cOre;
704 moab::Interface &moab = m_field.get_moab();
706 auto miit =
708 boost::make_tuple(ms_id, cubit_bc_type));
709 if (miit !=
711 CHKERR miit->getMeshsetIdEntitiesByDimension(moab, entities, recursive);
712 } else {
713 SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
714 "ms_id = %d is not there", ms_id);
715 }
717}
718
720 const unsigned int cubit_bc_type,
721 EntityHandle &meshset) const {
722 Interface &m_field = cOre;
724 auto miit =
726 boost::make_tuple(ms_id, cubit_bc_type));
727 if (miit !=
729 meshset = miit->meshset;
730 } else {
731 SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
732 "ms_id = %d is not there", ms_id);
733 }
735}
736
738 const int ms_id, const unsigned int cubit_bc_type,
739 const EntityHandle *entities, int num_entities, const int operation_type) {
740 auto miit =
742 boost::make_tuple(ms_id, cubit_bc_type));
743 if (miit !=
745 Interface &m_field = cOre;
746 return m_field.get_moab().contains_entities(miit->meshset, entities,
747 num_entities, operation_type);
748 } else
749 return false;
750}
751
753MeshsetsManager::getMeshsetsByType(const unsigned int cubit_bc_type,
754 Range &meshsets) const {
756 auto miit =
757 cubitMeshsets.get<CubitMeshsetType_mi_tag>().lower_bound(cubit_bc_type);
758 auto hi_miit =
759 cubitMeshsets.get<CubitMeshsetType_mi_tag>().upper_bound(cubit_bc_type);
760 for (; miit != hi_miit; miit++) {
761 meshsets.insert(miit->meshset);
762 }
764}
765
766struct BlockData {
767
769
770 int iD;
771 string addType;
772 string nAme;
774
775 // Materials
780
781 // BCs
788
790 std::vector<double> aTtr;
791
793 std::memcpy(dispBc.data.name, "Displacement", 12);
794 std::memcpy(forceBc.data.name, "Force", 5);
795 std::memcpy(pressureBc.data.name, "Pressure", 8);
796 std::memcpy(temperatureBc.data.name, "Temperature", 11);
797 std::memcpy(heatFluxBc.data.name, "HeatFlux", 8);
798 std::memcpy(cfgBc.data.name, "cfd_bc", 6);
799 }
800};
801
803 bool clean_file_options) {
804 Interface &m_field = cOre;
806 std::ifstream ini_file(file_name.c_str(), std::ifstream::in);
807 po::variables_map vm;
808 if (clean_file_options) {
810 boost::shared_ptr<boost::program_options::options_description>(
811 new po::options_description());
812 }
813
814 auto add_block_attributes = [&](auto prefix, auto &block_lists, auto &it) {
815 // remove spacec from blockset name
816 configFileOptionsPtr->add_options()(
817 (prefix + ".number_of_attributes").c_str(),
818 po::value<int>(&block_lists[it->getMeshsetId()].numberOfAttributes)
819 ->default_value(-1),
820 "Number of blockset attribute");
821 for (int ii = 1; ii <= 10; ii++) {
822 std::string surfix = ".user" + boost::lexical_cast<std::string>(ii);
823 configFileOptionsPtr->add_options()(
824 (prefix + surfix).c_str(),
825 po::value<double>(&block_lists[it->getMeshsetId()].aTtr[ii - 1])
826 ->default_value(0.0),
827 "Add block attribute");
828 }
829 };
830
831 // Add blocks
832 map<int, BlockData> block_lists;
834 block_lists[it->getMeshsetId()].cubitMeshset = it->getMeshset();
835 std::string prefix =
836 "block_" + boost::lexical_cast<std::string>(it->getMeshsetId());
837 configFileOptionsPtr->add_options()(
838 (prefix + ".add").c_str(),
839 po::value<string>(&block_lists[it->getMeshsetId()].addType)
840 ->default_value("UNKNOWNSET"),
841 "Add block set")(
842 (prefix + ".id").c_str(),
843 po::value<int>(&block_lists[it->getMeshsetId()].iD)->default_value(-1),
844 "Id of meshset")(
845 (prefix + ".name").c_str(),
846 po::value<string>(&block_lists[it->getMeshsetId()].nAme)
847 ->default_value(""),
848 "Name of the meshset");
849
850 // Block attributes
851 add_block_attributes(prefix, block_lists, it);
852
853 // Mat elastic
854 {
855 // double Young; ///< Young's modulus
856 // double Poisson; ///< Poisson's ratio
857 // double ThermalExpansion; ///< Thermal expansion
858 configFileOptionsPtr->add_options()(
859 (prefix + ".young").c_str(),
860 po::value<double>(
861 &block_lists[it->getMeshsetId()].matElastic.data.Young)
862 ->default_value(-1),
863 "Young modulus")(
864 (prefix + ".poisson").c_str(),
865 po::value<double>(
866 &block_lists[it->getMeshsetId()].matElastic.data.Poisson)
867 ->default_value(-2),
868 "Poisson ratio")(
869 (prefix + ".thermalexpansion").c_str(),
870 po::value<double>(
871 &block_lists[it->getMeshsetId()].matElastic.data.ThermalExpansion)
872 ->default_value(-1),
873 "Thermal expansion");
874 // TODO Add users parameters
875 }
876 // Mat Trans Iso
877 {
878 // Young's modulus in xy plane (Ep)
879 // Young's modulus in z-direction (Ez)
880 // Poisson's ratio in xy plane (vp)
881 // Poisson's ratio in z-direction (vpz)
882 // Shear modulus in z-direction (Gzp)
883 configFileOptionsPtr->add_options()(
884 (prefix + ".Youngp").c_str(),
885 po::value<double>(
886 &block_lists[it->getMeshsetId()].matTransIso.data.Youngp)
887 ->default_value(-1),
888 "Youngp")(
889 (prefix + ".Youngz").c_str(),
890 po::value<double>(
891 &block_lists[it->getMeshsetId()].matTransIso.data.Youngz)
892 ->default_value(-1),
893 "Youngz")(
894 (prefix + ".Poissonp").c_str(),
895 po::value<double>(
896 &block_lists[it->getMeshsetId()].matTransIso.data.Poissonp)
897 ->default_value(0),
898 "Poissonp")(
899 (prefix + ".Poissonpz").c_str(),
900 po::value<double>(
901 &block_lists[it->getMeshsetId()].matTransIso.data.Poissonpz)
902 ->default_value(0),
903 "Poissonpz")(
904 (prefix + ".Shearzp").c_str(),
905 po::value<double>(
906 &block_lists[it->getMeshsetId()].matTransIso.data.Shearzp)
907 ->default_value(-1),
908 "Shearzp");
909 // TODO Add users parameters
910 }
911 // Mat thermal
912 {
913 // double Conductivity; ///< Thermal conductivity
914 // double HeatCapacity; ///< Heat Capacity
915 configFileOptionsPtr->add_options()(
916 (prefix + ".conductivity").c_str(),
917 po::value<double>(
918 &block_lists[it->getMeshsetId()].matThermal.data.Conductivity)
919 ->default_value(-1),
920 "Conductivity")(
921 (prefix + ".capacity").c_str(),
922 po::value<double>(
923 &block_lists[it->getMeshsetId()].matThermal.data.HeatCapacity)
924 ->default_value(-1),
925 "Capacity");
926 // TODO Add users parameters
927 }
928 // Mat interface
929 {
930 // double alpha; ///< Elastic modulus multiplier
931 // double beta; ///< Damage Coupling multiplier between normal and
932 // shear (g=sqrt(gn^2 + beta(gt1^2 + gt2^2))) double ft; ///< Maximum
933 // stress of crack double Gf; ///< Fracture Energy
934 configFileOptionsPtr->add_options()(
935 (prefix + ".interface_alpha").c_str(),
936 po::value<double>(
937 &block_lists[it->getMeshsetId()].matInterf.data.alpha)
938 ->default_value(-1),
939 "alpha")((prefix + ".interface_beta").c_str(),
940 po::value<double>(
941 &block_lists[it->getMeshsetId()].matInterf.data.beta)
942 ->default_value(-1),
943 "beta")(
944 (prefix + ".interface_ft").c_str(),
945 po::value<double>(&block_lists[it->getMeshsetId()].matInterf.data.ft)
946 ->default_value(-1),
947 "ft")(
948 (prefix + ".interface_Gf").c_str(),
949 po::value<double>(&block_lists[it->getMeshsetId()].matInterf.data.Gf)
950 ->default_value(-1),
951 "Gf");
952 // TODO Add users parameters
953 }
954
955 // Displacement bc
956 {
957 // char flag1; //< Flag for X-Translation (0: N/A, 1: specified)
958 // char flag2; //< Flag for Y-Translation (0: N/A, 1: specified)
959 // char flag3; //< Flag for Z-Translation (0: N/A, 1: specified)
960 // char flag4; //< Flag for X-Rotation (0: N/A, 1: specified)
961 // char flag5; //< Flag for Y-Rotation (0: N/A, 1: specified)
962 // char flag6; //< Flag for Z-Rotation (0: N/A, 1: specified)
963 // double value1; //< Value for X-Translation
964 // double value2; //< Value for Y-Translation
965 // double value3; //< Value for Z-Translation
966 // double value4; //< Value for X-Rotation
967 // double value5; //< Value for Y-Rotation
968 // double value6; //< Value for Z-Rotation
969 configFileOptionsPtr->add_options()(
970 (prefix + ".disp_flag1").c_str(),
971 po::value<char>(&block_lists[it->getMeshsetId()].dispBc.data.flag1)
972 ->default_value(0),
973 "flag1")(
974 (prefix + ".disp_flag2").c_str(),
975 po::value<char>(&block_lists[it->getMeshsetId()].dispBc.data.flag2)
976 ->default_value(0),
977 "flag2")(
978 (prefix + ".disp_flag3").c_str(),
979 po::value<char>(&block_lists[it->getMeshsetId()].dispBc.data.flag3)
980 ->default_value(0),
981 "flag3")(
982 (prefix + ".disp_flag4").c_str(),
983 po::value<char>(&block_lists[it->getMeshsetId()].dispBc.data.flag4)
984 ->default_value(0),
985 "flag4")(
986 (prefix + ".disp_flag5").c_str(),
987 po::value<char>(&block_lists[it->getMeshsetId()].dispBc.data.flag5)
988 ->default_value(0),
989 "flag5")(
990 (prefix + ".disp_flag6").c_str(),
991 po::value<char>(&block_lists[it->getMeshsetId()].dispBc.data.flag6)
992 ->default_value(0),
993 "flag6")(
994 (prefix + ".disp_ux").c_str(),
995 po::value<double>(&block_lists[it->getMeshsetId()].dispBc.data.value1)
996 ->default_value(0),
997 "value1")(
998 (prefix + ".disp_uy").c_str(),
999 po::value<double>(&block_lists[it->getMeshsetId()].dispBc.data.value2)
1000 ->default_value(0),
1001 "value2")(
1002 (prefix + ".disp_uz").c_str(),
1003 po::value<double>(&block_lists[it->getMeshsetId()].dispBc.data.value3)
1004 ->default_value(0),
1005 "value3")(
1006 (prefix + ".disp_rx").c_str(),
1007 po::value<double>(&block_lists[it->getMeshsetId()].dispBc.data.value4)
1008 ->default_value(0),
1009 "value4")(
1010 (prefix + ".disp_ry").c_str(),
1011 po::value<double>(&block_lists[it->getMeshsetId()].dispBc.data.value5)
1012 ->default_value(0),
1013 "value5")(
1014 (prefix + ".disp_rz").c_str(),
1015 po::value<double>(&block_lists[it->getMeshsetId()].dispBc.data.value6)
1016 ->default_value(0),
1017 "value6");
1018 }
1019 // Force BC data
1020 {
1021 // char zero[3]; //< 3 zeros
1022 // double value1; //< Force magnitude
1023 // double value2; //< Moment magnitude
1024 // double value3; //< X-component of force direction vector
1025 // double value4; //< Y-component of force direction vector
1026 // double value5; //< Z-component of force direction vector
1027 // double value6; //< X-component of moment direction vector
1028 // double value7; //< Y-component of moment direction vector
1029 // double value8; //< Z-component of moment direction vector
1030 // char zero2; // 0
1031 configFileOptionsPtr->add_options()(
1032 (prefix + ".force_magnitude").c_str(),
1033 po::value<double>(
1034 &block_lists[it->getMeshsetId()].forceBc.data.value1)
1035 ->default_value(0),
1036 "value1")((prefix + ".moment_magnitude").c_str(),
1037 po::value<double>(
1038 &block_lists[it->getMeshsetId()].forceBc.data.value2)
1039 ->default_value(0),
1040 "value2")(
1041 (prefix + ".force_fx").c_str(),
1042 po::value<double>(
1043 &block_lists[it->getMeshsetId()].forceBc.data.value3)
1044 ->default_value(0),
1045 "value3")((prefix + ".force_fy").c_str(),
1046 po::value<double>(
1047 &block_lists[it->getMeshsetId()].forceBc.data.value4)
1048 ->default_value(0),
1049 "value4")(
1050 (prefix + ".force_fz").c_str(),
1051 po::value<double>(
1052 &block_lists[it->getMeshsetId()].forceBc.data.value5)
1053 ->default_value(0),
1054 "value5")((prefix + ".moment_mx").c_str(),
1055 po::value<double>(
1056 &block_lists[it->getMeshsetId()].forceBc.data.value6)
1057 ->default_value(0),
1058 "value6")(
1059 (prefix + ".moment_my").c_str(),
1060 po::value<double>(
1061 &block_lists[it->getMeshsetId()].forceBc.data.value7)
1062 ->default_value(0),
1063 "value7")((prefix + ".moment_mz").c_str(),
1064 po::value<double>(
1065 &block_lists[it->getMeshsetId()].forceBc.data.value8)
1066 ->default_value(0),
1067 "value8");
1068 }
1069 {
1070 // char name[11]; //< 11 characters for "Temperature"
1071 // char pre1; //< This is always zero
1072 // char pre2; //< 0: temperature is not applied on thin shells
1073 // (default); 1: temperature is applied on thin shells char flag1; //<
1074 // 0: N/A, 1: temperature value applied (not on thin shells) char flag2;
1075 // //< 0: N/A, 1: temperature applied on thin shell middle char flag3;
1076 // //< 0: N/A, 1: thin shell temperature gradient specified char flag4;
1077 // //< 0: N/A, 1: top thin shell temperature char flag5; //< 0: N/A, 1:
1078 // bottom thin shell temperature char flag6; //< This is always zero
1079 // double value1; //< Temperature (default case - no thin shells)
1080 // double value2; //< Temperature for middle of thin shells
1081 // double value3; //< Temperature gradient for thin shells
1082 // double value4; //< Temperature for top of thin shells
1083 // double value5; //< Temperature for bottom of thin shells
1084 // double value6; //< This is always zero, i.e. ignore
1085 configFileOptionsPtr->add_options()(
1086 (prefix + ".temperature_flag1").c_str(),
1087 po::value<char>(
1088 &block_lists[it->getMeshsetId()].temperatureBc.data.flag1)
1089 ->default_value(0),
1090 "flag1")(
1091 (prefix + ".temperature_t").c_str(),
1092 po::value<double>(
1093 &block_lists[it->getMeshsetId()].temperatureBc.data.value1)
1094 ->default_value(0),
1095 "value1");
1096 // TODO: Add more cases, see above
1097 }
1098 // Sideset
1099 {
1100 // char name[8]; //< 8 characters for "Pressure"
1101 // char zero; //< This is always zero
1102 // char flag2; //< 0: Pressure is interpreted as pure pressure 1:
1103 // pressure is interpreted as total force double value1; //< Pressure
1104 // value
1105 configFileOptionsPtr->add_options()(
1106 (prefix + ".pressure_flag2").c_str(),
1107 po::value<char>(
1108 &block_lists[it->getMeshsetId()].pressureBc.data.flag2)
1109 ->default_value(0),
1110 "flag2")((prefix + ".pressure_magnitude").c_str(),
1111 po::value<double>(
1112 &block_lists[it->getMeshsetId()].pressureBc.data.value1)
1113 ->default_value(0),
1114 "value1");
1115 }
1116 {
1117 // char name[8]; //< 8 characters for "HeatFlux" (no space)
1118 // char pre1; //< This is always zero
1119 // char pre2; //< 0: heat flux is not applied on thin shells (default);
1120 // 1: heat flux is applied on thin shells char flag1; //< 0: N/A, 1:
1121 // normal heat flux case (i.e. single value, case without thin shells)
1122 // char flag2; //< 0: N/A, 1: Thin shell top heat flux specified
1123 // char flag3; //< 0: N/A, 1: Thin shell bottom heat flux specidied
1124 // double value1; //< Heat flux value for default case (no thin shells)
1125 // double value2; //< Heat flux (thin shell top)
1126 // double value3; //< Heat flux (thin shell bottom)
1127 configFileOptionsPtr->add_options()(
1128 (prefix + ".heatflux_flag1").c_str(),
1129 po::value<char>(
1130 &block_lists[it->getMeshsetId()].heatFluxBc.data.flag1)
1131 ->default_value(0),
1132 "flag1")((prefix + ".heatflux_magnitude").c_str(),
1133 po::value<double>(
1134 &block_lists[it->getMeshsetId()].heatFluxBc.data.value1)
1135 ->default_value(0),
1136 "value1");
1137 }
1138 // Interface set
1139 {
1140 configFileOptionsPtr->add_options()(
1141 (prefix + ".interface_type").c_str(),
1142 po::value<char>(&block_lists[it->getMeshsetId()].cfgBc.data.type)
1143 ->default_value(0),
1144 "type");
1145 }
1146 }
1147
1148 map<int, BlockData> block_set_attributes;
1150 block_set_attributes[it->getMeshsetId()].cubitMeshset = it->getMeshset();
1151 block_set_attributes[it->getMeshsetId()].iD = it->getMeshsetId();
1152 block_set_attributes[it->getMeshsetId()].bcType = BLOCKSET;
1153 std::string block_name = it->getName();
1154 block_name.erase(
1155 std::remove_if(block_name.begin(), block_name.end(), ::isspace),
1156 block_name.end());
1157 block_set_attributes[it->getMeshsetId()].nAme = block_name;
1158 // Only blocks which have name
1159 if (block_name.compare("NoNameSet") != 0) {
1160 std::string prefix = "SET_ATTR_" + block_name;
1161 // Block attributes
1162 add_block_attributes(prefix, block_set_attributes, it);
1163 }
1164 }
1165
1166 po::parsed_options parsed =
1167 parse_config_file(ini_file, *configFileOptionsPtr, true);
1168 store(parsed, vm);
1169 po::notify(vm);
1170
1171 // Set type from name
1173
1174 CubitBCType bc_type;
1175 unsigned jj = 0;
1176 while (1 << jj != LASTSET_BC) {
1177 if (string(CubitBCNames[jj + 1]) ==
1178 block_lists[it->getMeshsetId()].addType) {
1179 bc_type = 1 << jj;
1180 }
1181 ++jj;
1182 }
1183 if (bc_type.none()) {
1184 block_lists[it->getMeshsetId()].bcType = UNKNOWNSET;
1185 // Skip the bockset nothing is defined for it
1186 continue;
1187 }
1188
1189 if (bc_type.to_ulong() == BLOCKSET)
1190 block_lists[it->getMeshsetId()].bcType = BLOCKSET;
1191 else if (bc_type.to_ulong() == NODESET)
1192 block_lists[it->getMeshsetId()].bcType = NODESET;
1193 else if (bc_type.to_ulong() == SIDESET)
1194 block_lists[it->getMeshsetId()].bcType = SIDESET;
1195 else {
1196 SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
1197 "Not yet implemented type %s\n",
1198 block_lists[it->getMeshsetId()].addType.c_str());
1199 }
1200 if (block_lists[it->getMeshsetId()].iD == -1) {
1201 SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
1202 "Unset iD number %d\n", block_lists[it->getMeshsetId()].iD);
1203 }
1204 }
1205
1206 std::vector<std::string> additional_parameters;
1207 additional_parameters =
1208 collect_unrecognized(parsed.options, po::include_positional);
1209 for (std::vector<std::string>::iterator vit = additional_parameters.begin();
1210 vit != additional_parameters.end(); vit++) {
1211 MOFEM_LOG_C("MeshsetMngSelf", Sev::warning, "Unrecognized option %s",
1212 vit->c_str());
1213 }
1214 for (map<int, BlockData>::iterator mit = block_lists.begin();
1215 mit != block_lists.end(); mit++) {
1216 CubitMeshSet_multiIndex::iterator cubit_meshset_it =
1217 cubitMeshsets.find(mit->second.cubitMeshset);
1218 if (cubit_meshset_it == cubitMeshsets.end()) {
1219 SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
1220 "Data inconsistency\n");
1221 }
1222 switch (mit->second.bcType) {
1223 case UNKNOWNSET:
1224 break;
1225 case BLOCKSET: {
1226 if ((CubitBCType(mit->second.bcType) & cubit_meshset_it->getBcType())
1227 .any() &&
1228 mit->second.iD == cubit_meshset_it->getMeshsetId()) {
1229 // Meshset is the same, only modification
1230 } else {
1231 CHKERR addMeshset(mit->second.bcType, mit->second.iD, mit->second.nAme);
1232 EntityHandle meshset = cubit_meshset_it->getMeshset();
1233 CHKERR addEntitiesToMeshset(mit->second.bcType, mit->second.iD,
1234 &meshset, 1);
1235 }
1236 // Add attributes
1237 CHKERR setAtributes(mit->second.bcType, mit->second.iD, mit->second.aTtr);
1238 // Add material elastic data if value are physical (i.e. Young > 0,
1239 // Poisson in (-1.0.5) and ThermalExpansion>0)
1240 if (mit->second.matElastic.data.Young != -1) {
1241 CHKERR setAtributesByDataStructure(mit->second.bcType, mit->second.iD,
1242 mit->second.matElastic);
1243 }
1244 if (mit->second.matTransIso.data.Youngp != -1) {
1245 CHKERR setAtributesByDataStructure(mit->second.bcType, mit->second.iD,
1246 mit->second.matTransIso);
1247 }
1248 if (mit->second.matThermal.data.Conductivity != -1) {
1249 CHKERR setAtributesByDataStructure(mit->second.bcType, mit->second.iD,
1250 mit->second.matThermal);
1251 }
1252 if (mit->second.matInterf.data.ft != -1) {
1253 CHKERR setAtributesByDataStructure(mit->second.bcType, mit->second.iD,
1254 mit->second.matInterf);
1255 }
1256 } break;
1257 case NODESET: {
1258 if ((CubitBCType(mit->second.bcType) & cubit_meshset_it->getBcType())
1259 .any() &&
1260 mit->second.iD == cubit_meshset_it->getMeshsetId()) {
1261 // Meshset is the same, only modification
1262 } else {
1263 CHKERR addMeshset(mit->second.bcType, mit->second.iD);
1264 EntityHandle meshset = cubit_meshset_it->getMeshset();
1265 CHKERR addEntitiesToMeshset(mit->second.bcType, mit->second.iD,
1266 &meshset, 1);
1267 }
1268 // Add displacement bc
1269 if (mit->second.dispBc.data.flag1 || mit->second.dispBc.data.flag2 ||
1270 mit->second.dispBc.data.flag3 || mit->second.dispBc.data.flag4 ||
1271 mit->second.dispBc.data.flag5 || mit->second.dispBc.data.flag6) {
1272 if (mit->second.dispBc.data.flag1 == '0')
1273 mit->second.dispBc.data.flag1 = 0;
1274 if (mit->second.dispBc.data.flag1 == 'N')
1275 mit->second.dispBc.data.flag1 = 0;
1276 if (mit->second.dispBc.data.flag1)
1277 mit->second.dispBc.data.flag1 = 1;
1278 if (mit->second.dispBc.data.flag2 == '0')
1279 mit->second.dispBc.data.flag2 = 0;
1280 if (mit->second.dispBc.data.flag2 == 'N')
1281 mit->second.dispBc.data.flag2 = 0;
1282 if (mit->second.dispBc.data.flag2)
1283 mit->second.dispBc.data.flag2 = 1;
1284 if (mit->second.dispBc.data.flag3 == '0')
1285 mit->second.dispBc.data.flag3 = 0;
1286 if (mit->second.dispBc.data.flag3 == 'N')
1287 mit->second.dispBc.data.flag3 = 0;
1288 if (mit->second.dispBc.data.flag3)
1289 mit->second.dispBc.data.flag3 = 1;
1290 if (mit->second.dispBc.data.flag4 == '0')
1291 mit->second.dispBc.data.flag4 = 0;
1292 if (mit->second.dispBc.data.flag4 == 'N')
1293 mit->second.dispBc.data.flag4 = 0;
1294 if (mit->second.dispBc.data.flag4)
1295 mit->second.dispBc.data.flag4 = 1;
1296 if (mit->second.dispBc.data.flag5 == '0')
1297 mit->second.dispBc.data.flag5 = 0;
1298 if (mit->second.dispBc.data.flag5 == 'N')
1299 mit->second.dispBc.data.flag5 = 0;
1300 if (mit->second.dispBc.data.flag5)
1301 mit->second.dispBc.data.flag5 = 1;
1302 if (mit->second.dispBc.data.flag6 == '0')
1303 mit->second.dispBc.data.flag6 = 0;
1304 if (mit->second.dispBc.data.flag6 == 'N')
1305 mit->second.dispBc.data.flag6 = 0;
1306 if (mit->second.dispBc.data.flag6)
1307 mit->second.dispBc.data.flag6 = 1;
1308 CHKERR setBcData(mit->second.bcType, mit->second.iD,
1309 mit->second.dispBc);
1310 }
1311 if (mit->second.forceBc.data.value1 != 0 ||
1312 mit->second.forceBc.data.value2 != 0) {
1313 CHKERR setBcData(mit->second.bcType, mit->second.iD,
1314 mit->second.forceBc);
1315 }
1316 // Add temperature boundary condition
1317 if (mit->second.temperatureBc.data.flag1) {
1318 if (mit->second.temperatureBc.data.flag1 == '0')
1319 mit->second.temperatureBc.data.flag1 = 0;
1320 if (mit->second.temperatureBc.data.flag1 == 'N')
1321 mit->second.temperatureBc.data.flag1 = 0;
1322 if (mit->second.temperatureBc.data.flag1)
1323 mit->second.temperatureBc.data.flag1 = 1;
1324 CHKERR setBcData(mit->second.bcType, mit->second.iD,
1325 mit->second.temperatureBc);
1326 }
1327 } break;
1328 case SIDESET: {
1329 if ((CubitBCType(mit->second.bcType) & cubit_meshset_it->getBcType())
1330 .any() &&
1331 mit->second.iD == cubit_meshset_it->getMeshsetId()) {
1332 // Meshset is the same, only modification
1333 } else {
1334 CHKERR addMeshset(mit->second.bcType, mit->second.iD);
1335 EntityHandle meshset = cubit_meshset_it->getMeshset();
1336 CHKERR addEntitiesToMeshset(mit->second.bcType, mit->second.iD,
1337 &meshset, 1);
1338 }
1339 // Add pressure
1340 if (mit->second.pressureBc.data.value1 != 0) {
1341 if (mit->second.pressureBc.data.flag2 == '0')
1342 mit->second.pressureBc.data.flag2 = 0;
1343 if (mit->second.pressureBc.data.flag2 == 'N')
1344 mit->second.pressureBc.data.flag2 = 0;
1345 if (mit->second.pressureBc.data.flag2)
1346 mit->second.pressureBc.data.flag2 = 1;
1347 CHKERR setBcData(mit->second.bcType, mit->second.iD,
1348 mit->second.pressureBc);
1349 }
1350 // Add heat flux
1351 if (mit->second.heatFluxBc.data.value1 != 0) {
1352 if (mit->second.heatFluxBc.data.flag1 == '0')
1353 mit->second.heatFluxBc.data.flag1 = 0;
1354 if (mit->second.heatFluxBc.data.flag1 == 'N')
1355 mit->second.heatFluxBc.data.flag1 = 0;
1356 if (mit->second.heatFluxBc.data.flag1)
1357 mit->second.heatFluxBc.data.flag1 = 1;
1358 CHKERR setBcData(mit->second.bcType, mit->second.iD,
1359 mit->second.heatFluxBc);
1360 }
1361 // Add Interface
1362 if (mit->second.cfgBc.data.type != 0) {
1363 CHKERR setBcData(mit->second.bcType, mit->second.iD, mit->second.cfgBc);
1364 }
1365 } break;
1366 default:
1367 SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
1368 "Not yet implemented type\n");
1369 }
1370 }
1371
1372 for (auto set_attr : block_set_attributes) {
1373 // Add attributes
1374 if (set_attr.second.numberOfAttributes > 0) {
1375 MOFEM_LOG("MeshsetMngSelf", Sev::verbose)
1376 << "Set attributes to blockset " << set_attr.second.nAme;
1377 set_attr.second.aTtr.resize(set_attr.second.numberOfAttributes);
1378 CHKERR setAtributes(set_attr.second.bcType, set_attr.second.iD,
1379 set_attr.second.aTtr);
1380 }
1381 }
1382
1384}
1385
1387 Interface &m_field = cOre;
1388 PetscBool flg_file;
1389 char meshset_file_name[255] = "config_file.cfg";
1391 PetscOptionsBegin(m_field.get_comm(), "", "Set meshsets form file",
1392 "none");
1393 CHKERR PetscOptionsString("-meshsets_config", "meshsets config file name",
1394 "", "add_cubit_meshsets.in", meshset_file_name, 255,
1395 &flg_file);
1396 if (flg_file == PETSC_TRUE) {
1397 ifstream f(meshset_file_name);
1398 if (!f.good()) {
1399 SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
1400 "File configuring meshsets ( %s ) can not be open\n",
1401 meshset_file_name);
1402 }
1403 CHKERR setMeshsetFromFile(string(meshset_file_name));
1404 MOFEM_LOG("MeshsetMngWorld", Sev::inform)
1405 << "Printing all meshsets (old and added from meshsets "
1406 "configurational file)";
1407 for (auto cit = getBegin(); cit != getEnd(); cit++) {
1408 MOFEM_LOG("MeshsetMngWorld", Sev::inform) << *cit;
1409 }
1410 }
1411 PetscOptionsEnd();
1413}
1414
1416 const int ms_id, const unsigned int cubit_bc_type,
1417 const std::string file_name, const std::string file_type,
1418 const std::string options) const {
1419
1421 MoFEM::Interface &m_field = cOre;
1422 const CubitMeshSets *cubit_meshset_ptr;
1423 CHKERR getCubitMeshsetPtr(ms_id, cubit_bc_type, &cubit_meshset_ptr);
1424 EntityHandle meshset = cubit_meshset_ptr->getMeshset();
1425 CHKERR m_field.get_moab().write_file(file_name.c_str(), file_type.c_str(),
1426 options.c_str(), &meshset, 1);
1428}
1429
1431 const int ms_id, const unsigned int cubit_bc_type, const int dim,
1432 const std::string file_name, const bool recursive,
1433 const std::string file_type, const std::string options) const {
1434
1436 MoFEM::Interface &m_field = cOre;
1437 moab::Interface &moab = m_field.get_moab();
1438 Range entities;
1439 CHKERR getEntitiesByDimension(ms_id, cubit_bc_type, dim, entities, recursive);
1440 EntityHandle meshset;
1441 CHKERR moab.create_meshset(MESHSET_SET, meshset);
1442 CHKERR moab.add_entities(meshset, entities);
1443 CHKERR moab.write_file(file_name.c_str(), file_type.c_str(), options.c_str(),
1444 &meshset, 1);
1445 CHKERR moab.delete_entities(&meshset, 1);
1447}
1448
1453 for (_IT_CUBITMESHSETS_FOR_LOOP_((*this), iit)) {
1454 EntityHandle meshset = iit->getMeshset();
1455 for (EntityType t = MBVERTEX; t != MBENTITYSET; ++t)
1456 CHKERR bit_mng->updateMeshsetByEntitiesChildren(meshset, bit, meshset, t,
1457 true);
1458 }
1460}
1461
1462} // namespace MoFEM
#define MOFEM_LOG_SEVERITY_SYNC(comm, severity)
Synchronise "SYNC" on curtain severity level.
#define MOFEM_LOG_C(channel, severity, format,...)
constexpr double a
MoFEMTypes
Those types control how functions respond on arguments, f.e. error handling.
@ MF_EXIST
#define CHK_THROW_MESSAGE(err, msg)
Check and throw MoFEM exception.
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
#define MYPCOMM_INDEX
default communicator number PCOMM
#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.
CubitBC
Types of sets and boundary conditions.
@ MAT_ELASTICSET
block name is "MAT_ELASTIC"
@ NODESET
@ SIDESET
@ LASTSET_BC
@ MAT_THERMALSET
block name is "MAT_THERMAL"
@ MAT_MOISTURESET
block name is "MAT_MOISTURE"
@ UNKNOWNSET
@ BLOCKSET
@ MOFEM_OPERATION_UNSUCCESSFUL
Definition definitions.h:34
@ MOFEM_DATA_INCONSISTENCY
Definition definitions.h:31
static const char *const CubitBCNames[]
Names of types of sets and boundary conditions.
#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 ...
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.
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.
MoFEMErrorCode getMeshset(const int ms_id, const unsigned int cubit_bc_type, EntityHandle &meshset) const
get meshset from CUBIT Id and CUBIT type
bool checkMeshset(const int ms_id, const CubitBCType cubit_bc_type) const
check for CUBIT Id and CUBIT type
CubitMeshSet_multiIndex::iterator getBegin() const
get begin iterator of cubit mehset of given type (instead you can use IT_CUBITMESHSETS_TYPE_FOR_LOOP(...
#define _IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(MESHSET_MANAGER, CUBITBCTYPE, IT)
Iterator that loops over a specific Cubit MeshSet in a moFEM field.
MoFEMErrorCode addMeshset(const CubitBCType cubit_bc_type, const int ms_id, const std::string name="")
add cubit meshset
MoFEMErrorCode getMeshsetsByType(const unsigned int cubit_bc_type, Range &meshsets) const
get all CUBIT meshsets by CUBIT type
MoFEMErrorCode getCubitMeshsetPtr(const int ms_id, const CubitBCType cubit_bc_type, const CubitMeshSets **cubit_meshset_ptr) const
get cubit meshset
#define _IT_CUBITMESHSETS_FOR_LOOP_(MESHSET_MANAGER, IT)
Iterator that loops over all the Cubit MeshSets in a moFEM field.
MoFEMErrorCode getEntitiesByDimension(const int ms_id, const unsigned int cubit_bc_type, const int dimension, Range &entities, const bool recursive=true) const
get entities from CUBIT/meshset of a particular entity dimension
CubitMeshSet_multiIndex::iterator getEnd() const
get begin iterator of cubit mehset of given type (instead you can use IT_CUBITMESHSETS_TYPE_FOR_LOOP(...
#define _IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(MESHSET_MANAGER, CUBITBCTYPE, IT)
Iterator that loops over a specific Cubit MeshSet having a particular BC meshset in a moFEM field.
auto bit
set bit
FTensor::Index< 'i', SPACE_DIM > i
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
std::bitset< 32 > CubitBCType
Definition Types.hpp:52
implementation of Data Operators for Forces and Sources
Definition Common.hpp:10
constexpr double t
plate stiffness
Definition plate.cpp:58
FTensor::Index< 'm', 3 > m
Managing BitRefLevels.
PressureCubitBcData pressureBc
CfgCubitBcData cfgBc
Mat_Elastic_TransIso matTransIso
HeatFluxCubitBcData heatFluxBc
DisplacementCubitBcData dispBc
ForceCubitBcData forceBc
std::vector< double > aTtr
TemperatureCubitBcData temperatureBc
EntityHandle cubitMeshset
Definition of the cfd_bc data structure.
Definition BCData.hpp:476
virtual moab::Interface & get_moab()=0
virtual MPI_Comm & get_comm() const =0
Core (interface) class.
Definition Core.hpp:82
this struct keeps basic methods for moab meshset about material and boundary conditions
unsigned long int getMaskedBcTypeULong() const
get meshset type and mask
EntityHandle getMeshset() const
get bc meshset
int getMeshsetId() const
get meshset id as it set in preprocessing software
MultiIndex Tag for field id.
Deprecated interface functions.
Definition of the displacement bc data structure.
Definition BCData.hpp:72
Definition of the force bc data structure.
Definition BCData.hpp:135
Generic attribute data structure.
Generic bc data structure.
Definition BCData.hpp:16
const CubitBCType tYpe
Type of boundary condition.
Definition BCData.hpp:55
Definition of the heat flux bc data structure.
Definition BCData.hpp:423
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.
Transverse Isotropic material data structure.
Elastic material data structure.
Linear interface data structure.
moisture transport material data structure
Thermal material data structure.
Interface for managing meshsets containing materials and boundary conditions.
MeshsetsManager(const MoFEM::Core &core)
MoFEMErrorCode printForceSet() const
print meshsets with force boundary conditions data structure
MoFEMErrorCode saveMeshsetToFile(const int ms_id, const unsigned int cubit_bc_type, const std::string file_name="out_meshset.vtk", const std::string file_type="VTK", const std::string options="") const
save cubit meshset entities on the moab mesh
MoFEMErrorCode setBcData(const CubitBCType cubit_bc_type, const int ms_id, const GenericCubitBcData &data)
set boundary data structure to meshset
MoFEMErrorCode broadcastMeshsets(int verb=DEFAULT_VERBOSITY)
Broadcast meshsets.
MoFEMErrorCode initialiseDatabaseFromMesh(int verb=DEFAULT_VERBOSITY)
MoFEMErrorCode setAtributes(const CubitBCType cubit_bc_type, const int ms_id, const std::vector< double > &attributes, const std::string name="")
set attributes to cubit meshset
MoFEMErrorCode deleteMeshset(const CubitBCType cubit_bc_type, const int ms_id, const MoFEMTypes bh=MF_EXIST)
delete cubit meshset
MoFEMErrorCode clearMap()
clear multi-index container
MoFEMErrorCode addEntitiesToMeshset(const CubitBCType cubit_bc_type, const int ms_id, const Range &ents)
add entities to cubit meshset
bool checkIfMeshsetContainsEntities(const int ms_id, const unsigned int cubit_bc_type, const EntityHandle *entities, int num_entities, const int operation_type=moab::Interface::INTERSECT)
Check if meshset constains entities.
static void sortMeshsets(std::vector< const CubitMeshSets * > &vec_ptr)
MoFEMErrorCode query_interface(boost::typeindex::type_index type_index, UnknownInterface **iface) const
MoFEMErrorCode updateAllMeshsetsByEntitiesChildren(const BitRefLevel &bit)
Update all blolsets, sidesets and node sets.
MoFEMErrorCode printPressureSet() const
print meshsets with pressure boundary conditions data structure
MoFEMErrorCode printBcSet(CUBIT_BC_DATA_TYPE &data, unsigned long int type) const
MoFEMErrorCode printMaterialsSet() const
print meshsets with material data structure set on it
MoFEMErrorCode setMeshsetFromFile()
get name of config file from line command '-meshsets_config'
MoFEMErrorCode setAtributesByDataStructure(const CubitBCType cubit_bc_type, const int ms_id, const GenericAttributeData &data, const std::string name="")
set (material) data structure to cubit meshset
CubitMeshSet_multiIndex cubitMeshsets
cubit meshsets
MoFEMErrorCode readMeshsets(int verb=DEFAULT_VERBOSITY)
Read meshsets.
MoFEMErrorCode printHeatFluxSet() const
print meshsets with heat flux boundary conditions data structure
MoFEMErrorCode printTemperatureSet() const
print meshsets with temperature boundary conditions data structure
MoFEMErrorCode getTags(int verb=-1)
get tags handlers used on meshsets
boost::shared_ptr< boost::program_options::options_description > configFileOptionsPtr
config file options
MoFEMErrorCode printDisplacementSet() const
print meshsets with displacement boundary conditions data structure
Definition of the pressure bc data structure.
Definition BCData.hpp:375
Definition of the temperature bc data structure.
Definition BCData.hpp:302
base class for all interface classes
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface reference to pointer of interface.