v0.14.0
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 
7 using namespace std;
8 namespace po = boost::program_options;
9 
10 namespace MoFEM {
11 
12 void MeshsetsManager::sortMeshsets(
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 
25 bool MeshsetsManager::brodcastMeshsets = true;
26 
27 MoFEMErrorCode
28 MeshsetsManager::query_interface(boost::typeindex::type_index type_index,
29  UnknownInterface **iface) const {
30  *iface = const_cast<MeshsetsManager *>(this);
31  return 0;
32 }
33 
34 MeshsetsManager::MeshsetsManager(const Core &core)
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(
41  LogManager::createSink(LogManager::getStrmWorld(), "MeshsetMngWorld"));
42  core_log->add_sink(
43  LogManager::createSink(LogManager::getStrmSync(), "MeshsetMngSync"));
44  core_log->add_sink(
45  LogManager::createSink(LogManager::getStrmSelf(), "MeshsetMngSelf"));
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 
59 MoFEMErrorCode MeshsetsManager::clearMap() {
60  MoFEMFunctionBeginHot;
61  cubitMeshsets.clear();
62  MoFEMFunctionReturnHot(0);
63 }
64 
65 MoFEMErrorCode MeshsetsManager::initialiseDatabaseFromMesh(int verb) {
66  Interface &m_field = cOre;
67  MoFEMFunctionBegin;
68  CHKERR readMeshsets(verb);
69  if (brodcastMeshsets)
70  CHKERR broadcastMeshsets(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 
89  MoFEMFunctionReturn(0);
90 }
91 
92 MoFEMErrorCode MeshsetsManager::readMeshsets(int verb) {
93  Interface &m_field = cOre;
94  moab::Interface &moab = m_field.get_moab();
95  MoFEMFunctionBegin;
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 
126  MoFEMFunctionReturn(0);
127 }
128 
129 MoFEMErrorCode MeshsetsManager::broadcastMeshsets(int verb) {
130  Interface &m_field = cOre;
131  moab::Interface &moab = m_field.get_moab();
132  MoFEMFunctionBegin;
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) {
143  MoFEMFunctionBegin;
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  }
154  MoFEMFunctionReturn(0);
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 =
214  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>()
215  .find(boost::make_tuple(
216  id, broadcast_block.getMaskedBcTypeULong()));
217  if (mit ==
218  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>()
219  .end()) {
220  EntityHandle m;
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 
244  MoFEMFunctionReturn(0);
245 }
246 
247 MoFEMErrorCode MeshsetsManager::getTags(int verb) {
248  MoFEMFunctionBegin;
249  Interface &m_field = cOre;
250  moab::Interface &moab = m_field.get_moab();
251  CHKERR getTags(moab, nsTag, ssTag, nsTag_data, ssTag_data, bhTag,
252  bhTag_header, verb);
253  MoFEMFunctionReturn(0);
254 }
255 
256 MoFEMErrorCode 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) {
260  MoFEMFunctionBegin;
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 
298  MoFEMFunctionReturn(0);
299 }
300 
301 MoFEMErrorCode MeshsetsManager::printDisplacementSet() const {
302  DisplacementCubitBcData mydata;
303  MoFEMFunctionBegin;
304  CHKERR printBcSet(mydata, NODESET | mydata.tYpe.to_ulong());
305  MoFEMFunctionReturn(0);
306 }
307 
308 MoFEMErrorCode MeshsetsManager::printPressureSet() const {
309  PressureCubitBcData mydata;
310  MoFEMFunctionBegin;
311  CHKERR printBcSet(mydata, SIDESET | mydata.tYpe.to_ulong());
312  MoFEMFunctionReturn(0);
313 }
314 
315 MoFEMErrorCode MeshsetsManager::printForceSet() const {
316  ForceCubitBcData mydata;
317  MoFEMFunctionBegin;
318  CHKERR printBcSet(mydata, NODESET | mydata.tYpe.to_ulong());
319  MoFEMFunctionReturn(0);
320 }
321 
322 MoFEMErrorCode MeshsetsManager::printTemperatureSet() const {
323  TemperatureCubitBcData mydata;
324  MoFEMFunctionBegin;
325  CHKERR printBcSet(mydata, NODESET | mydata.tYpe.to_ulong());
326  MoFEMFunctionReturn(0);
327 }
328 
329 MoFEMErrorCode MeshsetsManager::printHeatFluxSet() const {
330  HeatFluxCubitBcData mydata;
331  MoFEMFunctionBegin;
332  CHKERR printBcSet(mydata, SIDESET | mydata.tYpe.to_ulong());
333  MoFEMFunctionReturn(0);
334 }
335 
336 MoFEMErrorCode MeshsetsManager::printMaterialsSet() const {
337  MoFEMFunctionBegin;
338  const Interface &m_field = cOre;
339  const moab::Interface &moab = m_field.get_moab();
340  for (_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(
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 
353  for (_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(
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 
361  for (_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(
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  }
368  MoFEMFunctionReturn(0);
369 }
370 
371 bool MeshsetsManager::checkMeshset(const int ms_id,
372  const CubitBCType cubit_bc_type) const {
373  auto miit =
374  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
375  boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
376  if (miit !=
377  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
378  return true;
379  }
380  return false;
381 }
382 
383 bool 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 
396 MoFEMErrorCode MeshsetsManager::addMeshset(const CubitBCType cubit_bc_type,
397  const int ms_id,
398  const std::string name) {
399  Interface &m_field = cOre;
400  moab::Interface &moab = m_field.get_moab();
401  MoFEMFunctionBegin;
402  if (checkMeshset(ms_id, cubit_bc_type)) {
403  SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
404  "such cubit meshset is already there", 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 
425  MoFEMFunctionReturn(0);
426 }
427 
428 MoFEMErrorCode
429 MeshsetsManager::addEntitiesToMeshset(const CubitBCType cubit_bc_type,
430  const int ms_id, const Range &ents) {
431  Interface &m_field = cOre;
432  moab::Interface &moab = m_field.get_moab();
433  MoFEMFunctionBegin;
434  auto cit =
435  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
436  boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
437  if (cit ==
438  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
439  SETERRQ1(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 
445  MoFEMFunctionReturn(0);
446 }
447 
448 MoFEMErrorCode
449 MeshsetsManager::addEntitiesToMeshset(const CubitBCType cubit_bc_type,
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();
454  MoFEMFunctionBegin;
455  auto cit =
456  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
457  boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
458  if (cit ==
459  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
460  SETERRQ1(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 
466  MoFEMFunctionReturn(0);
467 }
468 
469 MoFEMErrorCode
470 MeshsetsManager::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();
475  MoFEMFunctionBegin;
476  auto cit =
477  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
478  boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
479  if (cit ==
480  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
481  SETERRQ1(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 
507  MoFEMFunctionReturn(0);
508 }
509 
510 MoFEMErrorCode MeshsetsManager::setAtributesByDataStructure(
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();
515  MoFEMFunctionBegin;
516  auto cit =
517  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
518  boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
519  if (cit ==
520  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
521  SETERRQ1(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),
534  CubitMeshSets_change_attributes_data_structure(moab, data));
535  if (!success)
536  SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
537  "modification unsuccessful");
538  MoFEMFunctionReturn(0);
539 }
540 
541 MoFEMErrorCode MeshsetsManager::setBcData(const CubitBCType cubit_bc_type,
542  const int ms_id,
543  const GenericCubitBcData &data) {
544  Interface &m_field = cOre;
545  moab::Interface &moab = m_field.get_moab();
546  MoFEMFunctionBegin;
547  auto cit =
548  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
549  boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
550  if (cit ==
551  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
552  SETERRQ1(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
553  "Cubit meshset with id is already there", ms_id);
554  }
555  bool success =
556  cubitMeshsets.modify(cubitMeshsets.project<0>(cit),
557  CubitMeshSets_change_bc_data_structure(moab, data));
558  if (!success)
559  SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
560  "modification unsuccessful");
561  MoFEMFunctionReturn(0);
562 }
563 
564 MoFEMErrorCode MeshsetsManager::deleteMeshset(const CubitBCType cubit_bc_type,
565  const int ms_id,
566  const MoFEMTypes bh) {
567  Interface &m_field = cOre;
568  moab::Interface &moab = m_field.get_moab();
569  MoFEMFunctionBegin;
570  auto miit =
571  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
572  boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
573  if (miit ==
574  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
575  if (bh & MF_EXIST) {
576  SETERRQ1(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
577  "meshset not found", ms_id);
578  } else {
579  MoFEMFunctionReturnHot(0);
580  }
581  }
582  EntityHandle meshset = miit->getMeshset();
583  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().erase(miit);
584  CHKERR moab.delete_entities(&meshset, 1);
585 
586  MoFEMFunctionReturn(0);
587 }
588 
589 MoFEMErrorCode MeshsetsManager::getCubitMeshsetPtr(
590  const int ms_id, const CubitBCType cubit_bc_type,
591  const CubitMeshSets **cubit_meshset_ptr) const {
592  Interface &m_field = cOre;
593  MoFEMFunctionBegin;
594  auto miit =
595  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
596  boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
597  if (miit !=
598  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
599  *cubit_meshset_ptr = &*miit;
600  } else {
601  SETERRQ1(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
602  "msId = %d is not there", ms_id);
603  }
604  MoFEMFunctionReturn(0);
605 }
606 
607 const CubitMeshSets *
608 MeshsetsManager::getCubitMeshsetPtr(const int ms_id,
609  const CubitBCType cubit_bc_type) const {
610  const CubitMeshSets *cubit_meshset_ptr;
611  CHK_THROW_MESSAGE(
612  getCubitMeshsetPtr(ms_id, cubit_bc_type, &cubit_meshset_ptr),
613  "Get not get meshset");
614  return cubit_meshset_ptr;
615 }
616 
617 MoFEMErrorCode MeshsetsManager::getCubitMeshsetPtr(
618  const string name, const CubitMeshSets **cubit_meshset_ptr) const {
619  Interface &m_field = cOre;
620  MoFEMFunctionBegin;
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  SETERRQ1(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  SETERRQ1(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;
632  MoFEMFunctionReturn(0);
633 }
634 
635 MoFEMErrorCode MeshsetsManager::getCubitMeshsetPtr(
636  const CubitBCType cubit_bc_type,
637  std::vector<const CubitMeshSets *> &vec_ptr) const {
638  MoFEMFunctionBegin;
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);
645  MoFEMFunctionReturn(0);
646 }
647 
648 std::vector<const CubitMeshSets *>
649 MeshsetsManager::getCubitMeshsetPtr(const CubitBCType cubit_bc_type) const {
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 
656 MoFEMErrorCode MeshsetsManager::getCubitMeshsetPtr(
657  const std::regex reg_exp_name,
658  std::vector<const CubitMeshSets *> &vec_ptr) const {
659  MoFEMFunctionBegin;
660  auto r =
661  cubitMeshsets.get<CubitMeshsetMaskedType_mi_tag>().equal_range(BLOCKSET);
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);
669  MoFEMFunctionReturn(0);
670 }
671 
672 std::vector<const CubitMeshSets *>
673 MeshsetsManager::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 
680 MoFEMErrorCode MeshsetsManager::getEntitiesByDimension(
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();
685  MoFEMFunctionBegin;
686  auto miit =
687  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
688  boost::make_tuple(msId, cubit_bc_type));
689  if (miit !=
690  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
691  CHKERR miit->getMeshsetIdEntitiesByDimension(moab, dimension, entities,
692  recursive);
693  } else {
694  SETERRQ1(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
695  "msId = %d is not there", msId);
696  }
697  MoFEMFunctionReturn(0);
698 }
699 
700 MoFEMErrorCode MeshsetsManager::getEntitiesByDimension(
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();
705  MoFEMFunctionBegin;
706  auto miit =
707  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
708  boost::make_tuple(ms_id, cubit_bc_type));
709  if (miit !=
710  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
711  CHKERR miit->getMeshsetIdEntitiesByDimension(moab, entities, recursive);
712  } else {
713  SETERRQ1(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
714  "ms_id = %d is not there", ms_id);
715  }
716  MoFEMFunctionReturn(0);
717 }
718 
719 MoFEMErrorCode MeshsetsManager::getMeshset(const int ms_id,
720  const unsigned int cubit_bc_type,
721  EntityHandle &meshset) const {
722  Interface &m_field = cOre;
723  MoFEMFunctionBegin;
724  auto miit =
725  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
726  boost::make_tuple(ms_id, cubit_bc_type));
727  if (miit !=
728  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
729  meshset = miit->meshset;
730  } else {
731  SETERRQ1(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
732  "ms_id = %d is not there", ms_id);
733  }
734  MoFEMFunctionReturn(0);
735 }
736 
737 bool MeshsetsManager::checkIfMeshsetContainsEntities(
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 =
741  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
742  boost::make_tuple(ms_id, cubit_bc_type));
743  if (miit !=
744  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
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 
752 MoFEMErrorCode
753 MeshsetsManager::getMeshsetsByType(const unsigned int cubit_bc_type,
754  Range &meshsets) const {
755  MoFEMFunctionBegin;
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  }
763  MoFEMFunctionReturn(0);
764 }
765 
766 struct BlockData {
767 
768  EntityHandle cubitMeshset;
769 
770  int iD;
771  string addType;
772  string nAme;
773  CubitBC bcType;
774 
775  // Materials
776  Mat_Elastic matElastic;
777  Mat_Elastic_TransIso matTransIso;
778  Mat_Thermal matThermal;
779  Mat_Interf matInterf;
780 
781  // BCs
782  DisplacementCubitBcData dispBc;
783  ForceCubitBcData forceBc;
784  PressureCubitBcData pressureBc;
785  TemperatureCubitBcData temperatureBc;
786  HeatFluxCubitBcData heatFluxBc;
787  CfgCubitBcData cfgBc;
788 
789  int numberOfAttributes;
790  std::vector<double> aTtr;
791 
792  BlockData() : numberOfAttributes(-1), aTtr(10, 0) {
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 
802 MoFEMErrorCode MeshsetsManager::setMeshsetFromFile(const string file_name,
803  bool clean_file_options) {
804  Interface &m_field = cOre;
805  MoFEMFunctionBegin;
806  std::ifstream ini_file(file_name.c_str(), std::ifstream::in);
807  po::variables_map vm;
808  if (clean_file_options) {
809  configFileOptionsPtr =
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;
833  for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(m_field, BLOCKSET, it)) {
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;
1149  for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(m_field, BLOCKSET, it)) {
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
1172  for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(m_field, BLOCKSET, it)) {
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  SETERRQ1(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  SETERRQ1(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 
1383  MoFEMFunctionReturn(0);
1384 }
1385 
1386 MoFEMErrorCode MeshsetsManager::setMeshsetFromFile() {
1387  Interface &m_field = cOre;
1388  PetscBool flg_file;
1389  char meshset_file_name[255] = "config_file.cfg";
1390  MoFEMFunctionBegin;
1391  CHKERR 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  SETERRQ1(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  }
1405  ierr = PetscOptionsEnd();
1406  CHKERRG(ierr);
1407  MoFEMFunctionReturn(0);
1408 }
1409 
1410 MoFEMErrorCode MeshsetsManager::saveMeshsetToFile(
1411  const int ms_id, const unsigned int cubit_bc_type,
1412  const std::string file_name, const std::string file_type,
1413  const std::string options) const {
1414 
1415  MoFEMFunctionBegin;
1416  MoFEM::Interface &m_field = cOre;
1417  const CubitMeshSets *cubit_meshset_ptr;
1418  CHKERR getCubitMeshsetPtr(ms_id, cubit_bc_type, &cubit_meshset_ptr);
1419  EntityHandle meshset = cubit_meshset_ptr->getMeshset();
1420  CHKERR m_field.get_moab().write_file(file_name.c_str(), file_type.c_str(),
1421  options.c_str(), &meshset, 1);
1422  MoFEMFunctionReturn(0);
1423 }
1424 
1425 MoFEMErrorCode MeshsetsManager::saveMeshsetToFile(
1426  const int ms_id, const unsigned int cubit_bc_type, const int dim,
1427  const std::string file_name, const bool recursive,
1428  const std::string file_type, const std::string options) const {
1429 
1430  MoFEMFunctionBegin;
1431  MoFEM::Interface &m_field = cOre;
1432  moab::Interface &moab = m_field.get_moab();
1433  Range entities;
1434  CHKERR getEntitiesByDimension(ms_id, cubit_bc_type, dim, entities, recursive);
1435  EntityHandle meshset;
1436  CHKERR moab.create_meshset(MESHSET_SET, meshset);
1437  CHKERR moab.add_entities(meshset, entities);
1438  CHKERR moab.write_file(file_name.c_str(), file_type.c_str(), options.c_str(),
1439  &meshset, 1);
1440  CHKERR moab.delete_entities(&meshset, 1);
1441  MoFEMFunctionReturn(0);
1442 }
1443 
1444 MoFEMErrorCode
1445 MeshsetsManager::updateAllMeshsetsByEntitiesChildren(const BitRefLevel &bit) {
1446  MoFEMFunctionBegin;
1447  BitRefManager *bit_mng = cOre.getInterface<BitRefManager>();
1448  for (_IT_CUBITMESHSETS_FOR_LOOP_((*this), iit)) {
1449  EntityHandle meshset = iit->getMeshset();
1450  for (EntityType t = MBVERTEX; t != MBENTITYSET; ++t)
1451  CHKERR bit_mng->updateMeshsetByEntitiesChildren(meshset, bit, meshset, t,
1452  true);
1453  }
1454  MoFEMFunctionReturn(0);
1455 }
1456 
1457 } // namespace MoFEM
CubitBCNames
const static char *const CubitBCNames[]
Names of types of sets and boundary conditions.
Definition: definitions.h:188
MoFEMFunctionReturnHot
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:460
MoFEM::UnknownInterface::getInterface
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface reference to pointer of interface.
Definition: UnknownInterface.hpp:93
CHK_MOAB_THROW
#define CHK_MOAB_THROW(err, msg)
Check error code of MoAB function and throw MoFEM exception.
Definition: definitions.h:589
MoFEM::CubitMeshSets::cubitBcType
CubitBCType cubitBcType
Definition: BCMultiIndices.hpp:22
MoFEM::CubitMeshSets_change_bc_data_structure
Definition: BCMultiIndices.hpp:437
SIDESET
@ SIDESET
Definition: definitions.h:160
MoFEM::LogManager::checkIfChannelExist
static bool checkIfChannelExist(const std::string channel)
Check if channel exist.
Definition: LogManager.cpp:404
MoFEM::MeshsetsManager::cOre
MoFEM::Core & cOre
Definition: MeshsetsManager.hpp:109
MoFEM::MeshsetsManager::getMeshsetsByType
MoFEMErrorCode getMeshsetsByType(const unsigned int cubit_bc_type, Range &meshsets) const
get all CUBIT meshsets by CUBIT type
Definition: MeshsetsManager.cpp:753
MYPCOMM_INDEX
#define MYPCOMM_INDEX
default communicator number PCOMM
Definition: definitions.h:228
MoFEM::MeshsetsManager::sortMeshsets
static void sortMeshsets(std::vector< const CubitMeshSets * > &vec_ptr)
Definition: MeshsetsManager.cpp:12
MoFEM::GenericCubitBcData
Generic bc data structure.
Definition: BCData.hpp:20
MoFEM::CoreTmp< 0 >
Core (interface) class.
Definition: Core.hpp:82
MoFEM::TemperatureCubitBcData
Definition of the temperature bc data structure.
Definition: BCData.hpp:306
MoFEM::MeshsetsManager::printTemperatureSet
MoFEMErrorCode printTemperatureSet() const
print meshsets with temperature boundary conditions data structure
Definition: MeshsetsManager.cpp:322
MoFEM::MeshsetsManager::addEntitiesToMeshset
MoFEMErrorCode addEntitiesToMeshset(const CubitBCType cubit_bc_type, const int ms_id, const Range &ents)
add entities to cubit meshset
Definition: MeshsetsManager.cpp:429
MOFEM_LOG_SEVERITY_SYNC
#define MOFEM_LOG_SEVERITY_SYNC(comm, severity)
Synchronise "SYNC" on curtain severity level.
Definition: LogManager.hpp:352
EntityHandle
MoFEM::CoreInterface::get_comm
virtual MPI_Comm & get_comm() const =0
MoFEM::BlockData::dispBc
DisplacementCubitBcData dispBc
Definition: MeshsetsManager.cpp:782
CHK_THROW_MESSAGE
#define CHK_THROW_MESSAGE(err, msg)
Check and throw MoFEM exception.
Definition: definitions.h:609
MoFEM::Mat_Elastic
Elastic material data structure.
Definition: MaterialBlocks.hpp:139
MoFEM::BlockData::addType
string addType
Definition: MeshsetsManager.cpp:771
MoFEM::MeshsetsManager::broadcastMeshsets
MoFEMErrorCode broadcastMeshsets(int verb=DEFAULT_VERBOSITY)
Boradcats meshsets.
Definition: MeshsetsManager.cpp:129
MoFEM::Exceptions::MoFEMErrorCode
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
Definition: Exceptions.hpp:56
MoFEM::CubitMeshSets
this struct keeps basic methods for moab meshset about material and boundary conditions
Definition: BCMultiIndices.hpp:19
_IT_CUBITMESHSETS_BY_BCDATA_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.
Definition: MeshsetsManager.hpp:49
MoFEM::BlockData::BlockData
BlockData()
Definition: MeshsetsManager.cpp:792
MoFEM::th
Tag th
Definition: Projection10NodeCoordsOnField.cpp:122
MoFEM::BlockData::temperatureBc
TemperatureCubitBcData temperatureBc
Definition: MeshsetsManager.cpp:785
MoFEM::MeshsetsManager::brodcastMeshsets
static bool brodcastMeshsets
Definition: MeshsetsManager.hpp:885
MoFEM::CubitMeshSets_change_attributes_data_structure
Definition: BCMultiIndices.hpp:425
MoFEM::ForceCubitBcData
Definition of the force bc data structure.
Definition: BCData.hpp:139
MoFEM::DisplacementCubitBcData
Definition of the displacement bc data structure.
Definition: BCData.hpp:76
MoFEM::GenericCubitBcData::tYpe
const CubitBCType tYpe
Type of boundary condition.
Definition: BCData.hpp:59
MoFEM::CubitMeshSets::getMaskedBcTypeULong
unsigned long int getMaskedBcTypeULong() const
get meshset type and mask
Definition: BCMultiIndices.hpp:76
MoFEM::LogManager::createSink
static boost::shared_ptr< SinkType > createSink(boost::shared_ptr< std::ostream > stream_ptr, std::string comm_filter)
Create a sink object.
Definition: LogManager.cpp:298
MoFEM::BlockData::aTtr
std::vector< double > aTtr
Definition: MeshsetsManager.cpp:790
sdf.r
int r
Definition: sdf.py:8
MoFEM::PressureCubitBcData
Definition of the pressure bc data structure.
Definition: BCData.hpp:379
MoFEM::DeprecatedCoreInterface
Deprecated interface functions.
Definition: DeprecatedCoreInterface.hpp:16
MoFEM::MeshsetsManager::getMeshset
MoFEMErrorCode getMeshset(const int ms_id, const unsigned int cubit_bc_type, EntityHandle &meshset) const
get meshset from CUBIT Id and CUBIT type
Definition: MeshsetsManager.cpp:719
MoFEM::Interface
DeprecatedCoreInterface Interface
Definition: Interface.hpp:2010
MoFEM::MeshsetsManager::bhTag_header
Tag bhTag_header
Definition: MeshsetsManager.hpp:896
MoFEM::BlockData::cfgBc
CfgCubitBcData cfgBc
Definition: MeshsetsManager.cpp:787
MoFEM::MeshsetsManager::ssTag_data
Tag ssTag_data
Definition: MeshsetsManager.hpp:894
MoFEM::Mat_Interf
Linear interface data structure.
Definition: MaterialBlocks.hpp:430
MoFEM::BlockData::matThermal
Mat_Thermal matThermal
Definition: MeshsetsManager.cpp:778
MoFEM::MeshsetsManager::initialiseDatabaseFromMesh
MoFEMErrorCode initialiseDatabaseFromMesh(int verb=DEFAULT_VERBOSITY)
Definition: MeshsetsManager.cpp:65
NODESET
@ NODESET
Definition: definitions.h:159
MoFEM::MeshsetsManager::nsTag
Tag nsTag
Definition: MeshsetsManager.hpp:891
MoFEM::MeshsetsManager::clearMap
MoFEMErrorCode clearMap()
clear multi-index container
Definition: MeshsetsManager.cpp:59
MoFEM::CubitMeshSets_change_name
change meshset name
Definition: BCMultiIndices.hpp:402
CHKERR
#define CHKERR
Inline error check.
Definition: definitions.h:548
MoFEM::MeshsetsManager::printForceSet
MoFEMErrorCode printForceSet() const
print meshsets with force boundary conditions data structure
Definition: MeshsetsManager.cpp:315
MoFEM::MeshsetsManager::saveMeshsetToFile
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
Definition: MeshsetsManager.cpp:1410
MoFEM::CoreInterface::get_moab
virtual moab::Interface & get_moab()=0
MoFEM::MeshsetsManager::updateAllMeshsetsByEntitiesChildren
MoFEMErrorCode updateAllMeshsetsByEntitiesChildren(const BitRefLevel &bit)
Update all blolsets, sidesets and node sets.
Definition: MeshsetsManager.cpp:1445
MoFEM
implementation of Data Operators for Forces and Sources
Definition: Common.hpp:10
MoFEM::MeshsetsManager::printHeatFluxSet
MoFEMErrorCode printHeatFluxSet() const
print meshsets with heat flux boundary conditions data structure
Definition: MeshsetsManager.cpp:329
a
constexpr double a
Definition: approx_sphere.cpp:30
MAT_THERMALSET
@ MAT_THERMALSET
block name is "MAT_THERMAL"
Definition: definitions.h:174
MoFEM::MeshsetsManager::getEntitiesByDimension
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
Definition: MeshsetsManager.cpp:680
MOFEM_LOG_C
#define MOFEM_LOG_C(channel, severity, format,...)
Definition: LogManager.hpp:311
MoFEM::Mat_Elastic_TransIso
Transverse Isotropic material data structure.
Definition: MaterialBlocks.hpp:371
MoFEM::Mat_Moisture
moisture transport material data structure
Definition: MaterialBlocks.hpp:263
bit
auto bit
set bit
Definition: hanging_node_approx.cpp:75
MoFEM::MeshsetsManager::addMeshset
MoFEMErrorCode addMeshset(const CubitBCType cubit_bc_type, const int ms_id, const std::string name="")
add cubit meshset
Definition: MeshsetsManager.cpp:396
MAT_ELASTICSET
@ MAT_ELASTICSET
block name is "MAT_ELASTIC"
Definition: definitions.h:172
MoFEM::BlockData::nAme
string nAme
Definition: MeshsetsManager.cpp:772
MoFEM::LogManager::getStrmSync
static boost::shared_ptr< std::ostream > getStrmSync()
Get the strm sync object.
Definition: LogManager.cpp:348
MoFEM::MeshsetsManager::ssTag
Tag ssTag
Definition: MeshsetsManager.hpp:892
MoFEM::BlockData::cubitMeshset
EntityHandle cubitMeshset
Definition: MeshsetsManager.cpp:768
MoFEM::MeshsetsManager::setAtributesByDataStructure
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
Definition: MeshsetsManager.cpp:510
MoFEM::CubitMeshSets_change_attributes
Definition: BCMultiIndices.hpp:413
MoFEM::CfgCubitBcData::data
_data_ data
Definition: BCData.hpp:485
MoFEM::LogManager::getStrmWorld
static boost::shared_ptr< std::ostream > getStrmWorld()
Get the strm world object.
Definition: LogManager.cpp:344
MoFEM::BitRefManager::updateMeshsetByEntitiesChildren
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.
Definition: BitRefManager.cpp:1029
MoFEM::ForceCubitBcData::data
_data_ data
Definition: BCData.hpp:152
MoFEM::MeshsetsManager::nsTag_data
Tag nsTag_data
Definition: MeshsetsManager.hpp:893
MoFEM::MeshsetsManager::cubitMeshsets
CubitMeshSet_multiIndex cubitMeshsets
cubit meshsets
Definition: MeshsetsManager.hpp:899
MoFEM::LogManager::getStrmSelf
static boost::shared_ptr< std::ostream > getStrmSelf()
Get the strm self object.
Definition: LogManager.cpp:340
MoFEM::Composite_Cubit_msId_And_MeshsetType_mi_tag
Definition: TagMultiIndices.hpp:15
MoFEM::BlockData::matElastic
Mat_Elastic matElastic
Definition: MeshsetsManager.cpp:776
MOFEM_OPERATION_UNSUCCESSFUL
@ MOFEM_OPERATION_UNSUCCESSFUL
Definition: definitions.h:34
MOFEM_LOG_TAG
#define MOFEM_LOG_TAG(channel, tag)
Tag channel.
Definition: LogManager.hpp:339
MoFEM::DisplacementCubitBcData::data
_data_ data
Definition: BCData.hpp:99
t
constexpr double t
plate stiffness
Definition: plate.cpp:58
MoFEM::GenericAttributeData
Generic attribute data structure.
Definition: MaterialBlocks.hpp:17
UNKNOWNSET
@ UNKNOWNSET
Definition: definitions.h:158
i
FTensor::Index< 'i', SPACE_DIM > i
Definition: hcurl_divergence_operator_2d.cpp:27
MoFEM::MeshsetsManager::printMaterialsSet
MoFEMErrorCode printMaterialsSet() const
print meshsets with material data structure set on it
Definition: MeshsetsManager.cpp:336
MoFEM::BlockData::pressureBc
PressureCubitBcData pressureBc
Definition: MeshsetsManager.cpp:784
MoFEM::MeshsetsManager::setAtributes
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
Definition: MeshsetsManager.cpp:470
MoFEM::PressureCubitBcData::data
_data_ data
Definition: BCData.hpp:387
MoFEM::MeshsetsManager::getTags
MoFEMErrorCode getTags(int verb=-1)
get tags handlers used on meshsets
Definition: MeshsetsManager.cpp:247
LASTSET_BC
@ LASTSET_BC
Definition: definitions.h:179
MoFEM::MeshsetsManager::deleteMeshset
MoFEMErrorCode deleteMeshset(const CubitBCType cubit_bc_type, const int ms_id, const MoFEMTypes bh=MF_EXIST)
delete cubit meshset
Definition: MeshsetsManager.cpp:564
MoFEM::UnknownInterface
base class for all interface classes
Definition: UnknownInterface.hpp:34
MoFEM::CubitMeshsetMaskedType_mi_tag
Definition: TagMultiIndices.hpp:13
MoFEM::TemperatureCubitBcData::data
_data_ data
Definition: BCData.hpp:325
MoFEM::MeshsetsManager::configFileOptionsPtr
boost::shared_ptr< boost::program_options::options_description > configFileOptionsPtr
config file options
Definition: MeshsetsManager.hpp:901
Range
MoFEM::Types::CubitBCType
std::bitset< 32 > CubitBCType
Definition: Types.hpp:52
MOFEM_LOG
#define MOFEM_LOG(channel, severity)
Log.
Definition: LogManager.hpp:308
MoFEM::MeshsetsManager::printDisplacementSet
MoFEMErrorCode printDisplacementSet() const
print meshsets with displacement boundary conditions data structure
Definition: MeshsetsManager.cpp:301
_IT_CUBITMESHSETS_BY_SET_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.
Definition: MeshsetsManager.hpp:71
MoFEM::MeshsetsManager::printBcSet
MoFEMErrorCode printBcSet(CUBIT_BC_DATA_TYPE &data, unsigned long int type) const
Definition: MeshsetsManager.hpp:906
MoFEM::MeshsetsManager::printPressureSet
MoFEMErrorCode printPressureSet() const
print meshsets with pressure boundary conditions data structure
Definition: MeshsetsManager.cpp:308
MoFEM::CubitMeshSets::getMeshset
EntityHandle getMeshset() const
get bc meshset
Definition: BCMultiIndices.hpp:62
MoFEM::MeshsetsManager::bhTag
Tag bhTag
Definition: MeshsetsManager.hpp:895
std
Definition: enable_if.hpp:5
MoFEM::Mat_Thermal
Thermal material data structure.
Definition: MaterialBlocks.hpp:201
HenckyOps::f
auto f
Definition: HenckyOps.hpp:15
MoFEM::CubitMeshSets::getMeshsetId
int getMeshsetId() const
get meshset id as it set in preprocessing software
Definition: BCMultiIndices.hpp:43
BLOCKSET
@ BLOCKSET
Definition: definitions.h:161
MoFEM::BlockData::matTransIso
Mat_Elastic_TransIso matTransIso
Definition: MeshsetsManager.cpp:777
MoFEM::Exceptions::ierr
static MoFEMErrorCodeGeneric< PetscErrorCode > ierr
Definition: Exceptions.hpp:76
MoFEM::BlockData::matInterf
Mat_Interf matInterf
Definition: MeshsetsManager.cpp:779
MOFEM_DATA_INCONSISTENCY
@ MOFEM_DATA_INCONSISTENCY
Definition: definitions.h:31
MoFEM::MeshsetsManager
Interface for managing meshsets containing materials and boundary conditions.
Definition: MeshsetsManager.hpp:104
MoFEM::BlockData
Definition: MeshsetsManager.cpp:766
MoFEMTypes
MoFEMTypes
Those types control how functions respond on arguments, f.e. error handling.
Definition: definitions.h:110
MoFEM::MeshsetsManager::setBcData
MoFEMErrorCode setBcData(const CubitBCType cubit_bc_type, const int ms_id, const GenericCubitBcData &data)
set boundary data structure to meshset
Definition: MeshsetsManager.cpp:541
MoFEM::BlockData::iD
int iD
Definition: MeshsetsManager.cpp:770
MoFEM::CubitMeshsets_name
Definition: TagMultiIndices.hpp:14
MoFEM::HeatFluxCubitBcData
Definition of the heat flux bc data structure.
Definition: BCData.hpp:427
_IT_CUBITMESHSETS_FOR_LOOP_
#define _IT_CUBITMESHSETS_FOR_LOOP_(MESHSET_MANAGER, IT)
Iterator that loops over all the Cubit MeshSets in a moFEM field.
Definition: MeshsetsManager.hpp:34
m
FTensor::Index< 'm', 3 > m
Definition: shallow_wave.cpp:80
MoFEM::BitRefManager
Managing BitRefLevels.
Definition: BitRefManager.hpp:21
MoFEM::Types::BitRefLevel
std::bitset< BITREFLEVEL_SIZE > BitRefLevel
Bit structure attached to each entity identifying to what mesh entity is attached.
Definition: Types.hpp:40
MoFEM::HeatFluxCubitBcData::data
_data_ data
Definition: BCData.hpp:441
MoFEM::BlockData::numberOfAttributes
int numberOfAttributes
Definition: MeshsetsManager.cpp:789
MoFEMFunctionBeginHot
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:453
MoFEM::MeshsetsManager::readMeshsets
MoFEMErrorCode readMeshsets(int verb=DEFAULT_VERBOSITY)
Boradcats meshsets.
Definition: MeshsetsManager.cpp:92
MoFEM::BlockData::forceBc
ForceCubitBcData forceBc
Definition: MeshsetsManager.cpp:783
MoFEM::CubitMeshsetType_mi_tag
MultiIndex Tag for field id.
Definition: TagMultiIndices.hpp:12
MoFEM::MeshsetsManager::getCubitMeshsetPtr
MoFEMErrorCode getCubitMeshsetPtr(const int ms_id, const CubitBCType cubit_bc_type, const CubitMeshSets **cubit_meshset_ptr) const
get cubit meshset
Definition: MeshsetsManager.cpp:589
MoFEM::LogManager::setLog
static LoggerType & setLog(const std::string channel)
Set ans resset chanel logger.
Definition: LogManager.cpp:389
MoFEM::MeshsetsManager::checkMeshset
bool checkMeshset(const int ms_id, const CubitBCType cubit_bc_type) const
check for CUBIT Id and CUBIT type
Definition: MeshsetsManager.cpp:371
MoFEM::BlockData::bcType
CubitBC bcType
Definition: MeshsetsManager.cpp:773
MoFEM::CfgCubitBcData
Definition of the cfd_bc data structure.
Definition: BCData.hpp:480
MF_EXIST
@ MF_EXIST
Definition: definitions.h:113
MoFEMFunctionReturn
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:429
MAT_MOISTURESET
@ MAT_MOISTURESET
block name is "MAT_MOISTURE"
Definition: definitions.h:176
CHKERRG
#define CHKERRG(n)
Check error code of MoFEM/MOAB/PETSc function.
Definition: definitions.h:496
MoFEM::MeshsetsManager::checkIfMeshsetContainsEntities
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.
Definition: MeshsetsManager.cpp:737
MoFEMFunctionBegin
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:359
CubitBC
CubitBC
Types of sets and boundary conditions.
Definition: definitions.h:157
MoFEM::BlockData::heatFluxBc
HeatFluxCubitBcData heatFluxBc
Definition: MeshsetsManager.cpp:786
MoFEM::MeshsetsManager::setMeshsetFromFile
MoFEMErrorCode setMeshsetFromFile()
get name of config file from line command '-meshsets_config'
Definition: MeshsetsManager.cpp:1386
Generated by Doxygen 1.8.17 and hosted at University of Glasgow