iMOAB.h File Reference

#include "moab/MOABConfig.h"
#include "moab/Types.hpp"
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>

Include dependency graph for iMOAB.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	iMOAB_AppID   int*
#define	iMOAB_String   char*
#define	iMOAB_GlobalID   int
#define	iMOAB_LocalID   int
#define	ErrCode   int
#define	__PRETTY_FUNCTION__   __func__
#define	CHK_MPI_ERR(ierr)
#define	IMOAB_CHECKPOINTER(prmObj, position)
#define	IMOAB_THROW_ERROR(message, retval)
#define	IMOAB_ASSERT_RET(condition, message, retval)
#define	IMOAB_ASSERT(condition, message)   IMOAB_ASSERT_RET( condition, message, moab::MB_UNHANDLED_OPTION )

Enumerations
enum	MOAB_TAG_TYPE {   DENSE_INTEGER = 0 , DENSE_DOUBLE = 1 , DENSE_ENTITYHANDLE = 2 , SPARSE_INTEGER = 3 ,   SPARSE_DOUBLE = 4 , SPARSE_ENTITYHANDLE = 5 }
	MOAB tag types can be: dense/sparse, and of int/double/EntityHandle types. They can also be defined on both elements and vertices of the mesh. More...
enum	MOAB_TAG_OWNER_TYPE { TAG_VERTEX = 0 , TAG_EDGE = 1 , TAG_FACE = 2 , TAG_ELEMENT = 3 }
	Define MOAB tag ownership information i.e., the entity where the tag is primarily defined This is typically used to query the tag data and to set it back. More...

Functions
ErrCode	iMOAB_Initialize (int argc, iMOAB_String *argv)
	Initialize the iMOAB interface implementation. More...
ErrCode	iMOAB_InitializeFortran (void)
	Initialize the iMOAB interface implementation from Fortran driver. More...
ErrCode	iMOAB_Finalize (void)
	Finalize the iMOAB interface implementation. More...
ErrCode	iMOAB_RegisterApplication (const iMOAB_String app_name, int *compid, iMOAB_AppID pid)
	Register application - Create a unique application ID and bootstrap interfaces for further queries. More...
ErrCode	iMOAB_DeregisterApplication (iMOAB_AppID pid)
	De-Register application: delete mesh (set) associated with the application ID. More...
ErrCode	iMOAB_RegisterApplicationFortran (const iMOAB_String app_name, int *compid, iMOAB_AppID pid)
	Register a Fortran-based application - Create a unique application ID and bootstrap interfaces for further queries. More...
ErrCode	iMOAB_DeregisterApplicationFortran (iMOAB_AppID pid)
	De-Register the Fortran based application: delete mesh (set) associated with the application ID. More...
ErrCode	iMOAB_ReadHeaderInfo (const iMOAB_String filename, int *num_global_vertices, int *num_global_elements, int *num_dimension, int *num_parts)
	It should be called on master task only, and information obtained could be broadcasted by the user. It is a fast lookup in the header of the file. More...
ErrCode	iMOAB_LoadMesh (iMOAB_AppID pid, const iMOAB_String filename, const iMOAB_String read_options, int *num_ghost_layers)
	Load a MOAB mesh file in parallel and exchange ghost layers as requested. More...
ErrCode	iMOAB_CreateVertices (iMOAB_AppID pid, int *coords_len, int *dim, double *coordinates)
	Create vertices for an app; it assumes no other vertices. More...
ErrCode	iMOAB_CreateElements (iMOAB_AppID pid, int *num_elem, int *type, int *num_nodes_per_element, int *connectivity, int *block_ID)
	Create elements for an app; it assumes connectivity from local vertices, in order. More...
ErrCode	iMOAB_ResolveSharedEntities (iMOAB_AppID pid, int *num_verts, int *marker)
	Resolve shared entities using global markers on shared vertices. More...
ErrCode	iMOAB_DetermineGhostEntities (iMOAB_AppID pid, int *ghost_dim, int *num_ghost_layers, int *bridge_dim)
	Create the requested number of ghost layers for the parallel mesh. More...
ErrCode	iMOAB_WriteMesh (iMOAB_AppID pid, const iMOAB_String filename, const iMOAB_String write_options)
	Write a MOAB mesh along with the solution tags to a file. More...
ErrCode	iMOAB_WriteLocalMesh (iMOAB_AppID pid, iMOAB_String prefix)
	Write a local MOAB mesh copy. More...
ErrCode	iMOAB_UpdateMeshInfo (iMOAB_AppID pid)
	Update local mesh data structure, from file information. 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)
	Retrieve all the important mesh information related to vertices, elements, vertex and surface boundary conditions. More...
ErrCode	iMOAB_GetVertexID (iMOAB_AppID pid, int *vertices_length, iMOAB_GlobalID *global_vertex_ID)
	Get the global vertex IDs for all locally visible (owned and shared/ghosted) vertices. More...
ErrCode	iMOAB_GetVertexOwnership (iMOAB_AppID pid, int *vertices_length, int *visible_global_rank_ID)
	Get vertex ownership information. More...
ErrCode	iMOAB_GetVisibleVerticesCoordinates (iMOAB_AppID pid, int *coords_length, double *coordinates)
	Get vertex coordinates for all local (owned and ghosted) vertices. More...
ErrCode	iMOAB_GetBlockID (iMOAB_AppID pid, int *block_length, iMOAB_GlobalID *global_block_IDs)
	Get the global block IDs for all locally visible (owned and shared/ghosted) blocks. More...
ErrCode	iMOAB_GetBlockInfo (iMOAB_AppID pid, iMOAB_GlobalID *global_block_ID, int *vertices_per_element, int *num_elements_in_block)
	Get the global block information and number of visible elements of belonging to a block (MATERIAL SET). More...
ErrCode	iMOAB_GetVisibleElementsInfo (iMOAB_AppID pid, int *num_visible_elements, iMOAB_GlobalID *element_global_IDs, int *ranks, iMOAB_GlobalID *block_IDs)
	Get the visible elements information. More...
ErrCode	iMOAB_GetBlockElementConnectivities (iMOAB_AppID pid, iMOAB_GlobalID *global_block_ID, int *connectivity_length, int *element_connectivity)
	Get the connectivities for elements contained within a certain block. More...
ErrCode	iMOAB_GetElementConnectivity (iMOAB_AppID pid, iMOAB_LocalID *elem_index, int *connectivity_length, int *element_connectivity)
	Get the connectivity for one element only. More...
ErrCode	iMOAB_GetElementOwnership (iMOAB_AppID pid, iMOAB_GlobalID *global_block_ID, int *num_elements_in_block, int *element_ownership)
	Get the element ownership within a certain block i.e., processor ID of the element owner. More...
ErrCode	iMOAB_GetElementID (iMOAB_AppID pid, iMOAB_GlobalID *global_block_ID, int *num_elements_in_block, iMOAB_GlobalID *global_element_ID, iMOAB_LocalID *local_element_ID)
	Get the global IDs for all locally visible elements belonging to a particular block. More...
ErrCode	iMOAB_GetPointerToSurfaceBC (iMOAB_AppID pid, int *surface_BC_length, iMOAB_LocalID *local_element_ID, int *reference_surface_ID, int *boundary_condition_value)
	Get the surface boundary condition information. More...
ErrCode	iMOAB_GetPointerToVertexBC (iMOAB_AppID pid, int *vertex_BC_length, iMOAB_LocalID *local_vertex_ID, int *boundary_condition_value)
	Get the vertex boundary condition information. More...
ErrCode	iMOAB_DefineTagStorage (iMOAB_AppID pid, const iMOAB_String tag_storage_name, int *tag_type, int *components_per_entity, int *tag_index)
	Define a MOAB Tag corresponding to the application depending on requested types. More...
ErrCode	iMOAB_SetIntTagStorage (iMOAB_AppID pid, const iMOAB_String tag_storage_name, int *num_tag_storage_length, int *entity_type, int *tag_storage_data)
	Store the specified values in a MOAB integer Tag. More...
ErrCode	iMOAB_GetIntTagStorage (iMOAB_AppID pid, const iMOAB_String tag_storage_name, int *num_tag_storage_length, int *entity_type, int *tag_storage_data)
	Get the specified values in a MOAB integer Tag. More...
ErrCode	iMOAB_SetDoubleTagStorage (iMOAB_AppID pid, const iMOAB_String tag_storage_name, int *num_tag_storage_length, int *entity_type, double *tag_storage_data)
	Store the specified values in a MOAB double Tag. More...
ErrCode	iMOAB_SetDoubleTagStorageWithGid (iMOAB_AppID pid, const iMOAB_String tag_storage_names, int *num_tag_storage_length, int *entity_type, double *tag_storage_data, int *globalIds)
	Store the specified values in a MOAB double Tag, for given ids. More...
ErrCode	iMOAB_GetDoubleTagStorage (iMOAB_AppID pid, const iMOAB_String tag_storage_name, int *num_tag_storage_length, int *entity_type, double *tag_storage_data)
	Retrieve the specified values in a MOAB double Tag. More...
ErrCode	iMOAB_SynchronizeTags (iMOAB_AppID pid, int *num_tag, int *tag_indices, int *ent_type)
	Exchange tag values for the given tags across process boundaries. More...
ErrCode	iMOAB_ReduceTagsMax (iMOAB_AppID pid, int *tag_index, int *ent_type)
	Perform global reductions with the processes in the current applications communicator. Specifically this routine performs reductions on the maximum value of the tag indicated by tag_index. More...
ErrCode	iMOAB_GetNeighborElements (iMOAB_AppID pid, iMOAB_LocalID *local_index, int *num_adjacent_elements, iMOAB_LocalID *adjacent_element_IDs)
	Retrieve the adjacencies for the element entities. More...
ErrCode	iMOAB_GetNeighborVertices (iMOAB_AppID pid, iMOAB_LocalID *local_vertex_ID, int *num_adjacent_vertices, iMOAB_LocalID *adjacent_vertex_IDs)
	Get the adjacencies for the vertex entities. More...
ErrCode	iMOAB_SetGlobalInfo (iMOAB_AppID pid, int *num_global_verts, int *num_global_elems)
	Set global information for number of vertices and number of elements; It is usually available from the h5m file, or it can be computed with a MPI_Reduce. More...
ErrCode	iMOAB_GetGlobalInfo (iMOAB_AppID pid, int *num_global_verts, int *num_global_elems)
	Get global information about number of vertices and number of elements. More...

Detailed Description

iMOAB: a language-agnostic, lightweight interface to MOAB.

Supports usage from C/C++, Fortran (77/90/2003), Python.

Remarks

1) All data in the interface are exposed via POD-types.

2) Pass everything by reference, so we do not have to use VAL()

3) Arrays are allocated by the user code. No concerns about de-allocation of the data will be taken up by the interface.

4) Always pass the pointer to the start of array along with the total allocated size for the array.

5) Return the filled array requested by user along with optionally the actual length of the array that was filled. (for typical cases, should be the allocated length)

Definition in file iMOAB.h.

Macro Definition Documentation

__PRETTY_FUNCTION__

#define __PRETTY_FUNCTION__   __func__

Definition at line 65 of file iMOAB.h.

CHK_MPI_ERR

#define CHK_MPI_ERR

(

ierr

)

Value:

    {                                                \
        if( 0 != ( ierr ) ) return moab::MB_FAILURE; \
    }

Definition at line 95 of file iMOAB.h.

ErrCode

#define ErrCode   int

Definition at line 58 of file iMOAB.h.

iMOAB_AppID

#define iMOAB_AppID   int*

\notes 1) Fortran MPI_Comm won't work. Take an integer argument and use MPI_F2C calls to get the C-Comm object 2) ReadHeaderInfo - Does it need the pid ? 3) Reuse the comm object from the registration for both load and write operations. Do not take comm objects again to avoid confusion and retain consistency. 4) Decipher the global comm object and the subset partioning for each application based on the comm object 5) GetMeshInfo - return separately the owned and ghosted vertices/elements – not together in visible_** but rather owned_** and ghosted_**. Make these arrays of size 2. 6) Should we sort the vertices after ghosting, such that the locally owned is first, and the ghosted appended next. 7) RCM only for the owned part of the mesh – do not screw with the ghosted layers 8) GetBlockID - identical to GetVertexID – return the global numbering for block 9) GetVertexID – remember that the order of vertices returned have an implicit numbering embedded in it. DO NOT CHANGE THIS ORDERING... 10) GetBlockInfo takes global Block ID; Remove blockname unless there is a separate use case for it.. 11) GetElementConnectivity - clarify whether we return global or local vertex numbering. Preferably local numbering else lot of deciphering for global.

Definition at line 51 of file iMOAB.h.

IMOAB_ASSERT

#define IMOAB_ASSERT	(		condition,
			message
	)		IMOAB_ASSERT_RET( condition, message, moab::MB_UNHANDLED_OPTION )

Definition at line 126 of file iMOAB.h.

IMOAB_ASSERT_RET

#define IMOAB_ASSERT_RET	(		condition,
			message,
			retval
	)

Value:

    {                                                                                                          \
        if( !( condition ) )                                                                                   \
        {                                                                                                      \
            printf( "iMOAB Error: %s.\n Failed condition: %s\n Location: %s in %s:%d.\n", message, #condition, \
                    __PRETTY_FUNCTION__, __FILE__, __LINE__ );                                                 \
            return retval;                                                                                     \
        }                                                                                                      \
    }

Definition at line 116 of file iMOAB.h.

IMOAB_CHECKPOINTER

#define IMOAB_CHECKPOINTER	(		prmObj,
			position
	)

Value:

    {                                                                                          \
        if( prmObj == nullptr )                                                                \
        {                                                                                      \
            printf( "InputParamError at %d: '%s' is invalid and null.\n", position, #prmObj ); \
            return moab::MB_UNHANDLED_OPTION;                                                  \
        }                                                                                      \
    }

Definition at line 100 of file iMOAB.h.

iMOAB_GlobalID

#define iMOAB_GlobalID   int

Definition at line 53 of file iMOAB.h.

iMOAB_LocalID

#define iMOAB_LocalID   int

Definition at line 54 of file iMOAB.h.

iMOAB_String

#define iMOAB_String   char*

Definition at line 52 of file iMOAB.h.

IMOAB_THROW_ERROR

#define IMOAB_THROW_ERROR	(		message,
			retval
	)

Value:

    {                                                                                                              \
        printf( "iMOAB Error: %s.\n Location: %s in %s:%d.\n", message, __PRETTY_FUNCTION__, __FILE__, __LINE__ ); \
        return retval;                                                                                             \
    }

Definition at line 109 of file iMOAB.h.

Enumeration Type Documentation

MOAB_TAG_OWNER_TYPE

enum MOAB_TAG_OWNER_TYPE

Define MOAB tag ownership information i.e., the entity where the tag is primarily defined This is typically used to query the tag data and to set it back.

Enumerator
TAG_VERTEX
TAG_EDGE
TAG_FACE
TAG_ELEMENT

Definition at line 87 of file iMOAB.h.

{
    TAG_VERTEX  = 0,
    TAG_EDGE    = 1,
    TAG_FACE    = 2,
    TAG_ELEMENT = 3
};

MOAB_TAG_TYPE

enum MOAB_TAG_TYPE

MOAB tag types can be: dense/sparse, and of int/double/EntityHandle types. They can also be defined on both elements and vertices of the mesh.

Enumerator
DENSE_INTEGER
DENSE_DOUBLE
DENSE_ENTITYHANDLE
SPARSE_INTEGER
SPARSE_DOUBLE
SPARSE_ENTITYHANDLE

Definition at line 73 of file iMOAB.h.

{
    DENSE_INTEGER       = 0,
    DENSE_DOUBLE        = 1,
    DENSE_ENTITYHANDLE  = 2,
    SPARSE_INTEGER      = 3,
    SPARSE_DOUBLE       = 4,
    SPARSE_ENTITYHANDLE = 5
};

Function Documentation

iMOAB_CreateElements()

ErrCode iMOAB_CreateElements	(	iMOAB_AppID	pid,
		int *	num_elem,
		int *	type,
		int *	num_nodes_per_element,
		int *	connectivity,
		int *	block_ID
	)

Create elements for an app; it assumes connectivity from local vertices, in order.

Note

Operations: Not collective

Parameters

[in]	pid	(iMOAB_AppID) The unique pointer to the application ID.
[in]	num_elem	(int*) Number of elements.
[in]	type	(int*) Type of element (moab type).
[in]	num_nodes_per_element	(int*) Number of nodes per element.
[in]	connectivity	(int *) Connectivity array, with respect to vertices (assumed contiguous).
[in]	block_ID	(int *) The local block identifier, which will now contain the elements.

Returns

ErrCode The error code indicating success or failure.

add the new ents to the clock set

Definition at line 2931 of file iMOAB.cpp.

{
    // Create elements
    appData& data = context.appDatas[*pid];
 
    ReadUtilIface* read_iface;
    MB_CHK_ERR( context.MBI->query_interface( read_iface ) );
 
    EntityType mbtype = (EntityType)( *type );
    EntityHandle actual_start_handle;
    EntityHandle* array = nullptr;
    MB_CHK_ERR(
        read_iface->get_element_connect( *num_elem, *num_nodes_per_element, mbtype, 1, actual_start_handle, array ) );
 
    // fill up with actual connectivity from input; assume the vertices are in order, and start
    // vertex is the first in the current data vertex range
    EntityHandle firstVertex = data.local_verts[0];
 
    for( int j = 0; j < *num_elem * ( *num_nodes_per_element ); j++ )
    {
        array[j] = connectivity[j] + firstVertex - 1;
    }  // assumes connectivity uses 1 based array (from fortran, mostly)
 
    Range new_elems( actual_start_handle, actual_start_handle + *num_elem - 1 );
 
    MB_CHK_ERR( context.MBI->add_entities( data.file_set, new_elems ) );
 
    data.primary_elems.merge( new_elems );
 
    // add to adjacency
    MB_CHK_ERR( read_iface->update_adjacencies( actual_start_handle, *num_elem, *num_nodes_per_element, array ) );
 
    // organize all new elements in block, with the given block ID; if the block set is not
    // existing, create  a new mesh set;
    Range sets;
    int set_no            = *block_ID;
    const void* setno_ptr = &set_no;
 
    EntityHandle block_set;
    ErrorCode rval = context.MBI->get_entities_by_type_and_tag( data.file_set, MBENTITYSET, &context.material_tag,
                                                                &setno_ptr, 1, sets );
 
    if( MB_FAILURE == rval || sets.empty() )
    {
        // create a new set, with this block ID
        MB_CHK_ERR( context.MBI->create_meshset( MESHSET_SET, block_set ) );
 
        MB_CHK_ERR( context.MBI->tag_set_data( context.material_tag, &block_set, 1, &set_no ) );
 
        // add the material set to file set
        MB_CHK_ERR( context.MBI->add_entities( data.file_set, &block_set, 1 ) );
    }
    else
    {
        block_set = sets[0];
    }  // first set is the one we want
 
    /// add the new ents to the clock set
    MB_CHK_ERR( context.MBI->add_entities( block_set, new_elems ) );
 
    return moab::MB_SUCCESS;
}

References moab::Interface::add_entities(), GlobalContext::appDatas, context, moab::Interface::create_meshset(), moab::Range::empty(), ErrorCode, appData::file_set, moab::ReadUtilIface::get_element_connect(), moab::Interface::get_entities_by_type_and_tag(), appData::local_verts, GlobalContext::material_tag, MB_CHK_ERR, MB_SUCCESS, MBENTITYSET, GlobalContext::MBI, moab::Range::merge(), MESHSET_SET, appData::primary_elems, moab::Interface::query_interface(), moab::Interface::tag_set_data(), and moab::ReadUtilIface::update_adjacencies().

iMOAB_CreateVertices()

ErrCode iMOAB_CreateVertices	(	iMOAB_AppID	pid,
		int *	coords_len,
		int *	dim,
		double *	coordinates
	)

Create vertices for an app; it assumes no other vertices.

Note

Operations: Not collective

Parameters

[in]	pid	(iMOAB_AppID) The unique pointer to the application ID.
[in]	coords_len	(int*) Size of the coordinates array (nverts * dim).
[in]	dim	(int*) Dimension of the vertex coordinates (usually 3).
[in]	coordinates	(double*) Coordinates of all vertices, interleaved.

Returns

ErrCode The error code indicating success or failure.

Definition at line 2911 of file iMOAB.cpp.

{
    appData& data = context.appDatas[*pid];
 
    if( !data.local_verts.empty() )  // we should have no vertices in the app
    {
        return moab::MB_FAILURE;
    }
 
    int nverts = *coords_len / *dim;
 
    MB_CHK_ERR( context.MBI->create_vertices( coordinates, nverts, data.local_verts ) );
 
    MB_CHK_ERR( context.MBI->add_entities( data.file_set, data.local_verts ) );
 
    // also add the vertices to the all_verts range
    data.all_verts.merge( data.local_verts );
    return moab::MB_SUCCESS;
}

References moab::Interface::add_entities(), appData::all_verts, GlobalContext::appDatas, context, moab::Interface::create_vertices(), moab::Range::empty(), appData::file_set, appData::local_verts, MB_CHK_ERR, MB_SUCCESS, GlobalContext::MBI, and moab::Range::merge().

iMOAB_DefineTagStorage()

ErrCode iMOAB_DefineTagStorage	(	iMOAB_AppID	pid,
		const iMOAB_String	tag_storage_name,
		int *	tag_type,
		int *	components_per_entity,
		int *	tag_index
	)

Define a MOAB Tag corresponding to the application depending on requested types.

Note

In MOAB, for most solution vectors, we only need to create a "Dense", "Double" Tag. A sparse tag can be created too. If the tag is already existing in the file, it will not be created. If it is a new tag, memory will be allocated when setting the values. Default values are 0 for for integer tags, 0.0 for double tags, 0 for entity handle tags.

Operations: Collective

Parameters

[in]	pid	(iMOAB_AppID) The unique pointer to the application ID.
[in]	tag_storage_name	(iMOAB_String) The tag name to store/retrieve the data in MOAB.
[in]	tag_type	(int*) The type of MOAB tag (Dense/Sparse, Double/Int/EntityHandle), enum MOAB_TAG_TYPE.
[in]	components_per_entity	(int*) The total size of vector dimension per entity for the tag (e.g., number of doubles per entity).
[out]	tag_index	(int*) The tag index which can be used as identifier in synchronize methods.

Returns

ErrCode The error code indicating success or failure.

Definition at line 2068 of file iMOAB.cpp.

{
    // we have 6 types of tags supported so far
    // check if tag type is valid
    if( *tag_type < 0 || *tag_type > 5 ) return moab::MB_FAILURE;
 
    DataType tagDataType;
    TagType tagType;
    void* defaultVal        = nullptr;
    int* defInt             = new int[*components_per_entity];
    double* defDouble       = new double[*components_per_entity];
    EntityHandle* defHandle = new EntityHandle[*components_per_entity];
 
    for( int i = 0; i < *components_per_entity; i++ )
    {
        defInt[i]    = 0;
        defDouble[i] = -1e+10;
        defHandle[i] = static_cast< EntityHandle >( 0 );
    }
 
    switch( *tag_type )
    {
        case 0:
            tagDataType = MB_TYPE_INTEGER;
            tagType     = MB_TAG_DENSE;
            defaultVal  = defInt;
            break;
 
        case 1:
            tagDataType = MB_TYPE_DOUBLE;
            tagType     = MB_TAG_DENSE;
            defaultVal  = defDouble;
            break;
 
        case 2:
            tagDataType = MB_TYPE_HANDLE;
            tagType     = MB_TAG_DENSE;
            defaultVal  = defHandle;
            break;
 
        case 3:
            tagDataType = MB_TYPE_INTEGER;
            tagType     = MB_TAG_SPARSE;
            defaultVal  = defInt;
            break;
 
        case 4:
            tagDataType = MB_TYPE_DOUBLE;
            tagType     = MB_TAG_SPARSE;
            defaultVal  = defDouble;
            break;
 
        case 5:
            tagDataType = MB_TYPE_HANDLE;
            tagType     = MB_TAG_SPARSE;
            defaultVal  = defHandle;
            break;
 
        default: {
            delete[] defInt;
            delete[] defDouble;
            delete[] defHandle;
            return moab::MB_FAILURE;
        }  // error
    }
 
    // split storage names if separated list
    std::string tag_name( tag_storage_name );
    // first separate the names of the tags
    // we assume that there are separators ":" between the tag names
    std::vector< std::string > tagNames;
    std::string separator( ":" );
    split_tag_names( tag_name, separator, tagNames );
 
    ErrorCode rval           = moab::MB_SUCCESS;  // assume success already :)
    appData& data            = context.appDatas[*pid];
    int already_defined_tags = 0;
 
    Tag tagHandle;
    for( size_t i = 0; i < tagNames.size(); i++ )
    {
        rval = context.MBI->tag_get_handle( tagNames[i].c_str(), *components_per_entity, tagDataType, tagHandle,
                                            tagType | MB_TAG_EXCL | MB_TAG_CREAT, defaultVal );
 
        if( MB_ALREADY_ALLOCATED == rval )
        {
            std::map< std::string, Tag >& mTags        = data.tagMap;
            std::map< std::string, Tag >::iterator mit = mTags.find( tagNames[i].c_str() );
 
            if( mit == mTags.end() )
            {
                // add it to the map
                mTags[tagNames[i]] = tagHandle;
                // push it to the list of tags, too
                *tag_index = (int)data.tagList.size();
                data.tagList.push_back( tagHandle );
            }
            rval = MB_SUCCESS;
            already_defined_tags++;
        }
        else if( MB_SUCCESS == rval )
        {
            data.tagMap[tagNames[i]] = tagHandle;
            *tag_index               = (int)data.tagList.size();
            data.tagList.push_back( tagHandle );
        }
        else
        {
            rval = moab::MB_FAILURE;  // some tags were not created
        }
    }
    // we don't need default values anymore, avoid leaks
    int rankHere = 0;
#ifdef MOAB_HAVE_MPI
    ParallelComm* pco = context.appDatas[*pid].pcomm;
    rankHere          = pco->rank();
#endif
    if( !rankHere && already_defined_tags )
        std::cout << " application with ID: " << *pid << " global id: " << data.global_id << " name: " << data.name
                  << " has " << already_defined_tags << " already defined tags out of " << tagNames.size()
                  << " tags \n";
    delete[] defInt;
    delete[] defDouble;
    delete[] defHandle;
    return rval;
}

References GlobalContext::appDatas, context, ErrorCode, appData::global_id, MB_ALREADY_ALLOCATED, MB_SUCCESS, MB_TAG_CREAT, MB_TAG_DENSE, MB_TAG_EXCL, MB_TAG_SPARSE, MB_TYPE_DOUBLE, MB_TYPE_HANDLE, MB_TYPE_INTEGER, GlobalContext::MBI, appData::name, moab::ParallelComm::rank(), split_tag_names(), moab::Interface::tag_get_handle(), appData::tagList, appData::tagMap, and TagType.

Referenced by iMOAB_ReceiveMesh().

iMOAB_DetermineGhostEntities()

ErrCode iMOAB_DetermineGhostEntities	(	iMOAB_AppID	pid,
		int *	ghost_dim,
		int *	num_ghost_layers,
		int *	bridge_dim
	)

Create the requested number of ghost layers for the parallel mesh.

Note

The routine assumes that the shared entities were resolved successfully, and that the mesh is properly distributed on separate tasks.

Operations: Collective.

Parameters

[in]	pid	(iMOAB_AppID) The unique pointer to the application ID.
[in]	ghost_dim	(int*) Desired ghost dimension (2 or 3, most of the time).
[in]	num_ghost_layers	(int*) Number of ghost layers requested.
[in]	bridge_dim	(int*) Bridge dimension (0 for vertices, 1 for edges, 2 for faces).

Returns

ErrCode The error code indicating success or failure.

Definition at line 3076 of file iMOAB.cpp.

{
    // verify we have valid ghost layers input specified. If invalid, exit quick.
    if( num_ghost_layers && *num_ghost_layers <= 0 )
    {
        return moab::MB_SUCCESS;
    }  // nothing to do
 
    appData& data     = context.appDatas[*pid];
    ParallelComm* pco = context.appDatas[*pid].pcomm;
 
    // maybe we should be passing this too; most of the time we do not need additional ents collective call
    constexpr int addl_ents = 0;
    MB_CHK_ERR( pco->exchange_ghost_cells( *ghost_dim, *bridge_dim, 1,  // get only one layer of ghost entities
                                           addl_ents, true, true, &data.file_set ) );
    for( int i = 2; i <= *num_ghost_layers; i++ )
    {
        MB_CHK_ERR( pco->correct_thin_ghost_layers() );                     // correct for thin layers
        MB_CHK_ERR( pco->exchange_ghost_cells( *ghost_dim, *bridge_dim, i,  // iteratively get one extra layer
                                               addl_ents, true, true, &data.file_set ) );
    }
 
    // Update ghost layer information
    data.num_ghost_layers = *num_ghost_layers;
 
    // now re-establish all mesh info; will reconstruct mesh info, based solely on what is in the file set
    return iMOAB_UpdateMeshInfo( pid );
}

References GlobalContext::appDatas, context, moab::ParallelComm::correct_thin_ghost_layers(), moab::ParallelComm::exchange_ghost_cells(), appData::file_set, iMOAB_UpdateMeshInfo(), MB_CHK_ERR, MB_SUCCESS, and appData::num_ghost_layers.

iMOAB_GetBlockElementConnectivities()

ErrCode iMOAB_GetBlockElementConnectivities	(	iMOAB_AppID	pid,
		iMOAB_GlobalID *	global_block_ID,
		int *	connectivity_length,
		int *	element_connectivity
	)

Get the connectivities for elements contained within a certain block.

Note

input is the block ID. Should we change to visible block local index?

Operations: Not Collective

Parameters

[in]	pid	(iMOAB_AppID) The unique pointer to the application ID.
[in]	global_block_ID	(iMOAB_GlobalID*) The global block ID of the set being queried.
[in]	connectivity_length	(int*) The allocated size of array. (typical size := vertices_per_element*num_elements_in_block)
[out]	element_connectivity	(int*) The connectivity array to store element ordering in MOAB canonical numbering scheme (array allocated by user); array contains vertex indices in the local numbering order for vertices elements are in the same order as provided by GetElementOwnership and GetElementID.

Returns

ErrCode The error code indicating success or failure.

Definition at line 1745 of file iMOAB.cpp.

{
    assert( global_block_ID );      // ensure global block ID argument is not null
    assert( connectivity_length );  // ensure connectivity length argument is not null
 
    appData& data                     = context.appDatas[*pid];
    std::map< int, int >& matMap      = data.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 = data.mat_sets[blockIndex];
    std::vector< EntityHandle > elems;
 
    MB_CHK_SET_ERR( context.MBI->get_entities_by_handle( matMeshSet, elems ), "can't get block elements" );
 
    if( elems.empty() ) return moab::MB_FAILURE;
 
    std::vector< EntityHandle > vconnect;
    MB_CHK_SET_ERR( context.MBI->get_connectivity( &elems[0], elems.size(), vconnect ), "can't get connectivity" );
 
    if( *connectivity_length != (int)vconnect.size() )
    {
        return moab::MB_FAILURE;
    }  // mismatched sizes
 
    for( int i = 0; i < *connectivity_length; i++ )
    {
        int inx = data.all_verts.index( vconnect[i] );
 
        if( -1 == inx )
        {
            return moab::MB_FAILURE;
        }  // error, vertex not in local range
 
        element_connectivity[i] = inx;
    }
 
    return moab::MB_SUCCESS;
}

References appData::all_verts, GlobalContext::appDatas, context, moab::Interface::get_connectivity(), moab::Interface::get_entities_by_handle(), moab::Range::index(), appData::mat_sets, appData::matIndex, MB_CHK_SET_ERR, MB_SUCCESS, and GlobalContext::MBI.

iMOAB_GetDoubleTagStorage()

ErrCode iMOAB_GetDoubleTagStorage	(	iMOAB_AppID	pid,
		const iMOAB_String	tag_storage_name,
		int *	num_tag_storage_length,
		int *	entity_type,
		double *	tag_storage_data
	)

Retrieve the specified values in a MOAB double Tag.

Note

Operations: Collective

Parameters

[in]	pid	(iMOAB_AppID) The unique pointer to the application ID.
[in]	tag_storage_name	(iMOAB_String) The tag names to retrieve the data in MOAB.
[in]	num_tag_storage_length	(int) The size of total tag storage data (e.g., num_visible_vertices*components_per_entity*num_tags or num_visible_elements*components_per_entity*num_tags)
[in]	entity_type	(int*) Type=0 for vertices, and Type=1 for primary elements.
[out]	tag_storage_data	(double*) The array data of type double to replace the internal tag memory; The data is assumed to be contiguous over the local set of visible entities (either vertices or elements). unrolled by tags

Returns

ErrCode The error code indicating success or failure.

Definition at line 2729 of file iMOAB.cpp.

{
    // exactly the same code, except tag type check
    std::string tag_names( tag_storage_names );
    // exactly the same code as for int tag :) maybe should check the type of tag too
    std::vector< std::string > tagNames;
    std::vector< Tag > tagHandles;
    std::string separator( ":" );
    split_tag_names( tag_names, separator, tagNames );
 
    appData& data = context.appDatas[*pid];
 
    // set it on a subset of entities, based on type and length
    Range* ents_to_get = nullptr;
 
    if( *ent_type == 0 )  // vertices
    {
        ents_to_get = &data.all_verts;
    }
    else if( *ent_type == 1 )
    {
        ents_to_get = &data.primary_elems;
    }
    int nents_to_get = (int)ents_to_get->size();
    int position     = 0;
    for( size_t i = 0; i < tagNames.size(); i++ )
    {
        if( data.tagMap.find( tagNames[i] ) == data.tagMap.end() )
        {
            return moab::MB_FAILURE;
        }  // tag not defined
 
        Tag tag = data.tagMap[tagNames[i]];
 
        int tagLength = 0;
        MB_CHK_ERR( context.MBI->tag_get_length( tag, tagLength ) );
 
        DataType dtype;
        MB_CHK_ERR( context.MBI->tag_get_data_type( tag, dtype ) );
 
        if( dtype != MB_TYPE_DOUBLE )
        {
            return moab::MB_FAILURE;
        }
 
        if( position + nents_to_get * tagLength > *num_tag_storage_length )
            return moab::MB_FAILURE;  // too many entity values to get
 
        MB_CHK_ERR( context.MBI->tag_get_data( tag, *ents_to_get, &tag_storage_data[position] ) );
        position = position + nents_to_get * tagLength;
    }
 
    return moab::MB_SUCCESS;  // no error
}

References appData::all_verts, GlobalContext::appDatas, context, MB_CHK_ERR, MB_SUCCESS, MB_TYPE_DOUBLE, GlobalContext::MBI, appData::primary_elems, moab::Range::size(), split_tag_names(), moab::Interface::tag_get_data(), moab::Interface::tag_get_data_type(), moab::Interface::tag_get_length(), and appData::tagMap.

iMOAB_GetElementConnectivity()

ErrCode iMOAB_GetElementConnectivity	(	iMOAB_AppID	pid,
		iMOAB_LocalID *	elem_index,
		int *	connectivity_length,
		int *	element_connectivity
	)

Get the connectivity for one element only.

Note

This is a convenience method and in general should not be used unless necessary. You should use colaesced calls for multiple elements for efficiency.

Operations: Not Collective

Parameters

[in]	pid	(iMOAB_AppID) The unique pointer to the application ID.
[in]	elem_index	(iMOAB_LocalID *) Local element index.
[in,out]	connectivity_length	(int *) On input, maximum length of connectivity. On output, actual length.
[out]	element_connectivity	(int*) The connectivity array to store connectivity in MOAB canonical numbering scheme. Array contains vertex indices in the local numbering order for vertices.

Returns

ErrCode The error code indicating success or failure.

Definition at line 1793 of file iMOAB.cpp.

{
    assert( elem_index );           // ensure element index argument is not null
    assert( connectivity_length );  // ensure connectivity length argument is not null
 
    appData& data = context.appDatas[*pid];
    assert( ( *elem_index >= 0 ) && ( *elem_index < (int)data.primary_elems.size() ) );
 
    int num_nodes;
    const EntityHandle* conn;
 
    EntityHandle eh = data.primary_elems[*elem_index];
 
    MB_CHK_SET_ERR( context.MBI->get_connectivity( eh, conn, num_nodes ), "can't get connectivity" );
 
    if( *connectivity_length < num_nodes )
    {
        return moab::MB_FAILURE;
    }  // wrong number of vertices
 
    for( int i = 0; i < num_nodes; i++ )
    {
        int index = data.all_verts.index( conn[i] );
 
        if( -1 == index )
        {
            return moab::MB_FAILURE;
        }
 
        element_connectivity[i] = index;
    }
 
    *connectivity_length = num_nodes;
 
    return moab::MB_SUCCESS;
}

References appData::all_verts, GlobalContext::appDatas, context, moab::Interface::get_connectivity(), moab::index, moab::Range::index(), MB_CHK_SET_ERR, MB_SUCCESS, GlobalContext::MBI, appData::primary_elems, and moab::Range::size().

iMOAB_GetElementID()

ErrCode iMOAB_GetElementID	(	iMOAB_AppID	pid,
		iMOAB_GlobalID *	global_block_ID,
		int *	num_elements_in_block,
		iMOAB_GlobalID *	global_element_ID,
		iMOAB_LocalID *	local_element_ID
	)

Get the global IDs for all locally visible elements belonging to a particular block.

Note

The method will return also the local index of each element, in the local range that contains all visible elements.

Operations: Not Collective

Parameters

[in]	pid	(iMOAB_AppID) The unique pointer to the application ID.
[in]	global_block_ID	(iMOAB_GlobalID*) The global block ID of the set being queried.
[in]	num_elements_in_block	(int*) The allocated size of global element ID array, same as num_elements_in_block returned from GetBlockInfo().
[out]	global_element_ID	(iMOAB_GlobalID*) The global IDs for all locally visible elements (array allocated by user).
[out]	local_element_ID	(iMOAB_LocalID*) (Optional) The local IDs for all locally visible elements (index in the range of all primary elements in the rank)

Returns

ErrCode The error code indicating success or failure.

Definition at line 1880 of file iMOAB.cpp.

{
    assert( global_block_ID );        // ensure global block ID argument is not null
    assert( num_elements_in_block );  // ensure number of elements in block argument is not null
 
    appData& data                = context.appDatas[*pid];
    std::map< int, int >& matMap = data.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 = data.mat_sets[blockIndex];
    Range elems;
    MB_CHK_SET_ERR( context.MBI->get_entities_by_handle( matMeshSet, elems ), "can't get block elements" );
 
    if( elems.empty() ) return moab::MB_FAILURE;
 
    if( *num_elements_in_block != (int)elems.size() )
    {
        return moab::MB_FAILURE;
    }  // bad memory allocation
 
    MB_CHK_SET_ERR( context.MBI->tag_get_data( context.globalID_tag, elems, global_element_ID ),
                    "can't get global IDs" );
 
    // check that elems are among primary_elems in data
    for( int i = 0; i < *num_elements_in_block; i++ )
    {
        local_element_ID[i] = data.primary_elems.index( elems[i] );
 
        if( -1 == local_element_ID[i] )
        {
            return moab::MB_FAILURE;
        }  // error, not in local primary elements
    }
 
    return moab::MB_SUCCESS;
}

References GlobalContext::appDatas, context, moab::Range::empty(), moab::Interface::get_entities_by_handle(), GlobalContext::globalID_tag, moab::Range::index(), appData::mat_sets, appData::matIndex, MB_CHK_SET_ERR, MB_SUCCESS, GlobalContext::MBI, appData::primary_elems, moab::Range::size(), and moab::Interface::tag_get_data().

iMOAB_GetElementOwnership()

ErrCode iMOAB_GetElementOwnership	(	iMOAB_AppID	pid,
		iMOAB_GlobalID *	global_block_ID,
		int *	num_elements_in_block,
		int *	element_ownership
	)

Get the element ownership within a certain block i.e., processor ID of the element owner.

Note

: Should we use local block index for input, instead of the global block ID ?

Operations: Not Collective

Parameters

[in]	pid	(iMOAB_AppID) The unique pointer to the application ID.
[in]	global_block_ID	(iMOAB_GlobalID) The global block ID of the set being queried.
[in]	num_elements_in_block	(int*) The allocated size of ownership array, same as num_elements_in_block returned from GetBlockInfo().
[out]	element_ownership	(int*) The ownership array to store processor ID for all elements (array allocated by user).

Returns

ErrCode The error code indicating success or failure.

Definition at line 1833 of file iMOAB.cpp.

{
    assert( global_block_ID );        // ensure global block ID argument is not null
    assert( num_elements_in_block );  // ensure number of elements in block argument is not null
 
    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 elems;
 
    MB_CHK_SET_ERR( context.MBI->get_entities_by_handle( matMeshSet, elems ), "can't get block elements" );
 
    if( elems.empty() ) return moab::MB_FAILURE;
 
    if( *num_elements_in_block != (int)elems.size() )
    {
        return moab::MB_FAILURE;
    }  // bad memory allocation
 
    int i = 0;
#ifdef MOAB_HAVE_MPI
    ParallelComm* pco = context.appDatas[*pid].pcomm;
#endif
 
    for( Range::iterator vit = elems.begin(); vit != elems.end(); vit++, i++ )
    {
#ifdef MOAB_HAVE_MPI
        MB_CHK_SET_ERR( pco->get_owner( *vit, element_ownership[i] ), "can't get owner" );
#else
        element_ownership[i] = 0; /* owned by 0 */
#endif
    }
 
    return moab::MB_SUCCESS;
}

References GlobalContext::appDatas, moab::Range::begin(), context, moab::Range::empty(), moab::Range::end(), moab::Interface::get_entities_by_handle(), moab::ParallelComm::get_owner(), MB_CHK_SET_ERR, MB_SUCCESS, GlobalContext::MBI, and moab::Range::size().

iMOAB_GetGlobalInfo()

ErrCode iMOAB_GetGlobalInfo	(	iMOAB_AppID	pid,
		int *	num_global_verts,
		int *	num_global_elems
	)

Get global information about number of vertices and number of elements.

Parameters

[in]	pid	(iMOAB_AppID) The unique pointer to the application ID.
[in]	num_global_verts	(int*) The number of total vertices in the mesh.
[in]	num_global_elems	(MPI_Comm) The number of total elements in the mesh.

Returns

ErrCode The error code indicating success or failure.

Definition at line 3007 of file iMOAB.cpp.

{
    appData& data = context.appDatas[*pid];
    if( nullptr != num_global_verts )
    {
        *num_global_verts = data.num_global_vertices;
    }
    if( nullptr != num_global_elems )
    {
        *num_global_elems = data.num_global_elements;
    }
 
    return moab::MB_SUCCESS;
}

References GlobalContext::appDatas, context, MB_SUCCESS, appData::num_global_elements, and appData::num_global_vertices.

iMOAB_GetIntTagStorage()

ErrCode iMOAB_GetIntTagStorage	(	iMOAB_AppID	pid,
		const iMOAB_String	tag_storage_name,
		int *	num_tag_storage_length,
		int *	entity_type,
		int *	tag_storage_data
	)

Get the specified values in a MOAB integer Tag.

Note

Operations: Collective

Parameters

[in]	pid	(iMOAB_AppID) The unique pointer to the application ID.
[in]	tag_storage_name	(iMOAB_String) The tag name to store/retreive the data in MOAB.
[in]	num_tag_storage_length	(int*) The size of tag storage data (e.g., num_visible_vertices*components_per_entity or num_visible_elements*components_per_entity).
[in]	entity_type	(int*) Type=0 for vertices, and Type=1 for primary elements.
[out]	tag_storage_data	(int*) The array data of type int to be copied from the internal tag memory; The data is assumed to be contiguous over the local set of visible entities (either vertices or elements).

Returns

ErrCode The error code indicating success or failure.

Definition at line 2241 of file iMOAB.cpp.

{
    std::string tag_name( tag_storage_name );
 
    appData& data = context.appDatas[*pid];
 
    if( data.tagMap.find( tag_name ) == data.tagMap.end() )
    {
        return moab::MB_FAILURE;
    }  // tag not defined
 
    Tag tag = data.tagMap[tag_name];
 
    int tagLength = 0;
    MB_CHK_ERR( context.MBI->tag_get_length( tag, tagLength ) );
 
    DataType dtype;
    MB_CHK_ERR( context.MBI->tag_get_data_type( tag, dtype ) );
 
    if( dtype != MB_TYPE_INTEGER )
    {
        MB_CHK_SET_ERR( moab::MB_FAILURE, "The tag is not of integer type." );
    }
 
    // set it on a subset of entities, based on type and length
    // if *entity_type = 0, then use vertices; else elements
    Range* ents_to_get = ( *ent_type == 0 ? &data.all_verts : &data.primary_elems );
    int nents_to_get   = *num_tag_storage_length / tagLength;
 
    if( nents_to_get > (int)ents_to_get->size() )
    {
        return moab::MB_FAILURE;
    }  // to many entities to get, or too little
 
    // now set the tag data
    MB_CHK_ERR( context.MBI->tag_get_data( tag, *ents_to_get, tag_storage_data ) );
 
    return moab::MB_SUCCESS;  // no error
}

References appData::all_verts, GlobalContext::appDatas, context, MB_CHK_ERR, MB_CHK_SET_ERR, MB_SUCCESS, MB_TYPE_INTEGER, GlobalContext::MBI, appData::primary_elems, moab::Range::size(), moab::Interface::tag_get_data(), moab::Interface::tag_get_data_type(), moab::Interface::tag_get_length(), and appData::tagMap.

iMOAB_GetNeighborElements()

ErrCode iMOAB_GetNeighborElements	(	iMOAB_AppID	pid,
		iMOAB_LocalID *	local_index,
		int *	num_adjacent_elements,
		iMOAB_LocalID *	adjacent_element_IDs
	)

Retrieve the adjacencies for the element entities.

Note

Operations: Not Collective

Parameters

[in]	pid	(iMOAB_AppID) The unique pointer to the application ID.
[in]	local_index	(iMOAB_LocalID*) The local element ID for which adjacency information is needed.
[out]	num_adjacent_elements	(int*) The total number of adjacent elements.
[out]	adjacent_element_IDs	(iMOAB_LocalID*) The local element IDs of all adjacent elements to the current one (typically, num_total_sides for internal elements or num_total_sides-num_sides_on_boundary for boundary elements).

Returns

ErrCode The error code indicating success or failure.

Definition at line 2872 of file iMOAB.cpp.

{
    assert( local_index && *local_index >= 0 );
 
    // one neighbor for each subentity of dimension-1
    MeshTopoUtil mtu( context.MBI );
    appData& data   = context.appDatas[*pid];
    EntityHandle eh = data.primary_elems[*local_index];
    Range adjs;
    MB_CHK_SET_ERR( mtu.get_bridge_adjacencies( eh, data.dimension - 1, data.dimension, adjs ),
                    "Getting bridge adjacencies failed" );
 
    if( *num_adjacent_elements < (int)adjs.size() )
    {
        return moab::MB_FAILURE;
    }  // not dimensioned correctly
 
    *num_adjacent_elements = (int)adjs.size();
 
    for( int i = 0; i < *num_adjacent_elements; i++ )
    {
        adjacent_element_IDs[i] = data.primary_elems.index( adjs[i] );
    }
 
    return moab::MB_SUCCESS;
}

References GlobalContext::appDatas, context, appData::dimension, moab::MeshTopoUtil::get_bridge_adjacencies(), moab::Range::index(), MB_CHK_SET_ERR, MB_SUCCESS, GlobalContext::MBI, appData::primary_elems, and moab::Range::size().

iMOAB_GetNeighborVertices()

ErrCode iMOAB_GetNeighborVertices	(	iMOAB_AppID	pid,
		iMOAB_LocalID *	local_vertex_ID,
		int *	num_adjacent_vertices,
		iMOAB_LocalID *	adjacent_vertex_IDs
	)

Get the adjacencies for the vertex entities.

Note

Operations: Not Collective

Parameters

[in]	pid	(iMOAB_AppID) The unique pointer to the application ID.
[in]	local_vertex_ID	(iMOAB_LocalID*) The local vertex ID for which adjacency information is needed.
[out]	num_adjacent_vertices	(int*) The total number of adjacent vertices.
[out]	adjacent_vertex_IDs	(iMOAB_LocalID*) The local element IDs of all adjacent vertices to the current one (typically, num_total_sides for internal elements or num_total_sides-num_sides_on_boundary for boundary elements).

Returns

ErrCode The error code indicating success or failure.

iMOAB_GetPointerToSurfaceBC()

ErrCode iMOAB_GetPointerToSurfaceBC	(	iMOAB_AppID	pid,
		int *	surface_BC_length,
		iMOAB_LocalID *	local_element_ID,
		int *	reference_surface_ID,
		int *	boundary_condition_value
	)

Get the surface boundary condition information.

Note

Operations: Not Collective

Parameters

[in]	pid	(iMOAB_AppID) The unique pointer to the application ID.
[in]	surface_BC_length	(int*) The allocated size of surface boundary condition array, same as num_visible_surfaceBC returned by GetMeshInfo().
[out]	local_element_ID	(iMOAB_LocalID*) The local element IDs that contains the side with the surface BC.
[out]	reference_surface_ID	(int*) The surface number with the BC in the canonical reference element (e.g., 1 to 6 for HEX, 1-4 for TET).
[out]	boundary_condition_value	(int*) The boundary condition type as obtained from the mesh description (value of the NeumannSet defined on the element).

Returns

ErrCode The error code indicating success or failure.

Definition at line 1928 of file iMOAB.cpp.

{
    // we have to fill bc data for neumann sets;/
 
    // it was counted above, in GetMeshInfo
    appData& data  = context.appDatas[*pid];
    int numNeuSets = (int)data.neu_sets.size();
 
    int index = 0;  // index [0, surface_BC_length) for the arrays returned
 
    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 subentities" );
 
        int neuVal;
        MB_CHK_SET_ERR( context.MBI->tag_get_data( context.neumann_tag, &nset, 1, &neuVal ), "can't get neumann tag" );
 
        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" );
 
            // get global id of the primary ents, and side number of the quad/subentity
            // this is moab ordering
            for( Range::iterator pit = adjPrimaryEnts.begin(); pit != adjPrimaryEnts.end(); pit++ )
            {
                EntityHandle primaryEnt = *pit;
                // get global id
                /*int globalID;
                rval = context.MBI->tag_get_data(gtags[3], &primaryEnt, 1, &globalID);
                if (MB_SUCCESS!=rval)
                  return moab::MB_FAILURE;
                global_element_ID[index] = globalID;*/
 
                // get local element id
                local_element_ID[index] = data.primary_elems.index( primaryEnt );
 
                if( -1 == local_element_ID[index] )
                {
                    return moab::MB_FAILURE;
                }  // did not find the element locally
 
                int side_number, sense, offset;
                MB_CHK_SET_ERR( context.MBI->side_number( primaryEnt, subent, side_number, sense, offset ),
                                "can't get side number" );
 
                reference_surface_ID[index]     = side_number + 1;  // moab is from 0 to 5, it needs 1 to 6
                boundary_condition_value[index] = neuVal;
                index++;
            }
        }
    }
 
    if( index != *surface_BC_length )
    {
        return moab::MB_FAILURE;
    }  // error in array allocations
 
    return moab::MB_SUCCESS;
}

References GlobalContext::appDatas, moab::Range::begin(), context, appData::dimension, moab::Range::end(), moab::Interface::get_adjacencies(), moab::Interface::get_entities_by_dimension(), moab::index, moab::Range::index(), MB_CHK_SET_ERR, MB_SUCCESS, GlobalContext::MBI, appData::neu_sets, GlobalContext::neumann_tag, appData::primary_elems, moab::Interface::side_number(), moab::side_number(), moab::Range::size(), and moab::Interface::tag_get_data().

iMOAB_GetPointerToVertexBC()

ErrCode iMOAB_GetPointerToVertexBC	(	iMOAB_AppID	pid,
		int *	vertex_BC_length,
		iMOAB_LocalID *	local_vertex_ID,
		int *	boundary_condition_value
	)

Get the vertex boundary condition information.

Note

Operations: Not Collective

Parameters

[in]	pid	(iMOAB_AppID) The unique pointer to the application ID.
[in]	vertex_BC_length	(int) The allocated size of vertex boundary condition array, same as num_visible_vertexBC returned by GetMeshInfo().
[out]	local_vertex_ID	(iMOAB_LocalID*) The local vertex ID that has Dirichlet BC defined.
[out]	boundary_condition_value	(int*) The boundary condition type as obtained from the mesh description (value of the Dirichlet_Set tag defined on the vertex).

Returns

ErrCode The error code indicating success or failure.

Definition at line 1998 of file iMOAB.cpp.

{
    // it was counted above, in GetMeshInfo
    appData& data   = context.appDatas[*pid];
    int numDiriSets = (int)data.diri_sets.size();
    int index       = 0;  // index [0, *vertex_BC_length) for the arrays returned
 
    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 vertices" );
 
        int diriVal;
        MB_CHK_SET_ERR( context.MBI->tag_get_data( context.dirichlet_tag, &diset, 1, &diriVal ),
                        "can't get dirichlet tag" );
 
        for( Range::iterator vit = verts.begin(); vit != verts.end(); ++vit )
        {
            EntityHandle vt = *vit;
            /*int vgid;
            rval = context.MBI->tag_get_data(gtags[3], &vt, 1, &vgid);
            if (MB_SUCCESS!=rval)
              return moab::MB_FAILURE;
            global_vertext_ID[index] = vgid;*/
            local_vertex_ID[index] = data.all_verts.index( vt );
 
            if( -1 == local_vertex_ID[index] )
            {
                return moab::MB_FAILURE;
            }  // vertex was not found
 
            boundary_condition_value[index] = diriVal;
            index++;
        }
    }
 
    if( *vertex_BC_length != index )
    {
        return moab::MB_FAILURE;
    }  // array allocation issue
 
    return moab::MB_SUCCESS;
}

References appData::all_verts, GlobalContext::appDatas, moab::Range::begin(), context, appData::diri_sets, GlobalContext::dirichlet_tag, moab::Range::end(), moab::Interface::get_entities_by_dimension(), moab::index, moab::Range::index(), MB_CHK_SET_ERR, MB_SUCCESS, GlobalContext::MBI, moab::Range::size(), and moab::Interface::tag_get_data().

iMOAB_GetVisibleElementsInfo()

ErrCode iMOAB_GetVisibleElementsInfo	(	iMOAB_AppID	pid,
		int *	num_visible_elements,
		iMOAB_GlobalID *	element_global_IDs,
		int *	ranks,
		iMOAB_GlobalID *	block_IDs
	)

Get the visible elements information.

Return for all visible elements the global IDs, ranks they belong to, block ids they belong to.

Note

Operations: Not Collective

Parameters

[in]	pid	(iMOAB_AppID) The unique pointer to the application ID.
[in]	num_visible_elements	(int*) The number of visible elements (returned by GetMeshInfo).
[out]	element_global_IDs	(iMOAB_GlobalID*) Element global ids to be added to the block.
[out]	ranks	(int*) The owning ranks of elements.
[out]	block_IDs	(iMOAB_GlobalID*) The block ids containing the elements.

Returns

ErrCode The error code indicating success or failure.

Definition at line 1686 of file iMOAB.cpp.

{
    appData& data = context.appDatas[*pid];
#ifdef MOAB_HAVE_MPI
    ParallelComm* pco = context.appDatas[*pid].pcomm;
#endif
 
    MB_CHK_SET_ERR( context.MBI->tag_get_data( context.globalID_tag, data.primary_elems, element_global_IDs ),
                    "can't get global IDs" );
 
    int i = 0;
 
    for( Range::iterator eit = data.primary_elems.begin(); eit != data.primary_elems.end(); ++eit, ++i )
    {
#ifdef MOAB_HAVE_MPI
        MB_CHK_SET_ERR( pco->get_owner( *eit, ranks[i] ), "can't get owner" );
 
#else
        /* everything owned by task 0 */
        ranks[i] = 0;
#endif
    }
 
    for( Range::iterator mit = data.mat_sets.begin(); mit != data.mat_sets.end(); ++mit )
    {
        EntityHandle matMeshSet = *mit;
        Range elems;
        MB_CHK_SET_ERR( context.MBI->get_entities_by_handle( matMeshSet, elems ), "can't get block elements" );
 
        int valMatTag;
        MB_CHK_SET_ERR( context.MBI->tag_get_data( context.material_tag, &matMeshSet, 1, &valMatTag ),
                        "can't get material tag" );
 
        for( Range::iterator eit = elems.begin(); eit != elems.end(); ++eit )
        {
            EntityHandle eh = *eit;
            int index       = data.primary_elems.index( eh );
 
            if( -1 == index )
            {
                return moab::MB_FAILURE;
            }
 
            if( -1 >= *num_visible_elements )
            {
                return moab::MB_FAILURE;
            }
 
            block_IDs[index] = valMatTag;
        }
    }
 
    return moab::MB_SUCCESS;
}

References GlobalContext::appDatas, moab::Range::begin(), context, moab::Range::end(), moab::Interface::get_entities_by_handle(), moab::ParallelComm::get_owner(), GlobalContext::globalID_tag, moab::index, moab::Range::index(), appData::mat_sets, GlobalContext::material_tag, MB_CHK_SET_ERR, MB_SUCCESS, GlobalContext::MBI, appData::primary_elems, and moab::Interface::tag_get_data().

iMOAB_ReduceTagsMax()

ErrCode iMOAB_ReduceTagsMax	(	iMOAB_AppID	pid,
		int *	tag_index,
		int *	ent_type
	)

Perform global reductions with the processes in the current applications communicator. Specifically this routine performs reductions on the maximum value of the tag indicated by tag_index.

Note

Operations: Collective

Parameters

[in]	pid	(iMOAB_AppID) The unique pointer to the application ID.
[in]	tag_index	(int*) The tag index of interest.
[in]	ent_type	(int*) The type of entity for tag reduction operation (vertices = 0, elements = 1)

Returns

ErrCode The error code indicating success or failure.

Definition at line 2833 of file iMOAB.cpp.

{
#ifdef MOAB_HAVE_MPI
    appData& data = context.appDatas[*pid];
    Range ent_exchange;
 
    if( *tag_index < 0 || *tag_index >= (int)data.tagList.size() )
    {
        return moab::MB_FAILURE;
    }  // error in tag index
 
    Tag tagh = data.tagList[*tag_index];
 
    if( *ent_type == 0 )
    {
        ent_exchange = data.all_verts;
    }
    else if( *ent_type == 1 )
    {
        ent_exchange = data.primary_elems;
    }
    else
    {
        return moab::MB_FAILURE;
    }  // unexpected type
 
    ParallelComm* pco = context.appDatas[*pid].pcomm;
    // we could do different MPI_Op; do not bother now, we will call from fortran
    MB_CHK_ERR( pco->reduce_tags( tagh, MPI_MAX, ent_exchange ) );
 
#else
    /* do nothing if serial */
    UNUSED( pid );
    UNUSED( tag_index );
    UNUSED( ent_type );
#endif
    return moab::MB_SUCCESS;
}

References appData::all_verts, GlobalContext::appDatas, context, MB_CHK_ERR, MB_SUCCESS, appData::primary_elems, moab::ParallelComm::reduce_tags(), appData::tagList, and UNUSED.

iMOAB_RegisterApplication()

ErrCode iMOAB_RegisterApplication	(	const iMOAB_String	app_name,
		int *	compid,
		iMOAB_AppID	pid
	)

Register application - Create a unique application ID and bootstrap interfaces for further queries.

Note

Internally, a mesh set will be associated with the application ID and all subsequent queries on the MOAB instance will be directed to this mesh/file set.

Operations: Collective

Parameters

[in]	app_name	(iMOAB_String) Application name (PROTEUS, NEK5000, etc)
[in]	comm	(MPI_Comm*) MPI communicator to be used for all mesh-related queries originating from this application
[in]	compid	(int*) The unique external component identifier
[out]	pid	(iMOAB_AppID) The unique pointer to the application ID

Returns

ErrCode The error code indicating success or failure.

iMOAB_RegisterApplicationFortran()

ErrCode iMOAB_RegisterApplicationFortran	(	const iMOAB_String	app_name,
		int *	compid,
		iMOAB_AppID	pid
	)

Register a Fortran-based application - Create a unique application ID and bootstrap interfaces for further queries.

Note

Internally, the comm object, usually a 32 bit integer in Fortran, will be converted using MPI_Comm_f2c and stored as MPI_Comm. A mesh set will be associated with the application ID and all subsequent queries on the MOAB instance will be directed to this mesh/file set.

Operations: Collective

Parameters

[in]	app_name	(iMOAB_String) Application name ("MySolver", "E3SM", "DMMoab", "PROTEUS", "NEK5000", etc)
[in]	communicator	(int*) Fortran MPI communicator to be used for all mesh-related queries originating from this application.
[in]	compid	(int*) External component id, (A const unique identifier).
[out]	pid	(iMOAB_AppID) The unique pointer to the application ID.

Returns

ErrCode The error code indicating success or failure.

iMOAB_ResolveSharedEntities()

ErrCode iMOAB_ResolveSharedEntities	(	iMOAB_AppID	pid,
		int *	num_verts,
		int *	marker
	)

Resolve shared entities using global markers on shared vertices.

Note

Global markers can be a global node id, for example, or a global DoF number (as for HOMME)

Operations: Collective .

Parameters

[in]	pid	(iMOAB_AppID) The unique pointer to the application ID.
[in]	num_verts	(int*) Number of vertices.
[in]	marker	(int*) Resolving marker (global id marker).

Returns

ErrCode The error code indicating success or failure.

Definition at line 3025 of file iMOAB.cpp.

{
    appData& data     = context.appDatas[*pid];
    ParallelComm* pco = context.appDatas[*pid].pcomm;
    EntityHandle cset = data.file_set;
    int dum_id        = 0;
    ErrorCode rval;
    if( data.primary_elems.empty() )
    {
        // skip actual resolve, assume vertices are distributed already ,
        // no need to share them
    }
    else
    {
        // create an integer tag for resolving ; maybe it can be a long tag in the future
        // (more than 2 B vertices;)
 
        Tag stag;
        MB_CHK_ERR( context.MBI->tag_get_handle( "__sharedmarker", 1, MB_TYPE_INTEGER, stag,
                                                 MB_TAG_CREAT | MB_TAG_DENSE, &dum_id ) );
 
        if( *num_verts > (int)data.local_verts.size() )
        {
            return moab::MB_FAILURE;
        }  // we are not setting the size
 
        MB_CHK_ERR( context.MBI->tag_set_data( stag, data.local_verts, (void*)marker ) );  // assumes integer tag
 
        MB_CHK_ERR( pco->resolve_shared_ents( cset, -1, -1, &stag ) );
 
        MB_CHK_ERR( context.MBI->tag_delete( stag ) );
    }
    // provide partition tag equal to rank
    Tag part_tag;
    dum_id = -1;
    rval   = context.MBI->tag_get_handle( "PARALLEL_PARTITION", 1, MB_TYPE_INTEGER, part_tag,
                                          MB_TAG_CREAT | MB_TAG_SPARSE, &dum_id );
 
    if( part_tag == nullptr || ( ( rval != MB_SUCCESS ) && ( rval != MB_ALREADY_ALLOCATED ) ) )
    {
        std::cout << " can't get par part tag.\n";
        return moab::MB_FAILURE;
    }
 
    int rank = pco->rank();
    MB_CHK_ERR( context.MBI->tag_set_data( part_tag, &cset, 1, &rank ) );
 
    return moab::MB_SUCCESS;
}

References GlobalContext::appDatas, context, moab::Range::empty(), ErrorCode, appData::file_set, appData::local_verts, MB_ALREADY_ALLOCATED, MB_CHK_ERR, MB_SUCCESS, MB_TAG_CREAT, MB_TAG_DENSE, MB_TAG_SPARSE, MB_TYPE_INTEGER, GlobalContext::MBI, appData::primary_elems, moab::ParallelComm::rank(), moab::ParallelComm::resolve_shared_ents(), moab::Range::size(), moab::Interface::tag_delete(), moab::Interface::tag_get_handle(), and moab::Interface::tag_set_data().

iMOAB_SetDoubleTagStorage()

ErrCode iMOAB_SetDoubleTagStorage	(	iMOAB_AppID	pid,
		const iMOAB_String	tag_storage_name,
		int *	num_tag_storage_length,
		int *	entity_type,
		double *	tag_storage_data
	)

Store the specified values in a MOAB double Tag.

Note

Operations: Collective

Parameters

[in]	pid	(iMOAB_AppID) The unique pointer to the application ID.
[in]	tag_storage_name	(iMOAB_String) The tag names, separated, to store the data.
[in]	num_tag_storage_length	(int*) The size of total tag storage data (e.g., num_visible_vertices*components_per_entity or num_visible_elements*components_per_entity*num_tags).
[in]	entity_type	(int*) Type=0 for vertices, and Type=1 for primary elements.
[out]	tag_storage_data	(double*) The array data of type double to replace the internal tag memory; The data is assumed to be contiguous over the local set of visible entities (either vertices or elements). unrolled by tags

Returns

ErrCode The error code indicating success or failure.

Definition at line 2285 of file iMOAB.cpp.

{
    std::string tag_names( tag_storage_names );
    // exactly the same code as for int tag :) maybe should check the type of tag too
    std::vector< std::string > tagNames;
    std::vector< Tag > tagHandles;
    std::string separator( ":" );
    split_tag_names( tag_names, separator, tagNames );
 
    appData& data = context.appDatas[*pid];
    // set it on a subset of entities, based on type and length
    // if *entity_type = 0, then use vertices; else elements
    Range* ents_to_set = ( *ent_type == 0 ? &data.all_verts : &data.primary_elems );
 
    int nents_to_be_set = (int)( *ents_to_set ).size();
    int position        = 0;
    for( size_t i = 0; i < tagNames.size(); i++ )
    {
        if( data.tagMap.find( tagNames[i] ) == data.tagMap.end() )
        {
            return moab::MB_FAILURE;
        }  // some tag not defined yet in the app
 
        Tag tag = data.tagMap[tagNames[i]];
 
        int tagLength = 0;
        MB_CHK_ERR( context.MBI->tag_get_length( tag, tagLength ) );
 
        DataType dtype;
        MB_CHK_ERR( context.MBI->tag_get_data_type( tag, dtype ) );
 
        if( dtype != MB_TYPE_DOUBLE )
        {
            return moab::MB_FAILURE;
        }
 
        // set it on the subset of entities, based on type and length
        if( position + tagLength * nents_to_be_set > *num_tag_storage_length )
            return moab::MB_FAILURE;  // too many entity values to be set
 
        MB_CHK_ERR( context.MBI->tag_set_data( tag, *ents_to_set, &tag_storage_data[position] ) );
        // increment position to next tag
        position = position + tagLength * nents_to_be_set;
    }
    return moab::MB_SUCCESS;  // no error
}

References appData::all_verts, GlobalContext::appDatas, context, MB_CHK_ERR, MB_SUCCESS, MB_TYPE_DOUBLE, GlobalContext::MBI, appData::primary_elems, moab::Range::size(), split_tag_names(), moab::Interface::tag_get_data_type(), moab::Interface::tag_get_length(), moab::Interface::tag_set_data(), and appData::tagMap.

iMOAB_SetDoubleTagStorageWithGid()

ErrCode iMOAB_SetDoubleTagStorageWithGid	(	iMOAB_AppID	pid,
		const iMOAB_String	tag_storage_names,
		int *	num_tag_storage_length,
		int *	entity_type,
		double *	tag_storage_data,
		int *	globalIds
	)

Store the specified values in a MOAB double Tag, for given ids.

Note

Operations: Collective

Parameters

[in]	pid	(iMOAB_AppID) The unique pointer to the application ID.
[in]	tag_storage_name	(iMOAB_String) The tag names, separated, to store the data.
[in]	num_tag_storage_length	(int*) The size of total tag storage data (e.g., num_visible_vertices*components_per_entity or num_visible_elements*components_per_entity*num_tags).
[in]	entity_type	(int*) Type=0 for vertices, and Type=1 for primary elements.
[in]	tag_storage_data	(double*) The array data of type double to replace the internal tag memory; The data is assumed to be permuted over the local set of visible entities (either vertices or elements). unrolled by tags in parallel, might be different order, or different entities on the task
[in]	globalIds	global ids of the cells to be set;

Returns

ErrCode The error code indicating success or failure.

Definition at line 2336 of file iMOAB.cpp.

{
    std::string tag_names( tag_storage_names );
    // exactly the same code as for int tag :) maybe should check the type of tag too
    std::vector< std::string > tagNames;
    std::vector< Tag > tagHandles;
    std::string separator( ":" );
    split_tag_names( tag_names, separator, tagNames );
 
    appData& data = context.appDatas[*pid];
    // set it on a subset of entities, based on type and length
    // if *entity_type = 0, then use vertices; else elements
    Range* ents_to_set  = ( *ent_type == 0 ? &data.all_verts : &data.primary_elems );
    int nents_to_be_set = (int)( *ents_to_set ).size();
 
    Tag gidTag = context.MBI->globalId_tag();
    std::vector< int > gids;
    gids.resize( nents_to_be_set );
    MB_CHK_ERR( context.MBI->tag_get_data( gidTag, *ents_to_set, &gids[0] ) );
 
    // so we will need to set the tags according to the global id passed;
    // so the order in tag_storage_data is the same as the order in globalIds, but the order
    // in local range is gids
    std::map< int, EntityHandle > eh_by_gid;
    int i = 0;
    for( Range::iterator it = ents_to_set->begin(); it != ents_to_set->end(); ++it, ++i )
    {
        eh_by_gid[gids[i]] = *it;
    }
 
    /// @todo Allow for tags of different length
    size_t nbLocalVals = *num_tag_storage_length / tagNames.size();  // assumes all tags have the same length?
 
    // check global ids to have different values
    std::set< int > globalIdsSet( globalIds, globalIds + nbLocalVals );
    if( globalIdsSet.size() < nbLocalVals )
    {
        std::cout << "iMOAB_SetDoubleTagStorageWithGid: for pid:" << *pid << " tags[0]:" << tagNames[0]
                  << " global ids passed are not unique, major error\n";
        std::cout << " nbLocalVals:" << nbLocalVals << " globalIdsSet.size():" << globalIdsSet.size()
                  << " first global id:" << globalIds[0] << "\n";
        return moab::MB_FAILURE;
    }
 
    std::vector< int > tagLengths( tagNames.size() );
    std::vector< Tag > tagList;
#ifdef MOAB_HAVE_MPI
    size_t total_tag_len = 0;
#endif
    for( size_t i = 0; i < tagNames.size(); i++ )
    {
        if( data.tagMap.find( tagNames[i] ) == data.tagMap.end() )
        {
            MB_SET_ERR( moab::MB_FAILURE, "tag missing" );
        }  // some tag not defined yet in the app
 
        Tag tag = data.tagMap[tagNames[i]];
        tagList.push_back( tag );
 
        int tagLength = 0;
        MB_CHK_ERR( context.MBI->tag_get_length( tag, tagLength ) );
 
#ifdef MOAB_HAVE_MPI
        total_tag_len += tagLength;
#endif
        tagLengths[i] = tagLength;
        DataType dtype;
        MB_CHK_ERR( context.MBI->tag_get_data_type( tag, dtype ) );
 
        if( dtype != MB_TYPE_DOUBLE )
        {
            MB_SET_ERR( moab::MB_FAILURE, "tag not double type" );
        }
    }
    bool serial = true;
#ifdef MOAB_HAVE_MPI
    ParallelComm* pco  = context.appDatas[*pid].pcomm;
    unsigned num_procs = pco->size();
    if( num_procs > 1 ) serial = false;
#endif
 
    if( serial )
    {
        // we do not assume anymore that the number of entities has to match
        // we will set only what matches, and skip entities that do not have corresponding global ids
        //assert( total_tag_len * nents_to_be_set - *num_tag_storage_length == 0 );
        // tags are unrolled, we loop over global ids first, then careful about tags
        for( int i = 0; i < nents_to_be_set; i++ )
        {
            int gid                                       = globalIds[i];
            std::map< int, EntityHandle >::iterator mapIt = eh_by_gid.find( gid );
            if( mapIt == eh_by_gid.end() ) continue;
            EntityHandle eh = mapIt->second;
            // now loop over tags
            int indexInTagValues = 0;  //
            for( size_t j = 0; j < tagList.size(); j++ )
            {
                indexInTagValues += i * tagLengths[j];
                MB_CHK_ERR( context.MBI->tag_set_data( tagList[j], &eh, 1, &tag_storage_data[indexInTagValues] ) );
                // advance the pointer/index
                indexInTagValues += ( nents_to_be_set - i ) * tagLengths[j];  // at the end of tag data
            }
        }
    }
#ifdef MOAB_HAVE_MPI
    else  // it can be not serial only if pco->size() > 1, parallel
    {
        // in this case, we have to use 2 crystal routers, to send data to the processor that needs it
        // we will create first a tuple to rendevous points, then from there send to the processor that requested it
        // it is a 2-hop global gather scatter
        // we do not expect the sizes to match
        //assert( nbLocalVals * tagNames.size() - *num_tag_storage_length == 0 );
        TupleList TLsend;
        TLsend.initialize( 2, 0, 0, total_tag_len, nbLocalVals );  //  to proc, marker(gid), total_tag_len doubles
        TLsend.enableWriteAccess();
        // the processor id that processes global_id is global_id / num_ents_per_proc
 
        int indexInRealLocal = 0;
        for( size_t i = 0; i < nbLocalVals; i++ )
        {
            // to proc, marker, element local index, index in el
            int marker              = globalIds[i];
            int to_proc             = marker % num_procs;
            int n                   = TLsend.get_n();
            TLsend.vi_wr[2 * n]     = to_proc;  // send to processor
            TLsend.vi_wr[2 * n + 1] = marker;
            int indexInTagValues    = 0;
            // tag data collect by number of tags
            for( size_t j = 0; j < tagList.size(); j++ )
            {
                indexInTagValues += i * tagLengths[j];
                for( int k = 0; k < tagLengths[j]; k++ )
                {
                    TLsend.vr_wr[indexInRealLocal++] = tag_storage_data[indexInTagValues + k];
                }
                indexInTagValues += ( nbLocalVals - i ) * tagLengths[j];
            }
            TLsend.inc_n();
        }
 
        //assert( nbLocalVals * total_tag_len - indexInRealLocal == 0 );
        // send now requests, basically inform the rendez-vous point who needs a particular global id
        // send the data to the other processors:
        ( pco->proc_config().crystal_router() )->gs_transfer( 1, TLsend, 0 );
        TupleList TLreq;
        TLreq.initialize( 2, 0, 0, 0, nents_to_be_set );
        TLreq.enableWriteAccess();
        for( int i = 0; i < nents_to_be_set; i++ )
        {
            // to proc, marker
            int marker             = gids[i];
            int to_proc            = marker % num_procs;
            int n                  = TLreq.get_n();
            TLreq.vi_wr[2 * n]     = to_proc;  // send to processor
            TLreq.vi_wr[2 * n + 1] = marker;
            // tag data collect by number of tags
            TLreq.inc_n();
        }
 
        // perform communication with crystal router
        pco->proc_config().crystal_router()->gs_transfer( 1, TLreq, 0 );
 
        // we know now that process TLreq.vi_wr[2 * n] needs tags for gid TLreq.vi_wr[2 * n + 1]
        // we should first order by global id, and then build the new TL with send to proc, global id and
        // tags for it
        // sort by global ids the tuple lists
        moab::TupleList::buffer sort_buffer;
        sort_buffer.buffer_init( TLreq.get_n() );
        TLreq.sort( 1, &sort_buffer );
        sort_buffer.reset();
        sort_buffer.buffer_init( TLsend.get_n() );
        TLsend.sort( 1, &sort_buffer );
        sort_buffer.reset();
        // now send the tag values to the proc that requested it
        // in theory, for a full  partition, TLreq  and TLsend should have the same size, and
        // each dof should have exactly one target proc. Is that true or not in general ?
        // how do we plan to use this? Is it better to store the comm graph for future
 
        // start copy from comm graph settle
        TupleList TLBack;
        TLBack.initialize( 3, 0, 0, total_tag_len, 0 );  // to proc, marker, tag from proc , tag values
        TLBack.enableWriteAccess();
 
        int n1 = TLreq.get_n();
        int n2 = TLsend.get_n();
 
        int indexInTLreq  = 0;
        int indexInTLsend = 0;  // advance both, according to the marker
        if( n1 > 0 && n2 > 0 )
        {
 
            while( indexInTLreq < n1 && indexInTLsend < n2 )  // if any is over, we are done
            {
                int currentValue1 = TLreq.vi_rd[2 * indexInTLreq + 1];
                int currentValue2 = TLsend.vi_rd[2 * indexInTLsend + 1];
                if( currentValue1 < currentValue2 )
                {
                    // we have a big problem; basically, we are saying that
                    // dof currentValue is on one model and not on the other
                    indexInTLreq++;
                    continue;
                }
 
                if( currentValue1 > currentValue2 )
                {
                    indexInTLsend++;
                    continue;
                }
 
                int size1 = 1;
                while( indexInTLreq + size1 < n1 && currentValue1 == TLreq.vi_rd[2 * ( indexInTLreq + size1 ) + 1] )
                    size1++;
                int size2 = 1;
                while( indexInTLsend + size2 < n2 && currentValue2 == TLsend.vi_rd[2 * ( indexInTLsend + size2 ) + 1] )
                    size2++;
 
                // must be found in both lists, find the start and end indices
                for( int i1 = 0; i1 < size1; i1++ )
                {
                    for( int i2 = 0; i2 < size2; i2++ )
                    {
                        // send the info back to components
                        int n = TLBack.get_n();
                        TLBack.reserve();
                        TLBack.vi_wr[3 * n] = TLreq.vi_rd[2 * ( indexInTLreq + i1 )];  // send back to the proc marker
                                                                                       // came from, info from comp2
                        TLBack.vi_wr[3 * n + 1] = currentValue1;  // initial value (resend, just for verif ?)
                        TLBack.vi_wr[3 * n + 2] = TLsend.vi_rd[2 * ( indexInTLsend + i2 )];  // from proc on comp2
                        // also fill tag values
                        for( size_t k = 0; k < total_tag_len; k++ )
                        {
                            TLBack.vr_rd[total_tag_len * n + k] =
                                TLsend.vr_rd[total_tag_len * indexInTLsend + k];  // deep copy of tag values
                        }
                    }
                }
                indexInTLreq += size1;
                indexInTLsend += size2;
            }
        }
 
        // invoke crystal router
        pco->proc_config().crystal_router()->gs_transfer( 1, TLBack, 0 );
 
        // end copy from comm graph
        // after we are done sending, we need to set those tag values, in a reverse process compared to send
        n1             = TLBack.get_n();
        double* ptrVal = &TLBack.vr_rd[0];  //
        for( int i = 0; i < n1; i++ )
        {
            const int gid    = TLBack.vi_rd[3 * i + 1];  // marker
            const auto mapIt = eh_by_gid.find( gid );
            if( mapIt == eh_by_gid.end() ) continue;
 
            EntityHandle eh = mapIt->second;
            // now loop over tags
            for( size_t j = 0; j < tagList.size(); j++ )
            {
                MB_CHK_ERR( context.MBI->tag_set_data( tagList[j], &eh, 1, (void*)ptrVal ) );
                // advance the pointer/index
                ptrVal += tagLengths[j];  // at the end of tag data per call
            }
        }
    }
#endif
    return MB_SUCCESS;
}

References appData::all_verts, GlobalContext::appDatas, moab::Range::begin(), context, moab::ProcConfig::crystal_router(), moab::TupleList::enableWriteAccess(), moab::Range::end(), moab::TupleList::get_n(), moab::Interface::globalId_tag(), moab::TupleList::inc_n(), moab::TupleList::initialize(), MB_CHK_ERR, MB_SET_ERR, MB_SUCCESS, MB_TYPE_DOUBLE, GlobalContext::MBI, appData::primary_elems, moab::ParallelComm::proc_config(), moab::TupleList::reserve(), moab::TupleList::buffer::reset(), moab::Range::size(), moab::ParallelComm::size(), moab::TupleList::sort(), split_tag_names(), moab::Interface::tag_get_data(), moab::Interface::tag_get_data_type(), moab::Interface::tag_get_length(), moab::Interface::tag_set_data(), appData::tagMap, moab::TupleList::vi_rd, moab::TupleList::vi_wr, moab::TupleList::vr_rd, and moab::TupleList::vr_wr.

iMOAB_SetGlobalInfo()

ErrCode iMOAB_SetGlobalInfo	(	iMOAB_AppID	pid,
		int *	num_global_verts,
		int *	num_global_elems
	)

Set global information for number of vertices and number of elements; It is usually available from the h5m file, or it can be computed with a MPI_Reduce.

Parameters

[in]	pid	(iMOAB_AppID) The unique pointer to the application ID.
[in]	num_global_verts	(int*) The number of total vertices in the mesh.
[in]	num_global_elems	(MPI_Comm) The number of total elements in the mesh.

Returns

ErrCode The error code indicating success or failure.

Definition at line 2999 of file iMOAB.cpp.

{
    appData& data            = context.appDatas[*pid];
    data.num_global_vertices = *num_global_verts;
    data.num_global_elements = *num_global_elems;
    return moab::MB_SUCCESS;
}

References GlobalContext::appDatas, context, MB_SUCCESS, appData::num_global_elements, and appData::num_global_vertices.

Referenced by iMOAB_UpdateMeshInfo().

iMOAB_SetIntTagStorage()

ErrCode iMOAB_SetIntTagStorage	(	iMOAB_AppID	pid,
		const iMOAB_String	tag_storage_name,
		int *	num_tag_storage_length,
		int *	entity_type,
		int *	tag_storage_data
	)

Store the specified values in a MOAB integer Tag.

Values are set on vertices or elements, depending on entity_type

Note

we could change the api to accept as input the tag index, as returned by iMOAB_DefineTagStorage.

Operations: Collective

Parameters

[in]	pid	(iMOAB_AppID) The unique pointer to the application ID.
[in]	tag_storage_name	(iMOAB_String) The tag name to store/retreive the data in MOAB.
[in]	num_tag_storage_length	(int*) The size of tag storage data (e.g., num_visible_vertices*components_per_entity or num_visible_elements*components_per_entity).
[in]	entity_type	(int*) Type=0 for vertices, and Type=1 for primary elements.
[out]	tag_storage_data	(int*) The array data of type int to replace the internal tag memory; The data is assumed to be contiguous over the local set of visible entities (either vertices or elements).

Returns

ErrCode The error code indicating success or failure.

Definition at line 2199 of file iMOAB.cpp.

{
    std::string tag_name( tag_storage_name );
 
    // Get the application data
    appData& data = context.appDatas[*pid];
    // check if tag is defined
    if( data.tagMap.find( tag_name ) == data.tagMap.end() ) return moab::MB_FAILURE;
 
    Tag tag = data.tagMap[tag_name];
 
    int tagLength = 0;
    MB_CHK_ERR( context.MBI->tag_get_length( tag, tagLength ) );
 
    DataType dtype;
    MB_CHK_ERR( context.MBI->tag_get_data_type( tag, dtype ) );
 
    if( dtype != MB_TYPE_INTEGER )
    {
        MB_CHK_SET_ERR( moab::MB_FAILURE, "The tag is not of integer type." );
    }
 
    // set it on a subset of entities, based on type and length
    // if *entity_type = 0, then use vertices; else elements
    Range* ents_to_set  = ( *ent_type == 0 ? &data.all_verts : &data.primary_elems );
    int nents_to_be_set = *num_tag_storage_length / tagLength;
 
    if( nents_to_be_set > (int)ents_to_set->size() )
    {
        return moab::MB_FAILURE;
    }  // to many entities to be set or too few
 
    // now set the tag data
    MB_CHK_ERR( context.MBI->tag_set_data( tag, *ents_to_set, tag_storage_data ) );
 
    return moab::MB_SUCCESS;  // no error
}

References appData::all_verts, GlobalContext::appDatas, context, MB_CHK_ERR, MB_CHK_SET_ERR, MB_SUCCESS, MB_TYPE_INTEGER, GlobalContext::MBI, appData::primary_elems, moab::Range::size(), moab::Interface::tag_get_data_type(), moab::Interface::tag_get_length(), moab::Interface::tag_set_data(), and appData::tagMap.

iMOAB_SynchronizeTags()

ErrCode iMOAB_SynchronizeTags	(	iMOAB_AppID	pid,
		int *	num_tag,
		int *	tag_indices,
		int *	ent_type
	)

Exchange tag values for the given tags across process boundaries.

Note

Operations: Collective

Parameters

[in]	pid	(iMOAB_AppID) The unique pointer to the application ID.
[in]	num_tags	(int*) Number of tags to exchange.
[in]	tag_indices	(int*) Array with tag indices of interest (size = *num_tags).
[in]	ent_type	(int*) The type of entity for tag exchange.

Returns

ErrCode The error code indicating success or failure.

Definition at line 2788 of file iMOAB.cpp.

{
#ifdef MOAB_HAVE_MPI
    appData& data = context.appDatas[*pid];
    Range ent_exchange;
    std::vector< Tag > tags;
 
    for( int i = 0; i < *num_tag; i++ )
    {
        if( tag_indices[i] < 0 || tag_indices[i] >= (int)data.tagList.size() )
        {
            return moab::MB_FAILURE;
        }  // error in tag index
 
        tags.push_back( data.tagList[tag_indices[i]] );
    }
 
    if( *ent_type == 0 )
    {
        ent_exchange = data.all_verts;
    }
    else if( *ent_type == 1 )
    {
        ent_exchange = data.primary_elems;
    }
    else
    {
        return moab::MB_FAILURE;
    }  // unexpected type
 
    ParallelComm* pco = context.appDatas[*pid].pcomm;
 
    MB_CHK_ERR( pco->exchange_tags( tags, tags, ent_exchange ) );
 
#else
    /* do nothing if serial */
    UNUSED( pid );
    UNUSED( num_tag );
    UNUSED( tag_indices );
    UNUSED( ent_type );
#endif
 
    return moab::MB_SUCCESS;
}

References appData::all_verts, GlobalContext::appDatas, context, moab::ParallelComm::exchange_tags(), MB_CHK_ERR, MB_SUCCESS, appData::primary_elems, appData::tagList, and UNUSED.