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

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

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

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

◆ 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  }
186 
187  for (int from_proc = 0; from_proc < pcomm->size(); ++from_proc) {
188 
189  Range r_dummy_nodes;
190 
191  if (from_proc == pcomm->rank()) {
192  std::vector<EntityHandle> dummy_nodes(vec_meshsets.size(), 0);
193  int i = 0;
194  for (auto m : vec_meshsets) {
195  CHKERR moab.create_vertex(coords, dummy_nodes[i]);
196  CHKERR set_tags_dummy_node(dummy_nodes[i], m);
197  ++i;
198  }
199  r_dummy_nodes.insert_list(dummy_nodes.begin(), dummy_nodes.end());
200  }
201 
202  CHKERR pcomm->broadcast_entities(from_proc, r_dummy_nodes, false, true);
203 
204  if (from_proc != pcomm->rank()) {
205 
206  for (auto dummy_node : r_dummy_nodes) {
207  CubitMeshSets broadcast_block(moab, dummy_node);
208  auto id = broadcast_block.getMeshsetId();
209  if (id != -1) {
210  auto mit =
211  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>()
212  .find(boost::make_tuple(
213  id, broadcast_block.getMaskedBcTypeULong()));
214  if (mit ==
215  cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>()
216  .end()) {
217  EntityHandle m;
218  CHKERR moab.create_meshset(MESHSET_SET, m);
219  CHKERR set_tags_dummy_node(m, dummy_node);
220  auto hint = cubitMeshsets.end();
221  auto p = cubitMeshsets.emplace_hint(hint, moab, m);
222  }
223  } else {
224  MOFEM_LOG("MeshsetMngSync", Sev::warning)
225  << "broadcasted vertex " << dummy_node << " has negative id";
226  }
227 
228  }
229 
230  } else {
231  MOFEM_LOG("MeshsetMngSync", Sev::verbose)
232  << "broadcast send from " << from_proc;
233  }
234 
235  CHKERR moab.delete_entities(r_dummy_nodes);
236  }
237 
238  MOFEM_LOG_SEVERITY_SYNC(m_field.get_comm(), Sev::verbose);
239  }
240 
241  MoFEMFunctionReturn(0);
242 }

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

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

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

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

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

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

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

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

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

287  {
288  DisplacementCubitBcData mydata;
289  MoFEMFunctionBegin;
290  CHKERR printBcSet(mydata, NODESET | mydata.tYpe.to_ulong());
291  MoFEMFunctionReturn(0);
292 }

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

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

◆ printHeatFluxSet()

MoFEMErrorCode MoFEM::MeshsetsManager::printHeatFluxSet ( ) const

print meshsets with heat flux boundary conditions data structure

Definition at line 315 of file MeshsetsManager.cpp.

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

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

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

◆ printPressureSet()

MoFEMErrorCode MoFEM::MeshsetsManager::printPressureSet ( ) const

print meshsets with pressure boundary conditions data structure

Definition at line 294 of file MeshsetsManager.cpp.

294  {
295  PressureCubitBcData mydata;
296  MoFEMFunctionBegin;
297  CHKERR printBcSet(mydata, SIDESET | mydata.tYpe.to_ulong());
298  MoFEMFunctionReturn(0);
299 }

◆ printTemperatureSet()

MoFEMErrorCode MoFEM::MeshsetsManager::printTemperatureSet ( ) const

print meshsets with temperature boundary conditions data structure

Definition at line 308 of file MeshsetsManager.cpp.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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:175
MoFEMFunctionReturnHot
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:447
MoFEM::UnknownInterface::getInterface
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface refernce to pointer of interface.
Definition: UnknownInterface.hpp:93
SIDESET
@ SIDESET
Definition: definitions.h:147
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:215
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:415
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:1975
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:146
MoFEM::MeshsetsManager::nsTag
Tag nsTag
Definition: MeshsetsManager.hpp:885
CHKERR
#define CHKERR
Inline error check.
Definition: definitions.h:535
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:161
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:666
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:382
MAT_ELASTICSET
@ MAT_ELASTICSET
block name is "MAT_ELASTIC"
Definition: definitions.h:159
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:496
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:145
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:456
LASTSET_BC
@ LASTSET_BC
Definition: definitions.h:166
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:1094
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:148
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:527
_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:440
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:575
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:100
MoFEMFunctionReturn
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:416
MAT_MOISTURESET
@ MAT_MOISTURESET
block name is "MAT_MOISTURE"
Definition: definitions.h:163
CHKERRG
#define CHKERRG(n)
Check error code of MoFEM/MOAB/PETSc function.
Definition: definitions.h:483
MoFEMFunctionBegin
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:346
MoFEM::MeshsetsManager::setMeshsetFromFile
MoFEMErrorCode setMeshsetFromFile()
get name of config file from line command '-meshsets_config'
Definition: MeshsetsManager.cpp:1372
Generated by Doxygen 1.8.17 and hosted at University of Glasgow