v0.14.0
Public Member Functions | Public Attributes | Static Public Attributes | Static Protected Member Functions | Protected Attributes | List of all members
MoFEM::MeshsetsManager Struct Reference

Interface for managing meshsets containing materials and boundary conditions. More...

#include <src/interfaces/MeshsetsManager.hpp>

Inheritance diagram for MoFEM::MeshsetsManager:
[legend]
Collaboration diagram for MoFEM::MeshsetsManager:
[legend]

Public Member Functions

MoFEMErrorCode query_interface (boost::typeindex::type_index type_index, UnknownInterface **iface) const
 
 MeshsetsManager (const MoFEM::Core &core)
 
virtual ~MeshsetsManager ()=default
 
MoFEMErrorCode getTags (int verb=-1)
 get tags handlers used on meshsets More...
 
Tag get_nsTag () const
 get tag handle used to store "id" of NODESET More...
 
Tag get_ssTag () const
 get tag handle used to store "id" of SIDESET More...
 
Tag get_nsTag_data () const
 get tag handle used to store boundary data on NODESET More...
 
Tag get_ssTag_data () const
 get tag handle used to store boundary data on SIDESET More...
 
Tag get_bhTag () const
 get tag handle used to store "id" of BLOCKSET More...
 
Tag get_bhTag_header () const
 get tag handle used to store of block set header (Used by Cubit) More...
 
MeshsetsManager * get_meshsets_manager_ptr ()
 return pointer to meshset manager More...
 
const MeshsetsManager * get_meshsets_manager_ptr () const
 return pointer to meshset manager More...
 
MoFEMErrorCode clearMap ()
 clear multi-index container More...
 
MoFEMErrorCode initialiseDatabaseFromMesh (int verb=DEFAULT_VERBOSITY)
 
MoFEMErrorCode readMeshsets (int verb=DEFAULT_VERBOSITY)
 Boradcats meshsets. More...
 
MoFEMErrorCode broadcastMeshsets (int verb=DEFAULT_VERBOSITY)
 Boradcats meshsets. More...
 
template<class CUBIT_BC_DATA_TYPE >
MoFEMErrorCode printBcSet (CUBIT_BC_DATA_TYPE &data, unsigned long int type) const
 
MoFEMErrorCode printDisplacementSet () const
 print meshsets with displacement boundary conditions data structure More...
 
MoFEMErrorCode printPressureSet () const
 print meshsets with pressure boundary conditions data structure More...
 
MoFEMErrorCode printForceSet () const
 print meshsets with force boundary conditions data structure More...
 
MoFEMErrorCode printTemperatureSet () const
 print meshsets with temperature boundary conditions data structure More...
 
MoFEMErrorCode printHeatFluxSet () const
 print meshsets with heat flux boundary conditions data structure More...
 
MoFEMErrorCode printMaterialsSet () const
 print meshsets with material data structure set on it More...
 
CubitMeshSet_multiIndex & getMeshsetsMultindex ()
 
CubitMeshSet_multiIndex::iterator getBegin () const
 get begin iterator of cubit mehset of given type (instead you can use IT_CUBITMESHSETS_TYPE_FOR_LOOP(MFIELD,CUBITBCTYPE,IT) More...
 
CubitMeshSet_multiIndex::iterator getEnd () const
 get begin iterator of cubit mehset of given type (instead you can use IT_CUBITMESHSETS_TYPE_FOR_LOOP(MFIELD,CUBITBCTYPE,IT) More...
 
CubitMeshsetByType::iterator getBegin (const unsigned int cubit_bc_type) const
 get begin iterator of cubit mehset of given type (instead you can use IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP(MFIELD,CUBITBCTYPE,IT) More...
 
CubitMeshsetByType::iterator getEnd (const unsigned int cubit_bc_type) const
 get begin iterator of cubit mehset of given type (instead you can use IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP(MFIELD,CUBITBCTYPE,IT) More...
 
CubitMeshsetByMask::iterator getBySetTypeBegin (const unsigned int cubit_bc_type) const
 get end iterator of cubit meshset of given type (instead you can use IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP(MFIELD,CUBITBCTYPE,IT) More...
 
CubitMeshsetByMask::iterator getBySetTypeEnd (const unsigned int cubit_bc_type) const
 get end iterator of cubit mehset of given type (instead you can use IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP(MFIELD,CUBITBCTYPE,IT) More...
 
CubitMeshsetByName::iterator getBegin (const std::string &name) const
 get begin iterator of cubit mehset of given type (instead you can use IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP(MFIELD,CUBITBCTYPE,IT) More...
 
CubitMeshsetByName::iterator getEnd (const std::string &name) const
 get begin iterator of cubit mehset of given type (instead you can use IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP(MFIELD,CUBITBCTYPE,IT) More...
 
bool checkMeshset (const int ms_id, const CubitBCType cubit_bc_type) const
 check for CUBIT Id and CUBIT type More...
 
bool checkMeshset (const string name, int *const number_of_meshsets_ptr=NULL) const
 check if meshset of given name exist More...
 
MoFEMErrorCode addMeshset (const CubitBCType cubit_bc_type, const int ms_id, const std::string name="")
 add cubit meshset More...
 
MoFEMErrorCode addEntitiesToMeshset (const CubitBCType cubit_bc_type, const int ms_id, const Range &ents)
 add entities to cubit meshset More...
 
MoFEMErrorCode addEntitiesToMeshset (const CubitBCType cubit_bc_type, const int ms_id, const EntityHandle *ents, const int nb_ents)
 add entities to cubit meshset More...
 
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 More...
 
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 More...
 
MoFEMErrorCode setBcData (const CubitBCType cubit_bc_type, const int ms_id, const GenericCubitBcData &data)
 set boundary data structure to meshset More...
 
MoFEMErrorCode deleteMeshset (const CubitBCType cubit_bc_type, const int ms_id, const MoFEMTypes bh=MF_EXIST)
 delete cubit meshset More...
 
MoFEMErrorCode getCubitMeshsetPtr (const int ms_id, const CubitBCType cubit_bc_type, const CubitMeshSets **cubit_meshset_ptr) const
 get cubit meshset More...
 
const CubitMeshSets * getCubitMeshsetPtr (const int ms_id, const CubitBCType cubit_bc_type) const
 get cubit meshset More...
 
MoFEMErrorCode getCubitMeshsetPtr (const CubitBCType cubit_bc_type, std::vector< const CubitMeshSets * > &vec_ptr) const
 Get vector of pointer by bc type. More...
 
std::vector< const CubitMeshSets * > getCubitMeshsetPtr (const CubitBCType cubit_bc_type) const
 Get vector of pointer by bc type. More...
 
MoFEMErrorCode getCubitMeshsetPtr (const string name, const CubitMeshSets **cubit_meshset_ptr) const
 get cubit meshset More...
 
MoFEMErrorCode getCubitMeshsetPtr (const std::regex reg_exp_name, std::vector< const CubitMeshSets * > &vec_ptr) const
 Get vector of pointer to blocksets with name satisfying regular expression. More...
 
std::vector< const CubitMeshSets * > getCubitMeshsetPtr (const std::regex reg_exp_name) const
 Get vector of pointer to blocksets with name satisfying regular expression. More...
 
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 More...
 
MoFEMErrorCode getEntitiesByDimension (const int ms_id, const unsigned int cubit_bc_type, Range &entities, const bool recursive=true) const
 get entities related to CUBIT/meshset, More...
 
MoFEMErrorCode getMeshset (const int ms_id, const unsigned int cubit_bc_type, EntityHandle &meshset) const
 get meshset from CUBIT Id and CUBIT type More...
 
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. More...
 
MoFEMErrorCode getMeshsetsByType (const unsigned int cubit_bc_type, Range &meshsets) const
 get all CUBIT meshsets by CUBIT type More...
 
MoFEMErrorCode setMeshsetFromFile (const string file_name, const bool clean_file_options=true)
 add blocksets reading config file More...
 
MoFEMErrorCode setMeshsetFromFile ()
 get name of config file from line command '-meshsets_config' More...
 
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 More...
 
MoFEMErrorCode saveMeshsetToFile (const int ms_id, const unsigned int cubit_bc_type, const int dim, const std::string file_name="out_meshset.vtk", const bool recursive=false, const std::string file_type="VTK", const std::string options="") const
 save cubit meshset entities on the moab mesh More...
 
boost::shared_ptr< boost::program_options::options_description > & getConfigFileOptionsPtr ()
 Get config file options, use with care. More...
 
MoFEMErrorCode updateAllMeshsetsByEntitiesChildren (const BitRefLevel &bit)
 Update all blolsets, sidesets and node sets. More...
 
- Public Member Functions inherited from MoFEM::UnknownInterface
template<class IFACE >
MoFEMErrorCode registerInterface (bool error_if_registration_failed=true)
 Register interface. More...
 
template<class IFACE >
MoFEMErrorCode getInterface (IFACE *&iface) const
 Get interface reference to pointer of interface. More...
 
template<class IFACE >
MoFEMErrorCode getInterface (IFACE **const iface) const
 Get interface pointer to pointer of interface. More...
 
template<class IFACE , typename boost::enable_if< boost::is_pointer< IFACE >, int >::type = 0>
IFACE getInterface () const
 Get interface pointer to pointer of interface. More...
 
template<class IFACE , typename boost::enable_if< boost::is_reference< IFACE >, int >::type = 0>
IFACE getInterface () const
 Get reference to interface. More...
 
template<class IFACE >
IFACE * getInterface () const
 Function returning pointer to interface. More...
 
virtual ~UnknownInterface ()=default
 

Public Attributes

MoFEM::Core & cOre
 

Static Public Attributes

static bool brodcastMeshsets = true
 

Static Protected Member Functions

static void sortMeshsets (std::vector< const CubitMeshSets * > &vec_ptr)
 

Protected Attributes

Tag nsTag
 
Tag ssTag
 
Tag nsTag_data
 
Tag ssTag_data
 
Tag bhTag
 
Tag bhTag_header
 
CubitMeshSet_multiIndex cubitMeshsets
 cubit meshsets More...
 
boost::shared_ptr< boost::program_options::options_description > configFileOptionsPtr
 config file options More...
 

Additional Inherited Members

- Static Public Member Functions inherited from MoFEM::UnknownInterface
static MoFEMErrorCode getLibVersion (Version &version)
 Get library version. More...
 
static MoFEMErrorCode getFileVersion (moab::Interface &moab, Version &version)
 Get database major version. More...
 
static MoFEMErrorCode setFileVersion (moab::Interface &moab, Version version=Version(MoFEM_VERSION_MAJOR, MoFEM_VERSION_MINOR, MoFEM_VERSION_BUILD))
 Get database major version. More...
 
static MoFEMErrorCode getInterfaceVersion (Version &version)
 Get database major version. More...
 

Detailed Description

Interface for managing meshsets containing materials and boundary conditions.

Examples
add_blockset.cpp, add_cubit_meshsets.cpp, cell_forces.cpp, cubit_bc_test.cpp, dynamic_first_order_con_law.cpp, elasticity.cpp, elasticity_mixed_formulation.cpp, EshelbianPlasticity.cpp, free_surface.cpp, heat_equation.cpp, mesh_cut.cpp, mesh_smoothing.cpp, meshset_to_vtk.cpp, photon_diffusion.cpp, plastic.cpp, prism_elements_from_surface.cpp, reaction_diffusion.cpp, seepage.cpp, simple_contact.cpp, split_sideset.cpp, thermo_elastic.cpp, and unsaturated_transport.cpp.

Definition at line 104 of file MeshsetsManager.hpp.

Constructor & Destructor Documentation

◆ MeshsetsManager()

MoFEM::MeshsetsManager::MeshsetsManager ( const MoFEM::Core &  core)

Definition at line 34 of file MeshsetsManager.cpp.

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 }

◆ ~MeshsetsManager()

virtual MoFEM::MeshsetsManager::~MeshsetsManager ( )
virtualdefault

Member Function Documentation

◆ addEntitiesToMeshset() [1/2]

MoFEMErrorCode MoFEM::MeshsetsManager::addEntitiesToMeshset ( const CubitBCType  cubit_bc_type,
const int  ms_id,
const EntityHandle *  ents,
const int  nb_ents 
)

add entities to cubit meshset

Parameters
cubit_bc_typetype of meshset, f.e. NODESET, SIDESET or BLOCKSET
ms_idid of meshset
entspointer to entities array
nb_entsnumber of entities in array
Returns
error code

Definition at line 438 of file MeshsetsManager.cpp.

440  {
441  Interface &m_field = cOre;
442  moab::Interface &moab = m_field.get_moab();
443  MoFEMFunctionBegin;
444  auto cit =
445  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
446  boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
447  if (cit ==
448  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
449  SETERRQ1(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
450  "Cannot find Cubit meshset with id: %d", ms_id);
451  }
452  EntityHandle meshset = cit->getMeshset();
453  CHKERR moab.add_entities(meshset, ents, nb_ents);
454 
455  MoFEMFunctionReturn(0);
456 }

◆ addEntitiesToMeshset() [2/2]

MoFEMErrorCode MoFEM::MeshsetsManager::addEntitiesToMeshset ( const CubitBCType  cubit_bc_type,
const int  ms_id,
const Range &  ents 
)

add entities to cubit meshset

Parameters
cubit_bc_typetype of meshset, f.e. NODESET, SIDESET or BLOCKSET
ms_idid of meshset
entsentities to add
Returns
error code
Examples
mesh_cut.cpp.

Definition at line 418 of file MeshsetsManager.cpp.

419  {
420  Interface &m_field = cOre;
421  moab::Interface &moab = m_field.get_moab();
422  MoFEMFunctionBegin;
423  auto cit =
424  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
425  boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
426  if (cit ==
427  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
428  SETERRQ1(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
429  "Cannot find Cubit meshset with id: %d", ms_id);
430  }
431  EntityHandle meshset = cit->getMeshset();
432  CHKERR moab.add_entities(meshset, ents);
433 
434  MoFEMFunctionReturn(0);
435 }

◆ broadcastMeshsets()

MoFEMErrorCode MoFEM::MeshsetsManager::broadcastMeshsets ( int  verb = DEFAULT_VERBOSITY)

Boradcats meshsets.

Parameters
verb
Returns
MoFEMErrorCode

Definition at line 129 of file MeshsetsManager.cpp.

129  {
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 }

◆ checkIfMeshsetContainsEntities()

bool MoFEM::MeshsetsManager::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.

Parameters
ms_id
cubit_bc_type
entities
num_entities
operation_type
Returns
true
false

Definition at line 726 of file MeshsetsManager.cpp.

728  {
729  auto miit =
730  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
731  boost::make_tuple(ms_id, cubit_bc_type));
732  if (miit !=
733  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
734  Interface &m_field = cOre;
735  return m_field.get_moab().contains_entities(miit->meshset, entities,
736  num_entities, operation_type);
737  } else
738  return false;
739 }

◆ checkMeshset()

bool MoFEM::MeshsetsManager::checkMeshset ( const string  name,
int *const  number_of_meshsets_ptr = NULL 
) const

check if meshset of given name exist

Parameters
namename of meshset
Returns
error code

Definition at line 372 of file MeshsetsManager.cpp.

373  {
374  auto miit = cubitMeshsets.get<CubitMeshsets_name>().lower_bound(name);
375  auto hi_miit = cubitMeshsets.get<CubitMeshsets_name>().upper_bound(name);
376  if (std::distance(miit, hi_miit) == 0) {
377  return false;
378  }
379  if (number_of_meshsets_ptr) {
380  *number_of_meshsets_ptr = std::distance(miit, hi_miit);
381  }
382  return true;
383 }

◆ clearMap()

MoFEMErrorCode MoFEM::MeshsetsManager::clearMap ( )

clear multi-index container

Returns
error code

Definition at line 59 of file MeshsetsManager.cpp.

59  {
60  MoFEMFunctionBeginHot;
61  cubitMeshsets.clear();
62  MoFEMFunctionReturnHot(0);
63 }

◆ deleteMeshset()

MoFEMErrorCode MoFEM::MeshsetsManager::deleteMeshset ( const CubitBCType  cubit_bc_type,
const int  ms_id,
const MoFEMTypes  bh = MF_EXIST 
)

delete cubit meshset

Parameters
seeCubitBC (NODESET, SIDESET or BLOCKSET and more)
ms_idid of the BLOCKSET/SIDESET/BLOCKSET: from CUBIT

Definition at line 553 of file MeshsetsManager.cpp.

555  {
556  Interface &m_field = cOre;
557  moab::Interface &moab = m_field.get_moab();
558  MoFEMFunctionBegin;
559  auto miit =
560  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
561  boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
562  if (miit ==
563  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
564  if (bh & MF_EXIST) {
565  SETERRQ1(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
566  "meshset not found", ms_id);
567  } else {
568  MoFEMFunctionReturnHot(0);
569  }
570  }
571  EntityHandle meshset = miit->getMeshset();
572  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().erase(miit);
573  CHKERR moab.delete_entities(&meshset, 1);
574 
575  MoFEMFunctionReturn(0);
576 }

◆ get_bhTag()

Tag MoFEM::MeshsetsManager::get_bhTag ( ) const
inline

get tag handle used to store "id" of BLOCKSET

Definition at line 149 of file MeshsetsManager.hpp.

149 { return bhTag; }

◆ get_bhTag_header()

Tag MoFEM::MeshsetsManager::get_bhTag_header ( ) const
inline

get tag handle used to store of block set header (Used by Cubit)

Definition at line 154 of file MeshsetsManager.hpp.

154 { return bhTag_header; }

◆ get_meshsets_manager_ptr() [1/2]

MeshsetsManager* MoFEM::MeshsetsManager::get_meshsets_manager_ptr ( )
inline

return pointer to meshset manager

Definition at line 159 of file MeshsetsManager.hpp.

159 { return this; }

◆ get_meshsets_manager_ptr() [2/2]

const MeshsetsManager* MoFEM::MeshsetsManager::get_meshsets_manager_ptr ( ) const
inline

return pointer to meshset manager

Definition at line 164 of file MeshsetsManager.hpp.

164 { return this; }

◆ get_nsTag()

Tag MoFEM::MeshsetsManager::get_nsTag ( ) const
inline

get tag handle used to store "id" of NODESET

Definition at line 129 of file MeshsetsManager.hpp.

129 { return nsTag; }

◆ get_nsTag_data()

Tag MoFEM::MeshsetsManager::get_nsTag_data ( ) const
inline

get tag handle used to store boundary data on NODESET

Definition at line 139 of file MeshsetsManager.hpp.

139 { return nsTag_data; }

◆ get_ssTag()

Tag MoFEM::MeshsetsManager::get_ssTag ( ) const
inline

get tag handle used to store "id" of SIDESET

Definition at line 134 of file MeshsetsManager.hpp.

134 { return ssTag; }

◆ get_ssTag_data()

Tag MoFEM::MeshsetsManager::get_ssTag_data ( ) const
inline

get tag handle used to store boundary data on SIDESET

Definition at line 144 of file MeshsetsManager.hpp.

144 { return ssTag_data; }

◆ getConfigFileOptionsPtr()

boost::shared_ptr<boost::program_options::options_description>& MoFEM::MeshsetsManager::getConfigFileOptionsPtr ( )
inline

Get config file options, use with care.

Returns
error code

Definition at line 869 of file MeshsetsManager.hpp.

869  {
870  return configFileOptionsPtr;
871  }

◆ getMeshsetsMultindex()

CubitMeshSet_multiIndex& MoFEM::MeshsetsManager::getMeshsetsMultindex ( )
inline
Examples
meshset_to_vtk.cpp.

Definition at line 229 of file MeshsetsManager.hpp.

229  {
230  return cubitMeshsets;
231  }

◆ getTags()

MoFEMErrorCode MoFEM::MeshsetsManager::getTags ( int  verb = -1)

get tags handlers used on meshsets

On meshsets range of tags in set. Depending on tag type and data on that tag type of meshset could be determined. This function get hanldes to tags.

Most of the tags are followinf convention used by MoAB or Cubit and other meshing softwares, f.e. gmesh.

Definition at line 247 of file MeshsetsManager.cpp.

247  {
248  MoFEMFunctionBegin;
249  Interface &m_field = cOre;
250  moab::Interface &moab = m_field.get_moab();
251  int default_val = -1;
252  CHKERR moab.tag_get_handle(DIRICHLET_SET_TAG_NAME, 1, MB_TYPE_INTEGER, nsTag,
253  MB_TAG_SPARSE | MB_TAG_CREAT, &default_val);
254 
255  CHKERR moab.tag_get_handle(NEUMANN_SET_TAG_NAME, 1, MB_TYPE_INTEGER, ssTag,
256  MB_TAG_SPARSE | MB_TAG_CREAT, &default_val);
257 
258  const int def_bc_data_len = 0;
259  std::string tag_name = std::string(DIRICHLET_SET_TAG_NAME) + "__BC_DATA";
260  CHKERR moab.tag_get_handle(
261  tag_name.c_str(), def_bc_data_len, MB_TYPE_OPAQUE, nsTag_data,
262  MB_TAG_CREAT | MB_TAG_SPARSE | MB_TAG_BYTES | MB_TAG_VARLEN, NULL);
263 
264  tag_name = std::string(NEUMANN_SET_TAG_NAME) + "__BC_DATA";
265  CHKERR moab.tag_get_handle(
266  tag_name.c_str(), def_bc_data_len, MB_TYPE_OPAQUE, ssTag_data,
267  MB_TAG_CREAT | MB_TAG_SPARSE | MB_TAG_BYTES | MB_TAG_VARLEN, NULL);
268 
269  CHKERR moab.tag_get_handle(MATERIAL_SET_TAG_NAME, 1, MB_TYPE_INTEGER, bhTag,
270  MB_TAG_SPARSE | MB_TAG_CREAT, &default_val);
271 
272  std::vector<unsigned int> def_uint_zero(3, 0);
273  CHKERR moab.tag_get_handle(
274  BLOCK_HEADER, 3 * sizeof(unsigned int), MB_TYPE_INTEGER, bhTag_header,
275  MB_TAG_CREAT | MB_TAG_SPARSE | MB_TAG_BYTES, &def_uint_zero[0]);
276 
277  Tag block_attribs;
278  int def_Block_Attributes_length = 0;
279  CHKERR moab.tag_get_handle(
280  BLOCK_ATTRIBUTES, def_Block_Attributes_length, MB_TYPE_DOUBLE,
281  block_attribs, MB_TAG_CREAT | MB_TAG_SPARSE | MB_TAG_VARLEN, NULL);
282 
283  Tag entity_name_tag;
284  CHKERR moab.tag_get_handle(NAME_TAG_NAME, NAME_TAG_SIZE, MB_TYPE_OPAQUE,
285  entity_name_tag, MB_TAG_SPARSE | MB_TAG_CREAT);
286 
287  MoFEMFunctionReturn(0);
288 }

◆ initialiseDatabaseFromMesh()

MoFEMErrorCode MoFEM::MeshsetsManager::initialiseDatabaseFromMesh ( int  verb = DEFAULT_VERBOSITY)

\brier initialize container form data on mesh

Returns
[description]

Definition at line 65 of file MeshsetsManager.cpp.

65  {
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 }

◆ printBcSet()

template<class CUBIT_BC_DATA_TYPE >
MoFEMErrorCode MoFEM::MeshsetsManager::printBcSet ( CUBIT_BC_DATA_TYPE &  data,
unsigned long int  type 
) const

Definition at line 901 of file MeshsetsManager.hpp.

902  {
903  MoFEMFunctionBegin;
904  const MoFEM::Interface &m_field = cOre;
905  const moab::Interface &moab = m_field.get_moab();
906  for (auto it : getCubitMeshsetPtr(type)) {
907  CHKERR it->getBcDataStructure(data);
908  MOFEM_LOG("MeshsetMngWorld", Sev::inform) << *it;
909  MOFEM_LOG("MeshsetMngWorld", Sev::inform) << data;
910  MOFEM_LOG("MeshsetMngWorld", Sev::inform) << "name " << it->getName();
911  for (EntityType t = MBVERTEX; t != MBENTITYSET; ++t) {
912  int nb;
913  CHKERR moab.get_number_entities_by_type(it->meshset, t, nb, true);
914  if (nb > 0) {
915  MOFEM_LOG("MeshsetMngSync", Sev::inform)
916  << "msId " << it->getMeshsetId() << " number of "
917  << moab::CN::EntityTypeName(t) << " " << nb;
918  }
919  }
920  MOFEM_LOG_SEVERITY_SYNC(m_field.get_comm(), Sev::inform);
921  }
922  MoFEMFunctionReturn(0);
923 }

◆ printDisplacementSet()

MoFEMErrorCode MoFEM::MeshsetsManager::printDisplacementSet ( ) const

print meshsets with displacement boundary conditions data structure

Examples
cell_forces.cpp, elasticity.cpp, elasticity_mixed_formulation.cpp, and simple_contact.cpp.

Definition at line 290 of file MeshsetsManager.cpp.

290  {
291  DisplacementCubitBcData mydata;
292  MoFEMFunctionBegin;
293  CHKERR printBcSet(mydata, NODESET | mydata.tYpe.to_ulong());
294  MoFEMFunctionReturn(0);
295 }

◆ printForceSet()

MoFEMErrorCode MoFEM::MeshsetsManager::printForceSet ( ) const

print meshsets with force boundary conditions data structure

Examples
cell_forces.cpp, elasticity.cpp, elasticity_mixed_formulation.cpp, and simple_contact.cpp.

Definition at line 304 of file MeshsetsManager.cpp.

304  {
305  ForceCubitBcData mydata;
306  MoFEMFunctionBegin;
307  CHKERR printBcSet(mydata, NODESET | mydata.tYpe.to_ulong());
308  MoFEMFunctionReturn(0);
309 }

◆ printHeatFluxSet()

MoFEMErrorCode MoFEM::MeshsetsManager::printHeatFluxSet ( ) const

print meshsets with heat flux boundary conditions data structure

Definition at line 318 of file MeshsetsManager.cpp.

318  {
319  HeatFluxCubitBcData mydata;
320  MoFEMFunctionBegin;
321  CHKERR printBcSet(mydata, SIDESET | mydata.tYpe.to_ulong());
322  MoFEMFunctionReturn(0);
323 }

◆ printMaterialsSet()

MoFEMErrorCode MoFEM::MeshsetsManager::printMaterialsSet ( ) const

print meshsets with material data structure set on it

Examples
cell_forces.cpp, elasticity.cpp, elasticity_mixed_formulation.cpp, and simple_contact.cpp.

Definition at line 325 of file MeshsetsManager.cpp.

325  {
326  MoFEMFunctionBegin;
327  const Interface &m_field = cOre;
328  const moab::Interface &moab = m_field.get_moab();
329  for (_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(
330  (*this), BLOCKSET | MAT_ELASTICSET, it)) {
331  Mat_Elastic data;
332  CHKERR it->getAttributeDataStructure(data);
333  MOFEM_LOG("MeshsetMngWorld", Sev::inform) << *it;
334  MOFEM_LOG("MeshsetMngWorld", Sev::inform) << data;
335  Range tets;
336  CHKERR moab.get_entities_by_dimension(it->meshset, 3, tets, true);
337  MOFEM_LOG("MeshsetMngWorld", Sev::inform)
338  << "MAT_ELATIC msId " << it->getMeshsetId() << " nb. volumes "
339  << tets.size();
340  }
341 
342  for (_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(
343  m_field, BLOCKSET | MAT_THERMALSET, it)) {
344  Mat_Thermal data;
345  CHKERR it->getAttributeDataStructure(data);
346  MOFEM_LOG("MeshsetMngWorld", Sev::inform) << *it;
347  MOFEM_LOG("MeshsetMngWorld", Sev::inform) << data;
348  }
349 
350  for (_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(
351  m_field, BLOCKSET | MAT_MOISTURESET, it)) {
352  Mat_Moisture data;
353  CHKERR it->getAttributeDataStructure(data);
354  MOFEM_LOG("MeshsetMngWorld", Sev::inform) << *it;
355  MOFEM_LOG("MeshsetMngWorld", Sev::inform) << data;
356  }
357  MoFEMFunctionReturn(0);
358 }

◆ printPressureSet()

MoFEMErrorCode MoFEM::MeshsetsManager::printPressureSet ( ) const

print meshsets with pressure boundary conditions data structure

Definition at line 297 of file MeshsetsManager.cpp.

297  {
298  PressureCubitBcData mydata;
299  MoFEMFunctionBegin;
300  CHKERR printBcSet(mydata, SIDESET | mydata.tYpe.to_ulong());
301  MoFEMFunctionReturn(0);
302 }

◆ printTemperatureSet()

MoFEMErrorCode MoFEM::MeshsetsManager::printTemperatureSet ( ) const

print meshsets with temperature boundary conditions data structure

Definition at line 311 of file MeshsetsManager.cpp.

311  {
312  TemperatureCubitBcData mydata;
313  MoFEMFunctionBegin;
314  CHKERR printBcSet(mydata, NODESET | mydata.tYpe.to_ulong());
315  MoFEMFunctionReturn(0);
316 }

◆ query_interface()

MoFEMErrorCode MoFEM::MeshsetsManager::query_interface ( boost::typeindex::type_index  type_index,
UnknownInterface **  iface 
) const
virtual

Implements MoFEM::UnknownInterface.

Definition at line 28 of file MeshsetsManager.cpp.

29  {
30  *iface = const_cast<MeshsetsManager *>(this);
31  return 0;
32 }

◆ readMeshsets()

MoFEMErrorCode MoFEM::MeshsetsManager::readMeshsets ( int  verb = DEFAULT_VERBOSITY)

Boradcats meshsets.

Parameters
verb
Returns
MoFEMErrorCode

Definition at line 92 of file MeshsetsManager.cpp.

92  {
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 }

◆ saveMeshsetToFile() [1/2]

MoFEMErrorCode MoFEM::MeshsetsManager::saveMeshsetToFile ( const int  ms_id,
const unsigned int  cubit_bc_type,
const int  dim,
const std::string  file_name = "out_meshset.vtk",
const bool  recursive = false,
const std::string  file_type = "VTK",
const std::string  options = "" 
) const

save cubit meshset entities on the moab mesh

Parameters
ms_idid of the cubit meshset
cubit_bc_typetype of a cubit mesheset (NODESET SIDESET BLOCKSET)
dimdimension of the entities
file_nameoptional name for the file
file_typeoptional file type for moab (VTK MOAB)
optionsoptional parameters for moab writer (PARALLEL=WRITE_PART)
Returns
MoFEMErrorCode

Definition at line 1414 of file MeshsetsManager.cpp.

1417  {
1418 
1419  MoFEMFunctionBegin;
1420  MoFEM::Interface &m_field = cOre;
1421  moab::Interface &moab = m_field.get_moab();
1422  Range entities;
1423  CHKERR getEntitiesByDimension(ms_id, cubit_bc_type, dim, entities, recursive);
1424  EntityHandle meshset;
1425  CHKERR moab.create_meshset(MESHSET_SET, meshset);
1426  CHKERR moab.add_entities(meshset, entities);
1427  CHKERR moab.write_file(file_name.c_str(), file_type.c_str(), options.c_str(),
1428  &meshset, 1);
1429  CHKERR moab.delete_entities(&meshset, 1);
1430  MoFEMFunctionReturn(0);
1431 }

◆ saveMeshsetToFile() [2/2]

MoFEMErrorCode MoFEM::MeshsetsManager::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

Parameters
ms_idid of the cubit meshset (NODESET SIDESET BLOCKSET)
cubit_bc_typetype of a cubit mesheset
file_nameoptional name for the file
file_typeoptional file type for moab (VTK MOAB)
optionsoptional parameters for moab writer (PARALLEL=WRITE_PART)
Returns
MoFEMErrorCode
Examples
meshset_to_vtk.cpp.

Definition at line 1399 of file MeshsetsManager.cpp.

1402  {
1403 
1404  MoFEMFunctionBegin;
1405  MoFEM::Interface &m_field = cOre;
1406  const CubitMeshSets *cubit_meshset_ptr;
1407  CHKERR getCubitMeshsetPtr(ms_id, cubit_bc_type, &cubit_meshset_ptr);
1408  EntityHandle meshset = cubit_meshset_ptr->getMeshset();
1409  CHKERR m_field.get_moab().write_file(file_name.c_str(), file_type.c_str(),
1410  options.c_str(), &meshset, 1);
1411  MoFEMFunctionReturn(0);
1412 }

◆ setAtributes()

MoFEMErrorCode MoFEM::MeshsetsManager::setAtributes ( const CubitBCType  cubit_bc_type,
const int  ms_id,
const std::vector< double > &  attributes,
const std::string  name = "" 
)

set attributes to cubit meshset

Parameters
cubit_bc_typetype of meshset, see CubitBC, i.e. BLOCKSET, NODESET, SIDESET
ms_idid of meshset
attributesattributes
nameset name to blockset
Returns
error code
Examples
add_cubit_meshsets.cpp.

Definition at line 459 of file MeshsetsManager.cpp.

461  {
462  Interface &m_field = cOre;
463  moab::Interface &moab = m_field.get_moab();
464  MoFEMFunctionBegin;
465  auto cit =
466  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
467  boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
468  if (cit ==
469  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
470  SETERRQ1(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
471  "Cannot find Cubit meshset with id: %d", ms_id);
472  }
473  if (name.size() > 0) {
474  bool success = cubitMeshsets.modify(cubitMeshsets.project<0>(cit),
475  CubitMeshSets_change_name(moab, name));
476  if (!success) {
477  SETERRQ(m_field.get_comm(), MOFEM_OPERATION_UNSUCCESSFUL,
478  "name to cubit meshset can not be set");
479  }
480  }
481  bool success =
482  cubitMeshsets.modify(cubitMeshsets.project<0>(cit),
483  CubitMeshSets_change_attributes(moab, attributes));
484  if (!success)
485  SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
486  "modification unsuccessful");
487 
488  std::ostringstream ss;
489  ss << "Block " << cit->getName();
490  ss << " Add attr: ";
491  for (unsigned int ii = 0; ii != attributes.size(); ii++) {
492  ss << attributes[ii] << " ";
493  }
494  MOFEM_LOG("MeshsetMngSelf", Sev::noisy) << ss.str();
495 
496  MoFEMFunctionReturn(0);
497 }

◆ setAtributesByDataStructure()

MoFEMErrorCode MoFEM::MeshsetsManager::setAtributesByDataStructure ( const CubitBCType  cubit_bc_type,
const int  ms_id,
const GenericAttributeData &  data,
const std::string  name = "" 
)

set (material) data structure to cubit meshset

Parameters
cubit_bc_typetype of meshset, see CubitBC, i.e. BLOCKSET, NODESET, SIDESET
ms_idid of meshset
attributesattributes
Returns
error code
Examples
add_cubit_meshsets.cpp.

Definition at line 499 of file MeshsetsManager.cpp.

501  {
502  Interface &m_field = cOre;
503  moab::Interface &moab = m_field.get_moab();
504  MoFEMFunctionBegin;
505  auto cit =
506  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
507  boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
508  if (cit ==
509  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
510  SETERRQ1(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
511  "Cannot find Cubit meshset with id: %d", ms_id);
512  }
513  if (name.size() > 0) {
514  bool success = cubitMeshsets.modify(cubitMeshsets.project<0>(cit),
515  CubitMeshSets_change_name(moab, name));
516  if (!success) {
517  SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
518  "name to cubit meshset can not be set");
519  }
520  }
521  bool success = cubitMeshsets.modify(
522  cubitMeshsets.project<0>(cit),
523  CubitMeshSets_change_attributes_data_structure(moab, data));
524  if (!success)
525  SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
526  "modification unsuccessful");
527  MoFEMFunctionReturn(0);
528 }

◆ setBcData()

MoFEMErrorCode MoFEM::MeshsetsManager::setBcData ( const CubitBCType  cubit_bc_type,
const int  ms_id,
const GenericCubitBcData &  data 
)

set boundary data structure to meshset

Parameters
cubit_bc_typetype of meshset, see CubitBC, i.e. BLOCKSET, NODESET, SIDESET
ms_idid of meshset
datadata structure
Returns
error code
Examples
add_cubit_meshsets.cpp.

Definition at line 530 of file MeshsetsManager.cpp.

532  {
533  Interface &m_field = cOre;
534  moab::Interface &moab = m_field.get_moab();
535  MoFEMFunctionBegin;
536  auto cit =
537  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
538  boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
539  if (cit ==
540  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
541  SETERRQ1(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
542  "Cubit meshset with id is already there", ms_id);
543  }
544  bool success =
545  cubitMeshsets.modify(cubitMeshsets.project<0>(cit),
546  CubitMeshSets_change_bc_data_structure(moab, data));
547  if (!success)
548  SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
549  "modification unsuccessful");
550  MoFEMFunctionReturn(0);
551 }

◆ setMeshsetFromFile() [1/2]

MoFEMErrorCode MoFEM::MeshsetsManager::setMeshsetFromFile ( )

get name of config file from line command '-meshsets_config'

Returns
error code

Option is "-meshsets_config file_name.cfg"

Definition at line 1375 of file MeshsetsManager.cpp.

1375  {
1376  Interface &m_field = cOre;
1377  PetscBool flg_file;
1378  char meshset_file_name[255] = "config_file.cfg";
1379  MoFEMFunctionBegin;
1380  CHKERR PetscOptionsBegin(m_field.get_comm(), "", "Set meshsets form file",
1381  "none");
1382  CHKERR PetscOptionsString("-meshsets_config", "meshsets config file name",
1383  "", "add_cubit_meshsets.in", meshset_file_name, 255,
1384  &flg_file);
1385  if (flg_file == PETSC_TRUE) {
1386  ifstream f(meshset_file_name);
1387  if (!f.good()) {
1388  SETERRQ1(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
1389  "File configuring meshsets ( %s ) can not be open\n",
1390  meshset_file_name);
1391  }
1392  CHKERR setMeshsetFromFile(string(meshset_file_name));
1393  }
1394  ierr = PetscOptionsEnd();
1395  CHKERRG(ierr);
1396  MoFEMFunctionReturn(0);
1397 }

◆ setMeshsetFromFile() [2/2]

MoFEMErrorCode MoFEM::MeshsetsManager::setMeshsetFromFile ( const string  file_name,
const bool  clean_file_options = true 
)

add blocksets reading config file

Example of config file

[block_1001]
# Example applying attributes to blockset
id=2001
add=BLOCKSET
user1=1.0 # attribute value 1
user2=2.0 # you can set up to 10 attributes (if needed could be easily
extended to more, let us know)
user3=3.0
[block_1002]
# Example applying material block (isotropic elastic material)
id=2002
add=BLOCKSET
name=MAT_ELASTIC
young=10
poisson=0.25
thermalexpansion=0
[block_1003]
# Example applying displacement constrains
id=2003
add=NODESET
# Each flag means that boundary consition on displacements is set.
disp_flag1=1 # Setting constrains in x- direction
disp_flag2=1 # Setting constrains in y- direction
disp_flag3=1 # Setting constrains in z- direction
disp_flag4=1 # Setting constrains on rotation over x- axis
disp_flag5=1 # Setting constrains on rotation over y- axis
disp_flag6=1 # Setting constrains on rotation over z-axis
disp_ux=1 # value of disp in x- direction
disp_uy=2
disp_uz=3
disp_rx=4 # value of rotation in y-direction
disp_ry=5
disp_rz=6
# Note above values could be interpreted differently if needed.
[block_1004]
# Example applying force boundary conditions
id=2004
add=NODESET
force_magnitude=1
moment_magnitude=1
force_fx=1
force_fy=1
force_fz=1
moment_mx=1
moment_my=1
moment_mz=1
[block_1005]
# Example applying pressure boundary conditions
id=2005
add=SIDESET
pressure_flag2=1 # 0: Pressure is interpreted as pure pressure 1:
pressure is interpreted as total force
pressure_magnitude=1
# Example applying temperature boundary conditions
[block_1006]
id=2006
add=NODESET
temperature_flag1=1 # 0: N/A, 1: temperature value applied
temperature_t=1
[block_1007]
id=2007
add=SIDESET
heatflux_flag1=1 # 0: N/A, 1: heat flux applied
heatflux_magnitude=1
[block_1008]
# Example applying material block (isotropic thermal material)
id=2008
add=BLOCKSET
name=MAT_THERMAL # Hast to be set for Thermal Mat
conductivity=1
capacity=1
[block_1009]
# Example applying interface
id=2009
add=SIDESET
interface_type=1
[block_1010]
# Example applying material block for interface element
id=2010
add=BLOCKSET
name=MAT_INTERF
interface_alpha = 1
interface_beta = 0
interface_ft = 1
interface_Gf = 1
[block_1009]
# Example applying material block (isotropic trans iso material)
id=2011
add=BLOCKSET
name=MAT_ELASTIC_TRANS_ISO
Youngp=1
Youngz=2
Poissonp=3
Poissonpz=4
Shearzp=5
[SET_ATTR_foo]
# Example set atttributes to block name "foo"
number_of_attributes=3
user1=1
user2=2
user3=3
Parameters
file_nameconfig file
Returns
error code
Examples
add_cubit_meshsets.cpp, meshset_to_vtk.cpp, and unsaturated_transport.cpp.

Definition at line 791 of file MeshsetsManager.cpp.

792  {
793  Interface &m_field = cOre;
794  MoFEMFunctionBegin;
795  std::ifstream ini_file(file_name.c_str(), std::ifstream::in);
796  po::variables_map vm;
797  if (clean_file_options) {
798  configFileOptionsPtr =
799  boost::shared_ptr<boost::program_options::options_description>(
800  new po::options_description());
801  }
802 
803  auto add_block_attributes = [&](auto prefix, auto &block_lists, auto &it) {
804  // remove spacec from blockset name
805  configFileOptionsPtr->add_options()(
806  (prefix + ".number_of_attributes").c_str(),
807  po::value<int>(&block_lists[it->getMeshsetId()].numberOfAttributes)
808  ->default_value(-1),
809  "Number of blockset attribute");
810  for (int ii = 1; ii <= 10; ii++) {
811  std::string surfix = ".user" + boost::lexical_cast<std::string>(ii);
812  configFileOptionsPtr->add_options()(
813  (prefix + surfix).c_str(),
814  po::value<double>(&block_lists[it->getMeshsetId()].aTtr[ii - 1])
815  ->default_value(0.0),
816  "Add block attribute");
817  }
818  };
819 
820  // Add blocks
821  map<int, BlockData> block_lists;
822  for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(m_field, BLOCKSET, it)) {
823  block_lists[it->getMeshsetId()].cubitMeshset = it->getMeshset();
824  std::string prefix =
825  "block_" + boost::lexical_cast<std::string>(it->getMeshsetId());
826  configFileOptionsPtr->add_options()(
827  (prefix + ".add").c_str(),
828  po::value<string>(&block_lists[it->getMeshsetId()].addType)
829  ->default_value("UNKNOWNSET"),
830  "Add block set")(
831  (prefix + ".id").c_str(),
832  po::value<int>(&block_lists[it->getMeshsetId()].iD)->default_value(-1),
833  "Id of meshset")(
834  (prefix + ".name").c_str(),
835  po::value<string>(&block_lists[it->getMeshsetId()].nAme)
836  ->default_value(""),
837  "Name of the meshset");
838 
839  // Block attributes
840  add_block_attributes(prefix, block_lists, it);
841 
842  // Mat elastic
843  {
844  // double Young; ///< Young's modulus
845  // double Poisson; ///< Poisson's ratio
846  // double ThermalExpansion; ///< Thermal expansion
847  configFileOptionsPtr->add_options()(
848  (prefix + ".young").c_str(),
849  po::value<double>(
850  &block_lists[it->getMeshsetId()].matElastic.data.Young)
851  ->default_value(-1),
852  "Young modulus")(
853  (prefix + ".poisson").c_str(),
854  po::value<double>(
855  &block_lists[it->getMeshsetId()].matElastic.data.Poisson)
856  ->default_value(-2),
857  "Poisson ratio")(
858  (prefix + ".thermalexpansion").c_str(),
859  po::value<double>(
860  &block_lists[it->getMeshsetId()].matElastic.data.ThermalExpansion)
861  ->default_value(-1),
862  "Thermal expansion");
863  // TODO Add users parameters
864  }
865  // Mat Trans Iso
866  {
867  // Young's modulus in xy plane (Ep)
868  // Young's modulus in z-direction (Ez)
869  // Poisson's ratio in xy plane (vp)
870  // Poisson's ratio in z-direction (vpz)
871  // Shear modulus in z-direction (Gzp)
872  configFileOptionsPtr->add_options()(
873  (prefix + ".Youngp").c_str(),
874  po::value<double>(
875  &block_lists[it->getMeshsetId()].matTransIso.data.Youngp)
876  ->default_value(-1),
877  "Youngp")(
878  (prefix + ".Youngz").c_str(),
879  po::value<double>(
880  &block_lists[it->getMeshsetId()].matTransIso.data.Youngz)
881  ->default_value(-1),
882  "Youngz")(
883  (prefix + ".Poissonp").c_str(),
884  po::value<double>(
885  &block_lists[it->getMeshsetId()].matTransIso.data.Poissonp)
886  ->default_value(0),
887  "Poissonp")(
888  (prefix + ".Poissonpz").c_str(),
889  po::value<double>(
890  &block_lists[it->getMeshsetId()].matTransIso.data.Poissonpz)
891  ->default_value(0),
892  "Poissonpz")(
893  (prefix + ".Shearzp").c_str(),
894  po::value<double>(
895  &block_lists[it->getMeshsetId()].matTransIso.data.Shearzp)
896  ->default_value(-1),
897  "Shearzp");
898  // TODO Add users parameters
899  }
900  // Mat thermal
901  {
902  // double Conductivity; ///< Thermal conductivity
903  // double HeatCapacity; ///< Heat Capacity
904  configFileOptionsPtr->add_options()(
905  (prefix + ".conductivity").c_str(),
906  po::value<double>(
907  &block_lists[it->getMeshsetId()].matThermal.data.Conductivity)
908  ->default_value(-1),
909  "Conductivity")(
910  (prefix + ".capacity").c_str(),
911  po::value<double>(
912  &block_lists[it->getMeshsetId()].matThermal.data.HeatCapacity)
913  ->default_value(-1),
914  "Capacity");
915  // TODO Add users parameters
916  }
917  // Mat interface
918  {
919  // double alpha; ///< Elastic modulus multiplier
920  // double beta; ///< Damage Coupling multiplier between normal and
921  // shear (g=sqrt(gn^2 + beta(gt1^2 + gt2^2))) double ft; ///< Maximum
922  // stress of crack double Gf; ///< Fracture Energy
923  configFileOptionsPtr->add_options()(
924  (prefix + ".interface_alpha").c_str(),
925  po::value<double>(
926  &block_lists[it->getMeshsetId()].matInterf.data.alpha)
927  ->default_value(-1),
928  "alpha")((prefix + ".interface_beta").c_str(),
929  po::value<double>(
930  &block_lists[it->getMeshsetId()].matInterf.data.beta)
931  ->default_value(-1),
932  "beta")(
933  (prefix + ".interface_ft").c_str(),
934  po::value<double>(&block_lists[it->getMeshsetId()].matInterf.data.ft)
935  ->default_value(-1),
936  "ft")(
937  (prefix + ".interface_Gf").c_str(),
938  po::value<double>(&block_lists[it->getMeshsetId()].matInterf.data.Gf)
939  ->default_value(-1),
940  "Gf");
941  // TODO Add users parameters
942  }
943 
944  // Displacement bc
945  {
946  // char flag1; //< Flag for X-Translation (0: N/A, 1: specified)
947  // char flag2; //< Flag for Y-Translation (0: N/A, 1: specified)
948  // char flag3; //< Flag for Z-Translation (0: N/A, 1: specified)
949  // char flag4; //< Flag for X-Rotation (0: N/A, 1: specified)
950  // char flag5; //< Flag for Y-Rotation (0: N/A, 1: specified)
951  // char flag6; //< Flag for Z-Rotation (0: N/A, 1: specified)
952  // double value1; //< Value for X-Translation
953  // double value2; //< Value for Y-Translation
954  // double value3; //< Value for Z-Translation
955  // double value4; //< Value for X-Rotation
956  // double value5; //< Value for Y-Rotation
957  // double value6; //< Value for Z-Rotation
958  configFileOptionsPtr->add_options()(
959  (prefix + ".disp_flag1").c_str(),
960  po::value<char>(&block_lists[it->getMeshsetId()].dispBc.data.flag1)
961  ->default_value(0),
962  "flag1")(
963  (prefix + ".disp_flag2").c_str(),
964  po::value<char>(&block_lists[it->getMeshsetId()].dispBc.data.flag2)
965  ->default_value(0),
966  "flag2")(
967  (prefix + ".disp_flag3").c_str(),
968  po::value<char>(&block_lists[it->getMeshsetId()].dispBc.data.flag3)
969  ->default_value(0),
970  "flag3")(
971  (prefix + ".disp_flag4").c_str(),
972  po::value<char>(&block_lists[it->getMeshsetId()].dispBc.data.flag4)
973  ->default_value(0),
974  "flag4")(
975  (prefix + ".disp_flag5").c_str(),
976  po::value<char>(&block_lists[it->getMeshsetId()].dispBc.data.flag5)
977  ->default_value(0),
978  "flag5")(
979  (prefix + ".disp_flag6").c_str(),
980  po::value<char>(&block_lists[it->getMeshsetId()].dispBc.data.flag6)
981  ->default_value(0),
982  "flag6")(
983  (prefix + ".disp_ux").c_str(),
984  po::value<double>(&block_lists[it->getMeshsetId()].dispBc.data.value1)
985  ->default_value(0),
986  "value1")(
987  (prefix + ".disp_uy").c_str(),
988  po::value<double>(&block_lists[it->getMeshsetId()].dispBc.data.value2)
989  ->default_value(0),
990  "value2")(
991  (prefix + ".disp_uz").c_str(),
992  po::value<double>(&block_lists[it->getMeshsetId()].dispBc.data.value3)
993  ->default_value(0),
994  "value3")(
995  (prefix + ".disp_rx").c_str(),
996  po::value<double>(&block_lists[it->getMeshsetId()].dispBc.data.value4)
997  ->default_value(0),
998  "value4")(
999  (prefix + ".disp_ry").c_str(),
1000  po::value<double>(&block_lists[it->getMeshsetId()].dispBc.data.value5)
1001  ->default_value(0),
1002  "value5")(
1003  (prefix + ".disp_rz").c_str(),
1004  po::value<double>(&block_lists[it->getMeshsetId()].dispBc.data.value6)
1005  ->default_value(0),
1006  "value6");
1007  }
1008  // Force BC data
1009  {
1010  // char zero[3]; //< 3 zeros
1011  // double value1; //< Force magnitude
1012  // double value2; //< Moment magnitude
1013  // double value3; //< X-component of force direction vector
1014  // double value4; //< Y-component of force direction vector
1015  // double value5; //< Z-component of force direction vector
1016  // double value6; //< X-component of moment direction vector
1017  // double value7; //< Y-component of moment direction vector
1018  // double value8; //< Z-component of moment direction vector
1019  // char zero2; // 0
1020  configFileOptionsPtr->add_options()(
1021  (prefix + ".force_magnitude").c_str(),
1022  po::value<double>(
1023  &block_lists[it->getMeshsetId()].forceBc.data.value1)
1024  ->default_value(0),
1025  "value1")((prefix + ".moment_magnitude").c_str(),
1026  po::value<double>(
1027  &block_lists[it->getMeshsetId()].forceBc.data.value2)
1028  ->default_value(0),
1029  "value2")(
1030  (prefix + ".force_fx").c_str(),
1031  po::value<double>(
1032  &block_lists[it->getMeshsetId()].forceBc.data.value3)
1033  ->default_value(0),
1034  "value3")((prefix + ".force_fy").c_str(),
1035  po::value<double>(
1036  &block_lists[it->getMeshsetId()].forceBc.data.value4)
1037  ->default_value(0),
1038  "value4")(
1039  (prefix + ".force_fz").c_str(),
1040  po::value<double>(
1041  &block_lists[it->getMeshsetId()].forceBc.data.value5)
1042  ->default_value(0),
1043  "value5")((prefix + ".moment_mx").c_str(),
1044  po::value<double>(
1045  &block_lists[it->getMeshsetId()].forceBc.data.value6)
1046  ->default_value(0),
1047  "value6")(
1048  (prefix + ".moment_my").c_str(),
1049  po::value<double>(
1050  &block_lists[it->getMeshsetId()].forceBc.data.value7)
1051  ->default_value(0),
1052  "value7")((prefix + ".moment_mz").c_str(),
1053  po::value<double>(
1054  &block_lists[it->getMeshsetId()].forceBc.data.value8)
1055  ->default_value(0),
1056  "value8");
1057  }
1058  {
1059  // char name[11]; //< 11 characters for "Temperature"
1060  // char pre1; //< This is always zero
1061  // char pre2; //< 0: temperature is not applied on thin shells
1062  // (default); 1: temperature is applied on thin shells char flag1; //<
1063  // 0: N/A, 1: temperature value applied (not on thin shells) char flag2;
1064  // //< 0: N/A, 1: temperature applied on thin shell middle char flag3;
1065  // //< 0: N/A, 1: thin shell temperature gradient specified char flag4;
1066  // //< 0: N/A, 1: top thin shell temperature char flag5; //< 0: N/A, 1:
1067  // bottom thin shell temperature char flag6; //< This is always zero
1068  // double value1; //< Temperature (default case - no thin shells)
1069  // double value2; //< Temperature for middle of thin shells
1070  // double value3; //< Temperature gradient for thin shells
1071  // double value4; //< Temperature for top of thin shells
1072  // double value5; //< Temperature for bottom of thin shells
1073  // double value6; //< This is always zero, i.e. ignore
1074  configFileOptionsPtr->add_options()(
1075  (prefix + ".temperature_flag1").c_str(),
1076  po::value<char>(
1077  &block_lists[it->getMeshsetId()].temperatureBc.data.flag1)
1078  ->default_value(0),
1079  "flag1")(
1080  (prefix + ".temperature_t").c_str(),
1081  po::value<double>(
1082  &block_lists[it->getMeshsetId()].temperatureBc.data.value1)
1083  ->default_value(0),
1084  "value1");
1085  // TODO: Add more cases, see above
1086  }
1087  // Sideset
1088  {
1089  // char name[8]; //< 8 characters for "Pressure"
1090  // char zero; //< This is always zero
1091  // char flag2; //< 0: Pressure is interpreted as pure pressure 1:
1092  // pressure is interpreted as total force double value1; //< Pressure
1093  // value
1094  configFileOptionsPtr->add_options()(
1095  (prefix + ".pressure_flag2").c_str(),
1096  po::value<char>(
1097  &block_lists[it->getMeshsetId()].pressureBc.data.flag2)
1098  ->default_value(0),
1099  "flag2")((prefix + ".pressure_magnitude").c_str(),
1100  po::value<double>(
1101  &block_lists[it->getMeshsetId()].pressureBc.data.value1)
1102  ->default_value(0),
1103  "value1");
1104  }
1105  {
1106  // char name[8]; //< 8 characters for "HeatFlux" (no space)
1107  // char pre1; //< This is always zero
1108  // char pre2; //< 0: heat flux is not applied on thin shells (default);
1109  // 1: heat flux is applied on thin shells char flag1; //< 0: N/A, 1:
1110  // normal heat flux case (i.e. single value, case without thin shells)
1111  // char flag2; //< 0: N/A, 1: Thin shell top heat flux specified
1112  // char flag3; //< 0: N/A, 1: Thin shell bottom heat flux specidied
1113  // double value1; //< Heat flux value for default case (no thin shells)
1114  // double value2; //< Heat flux (thin shell top)
1115  // double value3; //< Heat flux (thin shell bottom)
1116  configFileOptionsPtr->add_options()(
1117  (prefix + ".heatflux_flag1").c_str(),
1118  po::value<char>(
1119  &block_lists[it->getMeshsetId()].heatFluxBc.data.flag1)
1120  ->default_value(0),
1121  "flag1")((prefix + ".heatflux_magnitude").c_str(),
1122  po::value<double>(
1123  &block_lists[it->getMeshsetId()].heatFluxBc.data.value1)
1124  ->default_value(0),
1125  "value1");
1126  }
1127  // Interface set
1128  {
1129  configFileOptionsPtr->add_options()(
1130  (prefix + ".interface_type").c_str(),
1131  po::value<char>(&block_lists[it->getMeshsetId()].cfgBc.data.type)
1132  ->default_value(0),
1133  "type");
1134  }
1135  }
1136 
1137  map<int, BlockData> block_set_attributes;
1138  for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(m_field, BLOCKSET, it)) {
1139  block_set_attributes[it->getMeshsetId()].cubitMeshset = it->getMeshset();
1140  block_set_attributes[it->getMeshsetId()].iD = it->getMeshsetId();
1141  block_set_attributes[it->getMeshsetId()].bcType = BLOCKSET;
1142  std::string block_name = it->getName();
1143  block_name.erase(
1144  std::remove_if(block_name.begin(), block_name.end(), ::isspace),
1145  block_name.end());
1146  block_set_attributes[it->getMeshsetId()].nAme = block_name;
1147  // Only blocks which have name
1148  if (block_name.compare("NoNameSet") != 0) {
1149  std::string prefix = "SET_ATTR_" + block_name;
1150  // Block attributes
1151  add_block_attributes(prefix, block_set_attributes, it);
1152  }
1153  }
1154 
1155  po::parsed_options parsed =
1156  parse_config_file(ini_file, *configFileOptionsPtr, true);
1157  store(parsed, vm);
1158  po::notify(vm);
1159 
1160  // Set type from name
1161  for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(m_field, BLOCKSET, it)) {
1162 
1163  CubitBCType bc_type;
1164  unsigned jj = 0;
1165  while (1 << jj != LASTSET_BC) {
1166  if (string(CubitBCNames[jj + 1]) ==
1167  block_lists[it->getMeshsetId()].addType) {
1168  bc_type = 1 << jj;
1169  }
1170  ++jj;
1171  }
1172  if (bc_type.none()) {
1173  block_lists[it->getMeshsetId()].bcType = UNKNOWNSET;
1174  // Skip the bockset nothing is defined for it
1175  continue;
1176  }
1177 
1178  if (bc_type.to_ulong() == BLOCKSET)
1179  block_lists[it->getMeshsetId()].bcType = BLOCKSET;
1180  else if (bc_type.to_ulong() == NODESET)
1181  block_lists[it->getMeshsetId()].bcType = NODESET;
1182  else if (bc_type.to_ulong() == SIDESET)
1183  block_lists[it->getMeshsetId()].bcType = SIDESET;
1184  else {
1185  SETERRQ1(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
1186  "Not yet implemented type %s\n",
1187  block_lists[it->getMeshsetId()].addType.c_str());
1188  }
1189  if (block_lists[it->getMeshsetId()].iD == -1) {
1190  SETERRQ1(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
1191  "Unset iD number %d\n", block_lists[it->getMeshsetId()].iD);
1192  }
1193  }
1194 
1195  std::vector<std::string> additional_parameters;
1196  additional_parameters =
1197  collect_unrecognized(parsed.options, po::include_positional);
1198  for (std::vector<std::string>::iterator vit = additional_parameters.begin();
1199  vit != additional_parameters.end(); vit++) {
1200  MOFEM_LOG_C("MeshsetMngSelf", Sev::warning, "Unrecognized option %s",
1201  vit->c_str());
1202  }
1203  for (map<int, BlockData>::iterator mit = block_lists.begin();
1204  mit != block_lists.end(); mit++) {
1205  CubitMeshSet_multiIndex::iterator cubit_meshset_it =
1206  cubitMeshsets.find(mit->second.cubitMeshset);
1207  if (cubit_meshset_it == cubitMeshsets.end()) {
1208  SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
1209  "Data inconsistency\n");
1210  }
1211  switch (mit->second.bcType) {
1212  case UNKNOWNSET:
1213  break;
1214  case BLOCKSET: {
1215  if ((CubitBCType(mit->second.bcType) & cubit_meshset_it->getBcType())
1216  .any() &&
1217  mit->second.iD == cubit_meshset_it->getMeshsetId()) {
1218  // Meshset is the same, only modification
1219  } else {
1220  CHKERR addMeshset(mit->second.bcType, mit->second.iD, mit->second.nAme);
1221  EntityHandle meshset = cubit_meshset_it->getMeshset();
1222  CHKERR addEntitiesToMeshset(mit->second.bcType, mit->second.iD,
1223  &meshset, 1);
1224  }
1225  // Add attributes
1226  CHKERR setAtributes(mit->second.bcType, mit->second.iD, mit->second.aTtr);
1227  // Add material elastic data if value are physical (i.e. Young > 0,
1228  // Poisson in (-1.0.5) and ThermalExpansion>0)
1229  if (mit->second.matElastic.data.Young != -1) {
1230  CHKERR setAtributesByDataStructure(mit->second.bcType, mit->second.iD,
1231  mit->second.matElastic);
1232  }
1233  if (mit->second.matTransIso.data.Youngp != -1) {
1234  CHKERR setAtributesByDataStructure(mit->second.bcType, mit->second.iD,
1235  mit->second.matTransIso);
1236  }
1237  if (mit->second.matThermal.data.Conductivity != -1) {
1238  CHKERR setAtributesByDataStructure(mit->second.bcType, mit->second.iD,
1239  mit->second.matThermal);
1240  }
1241  if (mit->second.matInterf.data.ft != -1) {
1242  CHKERR setAtributesByDataStructure(mit->second.bcType, mit->second.iD,
1243  mit->second.matInterf);
1244  }
1245  } break;
1246  case NODESET: {
1247  if ((CubitBCType(mit->second.bcType) & cubit_meshset_it->getBcType())
1248  .any() &&
1249  mit->second.iD == cubit_meshset_it->getMeshsetId()) {
1250  // Meshset is the same, only modification
1251  } else {
1252  CHKERR addMeshset(mit->second.bcType, mit->second.iD);
1253  EntityHandle meshset = cubit_meshset_it->getMeshset();
1254  CHKERR addEntitiesToMeshset(mit->second.bcType, mit->second.iD,
1255  &meshset, 1);
1256  }
1257  // Add displacement bc
1258  if (mit->second.dispBc.data.flag1 || mit->second.dispBc.data.flag2 ||
1259  mit->second.dispBc.data.flag3 || mit->second.dispBc.data.flag4 ||
1260  mit->second.dispBc.data.flag5 || mit->second.dispBc.data.flag6) {
1261  if (mit->second.dispBc.data.flag1 == '0')
1262  mit->second.dispBc.data.flag1 = 0;
1263  if (mit->second.dispBc.data.flag1 == 'N')
1264  mit->second.dispBc.data.flag1 = 0;
1265  if (mit->second.dispBc.data.flag1)
1266  mit->second.dispBc.data.flag1 = 1;
1267  if (mit->second.dispBc.data.flag2 == '0')
1268  mit->second.dispBc.data.flag2 = 0;
1269  if (mit->second.dispBc.data.flag2 == 'N')
1270  mit->second.dispBc.data.flag2 = 0;
1271  if (mit->second.dispBc.data.flag2)
1272  mit->second.dispBc.data.flag2 = 1;
1273  if (mit->second.dispBc.data.flag3 == '0')
1274  mit->second.dispBc.data.flag3 = 0;
1275  if (mit->second.dispBc.data.flag3 == 'N')
1276  mit->second.dispBc.data.flag3 = 0;
1277  if (mit->second.dispBc.data.flag3)
1278  mit->second.dispBc.data.flag3 = 1;
1279  if (mit->second.dispBc.data.flag4 == '0')
1280  mit->second.dispBc.data.flag4 = 0;
1281  if (mit->second.dispBc.data.flag4 == 'N')
1282  mit->second.dispBc.data.flag4 = 0;
1283  if (mit->second.dispBc.data.flag4)
1284  mit->second.dispBc.data.flag4 = 1;
1285  if (mit->second.dispBc.data.flag5 == '0')
1286  mit->second.dispBc.data.flag5 = 0;
1287  if (mit->second.dispBc.data.flag5 == 'N')
1288  mit->second.dispBc.data.flag5 = 0;
1289  if (mit->second.dispBc.data.flag5)
1290  mit->second.dispBc.data.flag5 = 1;
1291  if (mit->second.dispBc.data.flag6 == '0')
1292  mit->second.dispBc.data.flag6 = 0;
1293  if (mit->second.dispBc.data.flag6 == 'N')
1294  mit->second.dispBc.data.flag6 = 0;
1295  if (mit->second.dispBc.data.flag6)
1296  mit->second.dispBc.data.flag6 = 1;
1297  CHKERR setBcData(mit->second.bcType, mit->second.iD,
1298  mit->second.dispBc);
1299  }
1300  if (mit->second.forceBc.data.value1 != 0 ||
1301  mit->second.forceBc.data.value2 != 0) {
1302  CHKERR setBcData(mit->second.bcType, mit->second.iD,
1303  mit->second.forceBc);
1304  }
1305  // Add temperature boundary condition
1306  if (mit->second.temperatureBc.data.flag1) {
1307  if (mit->second.temperatureBc.data.flag1 == '0')
1308  mit->second.temperatureBc.data.flag1 = 0;
1309  if (mit->second.temperatureBc.data.flag1 == 'N')
1310  mit->second.temperatureBc.data.flag1 = 0;
1311  if (mit->second.temperatureBc.data.flag1)
1312  mit->second.temperatureBc.data.flag1 = 1;
1313  CHKERR setBcData(mit->second.bcType, mit->second.iD,
1314  mit->second.temperatureBc);
1315  }
1316  } break;
1317  case SIDESET: {
1318  if ((CubitBCType(mit->second.bcType) & cubit_meshset_it->getBcType())
1319  .any() &&
1320  mit->second.iD == cubit_meshset_it->getMeshsetId()) {
1321  // Meshset is the same, only modification
1322  } else {
1323  CHKERR addMeshset(mit->second.bcType, mit->second.iD);
1324  EntityHandle meshset = cubit_meshset_it->getMeshset();
1325  CHKERR addEntitiesToMeshset(mit->second.bcType, mit->second.iD,
1326  &meshset, 1);
1327  }
1328  // Add pressure
1329  if (mit->second.pressureBc.data.value1 != 0) {
1330  if (mit->second.pressureBc.data.flag2 == '0')
1331  mit->second.pressureBc.data.flag2 = 0;
1332  if (mit->second.pressureBc.data.flag2 == 'N')
1333  mit->second.pressureBc.data.flag2 = 0;
1334  if (mit->second.pressureBc.data.flag2)
1335  mit->second.pressureBc.data.flag2 = 1;
1336  CHKERR setBcData(mit->second.bcType, mit->second.iD,
1337  mit->second.pressureBc);
1338  }
1339  // Add heat flux
1340  if (mit->second.heatFluxBc.data.value1 != 0) {
1341  if (mit->second.heatFluxBc.data.flag1 == '0')
1342  mit->second.heatFluxBc.data.flag1 = 0;
1343  if (mit->second.heatFluxBc.data.flag1 == 'N')
1344  mit->second.heatFluxBc.data.flag1 = 0;
1345  if (mit->second.heatFluxBc.data.flag1)
1346  mit->second.heatFluxBc.data.flag1 = 1;
1347  CHKERR setBcData(mit->second.bcType, mit->second.iD,
1348  mit->second.heatFluxBc);
1349  }
1350  // Add Interface
1351  if (mit->second.cfgBc.data.type != 0) {
1352  CHKERR setBcData(mit->second.bcType, mit->second.iD, mit->second.cfgBc);
1353  }
1354  } break;
1355  default:
1356  SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
1357  "Not yet implemented type\n");
1358  }
1359  }
1360 
1361  for (auto set_attr : block_set_attributes) {
1362  // Add attributes
1363  if (set_attr.second.numberOfAttributes > 0) {
1364  MOFEM_LOG("MeshsetMngSelf", Sev::verbose)
1365  << "Set attributes to blockset " << set_attr.second.nAme;
1366  set_attr.second.aTtr.resize(set_attr.second.numberOfAttributes);
1367  CHKERR setAtributes(set_attr.second.bcType, set_attr.second.iD,
1368  set_attr.second.aTtr);
1369  }
1370  }
1371 
1372  MoFEMFunctionReturn(0);
1373 }

◆ sortMeshsets()

void MoFEM::MeshsetsManager::sortMeshsets ( std::vector< const CubitMeshSets * > &  vec_ptr)
staticprotected

Definition at line 12 of file MeshsetsManager.cpp.

13  {
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 }

◆ updateAllMeshsetsByEntitiesChildren()

MoFEMErrorCode MoFEM::MeshsetsManager::updateAllMeshsetsByEntitiesChildren ( const BitRefLevel &  bit)

Update all blolsets, sidesets and node sets.

Parameters
bit
Returns
MoFEMErrorCode

Definition at line 1434 of file MeshsetsManager.cpp.

1434  {
1435  MoFEMFunctionBegin;
1436  BitRefManager *bit_mng = cOre.getInterface<BitRefManager>();
1437  for (_IT_CUBITMESHSETS_FOR_LOOP_((*this), iit)) {
1438  EntityHandle meshset = iit->getMeshset();
1439  for (EntityType t = MBVERTEX; t != MBENTITYSET; ++t)
1440  CHKERR bit_mng->updateMeshsetByEntitiesChildren(meshset, bit, meshset, t,
1441  true);
1442  }
1443  MoFEMFunctionReturn(0);
1444 }

Member Data Documentation

◆ bhTag

Tag MoFEM::MeshsetsManager::bhTag
protected

Definition at line 889 of file MeshsetsManager.hpp.

◆ bhTag_header

Tag MoFEM::MeshsetsManager::bhTag_header
protected

Definition at line 890 of file MeshsetsManager.hpp.

◆ brodcastMeshsets

bool MoFEM::MeshsetsManager::brodcastMeshsets = true
static

if true meshsets are synchrinised between processors

Definition at line 881 of file MeshsetsManager.hpp.

◆ configFileOptionsPtr

boost::shared_ptr<boost::program_options::options_description> MoFEM::MeshsetsManager::configFileOptionsPtr
protected

config file options

Definition at line 895 of file MeshsetsManager.hpp.

◆ cOre

MoFEM::Core& MoFEM::MeshsetsManager::cOre

Definition at line 109 of file MeshsetsManager.hpp.

◆ cubitMeshsets

CubitMeshSet_multiIndex MoFEM::MeshsetsManager::cubitMeshsets
protected

cubit meshsets

Definition at line 893 of file MeshsetsManager.hpp.

◆ nsTag

Tag MoFEM::MeshsetsManager::nsTag
protected

Definition at line 885 of file MeshsetsManager.hpp.

◆ nsTag_data

Tag MoFEM::MeshsetsManager::nsTag_data
protected

Definition at line 887 of file MeshsetsManager.hpp.

◆ ssTag

Tag MoFEM::MeshsetsManager::ssTag
protected

Definition at line 886 of file MeshsetsManager.hpp.

◆ ssTag_data

Tag MoFEM::MeshsetsManager::ssTag_data
protected

Definition at line 888 of file MeshsetsManager.hpp.

The documentation for this struct was generated from the following files:
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
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
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::MeshsetsManager::addEntitiesToMeshset
MoFEMErrorCode addEntitiesToMeshset(const CubitBCType cubit_bc_type, const int ms_id, const Range &ents)
add entities to cubit meshset
Definition: MeshsetsManager.cpp:418
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::MeshsetsManager::broadcastMeshsets
MoFEMErrorCode broadcastMeshsets(int verb=DEFAULT_VERBOSITY)
Boradcats meshsets.
Definition: MeshsetsManager.cpp:129
_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::th
Tag th
Definition: Projection10NodeCoordsOnField.cpp:122
MoFEM::MeshsetsManager::brodcastMeshsets
static bool brodcastMeshsets
Definition: MeshsetsManager.hpp:881
A
constexpr AssemblyType A
Definition: operators_tests.cpp:30
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::DeprecatedCoreInterface
Deprecated interface functions.
Definition: DeprecatedCoreInterface.hpp:16
MoFEM::CoreTmp< 0 >::get_moab
moab::Interface & get_moab()
Definition: Core.hpp:322
MoFEM::Interface
DeprecatedCoreInterface Interface
Definition: Interface.hpp:2002
MoFEM::MeshsetsManager::bhTag_header
Tag bhTag_header
Definition: MeshsetsManager.hpp:890
MoFEM::MeshsetsManager::ssTag_data
Tag ssTag_data
Definition: MeshsetsManager.hpp:888
NODESET
@ NODESET
Definition: definitions.h:159
MoFEM::MeshsetsManager::nsTag
Tag nsTag
Definition: MeshsetsManager.hpp:885
CHKERR
#define CHKERR
Inline error check.
Definition: definitions.h:548
MoFEM::CoreInterface::get_moab
virtual moab::Interface & get_moab()=0
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:669
MOFEM_LOG_C
#define MOFEM_LOG_C(channel, severity, format,...)
Definition: LogManager.hpp:311
bit
auto bit
set bit
Definition: hanging_node_approx.cpp:75
convert.type
type
Definition: convert.py:64
MoFEM::MeshsetsManager::addMeshset
MoFEMErrorCode addMeshset(const CubitBCType cubit_bc_type, const int ms_id, const std::string name="")
add cubit meshset
Definition: MeshsetsManager.cpp:385
MAT_ELASTICSET
@ MAT_ELASTICSET
block name is "MAT_ELASTIC"
Definition: definitions.h:172
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:886
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:499
MoFEM::LogManager::getStrmWorld
static boost::shared_ptr< std::ostream > getStrmWorld()
Get the strm world object.
Definition: LogManager.cpp:344
MoFEM::MeshsetsManager::nsTag_data
Tag nsTag_data
Definition: MeshsetsManager.hpp:887
MoFEM::MeshsetsManager::cubitMeshsets
CubitMeshSet_multiIndex cubitMeshsets
cubit meshsets
Definition: MeshsetsManager.hpp:893
MoFEM::LogManager::getStrmSelf
static boost::shared_ptr< std::ostream > getStrmSelf()
Get the strm self object.
Definition: LogManager.cpp:340
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
t
constexpr double t
plate stiffness
Definition: plate.cpp:59
UNKNOWNSET
@ UNKNOWNSET
Definition: definitions.h:158
i
FTensor::Index< 'i', SPACE_DIM > i
Definition: hcurl_divergence_operator_2d.cpp:27
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:459
LASTSET_BC
@ LASTSET_BC
Definition: definitions.h:179
N
const int N
Definition: speed_test.cpp:3
MoFEM::MeshsetsManager::configFileOptionsPtr
boost::shared_ptr< boost::program_options::options_description > configFileOptionsPtr
config file options
Definition: MeshsetsManager.hpp:895
Range
MoFEM::Types::CubitBCType
std::bitset< 32 > CubitBCType
Definition: Types.hpp:52
MOFEM_LOG
#define MOFEM_LOG(channel, severity)
Log.
Definition: LogManager.hpp:308
_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:901
MoFEM::MeshsetsManager::bhTag
Tag bhTag
Definition: MeshsetsManager.hpp:889
MoFEM::Core
CoreTmp< 0 > Core
Definition: Core.hpp:1140
HenckyOps::f
auto f
Definition: HenckyOps.hpp:15
MoFEM::MeshsetsManager::MeshsetsManager
MeshsetsManager(const MoFEM::Core &core)
Definition: MeshsetsManager.cpp:34
BLOCKSET
@ BLOCKSET
Definition: definitions.h:161
MoFEM::Exceptions::ierr
static MoFEMErrorCodeGeneric< PetscErrorCode > ierr
Definition: Exceptions.hpp:76
MOFEM_DATA_INCONSISTENCY
@ MOFEM_DATA_INCONSISTENCY
Definition: definitions.h:31
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:530
_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
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::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:578
MoFEM::LogManager::setLog
static LoggerType & setLog(const std::string channel)
Set ans resset chanel logger.
Definition: LogManager.cpp:389
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
MoFEMFunctionBegin
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:359
MoFEM::MeshsetsManager::setMeshsetFromFile
MoFEMErrorCode setMeshsetFromFile()
get name of config file from line command '-meshsets_config'
Definition: MeshsetsManager.cpp:1375
Generated by Doxygen 1.8.17 and hosted at University of Glasgow