MeshsetsManager

Interface for meshsets with entities with data and boundary conditions. More...

Collaboration diagram for MeshsetsManager:

Files
file	MeshsetsManager.hpp
	Interface for managing mesh sets containing materials and boundary conditions.

Classes
struct	MoFEM::MeshsetsManager
	Interface for managing meshsets containing materials and boundary conditions. More...

Macros
#define	_IT_CUBITMESHSETS_FOR_LOOP_(MESHSET_MANAGER, IT)
	Iterator that loops over all the Cubit MeshSets in a moFEM field.
#define	_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(MESHSET_MANAGER, CUBITBCTYPE, IT)
	Iterator that loops over a specific Cubit MeshSet in a moFEM field.
#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.
#define	_IT_CUBITMESHSETS_BY_NAME_FOR_LOOP_(MESHSET_MANAGER, NAME, IT)
	Iterator that loops over Cubit BlockSet having a particular name.

Functions
MoFEMErrorCode	MoFEM::MeshsetsManager::getTags (int verb=-1)
	Get tag handles used on meshsets.
static 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 version of getTags for external MOAB interface.
MoFEMErrorCode	MoFEM::MeshsetsManager::clearMap ()
	Clear the multi-index container.
MoFEMErrorCode	MoFEM::MeshsetsManager::discardBlocksetConfiguration (std::size_t *cleared_names=nullptr, std::size_t *cleared_attributes=nullptr, const bool clear_names=true, const bool clear_attributes=true)
	Remove imported BLOCKSET names and/or attributes from the mesh.
MoFEMErrorCode	MoFEM::MeshsetsManager::initialiseDatabaseFromMesh (int verb=DEFAULT_VERBOSITY)
	Initialize container from mesh data.
MoFEMErrorCode	MoFEM::MeshsetsManager::readMeshsets (int verb=DEFAULT_VERBOSITY)
	Read meshsets from mesh database.
MoFEMErrorCode	MoFEM::MeshsetsManager::broadcastMeshsets (int verb=DEFAULT_VERBOSITY)
	Broadcast meshsets across MPI processes.
MoFEMErrorCode	MoFEM::MeshsetsManager::printDisplacementSet () const
	Print meshsets with displacement boundary conditions.
MoFEMErrorCode	MoFEM::MeshsetsManager::printPressureSet () const
	Print meshsets with pressure boundary conditions.
MoFEMErrorCode	MoFEM::MeshsetsManager::printForceSet () const
	Print meshsets with force boundary conditions.
MoFEMErrorCode	MoFEM::MeshsetsManager::printTemperatureSet () const
	Print meshsets with temperature boundary conditions.
MoFEMErrorCode	MoFEM::MeshsetsManager::printHeatFluxSet () const
	Print meshsets with heat flux boundary conditions.
MoFEMErrorCode	MoFEM::MeshsetsManager::printMaterialsSet () const
	Print meshsets with material properties.
CubitMeshSet_multiIndex::iterator	MoFEM::MeshsetsManager::getBegin () const
	get begin iterator of cubit meshset of given type (instead you can use IT_CUBITMESHSETS_TYPE_FOR_LOOP(MFIELD,CUBITBCTYPE,IT)
CubitMeshSet_multiIndex::iterator	MoFEM::MeshsetsManager::getEnd () const
	get begin iterator of cubit meshset of given type (instead you can use IT_CUBITMESHSETS_TYPE_FOR_LOOP(MFIELD,CUBITBCTYPE,IT)
CubitMeshsetByType::iterator	MoFEM::MeshsetsManager::getBegin (const unsigned int cubit_bc_type) const
	get begin iterator of cubit meshset of given type (instead you can use IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP(MFIELD,CUBITBCTYPE,IT)
CubitMeshsetByType::iterator	MoFEM::MeshsetsManager::getEnd (const unsigned int cubit_bc_type) const
	get begin iterator of cubit meshset of given type (instead you can use IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP(MFIELD,CUBITBCTYPE,IT)
CubitMeshsetByMask::iterator	MoFEM::MeshsetsManager::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)
CubitMeshsetByMask::iterator	MoFEM::MeshsetsManager::getBySetTypeEnd (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)
CubitMeshsetByName::iterator	MoFEM::MeshsetsManager::getBegin (const std::string &name) const
	get begin iterator of cubit meshset of given type (instead you can use IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP(MFIELD,CUBITBCTYPE,IT)
CubitMeshsetByName::iterator	MoFEM::MeshsetsManager::getEnd (const std::string &name) const
	get begin iterator of cubit meshset of given type (instead you can use IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP(MFIELD,CUBITBCTYPE,IT)
bool	MoFEM::MeshsetsManager::checkMeshset (const int ms_id, const CubitBCType cubit_bc_type) const
	Check for CUBIT meshset by ID and type.
bool	MoFEM::MeshsetsManager::checkMeshset (const string name, int *const number_of_meshsets_ptr=NULL) const
	Check if meshset with given name exists.
MoFEMErrorCode	MoFEM::MeshsetsManager::addMeshset (const CubitBCType cubit_bc_type, const int ms_id, const std::string name="")
	Add CUBIT meshset to manager.
MoFEMErrorCode	MoFEM::MeshsetsManager::addEntitiesToMeshset (const CubitBCType cubit_bc_type, const int ms_id, const Range &ents)
	Add entities to CUBIT meshset.
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 (array version)
MoFEMErrorCode	MoFEM::MeshsetsManager::setAttributes (const CubitBCType cubit_bc_type, const int ms_id, const std::vector< double > &attributes, const std::string name="")
	Set attributes for CUBIT meshset.
MoFEMErrorCode	MoFEM::MeshsetsManager::setAttributesByDataStructure (const CubitBCType cubit_bc_type, const int ms_id, const GenericAttributeData &data, const std::string name="")
	Set attributes using data structure.
MoFEMErrorCode	MoFEM::MeshsetsManager::setBcData (const CubitBCType cubit_bc_type, const int ms_id, const GenericCubitBcData &data)
	Set boundary condition data for meshset.
MoFEMErrorCode	MoFEM::MeshsetsManager::getCubitMeshsetPtr (const int ms_id, const CubitBCType cubit_bc_type, const CubitMeshSets **cubit_meshset_ptr) const
	get cubit meshset
const CubitMeshSets *	MoFEM::MeshsetsManager::getCubitMeshsetPtr (const int ms_id, const CubitBCType cubit_bc_type) const
	get cubit meshset
MoFEMErrorCode	MoFEM::MeshsetsManager::getCubitMeshsetPtr (const CubitBCType cubit_bc_type, std::vector< const CubitMeshSets * > &vec_ptr) const
	Get vector of pointer by bc type.
std::vector< const CubitMeshSets * >	MoFEM::MeshsetsManager::getCubitMeshsetPtr (const CubitBCType cubit_bc_type) const
	Get vector of pointer by bc type.
MoFEMErrorCode	MoFEM::MeshsetsManager::getCubitMeshsetPtr (const string name, const CubitMeshSets **cubit_meshset_ptr) const
	get cubit meshset
MoFEMErrorCode	MoFEM::MeshsetsManager::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.
std::vector< const CubitMeshSets * >	MoFEM::MeshsetsManager::getCubitMeshsetPtr (const std::regex reg_exp_name) const
	Get vector of pointer to blocksets with name satisfying regular expression.
MoFEMErrorCode	MoFEM::MeshsetsManager::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
MoFEMErrorCode	MoFEM::MeshsetsManager::getEntitiesByDimension (const int ms_id, const unsigned int cubit_bc_type, Range &entities, const bool recursive=true) const
	get entities related to CUBIT/meshset,
MoFEMErrorCode	MoFEM::MeshsetsManager::getMeshset (const int ms_id, const unsigned int cubit_bc_type, EntityHandle &meshset) const
	get meshset from CUBIT Id and CUBIT type
MoFEMErrorCode	MoFEM::MeshsetsManager::getMeshsetsByType (const unsigned int cubit_bc_type, Range &meshsets) const
	get all CUBIT meshsets by CUBIT type
MoFEMErrorCode	MoFEM::MeshsetsManager::setMeshsetFromFile ()
	Load meshset configuration from command line specified file.

Detailed Description

Interface for meshsets with entities with data and boundary conditions.

Macro Definition Documentation

_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_

#define _IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_	(		MESHSET_MANAGER,
			CUBITBCTYPE,
			IT
	)

#include <src/interfaces/MeshsetsManager.hpp>

Value:

  CubitMeshsetByType::iterator IT =                                            \
      MESHSET_MANAGER.get_meshsets_manager_ptr()->getBegin(CUBITBCTYPE);       \
  IT != MESHSET_MANAGER.get_meshsets_manager_ptr()->getEnd(CUBITBCTYPE);       \
  IT++

Iterator that loops over a specific Cubit MeshSet in a moFEM field.

Parameters

mField	moFEM Field
see	CubitBC (NODESET, SIDESET or BLOCKSET and more)
iterator

Examples

mofem/atom_tests/add_cubit_meshsets.cpp, mofem/atom_tests/field_blas.cpp, mofem/atom_tests/field_blas_axpy.cpp, mofem/tutorials/cor-6_simple_elasticity/simple_elasticity.cpp, mofem/tutorials/cor-7_elasticity_mixed_formulation/src/ElasticityMixedFormulation.hpp, mofem/users_modules/basic_finite_elements/elasticity/elasticity.cpp, mofem/users_modules/basic_finite_elements/nonlinear_elasticity/nonlinear_dynamics.cpp, mofem/users_modules/basic_finite_elements/src/impl/HookeElement.cpp, and mofem/users_modules/bone_remodelling/bone_adaptation.cpp.

Definition at line 72 of file MeshsetsManager.hpp.

                       : public UnknownInterface {
 
  /**
   * \brief Query interface for MeshsetsManager
   * 
   * @param type_index type index for the interface to query
   * @param iface pointer to store the interface
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode query_interface(boost::typeindex::type_index type_index,
                                 UnknownInterface **iface) const;
 
  MoFEM::Core &cOre; ///< Reference to MoFEM Core interface
  
  /**
   * \brief Constructor for MeshsetsManager
   * 
   * @param core reference to MoFEM Core interface for accessing mesh and field data
   */
  MeshsetsManager(const MoFEM::Core &core);
  virtual ~MeshsetsManager() = default;
 
  /**
   * \brief Get tag handles used on meshsets
   * \ingroup mofem_meshset_mng
   *
   * Retrieves MOAB tag handles for meshset identification and data storage.
   * These tags follow CUBIT/MOAB conventions for nodesets, sidesets, and blocksets.
   * The function initializes internal tag handles for subsequent meshset operations.
   *
   * @param verb verbosity level for output (-1 = default, higher values = more verbose)
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode getTags(int verb = -1);
 
  /**
   * \brief Static version of getTags for external MOAB interface
   * \ingroup mofem_meshset_mng
   *
   * @param moab reference to MOAB interface
   * @param nsTag reference to store nodeset tag handle
   * @param ssTag reference to store sideset tag handle  
   * @param nsTag_data reference to store nodeset data tag handle
   * @param ssTag_data reference to store sideset data tag handle
   * @param bhTag reference to store blockset tag handle
   * @param bhTag_header reference to store blockset header tag handle
   * @param verb verbosity level for output
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  static MoFEMErrorCode getTags(moab::Interface &moab, Tag &nsTag, Tag &ssTag,
                                Tag &nsTag_data, Tag &ssTag_data, Tag &bhTag,
                                Tag &bhTag_header, int verb = -1);
 
  /**
   * \brief get tag handle used to store "id" of NODESET
   */
  inline Tag get_nsTag() const { return nsTag; }
 
  /**
   * \brief get tag handle used to store "id" of SIDESET
   */
  inline Tag get_ssTag() const { return ssTag; }
 
  /**
   * \brief get tag handle used to store boundary data on NODESET
   */
  inline Tag get_nsTag_data() const { return nsTag_data; }
 
  /**
   * \brief get tag handle used to store boundary data on SIDESET
   */
  inline Tag get_ssTag_data() const { return ssTag_data; }
 
  /**
   * \brief get tag handle used to store "id" of BLOCKSET
   */
  inline Tag get_bhTag() const { return bhTag; }
 
  /**
   * \brief get tag handle used to store of block set header (Used by Cubit)
   */
  inline Tag get_bhTag_header() const { return bhTag_header; }
 
  /**
   * \brief return pointer to meshset manager
   */
  MeshsetsManager *get_meshsets_manager_ptr() { return this; }
 
  /**
   * \brief return pointer to meshset manager
   */
  const MeshsetsManager *get_meshsets_manager_ptr() const { return this; }
 
  /**
   * \brief Clear the multi-index container
   * \ingroup mofem_meshset_mng
   *
   * Removes all stored meshset data from the internal container.
   * Useful for reinitialization or memory cleanup.
   *
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode clearMap();
 
  /**
   * \brief Remove imported BLOCKSET names and/or attributes from the mesh.
   * \ingroup mofem_meshset_mng
   *
   * This is used by the JSON config path to control how much embedded block
   * metadata is preserved from the mesh file before JSON data is applied.
   *
   * @param cleared_names optional pointer storing how many block names were removed
   * @param cleared_attributes optional pointer storing how many block attribute tags were removed
   * @param clear_names when true remove imported BLOCKSET names
   * @param clear_attributes when true remove imported BLOCKSET attributes
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode discardBlocksetConfiguration(
      std::size_t *cleared_names = nullptr,
      std::size_t *cleared_attributes = nullptr,
      const bool clear_names = true,
      const bool clear_attributes = true);
 
  /**
   * \brief Initialize container from mesh data
   * \ingroup mofem_meshset_mng
   *
   * Reads meshset information from the mesh database and populates the
   * internal multi-index container. This includes discovering nodesets,
   * sidesets, and blocksets with their associated tags and data.
   *
   * @param verb verbosity level for output
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode initialiseDatabaseFromMesh(int verb = DEFAULT_VERBOSITY);
 
  /**
   * @brief Read meshsets from mesh database
   * \ingroup mofem_meshset_mng
   *
   * Scans the mesh for existing meshsets and populates the manager's
   * internal data structures. This is typically called after mesh loading
   * to discover all available nodesets, sidesets, and blocksets.
   *
   * @param verb verbosity level for output
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode readMeshsets(int verb = DEFAULT_VERBOSITY);
 
  /**
   * @brief Broadcast meshsets across MPI processes
   * \ingroup mofem_meshset_mng
   *
   * Synchronizes meshset information across all MPI processes to ensure
   * consistent meshset data in parallel computations. Typically called
   * after meshset modifications on specific processes.
   *
   * @param verb verbosity level for output
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode broadcastMeshsets(int verb = DEFAULT_VERBOSITY);
 
  template <class CUBIT_BC_DATA_TYPE>
  MoFEMErrorCode printBcSet(CUBIT_BC_DATA_TYPE &data,
                            unsigned long int type) const;
 
  /**
   * \brief Print meshsets with displacement boundary conditions
   * \ingroup mofem_meshset_mng
   *
   * Outputs information about all meshsets containing displacement boundary
   * condition data, including constraint flags and prescribed values.
   *
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode printDisplacementSet() const;
 
  /**
   * \brief Print meshsets with pressure boundary conditions
   * \ingroup mofem_meshset_mng
   *
   * Outputs information about all meshsets containing pressure boundary
   * condition data, including pressure magnitudes and application flags.
   *
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode printPressureSet() const;
 
  /**
   * \brief Print meshsets with force boundary conditions
   * \ingroup mofem_meshset_mng
   *
   * Outputs information about all meshsets containing force boundary
   * condition data, including force and moment components.
   *
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode printForceSet() const;
 
  /**
   * \brief Print meshsets with temperature boundary conditions
   * \ingroup mofem_meshset_mng
   *
   * Outputs information about all meshsets containing temperature boundary
   * condition data, including prescribed temperature values.
   *
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode printTemperatureSet() const;
 
  /**
   * \brief Print meshsets with heat flux boundary conditions
   * \ingroup mofem_meshset_mng
   *
   * Outputs information about all meshsets containing heat flux boundary
   * condition data, including flux magnitudes and directions.
   *
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode printHeatFluxSet() const;
 
  /**
   * \brief Print meshsets with material properties
   * \ingroup mofem_meshset_mng
   *
   * Outputs information about all meshsets containing material data,
   * including material parameters and constitutive model information.
   *
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode printMaterialsSet() const;
 
  inline CubitMeshSet_multiIndex &getMeshsetsMultindex() {
    return cubitMeshsets;
  }
 
  /**
   * \ingroup mofem_meshset_mng
   * \brief get begin iterator of cubit meshset of given type (instead you can
   * use _IT_CUBITMESHSETS_TYPE_FOR_LOOP_(MFIELD,CUBITBCTYPE,IT)
   *
   * for(_IT_CUBITMESHSETS_FOR_LOOP_(mField,it) {
   *    ...
   * }
   *
   */
  inline CubitMeshSet_multiIndex::iterator getBegin() const {
    return cubitMeshsets.begin();
  }
 
  /**
   * \ingroup mofem_meshset_mng
   * \brief get begin iterator of cubit meshset of given type (instead you can
   * use _IT_CUBITMESHSETS_TYPE_FOR_LOOP_(MFIELD,CUBITBCTYPE,IT)
   *
   * for(_IT_CUBITMESHSETS_FOR_LOOP_(mField,it) {
   *    ...
   * }
   *
   */
  CubitMeshSet_multiIndex::iterator getEnd() const {
    return cubitMeshsets.end();
  }
 
  /**
    * \brief get begin iterator of cubit meshset of given type (instead you can
    use _IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(MFIELD,CUBITBCTYPE,IT)
    * \ingroup mofem_meshset_mng
 
    *
    *
    for(_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(mField,NODESET|DISPLACEMENTSET,it)
    {
    *   ...
    * }
    *
    * \param  type of meshset (NODESET, SIDESET or BLOCKSET and more)
    */
  inline CubitMeshsetByType::iterator
  getBegin(const unsigned int cubit_bc_type) const {
    return cubitMeshsets.get<CubitMeshsetType_mi_tag>().lower_bound(
        cubit_bc_type);
  }
 
  /**
    * \brief get begin iterator of cubit meshset of given type (instead you can
    use _IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(MFIELD,CUBITBCTYPE,IT)
    * \ingroup mofem_meshset_mng
 
    *
    *
    for(_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(mField,NODESET|DISPLACEMENTSET,it)
    {
    *   ...
    * }
    *
    * \param  type of meshset (NODESET, SIDESET or BLOCKSET and more)
    */
  inline CubitMeshsetByType::iterator
  getEnd(const unsigned int cubit_bc_type) const {
    return cubitMeshsets.get<CubitMeshsetType_mi_tag>().upper_bound(
        cubit_bc_type);
  }
 
  /**
    * \brief get end iterator of cubit meshset of given type (instead you can
    use _IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(MFIELD,CUBITBCTYPE,IT)
    * \ingroup mofem_meshset_mng
 
    *
    * for(_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(mField,NODESET,it) {
    *   ...
    * }
    *
    * \param  type of meshset (NODESET, SIDESET or BLOCKSET and more)
    */
  inline CubitMeshsetByMask::iterator
  getBySetTypeBegin(const unsigned int cubit_bc_type) const {
    return cubitMeshsets.get<CubitMeshsetMaskedType_mi_tag>().lower_bound(
        cubit_bc_type);
  }
 
  /**
    * \brief get end iterator of cubit meshset of given type (instead you can
    use _IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(MFIELD,CUBITBCTYPE,IT)
    * \ingroup mofem_meshset_mng
 
    *
    * for(_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(mField,NODESET,it) {
    *   ...
    * }
    *
    * \param  type of meshset (NODESET, SIDESET or BLOCKSET and more)
    */
  inline CubitMeshsetByMask::iterator
  getBySetTypeEnd(const unsigned int cubit_bc_type) const {
    return cubitMeshsets.get<CubitMeshsetMaskedType_mi_tag>().upper_bound(
        cubit_bc_type);
  }
 
  /**
    * \brief get begin iterator of cubit meshset of given type (instead you can
    use _IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(MFIELD,CUBITBCTYPE,IT)
    * \ingroup mofem_meshset_mng
 
    *
    *
    for(_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(mField,NODESET|DISPLACEMENTSET,it)
    {
    *   ...
    * }
    *
    * \param  type of meshset (NODESET, SIDESET or BLOCKSET and more)
    */
  inline CubitMeshsetByName::iterator getBegin(const std::string &name) const {
    return cubitMeshsets.get<CubitMeshsets_name>().lower_bound(name);
  }
 
  /**
    * \brief get begin iterator of cubit meshset of given type (instead you can
    use _IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(MFIELD,CUBITBCTYPE,IT)
    * \ingroup mofem_meshset_mng
 
    *
    *
    for(_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(mField,NODESET|DISPLACEMENTSET,it)
    {
    *   ...
    * }
    *
    * \param  type of meshset (NODESET, SIDESET or BLOCKSET and more)
    */
  inline CubitMeshsetByName::iterator getEnd(const std::string &name) const {
    return cubitMeshsets.get<CubitMeshsets_name>().upper_bound(name);
  }
 
  /**
    * \brief Check for CUBIT meshset by ID and type
    * \ingroup mofem_meshset_mng
    *
    * Verifies if a meshset with the specified CUBIT ID and type exists
    * in the manager's database. Useful for validation before accessing
    * meshset properties or entities.
    *
    * \todo All cubit interface functions should be outsourced to dedicated
    * interface
    *
    * @param ms_id CUBIT ID of the meshset (BLOCKSET/SIDESET/NODESET)
    * @param cubit_bc_type type of meshset (NODESET, SIDESET, BLOCKSET, etc.)
    * @return bool true if meshset exists, false otherwise
    */
  bool checkMeshset(const int ms_id, const CubitBCType cubit_bc_type) const;
 
  /**
   * \brief Check if meshset with given name exists
   * \ingroup mofem_meshset_mng
   *
   * Searches for meshsets by name and optionally returns the count of
   * matching meshsets. Multiple meshsets can have the same name.
   *
   * @param name name of the meshset to search for
   * @param number_of_meshsets_ptr optional pointer to store count of matching meshsets
   * @return bool true if at least one meshset with the name exists, false otherwise
   */
  bool checkMeshset(const string name,
                    int *const number_of_meshsets_ptr = NULL) const;
 
  /**
    * \brief Add CUBIT meshset to manager
    * \ingroup mofem_meshset_mng
    *
    * Creates a new meshset entry in the manager's database with the specified
    * CUBIT type and ID. The meshset can be given an optional name for easier
    * identification and access.
    *
    * @param cubit_bc_type type of meshset (NODESET, SIDESET, BLOCKSET, etc.)
    * @param ms_id CUBIT ID for the meshset
    * @param name optional name for the meshset (empty string if not specified)
    * @return MoFEMErrorCode Error code indicating success or failure
    */
  MoFEMErrorCode addMeshset(const CubitBCType cubit_bc_type, const int ms_id,
                            const std::string name = "");
 
  /// Adds an extra classification bit to an existing meshset type.
  /// Example: promote a plain BLOCKSET to BLOCKSET|MAT_THERMALSET.
  MoFEMErrorCode addBitToMeshsetType(const CubitBCType cubit_bc_type,
                                     const int ms_id,
                                     const CubitBCType type_bit);
 
  /**
   * \brief Add entities to CUBIT meshset
   * \ingroup mofem_meshset_mng
   *
   * Adds a range of mesh entities to an existing meshset. The entities
   * become part of the meshset for subsequent operations like applying
   * boundary conditions or material properties.
   *
   * @param cubit_bc_type type of meshset (NODESET, SIDESET, BLOCKSET, etc.)
   * @param ms_id CUBIT ID of the target meshset
   * @param ents range of entities to add to the meshset
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode addEntitiesToMeshset(const CubitBCType cubit_bc_type,
                                      const int ms_id, const Range &ents);
 
  /**
   * \brief Add entities to CUBIT meshset (array version)
   * \ingroup mofem_meshset_mng
   *
   * Adds an array of mesh entities to an existing meshset. This version
   * accepts entities as a C-style array with explicit count.
   *
   * @param cubit_bc_type type of meshset (NODESET, SIDESET, BLOCKSET, etc.)
   * @param ms_id CUBIT ID of the target meshset
   * @param ents pointer to array of entity handles
   * @param nb_ents number of entities in the array
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode addEntitiesToMeshset(const CubitBCType cubit_bc_type,
                                      const int ms_id, const EntityHandle *ents,
                                      const int nb_ents);
 
  /**
   * \brief Set attributes for CUBIT meshset
   * \ingroup mofem_meshset_mng
   *
   * Assigns attribute values to a meshset. Attributes are typically used
   * for material properties or other numerical parameters associated with
   * the meshset entities.
   *
   * @param cubit_bc_type type of meshset (BLOCKSET, NODESET, SIDESET, etc.)
   * @param ms_id CUBIT ID of the target meshset
   * @param attributes vector of attribute values to assign
   * @param name optional name to assign to the meshset
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode setAttributes(const CubitBCType cubit_bc_type, const int ms_id,
                              const std::vector<double> &attributes,
                              const std::string name = "");
 
  MoFEMErrorCode setName(const CubitBCType cubit_bc_type, const int ms_id,
                         const std::string &name);
 
  DEPRECATED inline auto setAtributes(const CubitBCType cubit_bc_type,
                                      const int ms_id,
                                      const std::vector<double> &attributes,
                                      const std::string name = "") {
    return setAttributes(cubit_bc_type, ms_id,
                         std::vector<double>(attributes), name);
  }
 
  /**
   * \brief Set attributes using data structure
   * \ingroup mofem_meshset_mng
   *
   * Assigns material or other attributes to a meshset using a structured
   * data object. This provides a more organized way to handle complex
   * attribute data with proper typing and validation.
   *
   * @param cubit_bc_type type of meshset (BLOCKSET, NODESET, SIDESET, etc.)
   * @param ms_id CUBIT ID of the target meshset
   * @param data structured data containing attribute information
   * @param name optional name to assign to the meshset
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode setAttributesByDataStructure(const CubitBCType cubit_bc_type,
                                             const int ms_id,
                                             const GenericAttributeData &data,
                                             const std::string name = "");
                                             
  DEPRECATED inline auto setAtributesByDataStructure(
      const CubitBCType cubit_bc_type, const int ms_id,
      const GenericAttributeData &data, const std::string name = "") {
    return setAttributesByDataStructure(cubit_bc_type, ms_id, data, name);
  }
 
 
  /**
   * \brief Set boundary condition data for meshset
   * \ingroup mofem_meshset_mng
   *
   * Assigns boundary condition data to a meshset. This includes constraint
   * information, prescribed values, and application flags for various
   * boundary condition types (displacement, force, pressure, etc.).
   *
   * @param cubit_bc_type type of meshset (BLOCKSET, NODESET, SIDESET, etc.)
   * @param ms_id CUBIT ID of the target meshset
   * @param data boundary condition data structure
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode setBcData(const CubitBCType cubit_bc_type, const int ms_id,
                           const GenericCubitBcData &data);
 
  /**
    * \brief delete cubit meshset
    * \ingroup mofem_bc
 
    *
    * \param  see CubitBC (NODESET, SIDESET or BLOCKSET and more)
    * \param ms_id id of the BLOCKSET/SIDESET/BLOCKSET: from CUBIT
    *
    */
  MoFEMErrorCode deleteMeshset(const CubitBCType cubit_bc_type, const int ms_id,
                               const MoFEMTypes bh = MF_EXIST);
 
  /**
   * \brief get cubit meshset
   * \ingroup mofem_meshset_mng
   *
   *
   */
  MoFEMErrorCode
  getCubitMeshsetPtr(const int ms_id, const CubitBCType cubit_bc_type,
                     const CubitMeshSets **cubit_meshset_ptr) const;
 
  /**
   * \brief get cubit meshset
   * \ingroup mofem_meshset_mng
   *
   *
   */
  const CubitMeshSets *
  getCubitMeshsetPtr(const int ms_id, const CubitBCType cubit_bc_type) const;
 
  /**
   * @brief Get vector of pointer by bc type
   *
   * \ingroup mofem_meshset_mng
   *
   * @param std::vector<const CubitMeshSets *>
   * @return MoFEMErrorCode
   */
  MoFEMErrorCode
  getCubitMeshsetPtr(const CubitBCType cubit_bc_type,
                     std::vector<const CubitMeshSets *> &vec_ptr) const;
 
/**
   * @brief Get vector of pointer by bc type
   *
   * \ingroup mofem_meshset_mng
   *
   * @return MoFEMErrorCode
   */
  std::vector<const CubitMeshSets *>
  getCubitMeshsetPtr(const CubitBCType cubit_bc_type) const;
 
  /**
   * \brief get cubit meshset
   *
   * \ingroup mofem_meshset_mng
   */
  MoFEMErrorCode
  getCubitMeshsetPtr(const string name,
                     const CubitMeshSets **cubit_meshset_ptr) const;
 
  /**
   * @brief Get vector of pointer to blocksets with name satisfying regular
   * expression.
   *
   * \ingroup mofem_meshset_mng
   *
   * @param reg_exp_name
   * @param std::vector<const CubitMeshSets *>
   * @return MoFEMErrorCode
   */
  MoFEMErrorCode
  getCubitMeshsetPtr(const std::regex reg_exp_name,
                     std::vector<const CubitMeshSets *> &vec_ptr) const;
 
  /**
   * @brief Get vector of pointer to blocksets with name satisfying regular
   * expression.
   *
   * \ingroup mofem_meshset_mng
   *
   * \code
  for (auto m :
       m_field.getInterface<MeshsetsManager>()->getCubitMeshsetPtr(std::regex(
 
           (boost::format("%s(.*)") % block_name).str()
 
               ))
 
  ) {
    MOFEM_LOG("WORLD", Sev::inform) << m->getName();
 
    Range ents;
    m_field.get_moab().get_entities_by_dimension(
        m->getMeshset(), 0, ents, false);
 
    auto print_ents = [](boost::shared_ptr<FieldEntity> ent_ptr) {
      MoFEMFunctionBegin;
      if(!(ent_ptr->getPStatus() & PSTATUS_NOT_OWNED)) {
        MOFEM_LOG("SYNC", Sev::inform) << ent_ptr->getName() << ": " <<
  ent_ptr->getEntFieldData();
      }
      MoFEMFunctionReturn(0);
    };
 
    CHKERR m_field.getInterface<FieldBlas>()->fieldLambdaOnEntities(
        print_ents, "VELOCITIES", &ents);
    CHKERR m_field.getInterface<FieldBlas>()->fieldLambdaOnEntities(
        print_ents, "DISPLACEMENTS", &ents);
    MOFEM_LOG_SEVERITY_SYNC(m_field.get_comm(), Sev::ifrom);
  }
   * \endcode
   *
   * @param reg_exp_name
   * @return std::vector<const CubitMeshSets *>
   */
  std::vector<const CubitMeshSets *>
  getCubitMeshsetPtr(const std::regex reg_exp_name) const;
 
  /**
    * \brief get entities from CUBIT/meshset of a particular entity dimension
    * \ingroup mofem_meshset_mng
 
    * Nodeset can contain nodes, edges, triangles and tets. This applies to
    other  meshsets too.
    * The nodeset's meshset contain the nodes in the MIDDLE of the surface or
    volume which is done by default in Cubit,
    * Hence if all nodes on a particular nodeset are required,
    * one should get all triangles or tetrahedrons for which the nodeset was
    create in Cubit,
    * and get all the connectivities of tris/tets.
 
    * \param ms_id id of the BLOCKSET/SIDESET/BLOCKSET: from CUBIT
    * \param  see CubitBC (NODESET, SIDESET or BLOCKSET and more)
    * \param dimensions (0 - Nodes, 1 - Edges, 2 - Faces, 3 -
    Volume(tetrahedral))
    * \param Range containing the retrieved entities
    * \param recursive If true, meshsets containing meshsets are queried
    recursively. Returns the contents of meshsets, but not the meshsets
    themselves if true.
    */
  MoFEMErrorCode getEntitiesByDimension(const int ms_id,
                                        const unsigned int cubit_bc_type,
                                        const int dimension, Range &entities,
                                        const bool recursive = true) const;
 
  /**
    * \brief get entities related to CUBIT/meshset,
    * \ingroup mofem_meshset_mng
 
    * NODESET will get Vertices only, even if the NODESET contains edges, tris
    and tets
    * SIDESET will get Tris, BLOCKSET will get Tets, DISPLACEMENTSET and
    FORCESET are stored in NODESET, PRESSURESET is stored in Sideset.
 
    * \param ms_id id of the BLOCKSET/SIDESET/BLOCKSET: from CUBIT
    * \param  see CubitBC (NODESET, SIDESET or BLOCKSET and more)
    * \param Range containing the retrieved entities related to the
    * \param recursive If true, meshsets containing meshsets are queried
    recursively.  Returns the contents of meshsets, but not the meshsets
    themselves if true.
    */
  MoFEMErrorCode getEntitiesByDimension(const int ms_id,
                                        const unsigned int cubit_bc_type,
                                        Range &entities,
                                        const bool recursive = true) const;
 
  /**
   * \ingroup mofem_meshset_mng
   * \brief get meshset from CUBIT Id and CUBIT type
   *
   * \param ms_id id of the BLOCKSET/SIDESET/BLOCKSET: from CUBIT
   * \param  see CubitBC (NODESET, SIDESET or BLOCKSET and more)
   * \param meshset where to store the retrieved entities
   */
  MoFEMErrorCode getMeshset(const int ms_id, const unsigned int cubit_bc_type,
                            EntityHandle &meshset) const;
 
  /**
   * @brief Check if meshset constains entities
   *
   * @param ms_id
   * @param cubit_bc_type
   * @param entities
   * @param num_entities
   * @param operation_type
   * @return true
   * @return false
   */
  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);
 
  /**
   * \ingroup mofem_meshset_mng
   * \brief get all CUBIT meshsets by CUBIT type
   *
   * \param  see CubitBC (NODESET, SIDESET or BLOCKSET and more).
   * \param meshsets is range of meshsets
   */
  MoFEMErrorCode getMeshsetsByType(const unsigned int cubit_bc_type,
                                   Range &meshsets) const;
 
  /**
   * \brief add blocksets reading config file
 
   Example of config file
   \code
 
   [block_1001]
 
   # Example applying attributes to blockset
 
   id=2001
   add=BLOCKSET
   user1=1.0  # attribute value 1
   user2=2.0  # legacy form supports user1 up to user10
   user3=3.0
   # alternatively, for any number of attributes:
   # user_array=1.0, 2.0, 3.0, 4.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
   # alternatively, number_of_attributes is inferred from:
   # user_array=1, 2, 3
 
   \endcode
 
   * @param file_name path to configuration file containing meshset definitions
   * @param clean_file_options whether to clean existing file options before loading
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode setMeshsetFromFile(const string file_name,
                                    const bool clean_file_options = true);
 
  /**
   * \brief Load meshset configuration from command line specified file
   * \ingroup mofem_meshset_mng
   *
   * Reads the configuration file name from the command line option
   * '-meshsets_config' and loads meshset definitions from that file.
   * This provides a convenient way to specify meshset configurations
   * at runtime without hardcoding file paths.
   *
   * Command line usage: -meshsets_config filename.cfg
   *
   * @return MoFEMErrorCode Error code indicating success or failure
   */
  MoFEMErrorCode setMeshsetFromFile();
 
  /**
   * @brief save cubit meshset entities on the moab mesh
   *
   * @param ms_id id of the cubit meshset (NODESET  SIDESET  BLOCKSET)
   * @param cubit_bc_type type of a cubit mesheset
   * @param file_name optional name for the file
   * @param file_type optional file type for moab (VTK MOAB)
   * @param options optional parameters for moab writer (PARALLEL=WRITE_PART)
   * @return MoFEMErrorCode
   */
  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;
 
  /**
   * @brief save cubit meshset entities on the moab mesh
   *
   * @param ms_id id of the cubit meshset
   * @param cubit_bc_type type of a cubit mesheset (NODESET  SIDESET  BLOCKSET)
   * @param dim dimension of the entities
   * @param file_name optional name for the file
   * @param file_type optional file type for moab (VTK MOAB)
   * @param options optional parameters for moab writer (PARALLEL=WRITE_PART)
   * @return MoFEMErrorCode
   */
  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;
 
  /**
   * \brief Get config file options, use with care
   * @return error code
   */
  inline boost::shared_ptr<boost::program_options::options_description> &
  getConfigFileOptionsPtr() {
    return configFileOptionsPtr;
  }
 
  /**
   * @brief Update all blocksets, sidesets and node sets
   * 
   * @param bit 
   * @return MoFEMErrorCode 
   */
  MoFEMErrorCode updateAllMeshsetsByEntitiesChildren(const BitRefLevel &bit);
 
  static bool broadcastMeshsetsOn; ///< if true meshsets are synchronised
                                   ///< between processors
 
  static void sortMeshsets(std::vector<const CubitMeshSets *> &vec_ptr);
 
protected:
  Tag nsTag;
  Tag ssTag;
  Tag nsTag_data;
  Tag ssTag_data;
  Tag bhTag;
  Tag bhTag_header;
 
  // cubit
  CubitMeshSet_multiIndex cubitMeshsets; ///< cubit meshsets
  boost::shared_ptr<boost::program_options::options_description>
      configFileOptionsPtr; ///< config file options
 
};
 
template <class CUBIT_BC_DATA_TYPE>
MoFEMErrorCode MeshsetsManager::printBcSet(CUBIT_BC_DATA_TYPE &data,
                                           unsigned long int type) const {
  MoFEMFunctionBegin;
  const MoFEM::Interface &m_field = cOre;
  const moab::Interface &moab = m_field.get_moab();
  for (auto it : getCubitMeshsetPtr(type)) {
    CHKERR it->getBcDataStructure(data);
    MOFEM_LOG("MeshsetMngWorld", Sev::inform) << *it;
    MOFEM_LOG("MeshsetMngWorld", Sev::inform) << data;
    MOFEM_LOG("MeshsetMngWorld", Sev::inform) << "name " << it->getName();
    for (EntityType t = MBVERTEX; t != MBENTITYSET; ++t) {
      int nb;
      CHKERR moab.get_number_entities_by_type(it->meshset, t, nb, true);
      if (nb > 0) {
        MOFEM_LOG("MeshsetMngSync", Sev::inform)
            << "msId " << it->getMeshsetId() << " number of "
            << moab::CN::EntityTypeName(t) << " " << nb;
      }
    }
    MOFEM_LOG_SEVERITY_SYNC(m_field.get_comm(), Sev::inform);
  }
  MoFEMFunctionReturn(0);
}
 
} // namespace MoFEM
 
#endif //__MESHSETSMANAGER_HPP__
 
/**
 * \defgroup mofem_meshset_mng MeshsetsManager
 * \brief Interface for meshsets with entities with data and boundary conditions
 *
 * \ingroup mofem
 **/

_IT_CUBITMESHSETS_BY_NAME_FOR_LOOP_

#define _IT_CUBITMESHSETS_BY_NAME_FOR_LOOP_	(		MESHSET_MANAGER,
			NAME,
			IT
	)

#include <src/interfaces/MeshsetsManager.hpp>

Value:

  CubitMeshsetByName::iterator IT =                                            \
      MESHSET_MANAGER.get_meshsets_manager_ptr()->getBegin(NAME);              \
  IT != MESHSET_MANAGER.get_meshsets_manager_ptr()->getEnd(NAME);              \
  IT++

Iterator that loops over Cubit BlockSet having a particular name.

Parameters

MESHSET_MANAGER	meshset manager (works as well with Interface)
NAME	name
IT	iterator

Example:

for(_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(mField,"SOME_BLOCK_NAME",it) {
...
  } 

Definition at line 117 of file MeshsetsManager.hpp.

_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_

#define _IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_	(		MESHSET_MANAGER,
			CUBITBCTYPE,
			IT
	)

#include <src/interfaces/MeshsetsManager.hpp>

Value:

  CubitMeshsetByMask::iterator IT =                                            \
      MESHSET_MANAGER.get_meshsets_manager_ptr()->getBySetTypeBegin(           \
          CUBITBCTYPE);                                                        \
  IT != MESHSET_MANAGER.get_meshsets_manager_ptr()->getBySetTypeEnd(           \
            CUBITBCTYPE);                                                      \
  IT++

Iterator that loops over a specific Cubit MeshSet having a particular BC meshset in a moFEM field.

Parameters

MESHSET_MANAGER	meshset manager (works as well with Interface)
see	CubitBC (NODESET, SIDESET or BLOCKSET and more)
iterator

Example:

for(_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(mField,NODESET|DISPLACEMENTSET,it) {
...
  } 

Examples

mofem/atom_tests/add_cubit_meshsets.cpp, mofem/atom_tests/continuity_check_on_contact_prism_side_ele.cpp, mofem/atom_tests/cubit_bc_test.cpp, mofem/atom_tests/forces_and_sources_testing_flat_prism_element.cpp, mofem/atom_tests/mesh_insert_interface_atom.cpp, mofem/tools/extrude_prisms.cpp, mofem/tools/mesh_cut.cpp, mofem/tutorials/clx-0_acoustics/helmholtz.cpp, mofem/tutorials/cor-0to1_unsaturated_transport/src/UnsaturatedFlow.hpp, mofem/tutorials/cor-0to1_unsaturated_transport/unsaturated_transport.cpp, mofem/tutorials/cor-10_navier_stokes/navier_stokes.cpp, mofem/tutorials/max-0_magnetostatics/src/MagneticElement.hpp, mofem/tutorials/scl-12_electrostatics/electrostatics.cpp, mofem/users_modules/basic_finite_elements/elasticity/elasticity.cpp, and mofem/users_modules/bone_remodelling/src/impl/Remodeling.cpp.

Definition at line 94 of file MeshsetsManager.hpp.

_IT_CUBITMESHSETS_FOR_LOOP_

#define _IT_CUBITMESHSETS_FOR_LOOP_	(		MESHSET_MANAGER,
			IT
	)

#include <src/interfaces/MeshsetsManager.hpp>

Value:

  CubitMeshSet_multiIndex::iterator IT =                                       \
      MESHSET_MANAGER.get_meshsets_manager_ptr()->getBegin();                  \
  IT != MESHSET_MANAGER.get_meshsets_manager_ptr()->getEnd();                  \
  IT++

Iterator that loops over all the Cubit MeshSets in a moFEM field.

Parameters

MESHSET_MANAGER	meshset manager (works as well with Interface)
iterator

Examples

mofem/atom_tests/add_cubit_meshsets.cpp, mofem/atom_tests/continuity_check_on_contact_prism_side_ele.cpp, mofem/atom_tests/forces_and_sources_testing_flat_prism_element.cpp, mofem/atom_tests/mesh_insert_interface_atom.cpp, mofem/tools/split_sideset.cpp, mofem/tutorials/cor-0to1_unsaturated_transport/unsaturated_transport.cpp, and mofem/users_modules/bone_remodelling/bone_adaptation.cpp.

Definition at line 57 of file MeshsetsManager.hpp.

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
	)

#include <src/interfaces/MeshsetsManager.hpp>

Add entities to CUBIT meshset (array version)

Adds an array of mesh entities to an existing meshset. This version accepts entities as a C-style array with explicit count.

Parameters

cubit_bc_type	type of meshset (NODESET, SIDESET, BLOCKSET, etc.)
ms_id	CUBIT ID of the target meshset
ents	pointer to array of entity handles
nb_ents	number of entities in the array

Returns

MoFEMErrorCode Error code indicating success or failure

Definition at line 583 of file MeshsetsManager.cpp.

                                                         {
  Interface &m_field = cOre;
  moab::Interface &moab = m_field.get_moab();
  MoFEMFunctionBegin;
  auto cit =
      cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
          boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
  if (cit ==
      cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
    SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
             "Cannot find Cubit meshset with id: %d", ms_id);
  }
  EntityHandle meshset = cit->getMeshset();
  CHKERR moab.add_entities(meshset, ents, nb_ents);
 
  MoFEMFunctionReturn(0);
}

addEntitiesToMeshset() [2/2]

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

#include <src/interfaces/MeshsetsManager.hpp>

Add entities to CUBIT meshset.

Adds a range of mesh entities to an existing meshset. The entities become part of the meshset for subsequent operations like applying boundary conditions or material properties.

Parameters

cubit_bc_type	type of meshset (NODESET, SIDESET, BLOCKSET, etc.)
ms_id	CUBIT ID of the target meshset
ents	range of entities to add to the meshset

Returns

MoFEMErrorCode Error code indicating success or failure

Examples

mofem/tools/mesh_cut.cpp.

Definition at line 563 of file MeshsetsManager.cpp.

                                                                          {
  Interface &m_field = cOre;
  moab::Interface &moab = m_field.get_moab();
  MoFEMFunctionBegin;
  auto cit =
      cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
          boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
  if (cit ==
      cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
    SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
             "Cannot find Cubit meshset with id: %d", ms_id);
  }
  EntityHandle meshset = cit->getMeshset();
  CHKERR moab.add_entities(meshset, ents);
 
  MoFEMFunctionReturn(0);
}

addMeshset()

MoFEMErrorCode MoFEM::MeshsetsManager::addMeshset	(	const CubitBCType	cubit_bc_type,
		const int	ms_id,
		const std::string	name = ""
	)

#include <src/interfaces/MeshsetsManager.hpp>

Add CUBIT meshset to manager.

Creates a new meshset entry in the manager's database with the specified CUBIT type and ID. The meshset can be given an optional name for easier identification and access.

Parameters

cubit_bc_type	type of meshset (NODESET, SIDESET, BLOCKSET, etc.)
ms_id	CUBIT ID for the meshset
name	optional name for the meshset (empty string if not specified)

Returns

MoFEMErrorCode Error code indicating success or failure

Examples

mofem/atom_tests/add_cubit_meshsets.cpp, and mofem/tools/mesh_cut.cpp.

Definition at line 506 of file MeshsetsManager.cpp.

                                                                 {
  Interface &m_field = cOre;
  moab::Interface &moab = m_field.get_moab();
  MoFEMFunctionBegin;
  if (checkMeshset(ms_id, cubit_bc_type)) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "such cubit meshset is already there id  = %d", ms_id);
  }
 
  CubitMeshSets cmeshset(moab, cubit_bc_type, ms_id);
  if ((cmeshset.cubitBcType & CubitBCType(NODESET | SIDESET | BLOCKSET))
          .any()) {
    auto p = cubitMeshsets.insert(cmeshset);
    if (!p.second) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
              "meshset not inserted");
    }
    if (name.size() > 0) {
      bool success =
          cubitMeshsets.modify(p.first, CubitMeshSets_change_name(moab, name));
      if (!success) {
        SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
                "name to cubit meshset can not be set");
      }
    }
  }
 
  MoFEMFunctionReturn(0);
}

broadcastMeshsets()

MoFEMErrorCode MoFEM::MeshsetsManager::broadcastMeshsets

(

int

verb = DEFAULT_VERBOSITY

)

#include <src/interfaces/MeshsetsManager.hpp>

Broadcast meshsets across MPI processes.

Synchronizes meshset information across all MPI processes to ensure consistent meshset data in parallel computations. Typically called after meshset modifications on specific processes.

Parameters

verb	verbosity level for output

Returns

MoFEMErrorCode Error code indicating success or failure

Definition at line 184 of file MeshsetsManager.cpp.

                                                          {
  Interface &m_field = cOre;
  moab::Interface &moab = m_field.get_moab();
  MoFEMFunctionBegin;
 
  ParallelComm *pcomm = ParallelComm::get_pcomm(&moab, MYPCOMM_INDEX);
  if (pcomm == NULL)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "MOAB communicator not set");
 
  auto all_to_all = [&](Range &verts, std::vector<Range> &recv_verts) {
    MoFEMFunctionBegin;
    int success;
    int buff_size;
    ParallelComm::Buffer buff_send(ParallelComm::INITIAL_BUFF_SIZE);
    buff_send.reset_ptr(sizeof(int));
    CHKERR pcomm->pack_buffer(verts, false, true, false, -1, &buff_send);
    buff_send.set_stored_size();
    buff_size = buff_send.buff_ptr - buff_send.mem_ptr;
 
    std::vector<int> recv_buff_sizes(pcomm->size(), 0);
    success =
        MPI_Allgather(&buff_size, 1, MPI_INT, recv_buff_sizes.data(), 1,
                      MPI_INT,
                      pcomm->comm());
    if (success != MPI_SUCCESS)
      SETERRQ(pcomm->comm(), MOFEM_DATA_INCONSISTENCY,
              "MPI_Allgather failed");
 
    std::vector<int> recv_buff_displs(
        recv_buff_sizes.size(),
        0); // that is relative (position) displacements in recv buffer
    int recv_buff_size = 0;
    for (std::size_t proc = 0; proc != recv_buff_sizes.size(); ++proc) {
      recv_buff_displs[proc] = recv_buff_size;
      recv_buff_size += recv_buff_sizes[proc];
    }
 
    std::vector<unsigned char> recv_buff(recv_buff_size);
    success = MPI_Allgatherv(
        buff_send.mem_ptr, buff_size, MPI_UNSIGNED_CHAR, recv_buff.data(),
        recv_buff_sizes.data(), recv_buff_displs.data(), MPI_UNSIGNED_CHAR,
        pcomm->comm());
    if (success != MPI_SUCCESS)
      SETERRQ(pcomm->comm(), MOFEM_DATA_INCONSISTENCY,
              "MPI_Allgatherv failed");
 
    recv_verts.clear();
    recv_verts.resize(pcomm->size());
    for (int from_proc = 0; from_proc < pcomm->size(); ++from_proc) {
      if (from_proc == pcomm->rank())
        continue;
      if (recv_buff_sizes[from_proc] < static_cast<int>(sizeof(int)))
        SETERRQ(pcomm->comm(), MOFEM_DATA_INCONSISTENCY,
                "Received meshset buffer is too small");
 
      std::vector<std::vector<EntityHandle>> L1hloc, L1hrem;
      std::vector<std::vector<int>> L1p;
      std::vector<EntityHandle> L2hloc, L2hrem, recv_ents;
      std::vector<unsigned int> L2p;
      auto *recv_ptr =
          recv_buff.data() + recv_buff_displs[from_proc] + sizeof(int);
      CHKERR pcomm->unpack_buffer(recv_ptr, false, from_proc, -1, L1hloc,
                                  L1hrem, L1p, L2hloc, L2hrem, L2p, recv_ents);
      recv_verts[from_proc].insert_list(recv_ents.begin(), recv_ents.end());
    }
 
    MoFEMFunctionReturn(0);
  };
 
  const double coords[] = {0, 0, 0};
 
  auto set_tags_dummy_node = [&](const EntityHandle dummy_node,
                                 const EntityHandle meshset) {
    MoFEMFunctionBegin;
    std::vector<Tag> tag_handles;
    CHKERR moab.tag_get_tags_on_entity(meshset, tag_handles);
    for (auto th : tag_handles) {
      void *data[1];
      int tag_size;
      CHKERR moab.tag_get_by_ptr(th, &meshset, 1, (const void **)data,
                                 &tag_size);
      if (tag_size > 0)
        CHKERR moab.tag_set_by_ptr(th, &dummy_node, 1, data, &tag_size);
    }
    MoFEMFunctionReturn(0);
  };
 
  for (auto t : {NODESET, SIDESET, BLOCKSET}) {
    std::vector<const CubitMeshSets *> vec_ptr;
    for (auto &m : cubitMeshsets) {
      if ((m.getBcType() & CubitBCType(t)).any()) {
        vec_ptr.push_back(&m);
      }
    }
    sortMeshsets(vec_ptr);
 
    std::vector<EntityHandle> vec_meshsets;
    vec_meshsets.reserve(vec_ptr.size());
    for (auto m_ptr : vec_ptr) {
      vec_meshsets.push_back(m_ptr->getMeshset());
    }
 
    switch (t) {
    case NODESET:
      MOFEM_LOG("MeshsetMngSync", Sev::verbose)
          << "broadcast NODESET " << vec_meshsets.size();
      break;
    case SIDESET:
      MOFEM_LOG("MeshsetMngSync", Sev::verbose)
          << "broadcast SIDESET " << vec_meshsets.size();
      break;
    case BLOCKSET:
      MOFEM_LOG("MeshsetMngSync", Sev::verbose)
          << "broadcast BLOCKSET " << vec_meshsets.size();
      break;
    default:
      MOFEM_LOG("MeshsetMngSync", Sev::verbose)
          << "broadcast Unknown " << vec_meshsets.size();
    }
 
    Range r_dummy_nodes;
    std::vector<EntityHandle> dummy_nodes(vec_meshsets.size(), 0);
    int i = 0;
    for (auto m : vec_meshsets) {
      CHKERR moab.create_vertex(coords, dummy_nodes[i]);
      CHKERR set_tags_dummy_node(dummy_nodes[i], m);
      ++i;
    }
    r_dummy_nodes.insert_list(dummy_nodes.begin(), dummy_nodes.end());
 
    std::vector<Range> recv_dummy_nodes;
    CHKERR all_to_all(r_dummy_nodes, recv_dummy_nodes);
 
    for (int from_proc = 0; from_proc < pcomm->size(); ++from_proc) {
      if (from_proc != pcomm->rank()) {
        for (auto dummy_node : recv_dummy_nodes[from_proc]) {
          CubitMeshSets broadcast_block(moab, dummy_node);
          auto id = broadcast_block.getMeshsetId();
          if (id != -1) {
            auto mit =
                cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>()
                    .find(boost::make_tuple(
                        id, broadcast_block.getMaskedBcTypeULong()));
            if (mit ==
                cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>()
                    .end()) {
              EntityHandle m;
              CHKERR moab.create_meshset(MESHSET_SET, m);
              CHKERR set_tags_dummy_node(m, dummy_node);
              auto hint = cubitMeshsets.end();
              /*auto p = */ cubitMeshsets.emplace_hint(hint, moab, m);
            }
          } else {
            MOFEM_LOG("MeshsetMngSync", Sev::warning)
                << "broadcasted vertex " << dummy_node << " has negative id";
          }
        }
      } else {
        MOFEM_LOG("MeshsetMngSync", Sev::verbose)
            << "broadcast send from " << from_proc;
      }
      CHKERR moab.delete_entities(recv_dummy_nodes[from_proc]);
    }
 
    CHKERR moab.delete_entities(r_dummy_nodes);
 
    MOFEM_LOG_SEVERITY_SYNC(m_field.get_comm(), Sev::verbose);
  }
 
  MoFEMFunctionReturn(0);
}

checkMeshset() [1/2]

bool MoFEM::MeshsetsManager::checkMeshset	(	const int	ms_id,
		const CubitBCType	cubit_bc_type
	)		const

#include <src/interfaces/MeshsetsManager.hpp>

Check for CUBIT meshset by ID and type.

Verifies if a meshset with the specified CUBIT ID and type exists in the manager's database. Useful for validation before accessing meshset properties or entities.

Todo:

All cubit interface functions should be outsourced to dedicated interface

Parameters

ms_id	CUBIT ID of the meshset (BLOCKSET/SIDESET/NODESET)
cubit_bc_type	type of meshset (NODESET, SIDESET, BLOCKSET, etc.)

Returns

bool true if meshset exists, false otherwise

Examples

mofem/tools/mesh_cut.cpp, mofem/tools/mesh_smoothing.cpp, mofem/tutorials/cor-9_reaction_diffusion/reaction_diffusion.cpp, and mofem/tutorials/scl-6_heat_equation/heat_equation.cpp.

Definition at line 481 of file MeshsetsManager.cpp.

                                                                          {
  auto miit =
      cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
          boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
  if (miit !=
      cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
    return true;
  }
  return false;
}

checkMeshset() [2/2]

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

#include <src/interfaces/MeshsetsManager.hpp>

Check if meshset with given name exists.

Searches for meshsets by name and optionally returns the count of matching meshsets. Multiple meshsets can have the same name.

Parameters

name	name of the meshset to search for
number_of_meshsets_ptr	optional pointer to store count of matching meshsets

Returns

bool true if at least one meshset with the name exists, false otherwise

Definition at line 493 of file MeshsetsManager.cpp.

                                                                            {
  auto miit = cubitMeshsets.get<CubitMeshsets_name>().lower_bound(name);
  auto hi_miit = cubitMeshsets.get<CubitMeshsets_name>().upper_bound(name);
  if (std::distance(miit, hi_miit) == 0) {
    return false;
  }
  if (number_of_meshsets_ptr) {
    *number_of_meshsets_ptr = std::distance(miit, hi_miit);
  }
  return true;
}

clearMap()

MoFEMErrorCode MoFEM::MeshsetsManager::clearMap

(

)

#include <src/interfaces/MeshsetsManager.hpp>

Clear the multi-index container.

Removes all stored meshset data from the internal container. Useful for reinitialization or memory cleanup.

Returns

MoFEMErrorCode Error code indicating success or failure

Definition at line 59 of file MeshsetsManager.cpp.

                                         {
  MoFEMFunctionBeginHot;
  cubitMeshsets.clear();
  MoFEMFunctionReturnHot(0);
}

discardBlocksetConfiguration()

MoFEMErrorCode MoFEM::MeshsetsManager::discardBlocksetConfiguration	(	std::size_t *	cleared_names = nullptr,
		std::size_t *	cleared_attributes = nullptr,
		const bool	clear_names = true,
		const bool	clear_attributes = true
	)

#include <src/interfaces/MeshsetsManager.hpp>

Remove imported BLOCKSET names and/or attributes from the mesh.

This is used by the JSON config path to control how much embedded block metadata is preserved from the mesh file before JSON data is applied.

Parameters

cleared_names	optional pointer storing how many block names were removed
cleared_attributes	optional pointer storing how many block attribute tags were removed
clear_names	when true remove imported BLOCKSET names
clear_attributes	when true remove imported BLOCKSET attributes

Returns

MoFEMErrorCode Error code indicating success or failure

Definition at line 65 of file MeshsetsManager.cpp.

                                                         {
  Interface &m_field = cOre;
  moab::Interface &moab = m_field.get_moab();
  MoFEMFunctionBegin;
 
  Tag block_attributes;
  CHKERR moab.tag_get_handle(BLOCK_ATTRIBUTES, block_attributes);
 
  Tag entity_name_tag;
  CHKERR moab.tag_get_handle(NAME_TAG_NAME, entity_name_tag);
 
  std::vector<EntityHandle> block_meshsets;
  block_meshsets.reserve(cubitMeshsets.size());
  for (const auto &meshset : cubitMeshsets) {
    if ((meshset.getBcType() & CubitBCType(BLOCKSET)).any()) {
      block_meshsets.push_back(meshset.getMeshset());
    }
  }
 
  std::sort(block_meshsets.begin(), block_meshsets.end());
  block_meshsets.erase(
      std::unique(block_meshsets.begin(), block_meshsets.end()),
      block_meshsets.end());
 
  std::size_t local_cleared_names = 0;
  std::size_t local_cleared_attributes = 0;
  for (const auto meshset : block_meshsets) {
    std::vector<Tag> tag_handles;
    CHKERR moab.tag_get_tags_on_entity(meshset, tag_handles);
    if (clear_names &&
        std::find(tag_handles.begin(), tag_handles.end(), entity_name_tag) !=
        tag_handles.end()) {
      CHKERR moab.tag_delete_data(entity_name_tag, &meshset, 1);
      ++local_cleared_names;
    }
    if (clear_attributes &&
        std::find(tag_handles.begin(), tag_handles.end(), block_attributes) !=
        tag_handles.end()) {
      CHKERR moab.tag_delete_data(block_attributes, &meshset, 1);
      ++local_cleared_attributes;
    }
  }
 
  if (cleared_names) {
    *cleared_names = local_cleared_names;
  }
  if (cleared_attributes) {
    *cleared_attributes = local_cleared_attributes;
  }
 
  MoFEMFunctionReturn(0);
}

getBegin() [1/3]

CubitMeshSet_multiIndex::iterator MoFEM::MeshsetsManager::getBegin ( ) const

inline

#include <src/interfaces/MeshsetsManager.hpp>

get begin iterator of cubit meshset of given type (instead you can use IT_CUBITMESHSETS_TYPE_FOR_LOOP(MFIELD,CUBITBCTYPE,IT)

for(IT_CUBITMESHSETS_FOR_LOOP(mField,it) { ... }

Definition at line 454 of file MeshsetsManager.hpp.

                                                          {
    return cubitMeshsets.begin();
  }

getBegin() [2/3]

CubitMeshsetByName::iterator MoFEM::MeshsetsManager::getBegin ( const std::string &  name ) const

inline

#include <src/interfaces/MeshsetsManager.hpp>

get begin iterator of cubit meshset of given type (instead you can use IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP(MFIELD,CUBITBCTYPE,IT)

for(IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP(mField,NODESET|DISPLACEMENTSET,it) { ... }

Parameters

type	of meshset (NODESET, SIDESET or BLOCKSET and more)

Definition at line 562 of file MeshsetsManager.hpp.

                                                                          {
    return cubitMeshsets.get<CubitMeshsets_name>().lower_bound(name);
  }

getBegin() [3/3]

CubitMeshsetByType::iterator MoFEM::MeshsetsManager::getBegin ( const unsigned int  cubit_bc_type ) const

inline

#include <src/interfaces/MeshsetsManager.hpp>

get begin iterator of cubit meshset of given type (instead you can use IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP(MFIELD,CUBITBCTYPE,IT)

for(IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP(mField,NODESET|DISPLACEMENTSET,it) { ... }

Parameters

type	of meshset (NODESET, SIDESET or BLOCKSET and more)

Definition at line 487 of file MeshsetsManager.hpp.

                                                   {
    return cubitMeshsets.get<CubitMeshsetType_mi_tag>().lower_bound(
        cubit_bc_type);
  }

getBySetTypeBegin()

CubitMeshsetByMask::iterator MoFEM::MeshsetsManager::getBySetTypeBegin ( const unsigned int  cubit_bc_type ) const

inline

#include <src/interfaces/MeshsetsManager.hpp>

get end iterator of cubit meshset of given type (instead you can use IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP(MFIELD,CUBITBCTYPE,IT)

for(IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP(mField,NODESET,it) { ... }

Parameters

type	of meshset (NODESET, SIDESET or BLOCKSET and more)

Definition at line 525 of file MeshsetsManager.hpp.

                                                            {
    return cubitMeshsets.get<CubitMeshsetMaskedType_mi_tag>().lower_bound(
        cubit_bc_type);
  }

getBySetTypeEnd()

CubitMeshsetByMask::iterator MoFEM::MeshsetsManager::getBySetTypeEnd ( const unsigned int  cubit_bc_type ) const

inline

#include <src/interfaces/MeshsetsManager.hpp>

get end iterator of cubit meshset of given type (instead you can use IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP(MFIELD,CUBITBCTYPE,IT)

for(IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP(mField,NODESET,it) { ... }

Parameters

type	of meshset (NODESET, SIDESET or BLOCKSET and more)

Definition at line 543 of file MeshsetsManager.hpp.

                                                          {
    return cubitMeshsets.get<CubitMeshsetMaskedType_mi_tag>().upper_bound(
        cubit_bc_type);
  }

getCubitMeshsetPtr() [1/7]

std::vector< const CubitMeshSets * > MoFEM::MeshsetsManager::getCubitMeshsetPtr

(

const CubitBCType

cubit_bc_type

)

const

#include <src/interfaces/MeshsetsManager.hpp>

Get vector of pointer by bc type.

Returns

MoFEMErrorCode

Definition at line 805 of file MeshsetsManager.cpp.

                                                                         {
  std::vector<const CubitMeshSets *> vec_ptr;
  CHK_MOAB_THROW(getCubitMeshsetPtr(cubit_bc_type, vec_ptr),
                 "Error in getting meshsets by name");
  return vec_ptr;
}

getCubitMeshsetPtr() [2/7]

MoFEMErrorCode MoFEM::MeshsetsManager::getCubitMeshsetPtr	(	const CubitBCType	cubit_bc_type,
		std::vector< const CubitMeshSets * > &	vec_ptr
	)		const

#include <src/interfaces/MeshsetsManager.hpp>

Get vector of pointer by bc type.

Parameters

std::vector<const

CubitMeshSets *>

Returns

MoFEMErrorCode

Definition at line 791 of file MeshsetsManager.cpp.

                                                     {
  MoFEMFunctionBegin;
  auto r = cubitMeshsets.get<CubitMeshsetType_mi_tag>().equal_range(
      cubit_bc_type.to_ulong());
  for (auto it = r.first; it != r.second; ++it) {
    vec_ptr.push_back(&*it);
  }
  sortMeshsets(vec_ptr);
  MoFEMFunctionReturn(0);
}

getCubitMeshsetPtr() [3/7]

const CubitMeshSets * MoFEM::MeshsetsManager::getCubitMeshsetPtr	(	const int	ms_id,
		const CubitBCType	cubit_bc_type
	)		const

#include <src/interfaces/MeshsetsManager.hpp>

get cubit meshset

Definition at line 764 of file MeshsetsManager.cpp.

                                                                           {
  const CubitMeshSets *cubit_meshset_ptr;
  CHK_THROW_MESSAGE(
      getCubitMeshsetPtr(ms_id, cubit_bc_type, &cubit_meshset_ptr),
      "Get not get meshset");
  return cubit_meshset_ptr;
}

getCubitMeshsetPtr() [4/7]

MoFEMErrorCode MoFEM::MeshsetsManager::getCubitMeshsetPtr	(	const int	ms_id,
		const CubitBCType	cubit_bc_type,
		const CubitMeshSets **	cubit_meshset_ptr
	)		const

#include <src/interfaces/MeshsetsManager.hpp>

get cubit meshset

Examples

/home/lk58p/mofem_install/vanilla_dev_release/mofem-cephas/mofem/users_modules/eshelbian_plasticity/src/impl/EshelbianPlasticity.cpp, mofem/tutorials/adv-5_poroelasticity/seepage.cpp, mofem/tutorials/vec-3_nonlinear_dynamics/nonlinear_dynamic_elastic.cpp, mofem/tutorials/vec-7_shape_optimisation/adjoint.cpp, thermo_elastic.cpp, and thermoplastic.cpp.

Definition at line 745 of file MeshsetsManager.cpp.

                                                   {
  Interface &m_field = cOre;
  MoFEMFunctionBegin;
  auto miit =
      cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
          boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
  if (miit !=
      cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
    *cubit_meshset_ptr = &*miit;
  } else {
    SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
             "msId = %d is not there", ms_id);
  }
  MoFEMFunctionReturn(0);
}

getCubitMeshsetPtr() [5/7]

std::vector< const CubitMeshSets * > MoFEM::MeshsetsManager::getCubitMeshsetPtr

(

const std::regex

reg_exp_name

)

const

#include <src/interfaces/MeshsetsManager.hpp>

Get vector of pointer to blocksets with name satisfying regular expression.

for (auto m :
     m_field.getInterface<MeshsetsManager>()->getCubitMeshsetPtr(std::regex(
 
         (boost::format("%s(.*)") % block_name).str()
 
             ))
 
) {
  MOFEM_LOG("WORLD", Sev::inform) << m->getName();
 
  Range ents;
  m_field.get_moab().get_entities_by_dimension(
      m->getMeshset(), 0, ents, false);
 
  auto print_ents = [](boost::shared_ptr<FieldEntity> ent_ptr) {
    MoFEMFunctionBegin;
    if(!(ent_ptr->getPStatus() & PSTATUS_NOT_OWNED)) {
      MOFEM_LOG("SYNC", Sev::inform) << ent_ptr->getName() << ": " <<
ent_ptr->getEntFieldData();
    }
    MoFEMFunctionReturn(0);
  };
 
  CHKERR m_field.getInterface<FieldBlas>()->fieldLambdaOnEntities(
      print_ents, "VELOCITIES", &ents);
  CHKERR m_field.getInterface<FieldBlas>()->fieldLambdaOnEntities(
      print_ents, "DISPLACEMENTS", &ents);
  MOFEM_LOG_SEVERITY_SYNC(m_field.get_comm(), Sev::ifrom);
}

Parameters

reg_exp_name

Returns

std::vector<const CubitMeshSets *>

Definition at line 829 of file MeshsetsManager.cpp.

                                                                     {
  std::vector<const CubitMeshSets *> vec_ptr;
  CHK_MOAB_THROW(getCubitMeshsetPtr(reg_exp_name, vec_ptr),
                 "Error in getting meshsets by name");
  return vec_ptr;
}

getCubitMeshsetPtr() [6/7]

MoFEMErrorCode MoFEM::MeshsetsManager::getCubitMeshsetPtr	(	const std::regex	reg_exp_name,
		std::vector< const CubitMeshSets * > &	vec_ptr
	)		const

#include <src/interfaces/MeshsetsManager.hpp>

Get vector of pointer to blocksets with name satisfying regular expression.

Parameters

reg_exp_name
std::vector<const	CubitMeshSets *>

Returns

MoFEMErrorCode

Definition at line 812 of file MeshsetsManager.cpp.

                                                     {
  MoFEMFunctionBegin;
  auto r =
      cubitMeshsets.get<CubitMeshsetMaskedType_mi_tag>().equal_range(BLOCKSET);
  for (; r.first != r.second; ++r.first) {
    const auto name = r.first->getName();
    if (std::regex_match(name, reg_exp_name)) {
      vec_ptr.push_back(&*r.first);
    }
  }
  sortMeshsets(vec_ptr);
  MoFEMFunctionReturn(0);
}

getCubitMeshsetPtr() [7/7]

MoFEMErrorCode MoFEM::MeshsetsManager::getCubitMeshsetPtr	(	const string	name,
		const CubitMeshSets **	cubit_meshset_ptr
	)		const

#include <src/interfaces/MeshsetsManager.hpp>

get cubit meshset

Definition at line 773 of file MeshsetsManager.cpp.

                                                                      {
  Interface &m_field = cOre;
  MoFEMFunctionBegin;
  auto miit = cubitMeshsets.get<CubitMeshsets_name>().lower_bound(name);
  auto hi_miit = cubitMeshsets.get<CubitMeshsets_name>().upper_bound(name);
  if (std::distance(miit, hi_miit) == 0) {
    SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
             "meshset name <%s> is not there", name.c_str());
  }
  if (std::distance(miit, hi_miit) > 1) {
    SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
             "more that one meshser of that name <%s>", name.c_str());
  }
  *cubit_meshset_ptr = &*miit;
  MoFEMFunctionReturn(0);
}

getEnd() [1/3]

CubitMeshSet_multiIndex::iterator MoFEM::MeshsetsManager::getEnd ( ) const

inline

#include <src/interfaces/MeshsetsManager.hpp>

get begin iterator of cubit meshset of given type (instead you can use IT_CUBITMESHSETS_TYPE_FOR_LOOP(MFIELD,CUBITBCTYPE,IT)

for(IT_CUBITMESHSETS_FOR_LOOP(mField,it) { ... }

Definition at line 468 of file MeshsetsManager.hpp.

                                                 {
    return cubitMeshsets.end();
  }

getEnd() [2/3]

CubitMeshsetByName::iterator MoFEM::MeshsetsManager::getEnd ( const std::string &  name ) const

inline

#include <src/interfaces/MeshsetsManager.hpp>

get begin iterator of cubit meshset of given type (instead you can use IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP(MFIELD,CUBITBCTYPE,IT)

for(IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP(mField,NODESET|DISPLACEMENTSET,it) { ... }

Parameters

type	of meshset (NODESET, SIDESET or BLOCKSET and more)

Definition at line 580 of file MeshsetsManager.hpp.

                                                                        {
    return cubitMeshsets.get<CubitMeshsets_name>().upper_bound(name);
  }

getEnd() [3/3]

CubitMeshsetByType::iterator MoFEM::MeshsetsManager::getEnd ( const unsigned int  cubit_bc_type ) const

inline

#include <src/interfaces/MeshsetsManager.hpp>

get begin iterator of cubit meshset of given type (instead you can use IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP(MFIELD,CUBITBCTYPE,IT)

for(IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP(mField,NODESET|DISPLACEMENTSET,it) { ... }

Parameters

type	of meshset (NODESET, SIDESET or BLOCKSET and more)

Definition at line 507 of file MeshsetsManager.hpp.

                                                 {
    return cubitMeshsets.get<CubitMeshsetType_mi_tag>().upper_bound(
        cubit_bc_type);
  }

getEntitiesByDimension() [1/2]

MoFEMErrorCode MoFEM::MeshsetsManager::getEntitiesByDimension	(	const int	ms_id,
		const unsigned int	cubit_bc_type,
		const int	dimension,
		Range &	entities,
		const bool	recursive = true
	)		const

#include <src/interfaces/MeshsetsManager.hpp>

get entities from CUBIT/meshset of a particular entity dimension

Nodeset can contain nodes, edges, triangles and tets. This applies to other meshsets too. The nodeset's meshset contain the nodes in the MIDDLE of the surface or volume which is done by default in Cubit, Hence if all nodes on a particular nodeset are required, one should get all triangles or tetrahedrons for which the nodeset was create in Cubit, and get all the connectivities of tris/tets.

Parameters

ms_id	id of the BLOCKSET/SIDESET/BLOCKSET: from CUBIT
see	CubitBC (NODESET, SIDESET or BLOCKSET and more)
dimensions	(0 - Nodes, 1 - Edges, 2 - Faces, 3 - Volume(tetrahedral))
Range	containing the retrieved entities
recursive	If true, meshsets containing meshsets are queried recursively. Returns the contents of meshsets, but not the meshsets themselves if true.

Examples

mofem/atom_tests/prism_elements_from_surface.cpp, and mofem/tools/mesh_cut.cpp.

Definition at line 836 of file MeshsetsManager.cpp.

                                                 {
  Interface &m_field = cOre;
  moab::Interface &moab = m_field.get_moab();
  MoFEMFunctionBegin;
  auto miit =
      cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
          boost::make_tuple(msId, cubit_bc_type));
  if (miit !=
      cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
    CHKERR miit->getMeshsetIdEntitiesByDimension(moab, dimension, entities,
                                                 recursive);
  } else {
    SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
             "msId = %d is not there", msId);
  }
  MoFEMFunctionReturn(0);
}

getEntitiesByDimension() [2/2]

MoFEMErrorCode MoFEM::MeshsetsManager::getEntitiesByDimension	(	const int	ms_id,
		const unsigned int	cubit_bc_type,
		Range &	entities,
		const bool	recursive = true
	)		const

#include <src/interfaces/MeshsetsManager.hpp>

get entities related to CUBIT/meshset,

NODESET will get Vertices only, even if the NODESET contains edges, tris and tets SIDESET will get Tris, BLOCKSET will get Tets, DISPLACEMENTSET and FORCESET are stored in NODESET, PRESSURESET is stored in Sideset.

Parameters

ms_id	id of the BLOCKSET/SIDESET/BLOCKSET: from CUBIT
see	CubitBC (NODESET, SIDESET or BLOCKSET and more)
Range	containing the retrieved entities related to the
recursive	If true, meshsets containing meshsets are queried recursively. Returns the contents of meshsets, but not the meshsets themselves if true.

Definition at line 856 of file MeshsetsManager.cpp.

                                {
  Interface &m_field = cOre;
  moab::Interface &moab = m_field.get_moab();
  MoFEMFunctionBegin;
  auto miit =
      cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
          boost::make_tuple(ms_id, cubit_bc_type));
  if (miit !=
      cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
    CHKERR miit->getMeshsetIdEntitiesByDimension(moab, entities, recursive);
  } else {
    SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
             "ms_id = %d is not there", ms_id);
  }
  MoFEMFunctionReturn(0);
}

getMeshset()

MoFEMErrorCode MoFEM::MeshsetsManager::getMeshset	(	const int	ms_id,
		const unsigned int	cubit_bc_type,
		EntityHandle &	meshset
	)		const

#include <src/interfaces/MeshsetsManager.hpp>

get meshset from CUBIT Id and CUBIT type

Parameters

ms_id	id of the BLOCKSET/SIDESET/BLOCKSET: from CUBIT
see	CubitBC (NODESET, SIDESET or BLOCKSET and more)
meshset	where to store the retrieved entities

Examples

mofem/tools/mesh_cut.cpp, and mofem/tutorials/vec-5_free_surface/free_surface.cpp.

Definition at line 875 of file MeshsetsManager.cpp.

                                                                        {
  Interface &m_field = cOre;
  MoFEMFunctionBegin;
  auto miit =
      cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
          boost::make_tuple(ms_id, cubit_bc_type));
  if (miit !=
      cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
    meshset = miit->meshset;
  } else {
    SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
             "ms_id = %d is not there", ms_id);
  }
  MoFEMFunctionReturn(0);
}

getMeshsetsByType()

MoFEMErrorCode MoFEM::MeshsetsManager::getMeshsetsByType	(	const unsigned int	cubit_bc_type,
		Range &	meshsets
	)		const

#include <src/interfaces/MeshsetsManager.hpp>

get all CUBIT meshsets by CUBIT type

Parameters

see	CubitBC (NODESET, SIDESET or BLOCKSET and more).
meshsets	is range of meshsets

Definition at line 909 of file MeshsetsManager.cpp.

                                                          {
  MoFEMFunctionBegin;
  auto miit =
      cubitMeshsets.get<CubitMeshsetType_mi_tag>().lower_bound(cubit_bc_type);
  auto hi_miit =
      cubitMeshsets.get<CubitMeshsetType_mi_tag>().upper_bound(cubit_bc_type);
  for (; miit != hi_miit; miit++) {
    meshsets.insert(miit->meshset);
  }
  MoFEMFunctionReturn(0);
}

getTags() [1/2]

MoFEMErrorCode MoFEM::MeshsetsManager::getTags

(

int

verb = -1

)

#include <src/interfaces/MeshsetsManager.hpp>

Get tag handles used on meshsets.

Retrieves MOAB tag handles for meshset identification and data storage. These tags follow CUBIT/MOAB conventions for nodesets, sidesets, and blocksets. The function initializes internal tag handles for subsequent meshset operations.

Parameters

verb	verbosity level for output (-1 = default, higher values = more verbose)

Returns

MoFEMErrorCode Error code indicating success or failure

Definition at line 357 of file MeshsetsManager.cpp.

                                                {
  MoFEMFunctionBegin;
  Interface &m_field = cOre;
  moab::Interface &moab = m_field.get_moab();
  CHKERR getTags(moab, nsTag, ssTag, nsTag_data, ssTag_data, bhTag,
                 bhTag_header, verb);
  MoFEMFunctionReturn(0);
}

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

#include <src/interfaces/MeshsetsManager.hpp>

Static version of getTags for external MOAB interface.

Parameters

moab	reference to MOAB interface
nsTag	reference to store nodeset tag handle
ssTag	reference to store sideset tag handle
nsTag_data	reference to store nodeset data tag handle
ssTag_data	reference to store sideset data tag handle
bhTag	reference to store blockset tag handle
bhTag_header	reference to store blockset header tag handle
verb	verbosity level for output

Returns

MoFEMErrorCode Error code indicating success or failure

Definition at line 366 of file MeshsetsManager.cpp.

                                                                     {
  MoFEMFunctionBegin;
 
  int default_val = -1;
  CHKERR moab.tag_get_handle(DIRICHLET_SET_TAG_NAME, 1, MB_TYPE_INTEGER, nsTag,
                             MB_TAG_SPARSE | MB_TAG_CREAT, &default_val);
 
  CHKERR moab.tag_get_handle(NEUMANN_SET_TAG_NAME, 1, MB_TYPE_INTEGER, ssTag,
                             MB_TAG_SPARSE | MB_TAG_CREAT, &default_val);
 
  const int def_bc_data_len = 0;
  std::string tag_name = std::string(DIRICHLET_SET_TAG_NAME) + "__BC_DATA";
  CHKERR moab.tag_get_handle(
      tag_name.c_str(), def_bc_data_len, MB_TYPE_OPAQUE, nsTag_data,
      MB_TAG_CREAT | MB_TAG_SPARSE | MB_TAG_BYTES | MB_TAG_VARLEN, NULL);
 
  tag_name = std::string(NEUMANN_SET_TAG_NAME) + "__BC_DATA";
  CHKERR moab.tag_get_handle(
      tag_name.c_str(), def_bc_data_len, MB_TYPE_OPAQUE, ssTag_data,
      MB_TAG_CREAT | MB_TAG_SPARSE | MB_TAG_BYTES | MB_TAG_VARLEN, NULL);
 
  CHKERR moab.tag_get_handle(MATERIAL_SET_TAG_NAME, 1, MB_TYPE_INTEGER, bhTag,
                             MB_TAG_SPARSE | MB_TAG_CREAT, &default_val);
 
  std::vector<unsigned int> def_uint_zero(3, 0);
  CHKERR moab.tag_get_handle(
      BLOCK_HEADER, 3 * sizeof(unsigned int), MB_TYPE_INTEGER, bhTag_header,
      MB_TAG_CREAT | MB_TAG_SPARSE | MB_TAG_BYTES, &def_uint_zero[0]);
 
  Tag block_attribs;
  int def_Block_Attributes_length = 0;
  CHKERR moab.tag_get_handle(
      BLOCK_ATTRIBUTES, def_Block_Attributes_length, MB_TYPE_DOUBLE,
      block_attribs, MB_TAG_CREAT | MB_TAG_SPARSE | MB_TAG_VARLEN, NULL);
 
  Tag entity_name_tag;
  CHKERR moab.tag_get_handle(NAME_TAG_NAME, NAME_TAG_SIZE, MB_TYPE_OPAQUE,
                             entity_name_tag, MB_TAG_SPARSE | MB_TAG_CREAT);
 
  MoFEMFunctionReturn(0);
}

initialiseDatabaseFromMesh()

MoFEMErrorCode MoFEM::MeshsetsManager::initialiseDatabaseFromMesh

(

int

verb = DEFAULT_VERBOSITY

)

#include <src/interfaces/MeshsetsManager.hpp>

Initialize container from mesh data.

Reads meshset information from the mesh database and populates the internal multi-index container. This includes discovering nodesets, sidesets, and blocksets with their associated tags and data.

Parameters

verb	verbosity level for output

Returns

MoFEMErrorCode Error code indicating success or failure

Definition at line 120 of file MeshsetsManager.cpp.

                                                                   {
  Interface &m_field = cOre;
  MoFEMFunctionBegin;
  CHKERR readMeshsets(verb);
  if (broadcastMeshsetsOn)
    CHKERR broadcastMeshsets(verb);
 
  std::vector<const CubitMeshSets *> vec_ptr;
  for (auto &m : cubitMeshsets) {
    vec_ptr.push_back(&m);
  }
  sortMeshsets(vec_ptr);
 
  for (auto m_ptr : vec_ptr) {
    MOFEM_LOG("MeshsetMngWorld", Sev::inform)
        << "meshset in database " << *m_ptr;
  }
  // Verbose synchronised print
  for (auto m_ptr : vec_ptr) {
    MOFEM_LOG("MeshsetMngSync", Sev::verbose)
        << "meshset in database " << *m_ptr;
  }
  MOFEM_LOG_SEVERITY_SYNC(m_field.get_comm(), Sev::verbose);
 
  MoFEMFunctionReturn(0);
}

printDisplacementSet()

MoFEMErrorCode MoFEM::MeshsetsManager::printDisplacementSet

(

)

const

#include <src/interfaces/MeshsetsManager.hpp>

Print meshsets with displacement boundary conditions.

Outputs information about all meshsets containing displacement boundary condition data, including constraint flags and prescribed values.

Returns

MoFEMErrorCode Error code indicating success or failure

Examples

mofem/tutorials/cor-7_elasticity_mixed_formulation/elasticity_mixed_formulation.cpp, and mofem/users_modules/basic_finite_elements/elasticity/elasticity.cpp.

Definition at line 411 of file MeshsetsManager.cpp.

                                                           {
  DisplacementCubitBcData mydata;
  MoFEMFunctionBegin;
  CHKERR printBcSet(mydata, NODESET | mydata.tYpe.to_ulong());
  MoFEMFunctionReturn(0);
}

printForceSet()

MoFEMErrorCode MoFEM::MeshsetsManager::printForceSet

(

)

const

#include <src/interfaces/MeshsetsManager.hpp>

Print meshsets with force boundary conditions.

Outputs information about all meshsets containing force boundary condition data, including force and moment components.

Returns

MoFEMErrorCode Error code indicating success or failure

Examples

mofem/tutorials/cor-7_elasticity_mixed_formulation/elasticity_mixed_formulation.cpp, and mofem/users_modules/basic_finite_elements/elasticity/elasticity.cpp.

Definition at line 425 of file MeshsetsManager.cpp.

                                                    {
  ForceCubitBcData mydata;
  MoFEMFunctionBegin;
  CHKERR printBcSet(mydata, NODESET | mydata.tYpe.to_ulong());
  MoFEMFunctionReturn(0);
}

printHeatFluxSet()

MoFEMErrorCode MoFEM::MeshsetsManager::printHeatFluxSet

(

)

const

#include <src/interfaces/MeshsetsManager.hpp>

Print meshsets with heat flux boundary conditions.

Outputs information about all meshsets containing heat flux boundary condition data, including flux magnitudes and directions.

Returns

MoFEMErrorCode Error code indicating success or failure

Definition at line 439 of file MeshsetsManager.cpp.

                                                       {
  HeatFluxCubitBcData mydata;
  MoFEMFunctionBegin;
  CHKERR printBcSet(mydata, SIDESET | mydata.tYpe.to_ulong());
  MoFEMFunctionReturn(0);
}

printMaterialsSet()

MoFEMErrorCode MoFEM::MeshsetsManager::printMaterialsSet

(

)

const

#include <src/interfaces/MeshsetsManager.hpp>

Print meshsets with material properties.

Outputs information about all meshsets containing material data, including material parameters and constitutive model information.

Returns

MoFEMErrorCode Error code indicating success or failure

Examples

mofem/tutorials/cor-7_elasticity_mixed_formulation/elasticity_mixed_formulation.cpp, and mofem/users_modules/basic_finite_elements/elasticity/elasticity.cpp.

Definition at line 446 of file MeshsetsManager.cpp.

                                                        {
  MoFEMFunctionBegin;
  const Interface &m_field = cOre;
  const moab::Interface &moab = m_field.get_moab();
  for (_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(
           (*this), BLOCKSET | MAT_ELASTICSET, it)) {
    Mat_Elastic data;
    CHKERR it->getAttributeDataStructure(data);
    MOFEM_LOG("MeshsetMngWorld", Sev::inform) << *it;
    MOFEM_LOG("MeshsetMngWorld", Sev::inform) << data;
    Range tets;
    CHKERR moab.get_entities_by_dimension(it->meshset, 3, tets, true);
    MOFEM_LOG("MeshsetMngWorld", Sev::inform)
        << "MAT_ELATIC msId " << it->getMeshsetId() << " nb. volumes "
        << tets.size();
  }
 
  for (_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(
           m_field, BLOCKSET | MAT_THERMALSET, it)) {
    Mat_Thermal data;
    CHKERR it->getAttributeDataStructure(data);
    MOFEM_LOG("MeshsetMngWorld", Sev::inform) << *it;
    MOFEM_LOG("MeshsetMngWorld", Sev::inform) << data;
  }
 
  for (_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(
           m_field, BLOCKSET | MAT_MOISTURESET, it)) {
    Mat_Moisture data;
    CHKERR it->getAttributeDataStructure(data);
    MOFEM_LOG("MeshsetMngWorld", Sev::inform) << *it;
    MOFEM_LOG("MeshsetMngWorld", Sev::inform) << data;
  }
  MoFEMFunctionReturn(0);
}

printPressureSet()

MoFEMErrorCode MoFEM::MeshsetsManager::printPressureSet

(

)

const

#include <src/interfaces/MeshsetsManager.hpp>

Print meshsets with pressure boundary conditions.

Outputs information about all meshsets containing pressure boundary condition data, including pressure magnitudes and application flags.

Returns

MoFEMErrorCode Error code indicating success or failure

Definition at line 418 of file MeshsetsManager.cpp.

                                                       {
  PressureCubitBcData mydata;
  MoFEMFunctionBegin;
  CHKERR printBcSet(mydata, SIDESET | mydata.tYpe.to_ulong());
  MoFEMFunctionReturn(0);
}

printTemperatureSet()

MoFEMErrorCode MoFEM::MeshsetsManager::printTemperatureSet

(

)

const

#include <src/interfaces/MeshsetsManager.hpp>

Print meshsets with temperature boundary conditions.

Outputs information about all meshsets containing temperature boundary condition data, including prescribed temperature values.

Returns

MoFEMErrorCode Error code indicating success or failure

Definition at line 432 of file MeshsetsManager.cpp.

                                                          {
  TemperatureCubitBcData mydata;
  MoFEMFunctionBegin;
  CHKERR printBcSet(mydata, NODESET | mydata.tYpe.to_ulong());
  MoFEMFunctionReturn(0);
}

readMeshsets()

MoFEMErrorCode MoFEM::MeshsetsManager::readMeshsets

(

int

verb = DEFAULT_VERBOSITY

)

#include <src/interfaces/MeshsetsManager.hpp>

Read meshsets from mesh database.

Scans the mesh for existing meshsets and populates the manager's internal data structures. This is typically called after mesh loading to discover all available nodesets, sidesets, and blocksets.

Parameters

verb	verbosity level for output

Returns

MoFEMErrorCode Error code indicating success or failure

Definition at line 147 of file MeshsetsManager.cpp.

                                                     {
  Interface &m_field = cOre;
  moab::Interface &moab = m_field.get_moab();
  MoFEMFunctionBegin;
 
  Range meshsets;
  CHKERR moab.get_entities_by_type(0, MBENTITYSET, meshsets, false);
  for (auto m : meshsets) {
    // check if meshset is cubit meshset
    CubitMeshSets block(moab, m);
    if ((block.cubitBcType & CubitBCType(NODESET | SIDESET | BLOCKSET)).any()) {
      auto p = cubitMeshsets.insert(block);
      if (!p.second) {
        // blockset/nodeset/sideset set exist, could be created on other
        // processor.
        Range ents;
        CHKERR m_field.get_moab().get_entities_by_handle(m, ents, true);
        CHKERR m_field.get_moab().add_entities(p.first->getMeshset(), ents);
        CHKERR m_field.get_moab().delete_entities(&m, 1);
      }
    }
  }
 
  std::vector<const CubitMeshSets *> vec_ptr;
  for (auto &m : cubitMeshsets) {
    vec_ptr.push_back(&m);
  }
  sortMeshsets(vec_ptr);
 
  for (auto m_ptr : vec_ptr) {
    MOFEM_LOG("MeshsetMngSync", Sev::verbose) << "read " << *m_ptr;
  }
  MOFEM_LOG_SEVERITY_SYNC(m_field.get_comm(), Sev::verbose);
 
  MoFEMFunctionReturn(0);
}

setAttributes()

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

#include <src/interfaces/MeshsetsManager.hpp>

Set attributes for CUBIT meshset.

Assigns attribute values to a meshset. Attributes are typically used for material properties or other numerical parameters associated with the meshset entities.

Parameters

cubit_bc_type	type of meshset (BLOCKSET, NODESET, SIDESET, etc.)
ms_id	CUBIT ID of the target meshset
attributes	vector of attribute values to assign
name	optional name to assign to the meshset

Returns

MoFEMErrorCode Error code indicating success or failure

Examples

mofem/atom_tests/add_cubit_meshsets.cpp.

Definition at line 604 of file MeshsetsManager.cpp.

                                                    {
  Interface &m_field = cOre;
  moab::Interface &moab = m_field.get_moab();
  MoFEMFunctionBegin;
  auto cit =
      cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
          boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
  if (cit ==
      cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
    SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
             "Cannot find Cubit meshset with id: %d", ms_id);
  }
  if (name.size() > 0) {
    bool success = cubitMeshsets.modify(cubitMeshsets.project<0>(cit),
                                        CubitMeshSets_change_name(moab, name));
    if (!success) {
      SETERRQ(m_field.get_comm(), MOFEM_OPERATION_UNSUCCESSFUL,
              "name to cubit meshset can not be set");
    }
  }
  bool success =
      cubitMeshsets.modify(cubitMeshsets.project<0>(cit),
                           CubitMeshSets_change_attributes(moab, attributes));
  if (!success)
    SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
            "modification unsuccessful");
 
  std::ostringstream ss;
  ss << "Block " << cit->getName();
  ss << " Add attr: ";
  for (unsigned int ii = 0; ii != attributes.size(); ii++) {
    ss << attributes[ii] << " ";
  }
  MOFEM_LOG("MeshsetMngSelf", Sev::noisy) << ss.str();
 
  MoFEMFunctionReturn(0);
}

setAttributesByDataStructure()

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

#include <src/interfaces/MeshsetsManager.hpp>

Set attributes using data structure.

Assigns material or other attributes to a meshset using a structured data object. This provides a more organized way to handle complex attribute data with proper typing and validation.

Parameters

cubit_bc_type	type of meshset (BLOCKSET, NODESET, SIDESET, etc.)
ms_id	CUBIT ID of the target meshset
data	structured data containing attribute information
name	optional name to assign to the meshset

Returns

MoFEMErrorCode Error code indicating success or failure

Examples

mofem/atom_tests/add_cubit_meshsets.cpp.

Definition at line 666 of file MeshsetsManager.cpp.

                                                            {
  Interface &m_field = cOre;
  moab::Interface &moab = m_field.get_moab();
  MoFEMFunctionBegin;
  auto cit =
      cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
          boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
  if (cit ==
      cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
    SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
             "Cannot find Cubit meshset with id: %d", ms_id);
  }
  if (name.size() > 0) {
    bool success = cubitMeshsets.modify(cubitMeshsets.project<0>(cit),
                                        CubitMeshSets_change_name(moab, name));
    if (!success) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
              "name to cubit meshset can not be set");
    }
  }
  bool success = cubitMeshsets.modify(
      cubitMeshsets.project<0>(cit),
      CubitMeshSets_change_attributes_data_structure(moab, data));
  if (!success)
    SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
            "modification unsuccessful");
  MoFEMFunctionReturn(0);
}

setBcData()

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

#include <src/interfaces/MeshsetsManager.hpp>

Set boundary condition data for meshset.

Assigns boundary condition data to a meshset. This includes constraint information, prescribed values, and application flags for various boundary condition types (displacement, force, pressure, etc.).

Parameters

cubit_bc_type	type of meshset (BLOCKSET, NODESET, SIDESET, etc.)
ms_id	CUBIT ID of the target meshset
data	boundary condition data structure

Returns

MoFEMErrorCode Error code indicating success or failure

Examples

mofem/atom_tests/add_cubit_meshsets.cpp.

Definition at line 697 of file MeshsetsManager.cpp.

                                                                          {
  Interface &m_field = cOre;
  moab::Interface &moab = m_field.get_moab();
  MoFEMFunctionBegin;
  auto cit =
      cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().find(
          boost::make_tuple(ms_id, cubit_bc_type.to_ulong()));
  if (cit ==
      cubitMeshsets.get<Composite_Cubit_msId_And_MeshsetType_mi_tag>().end()) {
    SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
            "Cubit meshset with id is already there id = %d", ms_id);
  }
  bool success =
      cubitMeshsets.modify(cubitMeshsets.project<0>(cit),
                           CubitMeshSets_change_bc_data_structure(moab, data));
  if (!success)
    SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
            "modification unsuccessful");
  MoFEMFunctionReturn(0);
}

setMeshsetFromFile()

MoFEMErrorCode MoFEM::MeshsetsManager::setMeshsetFromFile

(

)

#include <src/interfaces/MeshsetsManager.hpp>

Load meshset configuration from command line specified file.

Reads the configuration file name from the command line option '-meshsets_config' and loads meshset definitions from that file. This provides a convenient way to specify meshset configurations at runtime without hardcoding file paths.

Command line usage: -meshsets_config filename.cfg

Returns

MoFEMErrorCode Error code indicating success or failure

Definition at line 1649 of file MeshsetsManager.cpp.

                                                   {
  Interface &m_field = cOre;
  PetscBool flg_file;
  char meshset_file_name[255] = "config_file.cfg";
  MoFEMFunctionBegin;
  PetscOptionsBegin(m_field.get_comm(), "", "Set meshsets form file",
                           "none");
  CHKERR PetscOptionsString("-meshsets_config", "meshsets config  file name",
                            "", "add_cubit_meshsets.in", meshset_file_name, 255,
                            &flg_file);
  auto *json_config = m_field.getInterface<JsonConfigManager>();
  if (flg_file == PETSC_TRUE) {
    ifstream f(meshset_file_name);
    if (!f.good()) {
      SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
               "File configuring meshsets ( %s ) can not be open\n",
               meshset_file_name);
    }
    CHKERR setMeshsetFromFile(string(meshset_file_name));
    MOFEM_LOG("MeshsetMngWorld", Sev::inform)
        << "Printing all meshsets (old and added from meshsets "
           "configurational file)";
    for (auto cit = getBegin(); cit != getEnd(); cit++) {
      MOFEM_LOG("MeshsetMngWorld", Sev::inform) << *cit;
    }
  } else if (json_config->hasMeshsetsSection()) {
    CHKERR json_config->applyMeshsets();
  }
  PetscOptionsEnd();
  MoFEMFunctionReturn(0);
}