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

#include "src/interfaces/MeshsetsManager.hpp"

Inheritance diagram for MoFEM::MeshsetsManager:

Collaboration diagram for MoFEM::MeshsetsManager:

Public Member Functions
MoFEMErrorCode	query_interface (boost::typeindex::type_index type_index, UnknownInterface **iface) const
	Query interface for MeshsetsManager.

	MeshsetsManager (const MoFEM::Core &core)
	Constructor for MeshsetsManager.

virtual	~MeshsetsManager ()=default

MoFEMErrorCode	getTags (int verb=-1)
	Get tag handles used on meshsets.

Tag	get_nsTag () const
	get tag handle used to store "id" of NODESET

Tag	get_ssTag () const
	get tag handle used to store "id" of SIDESET

Tag	get_nsTag_data () const
	get tag handle used to store boundary data on NODESET

Tag	get_ssTag_data () const
	get tag handle used to store boundary data on SIDESET

Tag	get_bhTag () const
	get tag handle used to store "id" of BLOCKSET

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

MeshsetsManager *	get_meshsets_manager_ptr ()
	return pointer to meshset manager

const MeshsetsManager *	get_meshsets_manager_ptr () const
	return pointer to meshset manager

MoFEMErrorCode	clearMap ()
	Clear the multi-index container.

MoFEMErrorCode	initialiseDatabaseFromMesh (int verb=DEFAULT_VERBOSITY)
	Initialize container from mesh data.

MoFEMErrorCode	readMeshsets (int verb=DEFAULT_VERBOSITY)
	Read meshsets from mesh database.

MoFEMErrorCode	broadcastMeshsets (int verb=DEFAULT_VERBOSITY)
	Broadcast meshsets across MPI processes.

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

MoFEMErrorCode	printDisplacementSet () const
	Print meshsets with displacement boundary conditions.

MoFEMErrorCode	printPressureSet () const
	Print meshsets with pressure boundary conditions.

MoFEMErrorCode	printForceSet () const
	Print meshsets with force boundary conditions.

MoFEMErrorCode	printTemperatureSet () const
	Print meshsets with temperature boundary conditions.

MoFEMErrorCode	printHeatFluxSet () const
	Print meshsets with heat flux boundary conditions.

MoFEMErrorCode	printMaterialsSet () const
	Print meshsets with material properties.

CubitMeshSet_multiIndex &	getMeshsetsMultindex ()

CubitMeshSet_multiIndex::iterator	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	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	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	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	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	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	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	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	checkMeshset (const int ms_id, const CubitBCType cubit_bc_type) const
	Check for CUBIT meshset by ID and type.

bool	checkMeshset (const string name, int *const number_of_meshsets_ptr=NULL) const
	Check if meshset with given name exists.

MoFEMErrorCode	addMeshset (const CubitBCType cubit_bc_type, const int ms_id, const std::string name="")
	Add CUBIT meshset to manager.

MoFEMErrorCode	addEntitiesToMeshset (const CubitBCType cubit_bc_type, const int ms_id, const Range &ents)
	Add entities to CUBIT meshset.

MoFEMErrorCode	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	setAttributes (const CubitBCType cubit_bc_type, const int ms_id, const std::vector< double > &attributes, const std::string name="")
	Set attributes for CUBIT meshset.

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

MoFEMErrorCode	setAttributesByDataStructure (const CubitBCType cubit_bc_type, const int ms_id, const GenericAttributeData &data, const std::string name="")
	Set attributes using data structure.

DEPRECATED auto	setAtributesByDataStructure (const CubitBCType cubit_bc_type, const int ms_id, const GenericAttributeData &data, const std::string name="")

MoFEMErrorCode	setBcData (const CubitBCType cubit_bc_type, const int ms_id, const GenericCubitBcData &data)
	Set boundary condition data for meshset.

MoFEMErrorCode	deleteMeshset (const CubitBCType cubit_bc_type, const int ms_id, const MoFEMTypes bh=MF_EXIST)
	delete cubit meshset

MoFEMErrorCode	getCubitMeshsetPtr (const int ms_id, const CubitBCType cubit_bc_type, const CubitMeshSets **cubit_meshset_ptr) const
	get cubit meshset

const CubitMeshSets *	getCubitMeshsetPtr (const int ms_id, const CubitBCType cubit_bc_type) const
	get cubit meshset

MoFEMErrorCode	getCubitMeshsetPtr (const CubitBCType cubit_bc_type, std::vector< const CubitMeshSets * > &vec_ptr) const
	Get vector of pointer by bc type.

std::vector< const CubitMeshSets * >	getCubitMeshsetPtr (const CubitBCType cubit_bc_type) const
	Get vector of pointer by bc type.

MoFEMErrorCode	getCubitMeshsetPtr (const string name, const CubitMeshSets **cubit_meshset_ptr) const
	get cubit meshset

MoFEMErrorCode	getCubitMeshsetPtr (const std::regex reg_exp_name, std::vector< const CubitMeshSets * > &vec_ptr) const
	Get vector of pointer to blocksets with name satisfying regular expression.

std::vector< const CubitMeshSets * >	getCubitMeshsetPtr (const std::regex reg_exp_name) const
	Get vector of pointer to blocksets with name satisfying regular expression.

MoFEMErrorCode	getEntitiesByDimension (const int ms_id, const unsigned int cubit_bc_type, const int dimension, Range &entities, const bool recursive=true) const
	get entities from CUBIT/meshset of a particular entity dimension

MoFEMErrorCode	getEntitiesByDimension (const int ms_id, const unsigned int cubit_bc_type, Range &entities, const bool recursive=true) const
	get entities related to CUBIT/meshset,

MoFEMErrorCode	getMeshset (const int ms_id, const unsigned int cubit_bc_type, EntityHandle &meshset) const
	get meshset from CUBIT Id and CUBIT type

bool	checkIfMeshsetContainsEntities (const int ms_id, const unsigned int cubit_bc_type, const EntityHandle *entities, int num_entities, const int operation_type=moab::Interface::INTERSECT)
	Check if meshset constains entities.

MoFEMErrorCode	getMeshsetsByType (const unsigned int cubit_bc_type, Range &meshsets) const
	get all CUBIT meshsets by CUBIT type

MoFEMErrorCode	setMeshsetFromFile (const string file_name, const bool clean_file_options=true)
	add blocksets reading config file

MoFEMErrorCode	setMeshsetFromFile ()
	Load meshset configuration from command line specified file.

MoFEMErrorCode	saveMeshsetToFile (const int ms_id, const unsigned int cubit_bc_type, const std::string file_name="out_meshset.vtk", const std::string file_type="VTK", const std::string options="") const
	save cubit meshset entities on the moab mesh

MoFEMErrorCode	saveMeshsetToFile (const int ms_id, const unsigned int cubit_bc_type, const int dim, const std::string file_name="out_meshset.vtk", const bool recursive=false, const std::string file_type="VTK", const std::string options="") const
	save cubit meshset entities on the moab mesh

boost::shared_ptr< boost::program_options::options_description > &	getConfigFileOptionsPtr ()
	Get config file options, use with care.

MoFEMErrorCode	updateAllMeshsetsByEntitiesChildren (const BitRefLevel &bit)
	Update all blocksets, sidesets and node sets.

Public Member Functions inherited from MoFEM::UnknownInterface
template<class IFACE >
MoFEMErrorCode	registerInterface (bool error_if_registration_failed=true)
	Register interface.

template<class IFACE >
MoFEMErrorCode	getInterface (IFACE *&iface) const
	Get interface reference to pointer of interface.

template<class IFACE >
MoFEMErrorCode	getInterface (IFACE **const iface) const
	Get interface pointer to pointer of interface.

template<class IFACE , typename boost::enable_if< boost::is_pointer< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get interface pointer to pointer of interface.

template<class IFACE , typename boost::enable_if< boost::is_reference< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get reference to interface.

template<class IFACE >
IFACE *	getInterface () const
	Function returning pointer to interface.

virtual	~UnknownInterface ()=default

Static Public Member Functions
static MoFEMErrorCode	getTags (moab::Interface &moab, Tag &nsTag, Tag &ssTag, Tag &nsTag_data, Tag &ssTag_data, Tag &bhTag, Tag &bhTag_header, int verb=-1)
	Static version of getTags for external MOAB interface.

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

Static Public Member Functions inherited from MoFEM::UnknownInterface
static MoFEMErrorCode	getLibVersion (Version &version)
	Get library version.

static MoFEMErrorCode	getFileVersion (moab::Interface &moab, Version &version)
	Get database major version.

static MoFEMErrorCode	setFileVersion (moab::Interface &moab, Version version=Version(MoFEM_VERSION_MAJOR, MoFEM_VERSION_MINOR, MoFEM_VERSION_BUILD))
	Get database major version.

static MoFEMErrorCode	getInterfaceVersion (Version &version)
	Get database major version.

Public Attributes
MoFEM::Core &	cOre
	Reference to MoFEM Core interface.

Static Public Attributes
static bool	broadcastMeshsetsOn = true

Protected Attributes
Tag	nsTag

Tag	ssTag

Tag	nsTag_data

Tag	ssTag_data

Tag	bhTag

Tag	bhTag_header

CubitMeshSet_multiIndex	cubitMeshsets
	cubit meshsets

boost::shared_ptr< boost::program_options::options_description >	configFileOptionsPtr
	config file options

Detailed Description

Interface for managing meshsets containing materials and boundary conditions.

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.

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

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

CUBIT/Coreform Meshset Types

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

SIDESET <br>

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

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

Generic Multi-Format Support

The MeshsetsManager approach is not restricted to CUBIT and supports multiple meshing formats:

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

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

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

Typical Multi-Format Workflow

Mesh Import: Load mesh with native format-specific group definitions
Tag Discovery: MeshsetsManager discovers and categorizes existing tags
Meshset Creation: Convert format-specific groups to unified meshset representation
Data Association: Attach material properties and boundary condition data
Validation: Verify meshset consistency and completeness
Problem Setup: Use meshsets for finite element problem definition

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

Examples: /home/lk58p/mofem_install/vanilla_dev_release/mofem-cephas/mofem/users_modules/eshelbian_plasticity/src/impl/EshelbianPlasticity.cpp, ep.cpp, mofem/atom_tests/add_blockset.cpp, mofem/atom_tests/add_cubit_meshsets.cpp, mofem/atom_tests/cubit_bc_test.cpp, mofem/atom_tests/prism_elements_from_surface.cpp, mofem/tools/mesh_cut.cpp, mofem/tools/mesh_smoothing.cpp, mofem/tools/meshset_to_vtk.cpp, mofem/tools/split_sideset.cpp, mofem/tutorials/adv-0_plasticity/plastic.cpp, mofem/tutorials/adv-4_dynamic_first_order_con_law/dynamic_first_order_con_law.cpp, mofem/tutorials/adv-5_poroelasticity/seepage.cpp, mofem/tutorials/cor-0to1_unsaturated_transport/unsaturated_transport.cpp, mofem/tutorials/cor-7_elasticity_mixed_formulation/elasticity_mixed_formulation.cpp, mofem/tutorials/cor-9_reaction_diffusion/reaction_diffusion.cpp, mofem/tutorials/scl-6_heat_equation/heat_equation.cpp, mofem/tutorials/vec-3_nonlinear_dynamics/nonlinear_dynamic_elastic.cpp, mofem/tutorials/vec-5_free_surface/free_surface.cpp, mofem/tutorials/vec-7_shape_optimisation/adjoint.cpp, mofem/users_modules/adolc-plasticity/adolc_plasticity.cpp, mofem/users_modules/basic_finite_elements/elasticity/elasticity.cpp, mofem/users_modules/eshelbian_plasticity/ep.cpp, plastic.cpp, thermo_elastic.cpp, and thermoplastic.cpp.

Definition at line 208 of file MeshsetsManager.hpp.

Constructor & Destructor Documentation

◆ MeshsetsManager()

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

Constructor for MeshsetsManager.

Parameters

core	reference to MoFEM Core interface for accessing mesh and field data

Definition at line 34 of file MeshsetsManager.cpp.

    : cOre(const_cast<Core &>(core)) {
 
  if (!LogManager::checkIfChannelExist("MeshsetMngWorld")) {
    auto core_log = logging::core::get();
 
    core_log->add_sink(
        LogManager::createSink(LogManager::getStrmWorld(), "MeshsetMngWorld"));
    core_log->add_sink(
        LogManager::createSink(LogManager::getStrmSync(), "MeshsetMngSync"));
    core_log->add_sink(
        LogManager::createSink(LogManager::getStrmSelf(), "MeshsetMngSelf"));
 
    LogManager::setLog("MeshsetMngWorld");
    LogManager::setLog("MeshsetMngSync");
    LogManager::setLog("MeshsetMngSelf");
 
    MOFEM_LOG_TAG("MeshsetMngWorld", "MeshsetMng");
    MOFEM_LOG_TAG("MeshsetMngSync", "MeshsetMng");
    MOFEM_LOG_TAG("MeshsetMngSelf", "MeshsetMng");
  }
 
  MOFEM_LOG("MeshsetMngWorld", Sev::noisy) << "Mashset manager created";
}

◆ ~MeshsetsManager()

virtual MoFEM::MeshsetsManager::~MeshsetsManager ( )

virtualdefault

Member Function Documentation

◆ checkIfMeshsetContainsEntities()

bool MoFEM::MeshsetsManager::checkIfMeshsetContainsEntities	(	const int	ms_id,
		const unsigned int	cubit_bc_type,
		const EntityHandle *	entities,
		int	num_entities,
		const int	operation_type = `moab::Interface::INTERSECT`
	)

Check if meshset constains entities.

Parameters

ms_id
cubit_bc_type
entities
num_entities
operation_type

Returns: true; false

Definition at line 737 of file MeshsetsManager.cpp.

                                                                              {
  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()) {
    Interface &m_field = cOre;
    return m_field.get_moab().contains_entities(miit->meshset, entities,
                                                num_entities, operation_type);
  } else
    return false;
}

◆ get_bhTag()

Tag MoFEM::MeshsetsManager::get_bhTag ( ) const

inline

get tag handle used to store "id" of BLOCKSET

Definition at line 284 of file MeshsetsManager.hpp.

284{ return bhTag; }

MoFEM::MeshsetsManager::bhTag

Tag bhTag

Definition MeshsetsManager.hpp:1145

◆ get_bhTag_header()

Tag MoFEM::MeshsetsManager::get_bhTag_header ( ) const

inline

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

Definition at line 289 of file MeshsetsManager.hpp.

289{ return bhTag_header; }

MoFEM::MeshsetsManager::bhTag_header

Tag bhTag_header

Definition MeshsetsManager.hpp:1146

◆ get_meshsets_manager_ptr() [1/2]

MeshsetsManager * MoFEM::MeshsetsManager::get_meshsets_manager_ptr ( )

inline

return pointer to meshset manager

Definition at line 294 of file MeshsetsManager.hpp.

294{ return this; }

◆ get_meshsets_manager_ptr() [2/2]

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

inline

return pointer to meshset manager

Definition at line 299 of file MeshsetsManager.hpp.

299{ return this; }

◆ get_nsTag()

Tag MoFEM::MeshsetsManager::get_nsTag ( ) const

inline

get tag handle used to store "id" of NODESET

Definition at line 264 of file MeshsetsManager.hpp.

264{ return nsTag; }

MoFEM::MeshsetsManager::nsTag

Tag nsTag

Definition MeshsetsManager.hpp:1141

◆ get_nsTag_data()

Tag MoFEM::MeshsetsManager::get_nsTag_data ( ) const

inline

get tag handle used to store boundary data on NODESET

Definition at line 274 of file MeshsetsManager.hpp.

274{ return nsTag_data; }

MoFEM::MeshsetsManager::nsTag_data

Tag nsTag_data

Definition MeshsetsManager.hpp:1143

◆ get_ssTag()

Tag MoFEM::MeshsetsManager::get_ssTag ( ) const

inline

get tag handle used to store "id" of SIDESET

Definition at line 269 of file MeshsetsManager.hpp.

269{ return ssTag; }

MoFEM::MeshsetsManager::ssTag

Tag ssTag

Definition MeshsetsManager.hpp:1142

◆ get_ssTag_data()

Tag MoFEM::MeshsetsManager::get_ssTag_data ( ) const

inline

get tag handle used to store boundary data on SIDESET

Definition at line 279 of file MeshsetsManager.hpp.

279{ return ssTag_data; }

MoFEM::MeshsetsManager::ssTag_data

Tag ssTag_data

Definition MeshsetsManager.hpp:1144

◆ getConfigFileOptionsPtr()

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

inline

Get config file options, use with care.

Returns: error code

Definition at line 1123 of file MeshsetsManager.hpp.

                            {
    return configFileOptionsPtr;
  }

◆ getMeshsetsMultindex()

CubitMeshSet_multiIndex & MoFEM::MeshsetsManager::getMeshsetsMultindex ( )

inline

Examples: mofem/tools/meshset_to_vtk.cpp.

Definition at line 421 of file MeshsetsManager.hpp.

                                                         {
    return cubitMeshsets;
  }

◆ printBcSet()

template<class CUBIT_BC_DATA_TYPE >

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

Definition at line 1156 of file MeshsetsManager.hpp.

                                                                         {
  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);
}

◆ query_interface()

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

virtual

Query interface for MeshsetsManager.

Parameters

type_index	type index for the interface to query
iface	pointer to store the interface

Returns: MoFEMErrorCode Error code indicating success or failure

Implements MoFEM::UnknownInterface.

Definition at line 28 of file MeshsetsManager.cpp.

                                                                 {
  *iface = const_cast<MeshsetsManager *>(this);
  return 0;
}

◆ saveMeshsetToFile() [1/2]

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

save cubit meshset entities on the moab mesh

Parameters

ms_id	id of the cubit meshset
cubit_bc_type	type of a cubit mesheset (NODESET SIDESET BLOCKSET)
dim	dimension of the entities
file_name	optional name for the file
file_type	optional file type for moab (VTK MOAB)
options	optional parameters for moab writer (PARALLEL=WRITE_PART)

Returns: MoFEMErrorCode

Definition at line 1487 of file MeshsetsManager.cpp.

                                                              {
 
  MoFEMFunctionBegin;
  MoFEM::Interface &m_field = cOre;
  moab::Interface &moab = m_field.get_moab();
  Range entities;
  CHKERR getEntitiesByDimension(ms_id, cubit_bc_type, dim, entities, recursive);
  EntityHandle meshset;
  CHKERR moab.create_meshset(MESHSET_SET, meshset);
  CHKERR moab.add_entities(meshset, entities);
  CHKERR moab.write_file(file_name.c_str(), file_type.c_str(), options.c_str(),
                         &meshset, 1);
  CHKERR moab.delete_entities(&meshset, 1);
  MoFEMFunctionReturn(0);
}

◆ saveMeshsetToFile() [2/2]

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

save cubit meshset entities on the moab mesh

Parameters

ms_id	id of the cubit meshset (NODESET SIDESET BLOCKSET)
cubit_bc_type	type of a cubit mesheset
file_name	optional name for the file
file_type	optional file type for moab (VTK MOAB)
options	optional parameters for moab writer (PARALLEL=WRITE_PART)

Returns: MoFEMErrorCode

Examples: mofem/tools/meshset_to_vtk.cpp.

Definition at line 1472 of file MeshsetsManager.cpp.

                                   {
 
  MoFEMFunctionBegin;
  MoFEM::Interface &m_field = cOre;
  const CubitMeshSets *cubit_meshset_ptr;
  CHKERR getCubitMeshsetPtr(ms_id, cubit_bc_type, &cubit_meshset_ptr);
  EntityHandle meshset = cubit_meshset_ptr->getMeshset();
  CHKERR m_field.get_moab().write_file(file_name.c_str(), file_type.c_str(),
                                       options.c_str(), &meshset, 1);
  MoFEMFunctionReturn(0);
}

◆ setAtributes()

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

inline

Definition at line 663 of file MeshsetsManager.hpp.

                                                                 {
    return setAttributes(cubit_bc_type, ms_id,
                         std::vector<double>(attributes), name);
  }

◆ setAtributesByDataStructure()

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

inline

Examples: mofem/atom_tests/add_cubit_meshsets.cpp.

Definition at line 690 of file MeshsetsManager.hpp.

                                                                   {
    return setAttributesByDataStructure(cubit_bc_type, ms_id, data, name);
  }

◆ setMeshsetFromFile()

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

add blocksets reading config file

Example of config file

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

Parameters

file_name	path to configuration file containing meshset definitions
clean_file_options	whether to clean existing file options before loading

Returns: MoFEMErrorCode Error code indicating success or failure

Examples: mofem/atom_tests/add_cubit_meshsets.cpp, mofem/tools/meshset_to_vtk.cpp, and mofem/tutorials/cor-0to1_unsaturated_transport/unsaturated_transport.cpp.

Definition at line 802 of file MeshsetsManager.cpp.

                                                                            {
  Interface &m_field = cOre;
  MoFEMFunctionBegin;
  std::ifstream ini_file(file_name.c_str(), std::ifstream::in);
  po::variables_map vm;
  if (clean_file_options) {
    configFileOptionsPtr =
        boost::shared_ptr<boost::program_options::options_description>(
            new po::options_description());
  }
 
  auto add_block_attributes = [&](auto prefix, auto &block_lists, auto &it) {
    // remove spacec from blockset name
    configFileOptionsPtr->add_options()(
        (prefix + ".number_of_attributes").c_str(),
        po::value<int>(&block_lists[it->getMeshsetId()].numberOfAttributes)
            ->default_value(-1),
        "Number of blockset attribute");
    for (int ii = 1; ii <= 10; ii++) {
      std::string surfix = ".user" + boost::lexical_cast<std::string>(ii);
      configFileOptionsPtr->add_options()(
          (prefix + surfix).c_str(),
          po::value<double>(&block_lists[it->getMeshsetId()].aTtr[ii - 1])
              ->default_value(0.0),
          "Add block attribute");
    }
  };
 
  // Add blocks
  map<int, BlockData> block_lists;
  for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(m_field, BLOCKSET, it)) {
    const auto id = it->getMeshsetId();
    block_lists[id].cubitMeshset = it->getMeshset();
    std::string prefix =
        "block_" + boost::lexical_cast<std::string>(id);
    configFileOptionsPtr->add_options()(
        (prefix + ".add").c_str(),
        po::value<string>(&block_lists[it->getMeshsetId()].addType)
            ->default_value("UNKNOWNSET"),
        "Add block set")(
        (prefix + ".id").c_str(),
        po::value<int>(&block_lists[it->getMeshsetId()].iD)->default_value(-1),
        "Id of meshset")(
        (prefix + ".name").c_str(),
        po::value<string>(&block_lists[it->getMeshsetId()].nAme)
            ->default_value(""),
        "Name of the meshset");
 
    // Block attributes
    add_block_attributes(prefix, block_lists, it);
 
    // Mat elastic
    {
      // double Young;          ///< Young's modulus
      // double Poisson;        ///< Poisson's ratio
      // double ThermalExpansion;   ///< Thermal expansion
      configFileOptionsPtr->add_options()(
          (prefix + ".young").c_str(),
          po::value<double>()->default_value(-1)->notifier(
              [&block_lists, id](double v) {
                block_lists[id].matElastic.data.Young = v;
              }),
          "Young modulus")(
          (prefix + ".poisson").c_str(),
          po::value<double>()->default_value(-2)->notifier(
              [&block_lists, id](double v) {
                block_lists[id].matElastic.data.Poisson = v;
              }),
          "Poisson ratio")(
          (prefix + ".thermalexpansion").c_str(),
          po::value<double>()->default_value(-1)->notifier(
              [&block_lists, id](double v) {
                block_lists[id].matElastic.data.ThermalExpansion = v;
              }),
          "Thermal expansion");
      // TODO Add users parameters
    }
    // Mat Trans Iso
    {
      // Young's modulus in xy plane (Ep)
      // Young's modulus in z-direction (Ez)
      // Poisson's ratio in xy plane (vp)
      // Poisson's ratio in z-direction (vpz)
      // Shear modulus in z-direction (Gzp)
      configFileOptionsPtr->add_options()(
          (prefix + ".Youngp").c_str(),
          po::value<double>()->default_value(-1)->notifier(
              [&block_lists, id](double v) {
                block_lists[id].matTransIso.data.Youngp = v;
              }),
          "Youngp")(
          (prefix + ".Youngz").c_str(),
          po::value<double>()->default_value(-1)->notifier(
              [&block_lists, id](double v) {
                block_lists[id].matTransIso.data.Youngz = v;
              }),
          "Youngz")(
          (prefix + ".Poissonp").c_str(),
          po::value<double>()->default_value(0)->notifier(
              [&block_lists, id](double v) {
                block_lists[id].matTransIso.data.Poissonp = v;
              }),
          "Poissonp")(
          (prefix + ".Poissonpz").c_str(),
          po::value<double>()->default_value(0)->notifier(
              [&block_lists, id](double v) {
                block_lists[id].matTransIso.data.Poissonpz = v;
              }),
          "Poissonpz")(
          (prefix + ".Shearzp").c_str(),
          po::value<double>()->default_value(-1)->notifier(
              [&block_lists, id](double v) {
                block_lists[id].matTransIso.data.Shearzp = v;
              }),
          "Shearzp");
      // TODO Add users parameters
    }
    // Mat thermal
    {
      // double Conductivity; ///< Thermal conductivity
      // double HeatCapacity; ///< Heat Capacity
      configFileOptionsPtr->add_options()(
          (prefix + ".conductivity").c_str(),
          po::value<double>()->default_value(-1)->notifier(
              [&block_lists, id](double v) {
                block_lists[id].matThermal.data.Conductivity = v;
              }),
          "Conductivity")(
          (prefix + ".capacity").c_str(),
          po::value<double>()->default_value(-1)->notifier(
              [&block_lists, id](double v) {
                block_lists[id].matThermal.data.HeatCapacity = v;
              }),
          "Capacity");
      // TODO Add users parameters
    }
    // Mat interface
    {
      // double alpha; ///< Elastic modulus multiplier
      // double beta;  ///< Damage Coupling multiplier between normal and
      // shear (g=sqrt(gn^2 + beta(gt1^2 + gt2^2))) double ft;    ///< Maximum
      // stress of crack double Gf;    ///< Fracture Energy
      configFileOptionsPtr->add_options()(
          (prefix + ".interface_alpha").c_str(),
          po::value<double>()->default_value(-1)->notifier(
              [&block_lists, id](double v) {
                block_lists[id].matInterf.data.alpha = v;
              }),
          "alpha")((prefix + ".interface_beta").c_str(),
                   po::value<double>()->default_value(-1)->notifier(
                       [&block_lists, id](double v) {
                         block_lists[id].matInterf.data.beta = v;
                       }),
                   "beta")(
          (prefix + ".interface_ft").c_str(),
          po::value<double>()->default_value(-1)->notifier(
              [&block_lists, id](double v) {
                block_lists[id].matInterf.data.ft = v;
              }),
          "ft")(
          (prefix + ".interface_Gf").c_str(),
          po::value<double>()->default_value(-1)->notifier(
              [&block_lists, id](double v) {
                block_lists[id].matInterf.data.Gf = v;
              }),
          "Gf");
      // TODO Add users parameters
    }
 
    // Displacement bc
    {
      // char flag1; //< Flag for X-Translation (0: N/A, 1: specified)
      // char flag2; //< Flag for Y-Translation (0: N/A, 1: specified)
      // char flag3; //< Flag for Z-Translation (0: N/A, 1: specified)
      // char flag4; //< Flag for X-Rotation (0: N/A, 1: specified)
      // char flag5; //< Flag for Y-Rotation (0: N/A, 1: specified)
      // char flag6; //< Flag for Z-Rotation (0: N/A, 1: specified)
      // double value1; //< Value for X-Translation
      // double value2; //< Value for Y-Translation
      // double value3; //< Value for Z-Translation
      // double value4; //< Value for X-Rotation
      // double value5; //< Value for Y-Rotation
      // double value6; //< Value for Z-Rotation
      configFileOptionsPtr->add_options()(
          (prefix + ".disp_flag1").c_str(),
          po::value<char>()->default_value(0)->notifier(
              [&block_lists, id](char v) {
                block_lists[id].dispBc.data.flag1 = v;
              }),
          "flag1")(
          (prefix + ".disp_flag2").c_str(),
          po::value<char>()->default_value(0)->notifier(
              [&block_lists, id](char v) {
                block_lists[id].dispBc.data.flag2 = v;
              }),
          "flag2")(
          (prefix + ".disp_flag3").c_str(),
          po::value<char>()->default_value(0)->notifier(
              [&block_lists, id](char v) {
                block_lists[id].dispBc.data.flag3 = v;
              }),
          "flag3")(
          (prefix + ".disp_flag4").c_str(),
          po::value<char>()->default_value(0)->notifier(
              [&block_lists, id](char v) {
                block_lists[id].dispBc.data.flag4 = v;
              }),
          "flag4")(
          (prefix + ".disp_flag5").c_str(),
          po::value<char>()->default_value(0)->notifier(
              [&block_lists, id](char v) {
                block_lists[id].dispBc.data.flag5 = v;
              }),
          "flag5")(
          (prefix + ".disp_flag6").c_str(),
          po::value<char>()->default_value(0)->notifier(
              [&block_lists, id](char v) {
                block_lists[id].dispBc.data.flag6 = v;
              }),
          "flag6")(
          (prefix + ".disp_ux").c_str(),
          po::value<double>()->default_value(0)->notifier(
              [&block_lists, id](double v) {
                block_lists[id].dispBc.data.value1 = v;
              }),
          "value1")(
          (prefix + ".disp_uy").c_str(),
          po::value<double>()->default_value(0)->notifier(
              [&block_lists, id](double v) {
                block_lists[id].dispBc.data.value2 = v;
              }),
          "value2")(
          (prefix + ".disp_uz").c_str(),
          po::value<double>()->default_value(0)->notifier(
              [&block_lists, id](double v) {
                block_lists[id].dispBc.data.value3 = v;
              }),
          "value3")(
          (prefix + ".disp_rx").c_str(),
          po::value<double>()->default_value(0)->notifier(
              [&block_lists, id](double v) {
                block_lists[id].dispBc.data.value4 = v;
              }),
          "value4")(
          (prefix + ".disp_ry").c_str(),
          po::value<double>()->default_value(0)->notifier(
              [&block_lists, id](double v) {
                block_lists[id].dispBc.data.value5 = v;
              }),
          "value5")(
          (prefix + ".disp_rz").c_str(),
          po::value<double>()->default_value(0)->notifier(
              [&block_lists, id](double v) {
                block_lists[id].dispBc.data.value6 = v;
              }),
          "value6");
    }
    // Force BC data
    {
      // char zero[3]; //< 3 zeros
      // double value1; //< Force magnitude
      // double value2; //< Moment magnitude
      // double value3; //< X-component of force direction vector
      // double value4; //< Y-component of force direction vector
      // double value5; //< Z-component of force direction vector
      // double value6; //< X-component of moment direction vector
      // double value7; //< Y-component of moment direction vector
      // double value8; //< Z-component of moment direction vector
      // char zero2; // 0
      configFileOptionsPtr->add_options()(
          (prefix + ".force_magnitude").c_str(),
          po::value<double>()->default_value(0)->notifier(
              [&block_lists, id](double v) {
                block_lists[id].forceBc.data.value1 = v;
              }),
          "value1")((prefix + ".moment_magnitude").c_str(),
                    po::value<double>()->default_value(0)->notifier(
                        [&block_lists, id](double v) {
                          block_lists[id].forceBc.data.value2 = v;
                        }),
                    "value2")(
          (prefix + ".force_fx").c_str(),
          po::value<double>()->default_value(0)->notifier(
              [&block_lists, id](double v) {
                block_lists[id].forceBc.data.value3 = v;
              }),
          "value3")((prefix + ".force_fy").c_str(),
                    po::value<double>()->default_value(0)->notifier(
                        [&block_lists, id](double v) {
                          block_lists[id].forceBc.data.value4 = v;
                        }),
                    "value4")(
          (prefix + ".force_fz").c_str(),
          po::value<double>()->default_value(0)->notifier(
              [&block_lists, id](double v) {
                block_lists[id].forceBc.data.value5 = v;
              }),
          "value5")((prefix + ".moment_mx").c_str(),
                    po::value<double>()->default_value(0)->notifier(
                        [&block_lists, id](double v) {
                          block_lists[id].forceBc.data.value6 = v;
                        }),
                    "value6")(
          (prefix + ".moment_my").c_str(),
          po::value<double>()->default_value(0)->notifier(
              [&block_lists, id](double v) {
                block_lists[id].forceBc.data.value7 = v;
              }),
          "value7")((prefix + ".moment_mz").c_str(),
                    po::value<double>()->default_value(0)->notifier(
                        [&block_lists, id](double v) {
                          block_lists[id].forceBc.data.value8 = v;
                        }),
                    "value8");
    }
    {
      // char name[11]; //< 11 characters for "Temperature"
      // char pre1; //< This is always zero
      // char pre2; //< 0: temperature is not applied on thin shells
      // (default); 1: temperature is applied on thin shells char flag1; //<
      // 0: N/A, 1: temperature value applied (not on thin shells) char flag2;
      // //< 0: N/A, 1: temperature applied on thin shell middle char flag3;
      // //< 0: N/A, 1: thin shell temperature gradient specified char flag4;
      // //< 0: N/A, 1: top thin shell temperature char flag5; //< 0: N/A, 1:
      // bottom thin shell temperature char flag6; //< This is always zero
      // double value1; //< Temperature (default case - no thin shells)
      // double value2; //< Temperature for middle of thin shells
      // double value3; //< Temperature gradient for thin shells
      // double value4; //< Temperature for top of thin shells
      // double value5; //< Temperature for bottom of thin shells
      // double value6; //< This is always zero, i.e. ignore
      configFileOptionsPtr->add_options()(
          (prefix + ".temperature_flag1").c_str(),
          po::value<char>()->default_value(0)->notifier(
              [&block_lists, id](char v) {
                block_lists[id].temperatureBc.data.flag1 = v;
              }),
          "flag1")(
          (prefix + ".temperature_t").c_str(),
          po::value<double>()->default_value(0)->notifier(
              [&block_lists, id](double v) {
                block_lists[id].temperatureBc.data.value1 = v;
              }),
          "value1");
      // TODO: Add more cases, see above
    }
    // Sideset
    {
      // char name[8];   //< 8 characters for "Pressure"
      // char zero;      //< This is always zero
      // char flag2;     //< 0: Pressure is interpreted as pure pressure 1:
      // pressure is interpreted as total force double value1;  //< Pressure
      // value
      configFileOptionsPtr->add_options()(
          (prefix + ".pressure_flag2").c_str(),
          po::value<char>()->default_value(0)->notifier(
              [&block_lists, id](char v) {
                block_lists[id].pressureBc.data.flag2 = v;
              }),
          "flag2")((prefix + ".pressure_magnitude").c_str(),
                   po::value<double>()->default_value(0)->notifier(
                       [&block_lists, id](double v) {
                         block_lists[id].pressureBc.data.value1 = v;
                       }),
                   "value1");
    }
    {
      // char name[8]; //< 8 characters for "HeatFlux" (no space)
      // char pre1; //< This is always zero
      // char pre2; //< 0: heat flux is not applied on thin shells (default);
      // 1: heat flux is applied on thin shells char flag1; //< 0: N/A, 1:
      // normal heat flux case (i.e. single value, case without thin shells)
      // char flag2; //< 0: N/A, 1: Thin shell top heat flux specified
      // char flag3; //< 0: N/A, 1: Thin shell bottom heat flux specidied
      // double value1; //< Heat flux value for default case (no thin shells)
      // double value2; //< Heat flux (thin shell top)
      // double value3; //< Heat flux (thin shell bottom)
      configFileOptionsPtr->add_options()(
          (prefix + ".heatflux_flag1").c_str(),
          po::value<char>()->default_value(0)->notifier(
              [&block_lists, id](char v) {
                block_lists[id].heatFluxBc.data.flag1 = v;
              }),
          "flag1")((prefix + ".heatflux_magnitude").c_str(),
                   po::value<double>()->default_value(0)->notifier(
                       [&block_lists, id](double v) {
                         block_lists[id].heatFluxBc.data.value1 = v;
                       }),
                   "value1");
    }
    // Interface set
    {
      configFileOptionsPtr->add_options()(
          (prefix + ".interface_type").c_str(),
          po::value<char>()->default_value(0)->notifier(
              [&block_lists, id](char v) {
                block_lists[id].cfgBc.data.type = v;
              }),
          "type");
    }
  }
 
  map<int, BlockData> block_set_attributes;
  for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(m_field, BLOCKSET, it)) {
    block_set_attributes[it->getMeshsetId()].cubitMeshset = it->getMeshset();
    block_set_attributes[it->getMeshsetId()].iD = it->getMeshsetId();
    block_set_attributes[it->getMeshsetId()].bcType = BLOCKSET;
    std::string block_name = it->getName();
    block_name.erase(
        std::remove_if(block_name.begin(), block_name.end(), ::isspace),
        block_name.end());
    block_set_attributes[it->getMeshsetId()].nAme = block_name;
    // Only blocks which have name
    if (block_name.compare("NoNameSet") != 0) {
      std::string prefix = "SET_ATTR_" + block_name;
      // Block attributes
      add_block_attributes(prefix, block_set_attributes, it);
    }
  }
 
  po::parsed_options parsed =
      parse_config_file(ini_file, *configFileOptionsPtr, true);
  store(parsed, vm);
  po::notify(vm);
 
  // Set type from name
  for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(m_field, BLOCKSET, it)) {
 
    CubitBCType bc_type;
    unsigned jj = 0;
    while (1 << jj != LASTSET_BC) {
      if (string(CubitBCNames[jj + 1]) ==
          block_lists[it->getMeshsetId()].addType) {
        bc_type = 1 << jj;
      }
      ++jj;
    }
    if (bc_type.none()) {
      block_lists[it->getMeshsetId()].bcType = UNKNOWNSET;
      // Skip the bockset nothing is defined for it
      continue;
    }
 
    if (bc_type.to_ulong() == BLOCKSET)
      block_lists[it->getMeshsetId()].bcType = BLOCKSET;
    else if (bc_type.to_ulong() == NODESET)
      block_lists[it->getMeshsetId()].bcType = NODESET;
    else if (bc_type.to_ulong() == SIDESET)
      block_lists[it->getMeshsetId()].bcType = SIDESET;
    else {
      SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
               "Not yet implemented type %s\n",
               block_lists[it->getMeshsetId()].addType.c_str());
    }
    if (block_lists[it->getMeshsetId()].iD == -1) {
      SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
               "Unset iD number %d\n", block_lists[it->getMeshsetId()].iD);
    }
  }
 
  std::vector<std::string> additional_parameters;
  additional_parameters =
      collect_unrecognized(parsed.options, po::include_positional);
  for (std::vector<std::string>::iterator vit = additional_parameters.begin();
       vit != additional_parameters.end(); vit++) {
    MOFEM_LOG_C("MeshsetMngSelf", Sev::warning, "Unrecognized option %s",
                vit->c_str());
  }
  for (map<int, BlockData>::iterator mit = block_lists.begin();
       mit != block_lists.end(); mit++) {
    CubitMeshSet_multiIndex::iterator cubit_meshset_it =
        cubitMeshsets.find(mit->second.cubitMeshset);
    if (cubit_meshset_it == cubitMeshsets.end()) {
      SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
              "Data inconsistency\n");
    }
    switch (mit->second.bcType) {
    case UNKNOWNSET:
      break;
    case BLOCKSET: {
      if ((CubitBCType(mit->second.bcType) & cubit_meshset_it->getBcType())
              .any() &&
          mit->second.iD == cubit_meshset_it->getMeshsetId()) {
        // Meshset is the same, only modification
      } else {
        CHKERR addMeshset(mit->second.bcType, mit->second.iD, mit->second.nAme);
        EntityHandle meshset = cubit_meshset_it->getMeshset();
        CHKERR addEntitiesToMeshset(mit->second.bcType, mit->second.iD,
                                    &meshset, 1);
      }
      // Add attributes
      CHKERR setAttributes(mit->second.bcType, mit->second.iD, mit->second.aTtr);
      // Add material elastic data if value are physical (i.e. Young > 0,
      // Poisson in (-1.0.5) and ThermalExpansion>0)
      if (mit->second.matElastic.data.Young != -1) {
        CHKERR setAttributesByDataStructure(mit->second.bcType, mit->second.iD,
                                           mit->second.matElastic);
      }
      if (mit->second.matTransIso.data.Youngp != -1) {
        CHKERR setAttributesByDataStructure(mit->second.bcType, mit->second.iD,
                                           mit->second.matTransIso);
      }
      if (mit->second.matThermal.data.Conductivity != -1) {
        CHKERR setAttributesByDataStructure(mit->second.bcType, mit->second.iD,
                                           mit->second.matThermal);
      }
      if (mit->second.matInterf.data.ft != -1) {
        CHKERR setAttributesByDataStructure(mit->second.bcType, mit->second.iD,
                                           mit->second.matInterf);
      }
    } break;
    case NODESET: {
      if ((CubitBCType(mit->second.bcType) & cubit_meshset_it->getBcType())
              .any() &&
          mit->second.iD == cubit_meshset_it->getMeshsetId()) {
        // Meshset is the same, only modification
      } else {
        CHKERR addMeshset(mit->second.bcType, mit->second.iD);
        EntityHandle meshset = cubit_meshset_it->getMeshset();
        CHKERR addEntitiesToMeshset(mit->second.bcType, mit->second.iD,
                                    &meshset, 1);
      }
      // Add displacement bc
      if (mit->second.dispBc.data.flag1 || mit->second.dispBc.data.flag2 ||
          mit->second.dispBc.data.flag3 || mit->second.dispBc.data.flag4 ||
          mit->second.dispBc.data.flag5 || mit->second.dispBc.data.flag6) {
        if (mit->second.dispBc.data.flag1 == '0')
          mit->second.dispBc.data.flag1 = 0;
        if (mit->second.dispBc.data.flag1 == 'N')
          mit->second.dispBc.data.flag1 = 0;
        if (mit->second.dispBc.data.flag1)
          mit->second.dispBc.data.flag1 = 1;
        if (mit->second.dispBc.data.flag2 == '0')
          mit->second.dispBc.data.flag2 = 0;
        if (mit->second.dispBc.data.flag2 == 'N')
          mit->second.dispBc.data.flag2 = 0;
        if (mit->second.dispBc.data.flag2)
          mit->second.dispBc.data.flag2 = 1;
        if (mit->second.dispBc.data.flag3 == '0')
          mit->second.dispBc.data.flag3 = 0;
        if (mit->second.dispBc.data.flag3 == 'N')
          mit->second.dispBc.data.flag3 = 0;
        if (mit->second.dispBc.data.flag3)
          mit->second.dispBc.data.flag3 = 1;
        if (mit->second.dispBc.data.flag4 == '0')
          mit->second.dispBc.data.flag4 = 0;
        if (mit->second.dispBc.data.flag4 == 'N')
          mit->second.dispBc.data.flag4 = 0;
        if (mit->second.dispBc.data.flag4)
          mit->second.dispBc.data.flag4 = 1;
        if (mit->second.dispBc.data.flag5 == '0')
          mit->second.dispBc.data.flag5 = 0;
        if (mit->second.dispBc.data.flag5 == 'N')
          mit->second.dispBc.data.flag5 = 0;
        if (mit->second.dispBc.data.flag5)
          mit->second.dispBc.data.flag5 = 1;
        if (mit->second.dispBc.data.flag6 == '0')
          mit->second.dispBc.data.flag6 = 0;
        if (mit->second.dispBc.data.flag6 == 'N')
          mit->second.dispBc.data.flag6 = 0;
        if (mit->second.dispBc.data.flag6)
          mit->second.dispBc.data.flag6 = 1;
        CHKERR setBcData(mit->second.bcType, mit->second.iD,
                         mit->second.dispBc);
      }
      if (mit->second.forceBc.data.value1 != 0 ||
          mit->second.forceBc.data.value2 != 0) {
        CHKERR setBcData(mit->second.bcType, mit->second.iD,
                         mit->second.forceBc);
      }
      // Add temperature boundary condition
      if (mit->second.temperatureBc.data.flag1) {
        if (mit->second.temperatureBc.data.flag1 == '0')
          mit->second.temperatureBc.data.flag1 = 0;
        if (mit->second.temperatureBc.data.flag1 == 'N')
          mit->second.temperatureBc.data.flag1 = 0;
        if (mit->second.temperatureBc.data.flag1)
          mit->second.temperatureBc.data.flag1 = 1;
        CHKERR setBcData(mit->second.bcType, mit->second.iD,
                         mit->second.temperatureBc);
      }
    } break;
    case SIDESET: {
      if ((CubitBCType(mit->second.bcType) & cubit_meshset_it->getBcType())
              .any() &&
          mit->second.iD == cubit_meshset_it->getMeshsetId()) {
        // Meshset is the same, only modification
      } else {
        CHKERR addMeshset(mit->second.bcType, mit->second.iD);
        EntityHandle meshset = cubit_meshset_it->getMeshset();
        CHKERR addEntitiesToMeshset(mit->second.bcType, mit->second.iD,
                                    &meshset, 1);
      }
      // Add pressure
      if (mit->second.pressureBc.data.value1 != 0) {
        if (mit->second.pressureBc.data.flag2 == '0')
          mit->second.pressureBc.data.flag2 = 0;
        if (mit->second.pressureBc.data.flag2 == 'N')
          mit->second.pressureBc.data.flag2 = 0;
        if (mit->second.pressureBc.data.flag2)
          mit->second.pressureBc.data.flag2 = 1;
        CHKERR setBcData(mit->second.bcType, mit->second.iD,
                         mit->second.pressureBc);
      }
      // Add heat flux
      if (mit->second.heatFluxBc.data.value1 != 0) {
        if (mit->second.heatFluxBc.data.flag1 == '0')
          mit->second.heatFluxBc.data.flag1 = 0;
        if (mit->second.heatFluxBc.data.flag1 == 'N')
          mit->second.heatFluxBc.data.flag1 = 0;
        if (mit->second.heatFluxBc.data.flag1)
          mit->second.heatFluxBc.data.flag1 = 1;
        CHKERR setBcData(mit->second.bcType, mit->second.iD,
                         mit->second.heatFluxBc);
      }
      // Add Interface
      if (mit->second.cfgBc.data.type != 0) {
        CHKERR setBcData(mit->second.bcType, mit->second.iD, mit->second.cfgBc);
      }
    } break;
    default:
      SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
              "Not yet implemented type\n");
    }
  }
 
  for (auto set_attr : block_set_attributes) {
    // Add attributes
    if (set_attr.second.numberOfAttributes > 0) {
      MOFEM_LOG("MeshsetMngSelf", Sev::verbose)
          << "Set attributes to blockset " << set_attr.second.nAme;
      set_attr.second.aTtr.resize(set_attr.second.numberOfAttributes);
      CHKERR setAttributes(set_attr.second.bcType, set_attr.second.iD,
                          set_attr.second.aTtr);
    }
  }
 
  MoFEMFunctionReturn(0);
}

◆ sortMeshsets()

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

static

Definition at line 12 of file MeshsetsManager.cpp.

                                               {
  std::sort(vec_ptr.begin(), vec_ptr.end(),
            [](const CubitMeshSets *a, const CubitMeshSets *b) {
              if (a->getBcType().to_ullong() < b->getBcType().to_ullong())
                return true;
              if (a->getBcType().to_ullong() > b->getBcType().to_ullong())
                return false;
              else
                return a->getMeshsetId() < b->getMeshsetId();
            });
}

◆ updateAllMeshsetsByEntitiesChildren()

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

Update all blocksets, sidesets and node sets.

Parameters

bit

Returns: MoFEMErrorCode

Examples: thermoplastic.cpp.

Definition at line 1507 of file MeshsetsManager.cpp.

                                                                           {
  MoFEMFunctionBegin;
  BitRefManager *bit_mng = cOre.getInterface<BitRefManager>();
  for (_IT_CUBITMESHSETS_FOR_LOOP_((*this), iit)) {
    EntityHandle meshset = iit->getMeshset();
    for (EntityType t = MBVERTEX; t != MBENTITYSET; ++t)
      CHKERR bit_mng->updateMeshsetByEntitiesChildren(meshset, bit, meshset, t,
                                                      true);
  }
  MoFEMFunctionReturn(0);
}

Member Data Documentation

◆ bhTag

Tag MoFEM::MeshsetsManager::bhTag

protected

Definition at line 1145 of file MeshsetsManager.hpp.

◆ bhTag_header

Tag MoFEM::MeshsetsManager::bhTag_header

protected

Definition at line 1146 of file MeshsetsManager.hpp.

◆ broadcastMeshsetsOn

bool MoFEM::MeshsetsManager::broadcastMeshsetsOn = true

static

if true meshsets are synchronised between processors

Definition at line 1135 of file MeshsetsManager.hpp.

◆ configFileOptionsPtr

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

protected

config file options

Definition at line 1151 of file MeshsetsManager.hpp.

◆ cOre

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

Reference to MoFEM Core interface.

Definition at line 220 of file MeshsetsManager.hpp.

◆ cubitMeshsets

CubitMeshSet_multiIndex MoFEM::MeshsetsManager::cubitMeshsets

protected

cubit meshsets

Definition at line 1149 of file MeshsetsManager.hpp.

◆ nsTag

Tag MoFEM::MeshsetsManager::nsTag

protected

Definition at line 1141 of file MeshsetsManager.hpp.

◆ nsTag_data

Tag MoFEM::MeshsetsManager::nsTag_data

protected

Definition at line 1143 of file MeshsetsManager.hpp.

◆ ssTag

Tag MoFEM::MeshsetsManager::ssTag

protected

Definition at line 1142 of file MeshsetsManager.hpp.

◆ ssTag_data

Tag MoFEM::MeshsetsManager::ssTag_data

protected

Definition at line 1144 of file MeshsetsManager.hpp.

The documentation for this struct was generated from the following files:

src/interfaces/MeshsetsManager.hpp
src/interfaces/impl/MeshsetsManager.cpp

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Attributes

Detailed Description

Connection to BcManager

MOAB Meshset Integration

CUBIT/Coreform Meshset Types

NODESET

SIDESET <br>

BLOCKSET

Generic Multi-Format Support

Gmsh Integration

Salome/MED Format Support

Other Format Support

Typical Multi-Format Workflow

Key Capabilities

Constructor & Destructor Documentation

◆ MeshsetsManager()

◆ ~MeshsetsManager()

Member Function Documentation

◆ checkIfMeshsetContainsEntities()

◆ get_bhTag()

◆ get_bhTag_header()

◆ get_meshsets_manager_ptr() [1/2]

◆ get_meshsets_manager_ptr() [2/2]

◆ get_nsTag()

◆ get_nsTag_data()

◆ get_ssTag()

◆ get_ssTag_data()

◆ getConfigFileOptionsPtr()

◆ getMeshsetsMultindex()

◆ printBcSet()

◆ query_interface()

◆ saveMeshsetToFile() [1/2]

◆ saveMeshsetToFile() [2/2]

◆ setAtributes()

◆ setAtributesByDataStructure()

◆ setMeshsetFromFile()

◆ sortMeshsets()

◆ updateAllMeshsetsByEntitiesChildren()

Member Data Documentation

◆ bhTag

◆ bhTag_header

◆ broadcastMeshsetsOn

◆ configFileOptionsPtr

◆ cOre

◆ cubitMeshsets

◆ nsTag

◆ nsTag_data

◆ ssTag

◆ ssTag_data