MeshsetsManager.hpp

Go to the documentation of this file.

/** \file MeshsetsManager.hpp
 * \brief Interface for managing mesh sets containing materials and boundary conditions
 * \ingroup mofem_meshset_mng
 *
 * The MeshsetsManager provides a comprehensive, format-agnostic interface for handling
 * mesh sets within the MoFEM finite element framework. It serves as the foundational
 * data management layer for boundary conditions and material properties, supporting
 * multiple meshing software formats and integration patterns.
 *
 * Key functionality includes:
 * - Generic meshset management compatible with CUBIT, Gmsh, Salome/MED, and other formats
 * - MOAB-based efficient storage and parallel processing of meshset data
 * - Integration with BcManager for high-level boundary condition application
 * - Support for NODESET (vertex groups), SIDESET (surface groups), and BLOCKSET (volume groups)
 * - Material property and boundary condition data association
 * - Configuration file loading and parallel data synchronization
 * - Multi-format tag translation and meshset discovery
 *
 * Format Support:
 * - CUBIT/Coreform: Native support for nodesets, sidesets, and blocksets
 * - Gmsh: Physical group translation to MoFEM meshsets
 * - Salome/MED: Mesh group and CAD-based boundary definitions
 * - Exodus II, ANSYS, Abaqus: Standard finite element format compatibility
 * - Custom formats: Extensible tag-based approach for new meshing software
 *
 * The interface bridges the gap between mesh generation software conventions and
 * MoFEM's finite element infrastructure, providing a unified approach to boundary
 * condition and material management regardless of the original mesh source.
 *
 */
 
#ifndef __MESHSETSMANAGER_HPP__
#define __MESHSETSMANAGER_HPP__
 
namespace MoFEM {
 
typedef CubitMeshSet_multiIndex::index<CubitMeshsetType_mi_tag>::type
    CubitMeshsetByType;
 
typedef CubitMeshSet_multiIndex::index<CubitMeshsetMaskedType_mi_tag>::type
    CubitMeshsetByMask;
 
typedef CubitMeshSet_multiIndex::index<CubitMeshsets_name>::type
    CubitMeshsetByName;
 
typedef CubitMeshSet_multiIndex::index<CubitMeshsetType_mi_tag>::type
    CubitMeshsetById;
 
/**
 * \brief Iterator that loops over all the Cubit MeshSets in a moFEM field
 * \ingroup mofem_meshset_mng
 
 *
 * \param MESHSET_MANAGER meshset manager (works as well with Interface)
 * \param iterator
 */
#define _IT_CUBITMESHSETS_FOR_LOOP_(MESHSET_MANAGER, IT)                       \
  CubitMeshSet_multiIndex::iterator IT =                                       \
      MESHSET_MANAGER.get_meshsets_manager_ptr()->getBegin();                  \
  IT != MESHSET_MANAGER.get_meshsets_manager_ptr()->getEnd();                  \
  IT++
 
/**
* \brief Iterator that loops over a specific Cubit MeshSet in a moFEM field
* \ingroup mofem_meshset_mng
 
*
* \param mField moFEM Field
* \param  see CubitBC (NODESET, SIDESET or BLOCKSET and more)
* \param iterator
*/
#define _IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(MESHSET_MANAGER,            \
                                                   CUBITBCTYPE, IT)            \
  CubitMeshsetByType::iterator IT =                                            \
      MESHSET_MANAGER.get_meshsets_manager_ptr()->getBegin(CUBITBCTYPE);       \
  IT != MESHSET_MANAGER.get_meshsets_manager_ptr()->getEnd(CUBITBCTYPE);       \
  IT++
 
/**
* \brief Iterator that loops over a specific Cubit MeshSet having a particular
BC meshset in a moFEM field
* \ingroup mofem_meshset_mng
 
*
* \param MESHSET_MANAGER meshset manager (works as well with Interface)
* \param  see CubitBC (NODESET, SIDESET or BLOCKSET and more)
* \param iterator
*
* Example: \code
for(_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(mField,NODESET|DISPLACEMENTSET,it) {
...
* } \endcode
*/
#define _IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(MESHSET_MANAGER, CUBITBCTYPE,  \
                                                IT)                            \
  CubitMeshsetByMask::iterator IT =                                            \
      MESHSET_MANAGER.get_meshsets_manager_ptr()->getBySetTypeBegin(           \
          CUBITBCTYPE);                                                        \
  IT != MESHSET_MANAGER.get_meshsets_manager_ptr()->getBySetTypeEnd(           \
            CUBITBCTYPE);                                                      \
  IT++
 
/**
* \brief Iterator that loops over Cubit BlockSet having a particular name
* \ingroup mofem_meshset_mng
 
 
* \param MESHSET_MANAGER meshset manager (works as well with Interface)
* \param NAME name
* \param IT iterator
*
* Example: \code
for(_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(mField,"SOME_BLOCK_NAME",it) {
...
* } \endcode
*/
#define _IT_CUBITMESHSETS_BY_NAME_FOR_LOOP_(MESHSET_MANAGER, NAME, IT)         \
  CubitMeshsetByName::iterator IT =                                            \
      MESHSET_MANAGER.get_meshsets_manager_ptr()->getBegin(NAME);              \
  IT != MESHSET_MANAGER.get_meshsets_manager_ptr()->getEnd(NAME);              \
  IT++
 
/** \brief Interface for managing meshsets containing materials and boundary
 * conditions
 * \ingroup mofem_meshset_mng
 *
 * The MeshsetsManager provides comprehensive functionality for creating, managing,
 * and querying mesh sets (materials, boundary conditions, and blocks) within the
 * MoFEM framework. It serves as the foundation for higher-level boundary condition
 * management and integrates seamlessly with various meshing software formats.
 *
 * \section mm_bc_connection Connection to BcManager
 * 
 * The MeshsetsManager acts as the data layer for the BcManager interface:
 * - **Data Storage**: MeshsetsManager stores meshset definitions, attributes, and entity associations
 * - **BcManager Interface**: BcManager provides high-level boundary condition application using MeshsetsManager data
 * - **Workflow Integration**: MeshsetsManager discovers and organizes meshsets, BcManager applies them to finite element problems
 * - **Data Consistency**: Both interfaces ensure synchronized boundary condition data across parallel processes
 *
 * \section mm_moab_integration MOAB Meshset Integration
 * 
 * MeshsetsManager leverages MOAB's native meshset capabilities:
 * - **MOAB Meshsets**: Uses MOAB::EntitySet as the underlying container for mesh entities
 * - **Tag System**: Utilizes MOAB tags for meshset identification and data storage
 * - **Entity Management**: Manages collections of vertices, edges, faces, and volumes within meshsets
 * - **Memory Efficiency**: Benefits from MOAB's optimized storage and query mechanisms
 * - **Parallel Support**: Inherits MOAB's parallel meshset handling for distributed computations
 *
 * \section mm_cubit_concepts CUBIT/Coreform Meshset Types
 * 
 * \subsection mm_nodeset NODESET
 * - **Purpose**: Groups of vertices/nodes for applying nodal boundary conditions
 * - **Usage**: Displacement constraints, temperature, concentrated forces, point sources
 * - **CUBIT Creation**: Select vertices → Create Nodeset → Assign boundary conditions
 * - **Examples**: Fixed supports, prescribed displacements, temperature constraints
 *
 * \subsection mm_sideset SIDESET  
 * - **Purpose**: Groups of faces/surfaces for applying surface boundary conditions
 * - **Usage**: Pressure loads, heat flux, traction forces, interface conditions
 * - **CUBIT Creation**: Select surfaces → Create Sideset → Assign surface conditions
 * - **Examples**: Pressure on surfaces, heat transfer boundaries, contact interfaces
 *
 * \subsection mm_blockset BLOCKSET
 * - **Purpose**: Groups of volumes/elements for material property assignment
 * - **Usage**: Material definitions, element types, constitutive models
 * - **CUBIT Creation**: Select volumes → Create Block → Assign material properties
 * - **Examples**: Steel regions, concrete blocks, fluid domains, different element types
 *
 * \section mm_generic_approach Generic Multi-Format Support
 * 
 * The MeshsetsManager approach is **not restricted to CUBIT** and supports multiple meshing formats:
 * 
 * \subsection mm_gmsh Gmsh Integration
 * - **Physical Groups**: Gmsh physical groups map to MoFEM meshsets
 * - **Tag Translation**: Converts Gmsh physical tags to MOAB meshset tags
 * - **Entity Types**: Supports Gmsh's point, line, surface, and volume physical groups
 * - **Boundary Conditions**: Gmsh boundary markers become MoFEM boundary condition meshsets
 *
 * \subsection mm_salome Salome/MED Format Support
 * - **MED Groups**: Salome mesh groups translate to MoFEM meshsets
 * - **CAD Integration**: Preserves CAD-based boundary and material definitions
 * - **Multi-Physics**: Supports Salome's multi-physics mesh organization
 * - **CGNS Compatibility**: Handles complex boundary condition hierarchies
 *
 * \subsection mm_other_formats Other Format Support
 * - **Exodus II**: Supports element blocks, node sets, and side sets
 * - **ANSYS**: Converts component definitions to meshsets
 * - **Abaqus**: Translates element sets and node sets
 * - **Custom Formats**: Generic tag-based approach accommodates new formats
 *
 * \section mm_workflow Typical Multi-Format Workflow
 * 
 * 1. **Mesh Import**: Load mesh with native format-specific group definitions
 * 2. **Tag Discovery**: MeshsetsManager discovers and categorizes existing tags
 * 3. **Meshset Creation**: Convert format-specific groups to unified meshset representation
 * 4. **Data Association**: Attach material properties and boundary condition data
 * 5. **Validation**: Verify meshset consistency and completeness
 * 6. **Problem Setup**: Use meshsets for finite element problem definition
 *
 * \section mm_capabilities Key Capabilities
 * - Creating and managing meshsets from various meshing software
 * - Setting material properties and boundary condition data
 * - Querying meshset contents and properties across different formats
 * - Loading/saving meshset configurations with format preservation
 * - Broadcasting meshset data across MPI processes
 * - Generic tag-based approach for extensibility to new formats
 */
struct MeshsetsManager : 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 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 = "");
 
  /**
   * \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 = "");
 
  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  # you can set up to 10 attributes (if needed could be easily
   extended to more, let us know)
   user3=3.0
 
   [block_1002]
 
   # Example applying material block (isotropic elastic material)
 
   id=2002
   add=BLOCKSET
   name=MAT_ELASTIC
   young=10
   poisson=0.25
   thermalexpansion=0
 
   [block_1003]
 
   # Example applying displacement constrains
 
   id=2003
   add=NODESET
 
   # Each flag means that boundary consition on displacements is set.
   disp_flag1=1 # Setting constrains in x- direction
   disp_flag2=1 # Setting constrains in y- direction
   disp_flag3=1 # Setting constrains in z- direction
   disp_flag4=1 # Setting constrains on rotation over x- axis
   disp_flag5=1 # Setting constrains on rotation over y- axis
   disp_flag6=1 # Setting constrains on rotation over z-axis
   disp_ux=1 # value of disp in x- direction
   disp_uy=2
   disp_uz=3
   disp_rx=4 # value of rotation in y-direction
   disp_ry=5
   disp_rz=6
 
   # Note above values could be interpreted differently if needed.
 
   [block_1004]
 
   # Example applying force boundary conditions
 
   id=2004
   add=NODESET
   force_magnitude=1
   moment_magnitude=1
   force_fx=1
   force_fy=1
   force_fz=1
   moment_mx=1
   moment_my=1
   moment_mz=1
 
   [block_1005]
 
   # Example applying pressure boundary conditions
 
   id=2005
   add=SIDESET
   pressure_flag2=1       # 0: Pressure is interpreted as pure pressure 1:
   pressure is interpreted as total force
   pressure_magnitude=1
 
   # Example applying temperature boundary conditions
 
   [block_1006]
 
   id=2006
   add=NODESET
   temperature_flag1=1        # 0: N/A, 1: temperature value applied
   temperature_t=1
 
   [block_1007]
 
   id=2007
   add=SIDESET
   heatflux_flag1=1        # 0: N/A, 1: heat flux applied
   heatflux_magnitude=1
 
   [block_1008]
 
   # Example applying material block (isotropic thermal material)
 
   id=2008
   add=BLOCKSET
   name=MAT_THERMAL # Hast to be set for Thermal Mat
   conductivity=1
   capacity=1
 
   [block_1009]
 
   # Example applying interface
   id=2009
   add=SIDESET
   interface_type=1
 
   [block_1010]
 
   # Example applying material block for interface element
 
   id=2010
   add=BLOCKSET
   name=MAT_INTERF
   interface_alpha = 1
   interface_beta = 0
   interface_ft = 1
   interface_Gf = 1
 
 
   [block_1009]
 
   # Example applying material block (isotropic trans iso material)
 
   id=2011
   add=BLOCKSET
   name=MAT_ELASTIC_TRANS_ISO
   Youngp=1
   Youngz=2
   Poissonp=3
   Poissonpz=4
   Shearzp=5
 
   [SET_ATTR_foo]
 
   # Example set atttributes to block name "foo"
   number_of_attributes=3
   user1=1
   user2=2
   user3=3
 
   \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
 **/