v0.14.0
Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | 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
 

Static Public Member Functions

static MoFEMErrorCode getTags (moab::Interface &moab, Tag &nsTag, Tag &ssTag, Tag &nsTag_data, Tag &ssTag_data, Tag &bhTag, Tag &bhTag_header, int verb=-1)
 
static void sortMeshsets (std::vector< const CubitMeshSets * > &vec_ptr)
 
- 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...
 

Public Attributes

MoFEM::Core & cOre
 

Static Public Attributes

static bool brodcastMeshsets = true
 

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...
 

Detailed Description

Interface for managing meshsets containing materials and boundary conditions.

Examples
add_blockset.cpp, add_cubit_meshsets.cpp, adolc_plasticity.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, 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 449 of file MeshsetsManager.cpp.

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

◆ 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 429 of file MeshsetsManager.cpp.

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

◆ 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 737 of file MeshsetsManager.cpp.

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

◆ 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 383 of file MeshsetsManager.cpp.

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

◆ 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 564 of file MeshsetsManager.cpp.

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

◆ get_bhTag()

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

get tag handle used to store "id" of BLOCKSET

Definition at line 153 of file MeshsetsManager.hpp.

153 { 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 158 of file MeshsetsManager.hpp.

158 { 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 163 of file MeshsetsManager.hpp.

163 { 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 168 of file MeshsetsManager.hpp.

168 { return this; }

◆ get_nsTag()

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

get tag handle used to store "id" of NODESET

Definition at line 133 of file MeshsetsManager.hpp.

133 { 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 143 of file MeshsetsManager.hpp.

143 { return nsTag_data; }

◆ get_ssTag()

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

get tag handle used to store "id" of SIDESET

Definition at line 138 of file MeshsetsManager.hpp.

138 { 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 148 of file MeshsetsManager.hpp.

148 { 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 873 of file MeshsetsManager.hpp.

873  {
874  return configFileOptionsPtr;
875  }

◆ getMeshsetsMultindex()

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

Definition at line 233 of file MeshsetsManager.hpp.

233  {
234  return cubitMeshsets;
235  }

◆ getTags() [1/2]

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  CHKERR getTags(moab, nsTag, ssTag, nsTag_data, ssTag_data, bhTag,
252  bhTag_header, verb);
253  MoFEMFunctionReturn(0);
254 }

◆ getTags() [2/2]

MoFEMErrorCode MoFEM::MeshsetsManager::getTags ( moab::Interface &  moab,
Tag &  nsTag,
Tag &  ssTag,
Tag &  nsTag_data,
Tag &  ssTag_data,
Tag &  bhTag,
Tag &  bhTag_header,
int  verb = -1 
)
static

Definition at line 256 of file MeshsetsManager.cpp.

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

◆ 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 906 of file MeshsetsManager.hpp.

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

◆ 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 301 of file MeshsetsManager.cpp.

301  {
302  DisplacementCubitBcData mydata;
303  MoFEMFunctionBegin;
304  CHKERR printBcSet(mydata, NODESET | mydata.tYpe.to_ulong());
305  MoFEMFunctionReturn(0);
306 }

◆ 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 315 of file MeshsetsManager.cpp.

315  {
316  ForceCubitBcData mydata;
317  MoFEMFunctionBegin;
318  CHKERR printBcSet(mydata, NODESET | mydata.tYpe.to_ulong());
319  MoFEMFunctionReturn(0);
320 }

◆ printHeatFluxSet()

MoFEMErrorCode MoFEM::MeshsetsManager::printHeatFluxSet ( ) const

print meshsets with heat flux boundary conditions data structure

Definition at line 329 of file MeshsetsManager.cpp.

329  {
330  HeatFluxCubitBcData mydata;
331  MoFEMFunctionBegin;
332  CHKERR printBcSet(mydata, SIDESET | mydata.tYpe.to_ulong());
333  MoFEMFunctionReturn(0);
334 }

◆ 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 336 of file MeshsetsManager.cpp.

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

◆ printPressureSet()

MoFEMErrorCode MoFEM::MeshsetsManager::printPressureSet ( ) const

print meshsets with pressure boundary conditions data structure

Definition at line 308 of file MeshsetsManager.cpp.

308  {
309  PressureCubitBcData mydata;
310  MoFEMFunctionBegin;
311  CHKERR printBcSet(mydata, SIDESET | mydata.tYpe.to_ulong());
312  MoFEMFunctionReturn(0);
313 }

◆ printTemperatureSet()

MoFEMErrorCode MoFEM::MeshsetsManager::printTemperatureSet ( ) const

print meshsets with temperature boundary conditions data structure

Definition at line 322 of file MeshsetsManager.cpp.

322  {
323  TemperatureCubitBcData mydata;
324  MoFEMFunctionBegin;
325  CHKERR printBcSet(mydata, NODESET | mydata.tYpe.to_ulong());
326  MoFEMFunctionReturn(0);
327 }

◆ 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 1425 of file MeshsetsManager.cpp.

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

◆ 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 1410 of file MeshsetsManager.cpp.

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

◆ 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 470 of file MeshsetsManager.cpp.

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

◆ 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 510 of file MeshsetsManager.cpp.

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

◆ 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 541 of file MeshsetsManager.cpp.

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

◆ 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 1386 of file MeshsetsManager.cpp.

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

◆ 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 802 of file MeshsetsManager.cpp.

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

◆ sortMeshsets()

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

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 1445 of file MeshsetsManager.cpp.

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

Member Data Documentation

◆ bhTag

Tag MoFEM::MeshsetsManager::bhTag
protected

Definition at line 895 of file MeshsetsManager.hpp.

◆ bhTag_header

Tag MoFEM::MeshsetsManager::bhTag_header
protected

Definition at line 896 of file MeshsetsManager.hpp.

◆ brodcastMeshsets

bool MoFEM::MeshsetsManager::brodcastMeshsets = true
static

if true meshsets are synchrinised between processors

Definition at line 885 of file MeshsetsManager.hpp.

◆ configFileOptionsPtr

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

config file options

Definition at line 901 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 899 of file MeshsetsManager.hpp.

◆ nsTag

Tag MoFEM::MeshsetsManager::nsTag
protected

Definition at line 891 of file MeshsetsManager.hpp.

◆ nsTag_data

Tag MoFEM::MeshsetsManager::nsTag_data
protected

Definition at line 893 of file MeshsetsManager.hpp.

◆ ssTag

Tag MoFEM::MeshsetsManager::ssTag
protected

Definition at line 892 of file MeshsetsManager.hpp.

◆ ssTag_data

Tag MoFEM::MeshsetsManager::ssTag_data
protected

Definition at line 894 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: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::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:885
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:2010
MoFEM::MeshsetsManager::bhTag_header
Tag bhTag_header
Definition: MeshsetsManager.hpp:896
MoFEM::MeshsetsManager::ssTag_data
Tag ssTag_data
Definition: MeshsetsManager.hpp:894
NODESET
@ NODESET
Definition: definitions.h:159
MoFEM::MeshsetsManager::nsTag
Tag nsTag
Definition: MeshsetsManager.hpp:891
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:680
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:396
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:892
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::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: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_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:58
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:470
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
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: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
_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::bhTag
Tag bhTag
Definition: MeshsetsManager.hpp:895
MoFEM::Core
CoreTmp< 0 > Core
Definition: Core.hpp:1148
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:541
_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:589
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:1386
Generated by Doxygen 1.8.17 and hosted at University of Glasgow