Mesh Query Operations

Functions for querying mesh information (vertices, elements, blocks, BCs) More...

Collaboration diagram for Mesh Query Operations:

Functions
ErrCode	iMOAB_UpdateMeshInfo (iMOAB_AppID pid)
	Update application's mesh information after loading or modification. More...
ErrCode	iMOAB_GetMeshInfo (iMOAB_AppID pid, int *num_visible_vertices, int *num_visible_elements, int *num_visible_blocks, int *num_visible_surfaceBC, int *num_visible_vertexBC)
	Query mesh statistics including vertices, elements, and boundary conditions. More...
ErrCode	iMOAB_GetVertexID (iMOAB_AppID pid, int *vertices_length, iMOAB_GlobalID *global_vertex_ID)
	Retrieve global IDs for all vertices in application's mesh. More...
ErrCode	iMOAB_GetVertexOwnership (iMOAB_AppID pid, int *vertices_length, int *visible_global_rank_ID)
	Retrieve parallel ownership information for all vertices. More...
ErrCode	iMOAB_GetVisibleVerticesCoordinates (iMOAB_AppID pid, int *coords_length, double *coordinates)
	Retrieve coordinates for all vertices in interleaved format. More...
ErrCode	iMOAB_GetBlockID (iMOAB_AppID pid, int *block_length, iMOAB_GlobalID *global_block_IDs)
	Retrieve global IDs for all material blocks in mesh. More...
ErrCode	iMOAB_GetBlockInfo (iMOAB_AppID pid, iMOAB_GlobalID *global_block_ID, int *vertices_per_element, int *num_elements_in_block)
	Retrieve information about a specific material block. More...

Detailed Description

Functions for querying mesh information (vertices, elements, blocks, BCs)

Function Documentation

iMOAB_GetBlockID()

ErrCode iMOAB_GetBlockID	(	iMOAB_AppID	pid,
		int *	block_length,
		iMOAB_GlobalID *	global_block_IDs
	)

Retrieve global IDs for all material blocks in mesh.

Get the global block IDs for all locally visible (owned and shared/ghosted) blocks.

Extracts MATERIAL_SET tag values for all material blocks. Blocks are identified by unique integer IDs and contain elements with similar material properties.

Parameters

[in]	pid	Application ID
[in]	block_length	Number of blocks (must match actual count)
[out]	global_block_IDs	Array of material set IDs (size = block_length)

Precondition

Application must be registered and mesh loaded

block_length must match block count from iMOAB_GetMeshInfo

global_block_IDs array must be pre-allocated

Postcondition

global_block_IDs populated with MATERIAL_SET tag values

Internal matIndex map populated for fast block lookup

Note

Material blocks are mesh sets containing elements of same material

Creates internal index map for subsequent block queries

Block IDs are user-defined and may not be consecutive

Returns

moab::MB_SUCCESS on success, moab::MB_FAILURE if count mismatch

See also

iMOAB_GetBlockInfo(), iMOAB_GetMeshInfo()

Definition at line 1599 of file iMOAB.cpp.

{
    Range& matSets = context.appDatas[*pid].mat_sets;
 
    // Validate array size matches actual block count
    if( *block_length != (int)matSets.size() )
    {
        return moab::MB_INVALID_SIZE;  // Size mismatch
    }
 
    // Extract MATERIAL_SET tag values for all material blocks
    MB_CHK_SET_ERR( context.MBI->tag_get_data( context.material_tag, matSets, global_block_IDs ),
                    "can't get material IDs" );
 
    // Build internal index map: block_id -> array_index for fast lookup
    std::map< int, int >& matIdx = context.appDatas[*pid].matIndex;
    for( unsigned i = 0; i < matSets.size(); i++ )
    {
        matIdx[global_block_IDs[i]] = i;  // Cache block index for future queries
    }
 
    return moab::MB_SUCCESS;
}

References GlobalContext::appDatas, context, GlobalContext::material_tag, MB_CHK_SET_ERR, MB_INVALID_SIZE, MB_SUCCESS, GlobalContext::MBI, moab::Range::size(), and moab::Interface::tag_get_data().

iMOAB_GetBlockInfo()

ErrCode iMOAB_GetBlockInfo	(	iMOAB_AppID	pid,
		iMOAB_GlobalID *	global_block_ID,
		int *	vertices_per_element,
		int *	num_elements_in_block
	)

Retrieve information about a specific material block.

Get the global block information and number of visible elements of belonging to a block (MATERIAL SET).

Queries element count and connectivity size for specified material block. Assumes all elements in block have same topology type.

Parameters

[in]	pid	Application ID
[in]	global_block_ID	Material block ID to query
[out]	vertices_per_element	Number of vertices per element in this block
[out]	num_elements_in_block	Total number of elements in this block

Precondition

Application must be registered and mesh loaded

iMOAB_GetBlockID must have been called first (to populate matIndex)

global_block_ID must be valid block ID from iMOAB_GetBlockID

Postcondition

vertices_per_element set to connectivity size

num_elements_in_block set to element count

Note

All elements in block assumed to have same topology

vertices_per_element depends on element type (4=tet, 8=hex, etc.)

Warning

Returns failure if block ID not found in matIndex map

Returns

moab::MB_SUCCESS on success, moab::MB_FAILURE if block not found

See also

iMOAB_GetBlockID(), iMOAB_GetBlockElementConnectivities()

Definition at line 1650 of file iMOAB.cpp.

{
    assert( global_block_ID );
 
    std::map< int, int >& matMap      = context.appDatas[*pid].matIndex;
    std::map< int, int >::iterator it = matMap.find( *global_block_ID );
 
    if( it == matMap.end() )
    {
        return moab::MB_FAILURE;
    }  // error in finding block with id
 
    int blockIndex          = matMap[*global_block_ID];
    EntityHandle matMeshSet = context.appDatas[*pid].mat_sets[blockIndex];
    Range blo_elems;
    MB_CHK_SET_ERR( context.MBI->get_entities_by_handle( matMeshSet, blo_elems ), "can't get block elements" );
 
    if( blo_elems.empty() ) return moab::MB_FAILURE;
 
    EntityType type = context.MBI->type_from_handle( blo_elems[0] );
 
    if( !blo_elems.all_of_type( type ) ) return moab::MB_FAILURE;
 
    const EntityHandle* conn = nullptr;
    int num_verts            = 0;
    MB_CHK_SET_ERR( context.MBI->get_connectivity( blo_elems[0], conn, num_verts ), "can't get connectivity" );
 
    *vertices_per_element  = num_verts;
    *num_elements_in_block = (int)blo_elems.size();
 
    return moab::MB_SUCCESS;
}

References moab::Range::all_of_type(), GlobalContext::appDatas, context, moab::Range::empty(), moab::Interface::get_connectivity(), moab::Interface::get_entities_by_handle(), MB_CHK_SET_ERR, MB_SUCCESS, GlobalContext::MBI, moab::Range::size(), and moab::Interface::type_from_handle().

iMOAB_GetMeshInfo()

ErrCode iMOAB_GetMeshInfo	(	iMOAB_AppID	pid,
		int *	num_visible_vertices,
		int *	num_visible_elements,
		int *	num_visible_blocks,
		int *	num_visible_surfaceBC,
		int *	num_visible_vertexBC
	)

Query mesh statistics including vertices, elements, and boundary conditions.

Retrieve all the important mesh information related to vertices, elements, vertex and surface boundary conditions.

Retrieves counts of vertices, elements, material blocks, and boundary condition sets. Each output array has 3 components: [owned, ghost, total]. Useful for memory allocation and understanding parallel mesh distribution.

Array Format:

All output arrays use 3-element format: [owned, ghost, total]

• owned: Entities owned by this process
• ghost: Ghost/halo entities from neighboring processes
• total: Sum of owned and ghost entities

Parameters

[in]	pid	Application ID
[out]	num_visible_vertices	Vertex counts [local(non-ghost), ghost, total]
[out]	num_visible_elements	Element counts [owned, ghost, total]
[out]	num_visible_blocks	Material block counts [owned, ghost, total]
[out]	num_visible_surfaceBC	Surface BC counts (total face count across all BC sets)
[out]	num_visible_vertexBC	Vertex BC counts (total vertex count across all BC sets)

Precondition

Application must be registered and mesh loaded

iMOAB_UpdateMeshInfo must have been called

Postcondition

Output arrays populated with mesh statistics

Note

All parameters are optional (can be NULL if not needed)

Surface BC count includes all faces in Neumann sets

Vertex BC count includes all vertices in Dirichlet sets

Material blocks queried via MATERIAL_SET tag

BCs queried via NEUMANN_SET and DIRICHLET_SET tags

Returns

moab::MB_SUCCESS on success, error code otherwise

See also

iMOAB_UpdateMeshInfo(), iMOAB_LoadMesh()

Definition at line 1332 of file iMOAB.cpp.

{
    appData& data        = context.appDatas[*pid];
    EntityHandle fileSet = data.file_set;
 
    // this will include ghost elements
    // first clear all data ranges; this can be called after ghosting
    if( num_visible_elements )
    {
        num_visible_elements[2] = static_cast< int >( data.primary_elems.size() );
        // separate ghost and local/owned primary elements
        num_visible_elements[0] = static_cast< int >( data.owned_elems.size() );
        num_visible_elements[1] = static_cast< int >( data.ghost_elems.size() );
    }
    if( num_visible_vertices )
    {
        num_visible_vertices[2] = static_cast< int >( data.all_verts.size() );
        num_visible_vertices[1] = static_cast< int >( data.ghost_vertices.size() );
        // local are those that are not ghosts; they may include shared, not owned vertices
        num_visible_vertices[0] = num_visible_vertices[2] - num_visible_vertices[1];
    }
 
    if( num_visible_blocks )
    {
        MB_CHK_SET_ERR( context.MBI->get_entities_by_type_and_tag( fileSet, MBENTITYSET, &( context.material_tag ), 0,
                                                                   1, data.mat_sets, Interface::UNION ),
                        "can't get material sets" );
 
        num_visible_blocks[2] = data.mat_sets.size();
        num_visible_blocks[0] = num_visible_blocks[2];
        num_visible_blocks[1] = 0;
    }
 
    if( num_visible_surfaceBC )
    {
        MB_CHK_SET_ERR( context.MBI->get_entities_by_type_and_tag( fileSet, MBENTITYSET, &( context.neumann_tag ), 0, 1,
                                                                   data.neu_sets, Interface::UNION ),
                        "can't get neumann sets" );
 
        num_visible_surfaceBC[2] = 0;
        // count how many faces are in each neu set, and how many regions are
        // adjacent to them;
        int numNeuSets = (int)data.neu_sets.size();
 
        for( int i = 0; i < numNeuSets; i++ )
        {
            Range subents;
            EntityHandle nset = data.neu_sets[i];
            MB_CHK_SET_ERR( context.MBI->get_entities_by_dimension( nset, data.dimension - 1, subents ),
                            "can't get neumann sets" );
 
            for( Range::iterator it = subents.begin(); it != subents.end(); ++it )
            {
                EntityHandle subent = *it;
                Range adjPrimaryEnts;
                MB_CHK_SET_ERR( context.MBI->get_adjacencies( &subent, 1, data.dimension, false, adjPrimaryEnts ),
                                "can't get adjacencies" );
 
                num_visible_surfaceBC[2] += (int)adjPrimaryEnts.size();
            }
        }
 
        num_visible_surfaceBC[0] = num_visible_surfaceBC[2];
        num_visible_surfaceBC[1] = 0;
    }
 
    if( num_visible_vertexBC )
    {
        MB_CHK_SET_ERR( context.MBI->get_entities_by_type_and_tag( fileSet, MBENTITYSET, &( context.dirichlet_tag ), 0,
                                                                   1, data.diri_sets, Interface::UNION ),
                        "can't get dirichlet sets" );
 
        num_visible_vertexBC[2] = 0;
        int numDiriSets         = (int)data.diri_sets.size();
 
        for( int i = 0; i < numDiriSets; i++ )
        {
            Range verts;
            EntityHandle diset = data.diri_sets[i];
            MB_CHK_SET_ERR( context.MBI->get_entities_by_dimension( diset, 0, verts ), "can't get dirichlet sets" );
 
            num_visible_vertexBC[2] += (int)verts.size();
        }
 
        num_visible_vertexBC[0] = num_visible_vertexBC[2];
        num_visible_vertexBC[1] = 0;
    }
 
    return moab::MB_SUCCESS;
}

References appData::all_verts, GlobalContext::appDatas, moab::Range::begin(), context, appData::dimension, appData::diri_sets, GlobalContext::dirichlet_tag, moab::Range::end(), appData::file_set, moab::Interface::get_adjacencies(), moab::Interface::get_entities_by_dimension(), moab::Interface::get_entities_by_type_and_tag(), appData::ghost_elems, appData::ghost_vertices, appData::mat_sets, GlobalContext::material_tag, MB_CHK_SET_ERR, MB_SUCCESS, MBENTITYSET, GlobalContext::MBI, appData::neu_sets, GlobalContext::neumann_tag, appData::owned_elems, appData::primary_elems, moab::Range::size(), and moab::Interface::UNION.

iMOAB_GetVertexID()

ErrCode iMOAB_GetVertexID	(	iMOAB_AppID	pid,
		int *	vertices_length,
		iMOAB_GlobalID *	global_vertex_ID
	)

Retrieve global IDs for all vertices in application's mesh.

Get the global vertex IDs for all locally visible (owned and shared/ghosted) vertices.

Extracts GLOBAL_ID tag values for all vertices. Global IDs are unique across all processes and are used for parallel mesh operations and entity identification.

Parameters

[in]	pid	Application ID
[in]	vertices_length	Number of vertices (must match actual vertex count)
[out]	global_vertex_ID	Array of global IDs (size = vertices_length)

Precondition

Application must be registered and mesh loaded

vertices_length must equal total vertex count from iMOAB_GetMeshInfo

global_vertex_ID array must be pre-allocated

Postcondition

global_vertex_ID populated with GLOBAL_ID tag values

Note

Global IDs are 1-indexed and unique across all processes

Array must be sized correctly or assertion will fail

Returns

moab::MB_SUCCESS on success, error code otherwise

See also

iMOAB_GetMeshInfo(), iMOAB_GetVertexOwnership()

Definition at line 1452 of file iMOAB.cpp.

{
    IMOAB_CHECKPOINTER( vertices_length, 2 );
    IMOAB_CHECKPOINTER( global_vertex_ID, 3 );
 
    const Range& verts = context.appDatas[*pid].all_verts;
 
    // Validate array size matches actual vertex count to prevent buffer overruns
    IMOAB_ASSERT( *vertices_length == static_cast< int >( verts.size() ), "Invalid vertices length provided" );
 
    // Extract GLOBAL_ID tag values for all vertices in order
    return context.MBI->tag_get_data( context.globalID_tag, verts, global_vertex_ID );
}

References GlobalContext::appDatas, context, GlobalContext::globalID_tag, IMOAB_ASSERT, IMOAB_CHECKPOINTER, GlobalContext::MBI, moab::Range::size(), and moab::Interface::tag_get_data().

iMOAB_GetVertexOwnership()

ErrCode iMOAB_GetVertexOwnership	(	iMOAB_AppID	pid,
		int *	vertices_length,
		int *	visible_global_rank_ID
	)

Retrieve parallel ownership information for all vertices.

Get vertex ownership information.

Queries which MPI rank owns each vertex. In parallel simulations, each vertex is owned by exactly one process, though it may be ghosted on others.

Parameters

[in]	pid	Application ID
[in]	vertices_length	Number of vertices (must match actual count)
[out]	visible_global_rank_ID	Array of owning ranks (size = vertices_length)

Precondition

Application must be registered and mesh loaded

For parallel: mesh must have parallel ownership information

visible_global_rank_ID array must be pre-allocated

Postcondition

visible_global_rank_ID[i] = rank that owns vertex i

Note

In serial runs, all vertices owned by rank 0

Ghost vertices report the rank of their owner, not local rank

Returns

moab::MB_SUCCESS on success, moab::MB_FAILURE if count mismatch

See also

iMOAB_GetVertexID(), iMOAB_GetElementOwnership()

Definition at line 1490 of file iMOAB.cpp.

{
    assert( vertices_length && *vertices_length );
    assert( visible_global_rank_ID );
 
    Range& verts = context.appDatas[*pid].all_verts;
 
#ifdef MOAB_HAVE_MPI
    // Parallel: query actual ownership from ParallelComm
    ParallelComm* pco = context.appDatas[*pid].pcomm;
 
    int i = 0;
    for( Range::iterator vit = verts.begin(); vit != verts.end(); ++vit, i++ )
    {
        // Get owning rank for this vertex (may be local or remote)
        MB_CHK_SET_ERR( pco->get_owner( *vit, visible_global_rank_ID[i] ), "can't get owner" );
    }
 
    // Validate we processed exactly the expected number of vertices
    if( i != *vertices_length )
    {
        return moab::MB_INVALID_SIZE;  // Array size mismatch
    }
 
#else
    // Serial: all vertices owned by rank 0
    if( (int)verts.size() != *vertices_length )
    {
        return moab::MB_INVALID_SIZE;  // Array size mismatch
    }  // warning array allocation problem
 
    int i = 0;
    for( Range::iterator vit = verts.begin(); vit != verts.end(); ++vit, i++ )
    {
        visible_global_rank_ID[i] = 0;
    }  // all vertices are owned by processor 0, as this is serial run
 
#endif
 
    return moab::MB_SUCCESS;
}

References GlobalContext::appDatas, moab::Range::begin(), context, moab::Range::end(), moab::ParallelComm::get_owner(), MB_CHK_SET_ERR, MB_INVALID_SIZE, MB_SUCCESS, and moab::Range::size().

iMOAB_GetVisibleVerticesCoordinates()

ErrCode iMOAB_GetVisibleVerticesCoordinates	(	iMOAB_AppID	pid,
		int *	coords_length,
		double *	coordinates
	)

Retrieve coordinates for all vertices in interleaved format.

Get vertex coordinates for all local (owned and ghosted) vertices.

Extracts 3D coordinates (x,y,z) for all vertices in interleaved format: [x0,y0,z0, x1,y1,z1, ...]. Coordinates are returned in same order as vertex IDs.

Parameters

[in]	pid	Application ID
[in]	coords_length	Length of coordinates array (must equal 3 * num_vertices)
[out]	coordinates	Interleaved coordinate array (size = 3 * num_vertices)

Precondition

Application must be registered and mesh loaded

coords_length must equal 3 * vertex count

coordinates array must be pre-allocated

Postcondition

coordinates filled with interleaved x,y,z values

Note

Format: [x0,y0,z0, x1,y1,z1, x2,y2,z2, ...]

Always returns 3D coordinates even for 2D meshes (z=0)

Warning

Array size must be exact or function returns failure

Returns

moab::MB_SUCCESS on success, moab::MB_FAILURE if size mismatch

See also

iMOAB_GetVertexID(), iMOAB_GetMeshInfo()

Definition at line 1557 of file iMOAB.cpp.

{
    Range& verts = context.appDatas[*pid].all_verts;
 
    // Validate array size: need 3 coordinates (x,y,z) per vertex
    if( *coords_length != 3 * (int)verts.size() )
    {
        return moab::MB_INVALID_SIZE;  // Size mismatch
    }
 
    // Extract coordinates in interleaved format (deep copy)
    MB_CHK_SET_ERR( context.MBI->get_coords( verts, coordinates ), "can't get coordinates" );
 
    return moab::MB_SUCCESS;
}

References GlobalContext::appDatas, context, moab::Interface::get_coords(), MB_CHK_SET_ERR, MB_INVALID_SIZE, MB_SUCCESS, GlobalContext::MBI, and moab::Range::size().

iMOAB_UpdateMeshInfo()

ErrCode iMOAB_UpdateMeshInfo

(

iMOAB_AppID

pid

)

Update application's mesh information after loading or modification.

Update local mesh data structure, from file information.

Refreshes all cached mesh metadata including vertex/element counts, ranges, owned/ghost entities, and material/boundary condition sets. Must be called after mesh loading or ghosting.

Update Process:

1. Clear all existing cached ranges (vertices, elements, sets)
2. Query all vertices from file set
3. Determine mesh dimension (3D → 2D → 1D → 0D) by checking for elements
4. Extract primary elements of detected dimension
5. Separate owned vs ghost entities based on parallel ownership
6. Query material sets (MATERIAL_SET tag)
7. Query boundary condition sets (NEUMANN_SET, DIRICHLET_SET tags)
8. Separate local vs owned vertices based on parallel partitioning

Parameters

[in]

pid

Application ID

Precondition

Application must be registered and mesh loaded

Postcondition

Mesh dimension determined and cached

All vertex/element ranges updated

Owned/ghost entity ranges computed

Material and BC sets identified

Note

Call this after iMOAB_LoadMesh or ghost layer exchange

Automatically called by iMOAB_LoadMesh

Warning

Clears all existing cached mesh information

Returns

moab::MB_SUCCESS on success, error code otherwise

See also

iMOAB_LoadMesh(), iMOAB_GetMeshInfo()

Definition at line 1186 of file iMOAB.cpp.

{
    // this will include ghost elements info
    appData& data        = context.appDatas[*pid];
    EntityHandle fileSet = data.file_set;
 
    // first clear all data ranges; this can be called after ghosting
    data.all_verts.clear();
    data.primary_elems.clear();
    data.local_verts.clear();
    data.owned_verts.clear();
    data.ghost_vertices.clear();
    data.owned_elems.clear();
    data.ghost_elems.clear();
    data.mat_sets.clear();
    data.neu_sets.clear();
    data.diri_sets.clear();
 
    // Let us get all the vertex entities
    MB_CHK_SET_ERR( context.MBI->get_entities_by_type( fileSet, MBVERTEX, data.all_verts, true ),
                    "can't get vertices" );
 
    // Let us check first entities of dimension = 3
    data.dimension = 3;
    MB_CHK_SET_ERR( context.MBI->get_entities_by_dimension( fileSet, data.dimension, data.primary_elems, true ),
                    "can't get primary elements" );
 
    if( data.primary_elems.empty() )
    {
        // Now 3-D elements. Let us check entities of dimension = 2
        data.dimension = 2;
        MB_CHK_SET_ERR( context.MBI->get_entities_by_dimension( fileSet, data.dimension, data.primary_elems, true ),
                        "can't get primary elements" );
 
        if( data.primary_elems.empty() )
        {
            // Now 3-D/2-D elements. Let us check entities of dimension = 1
            data.dimension = 1;
            MB_CHK_SET_ERR( context.MBI->get_entities_by_dimension( fileSet, data.dimension, data.primary_elems, true ),
                            "can't get primary elements" );
 
            if( data.primary_elems.empty() )
            {
                // no elements of dimension 1 or 2 or 3; it could happen for point clouds
                data.dimension = 0;
            }
        }
    }
 
    // check if the current mesh is just a point cloud
    data.point_cloud = ( ( data.primary_elems.size() == 0 && data.all_verts.size() > 0 ) || data.dimension == 0 );
 
#ifdef MOAB_HAVE_MPI
 
    if( context.MPI_initialized )
    {
        ParallelComm* pco = context.appDatas[*pid].pcomm;
 
        // filter ghost vertices, from local
        MB_CHK_SET_ERR( pco->filter_pstatus( data.all_verts, PSTATUS_GHOST, PSTATUS_NOT, -1, &data.local_verts ),
                        "can't filter ghost vertices" );
 
        // Store handles for all ghosted entities
        data.ghost_vertices = subtract( data.all_verts, data.local_verts );
 
        // filter ghost elements, from local
        MB_CHK_SET_ERR( pco->filter_pstatus( data.primary_elems, PSTATUS_GHOST, PSTATUS_NOT, -1, &data.owned_elems ),
                        "can't filter ghost elements" );
 
        data.ghost_elems = subtract( data.primary_elems, data.owned_elems );
        // now update global number of primary cells and global number of vertices
        // determine first number of owned vertices
        // Get local owned vertices
        MB_CHK_SET_ERR( pco->filter_pstatus( data.all_verts, PSTATUS_NOT_OWNED, PSTATUS_NOT, -1, &data.owned_verts ),
                        "can't filter ghost vertices" );
        int local[2], global[2];
        local[0] = data.owned_verts.size();
        local[1] = data.owned_elems.size();
        MPI_Allreduce( local, global, 2, MPI_INT, MPI_SUM, pco->comm() );
        MB_CHK_SET_ERR( iMOAB_SetGlobalInfo( pid, &( global[0] ), &( global[1] ) ), "can't set global info" );
    }
    else
    {
        data.local_verts = data.all_verts;
        data.owned_elems = data.primary_elems;
    }
 
#else
 
    data.local_verts = data.all_verts;
    data.owned_elems = data.primary_elems;
 
#endif
 
    // Get the references for some standard internal tags such as material blocks, BCs, etc
    MB_CHK_SET_ERR( context.MBI->get_entities_by_type_and_tag( fileSet, MBENTITYSET, &( context.material_tag ), 0, 1,
                                                               data.mat_sets, Interface::UNION ),
                    "can't get material sets" );
 
    MB_CHK_SET_ERR( context.MBI->get_entities_by_type_and_tag( fileSet, MBENTITYSET, &( context.neumann_tag ), 0, 1,
                                                               data.neu_sets, Interface::UNION ),
                    "can't get neumann sets" );
 
    MB_CHK_SET_ERR( context.MBI->get_entities_by_type_and_tag( fileSet, MBENTITYSET, &( context.dirichlet_tag ), 0, 1,
                                                               data.diri_sets, Interface::UNION ),
                    "can't get dirichlet sets" );
 
    return moab::MB_SUCCESS;
}

References appData::all_verts, GlobalContext::appDatas, moab::Range::clear(), moab::ParallelComm::comm(), context, appData::dimension, appData::diri_sets, GlobalContext::dirichlet_tag, moab::Range::empty(), appData::file_set, moab::ParallelComm::filter_pstatus(), moab::Interface::get_entities_by_dimension(), moab::Interface::get_entities_by_type(), moab::Interface::get_entities_by_type_and_tag(), appData::ghost_elems, appData::ghost_vertices, iMOAB_SetGlobalInfo(), appData::local_verts, appData::mat_sets, GlobalContext::material_tag, MB_CHK_SET_ERR, MB_SUCCESS, MBENTITYSET, GlobalContext::MBI, MBVERTEX, GlobalContext::MPI_initialized, appData::neu_sets, GlobalContext::neumann_tag, appData::owned_elems, appData::owned_verts, appData::point_cloud, appData::primary_elems, PSTATUS_GHOST, PSTATUS_NOT, PSTATUS_NOT_OWNED, moab::Range::size(), moab::subtract(), and moab::Interface::UNION.

Referenced by iMOAB_DetermineGhostEntities(), iMOAB_LoadMesh(), iMOAB_MergeVertices(), and iMOAB_ReceiveMesh().