moab::WriteUtil Class Reference

#include <WriteUtil.hpp>

Inheritance diagram for moab::WriteUtil:

Collaboration diagram for moab::WriteUtil:

Public Member Functions
	WriteUtil (Core *mdb)
	Constructor takes Core pointer. More...
	~WriteUtil ()
	Destructor. More...
virtual ErrorCode	check_doesnt_exist (const char *file_name)
	Check if the specified file already exists. Returns MB_SUCCESS if file does not exist, MB_ALREADY_ALLOCATED if file does exist, or MB_FAILURE for some other error condition. More...
virtual ErrorCode	gather_entities (Range &all_ents, const EntityHandle *ent_sets=NULL, const int num_sets=0)
	Gather all entities in the mesh, or in the sets specified. More...
ErrorCode	get_node_coords (const int num_arrays, const int num_nodes, const Range &entities, Tag node_id_tag, const int start_node_id, std::vector< double * > &arrays)
	Gets arrays for coordinate data from the MB. More...
ErrorCode	get_node_coords (const int which_array, Range::const_iterator begin, const Range::const_iterator &end, const size_t output_size, double *const output_array)
ErrorCode	get_element_connect (const int num_elements, const int verts_per_element, Tag node_id_tag, const Range &entities, Tag element_id_tag, int start_element_id, int *array, bool add_sizes=false)
ErrorCode	get_element_connect (Range::const_iterator begin, const Range::const_iterator &end, const int vertices_per_elem, Tag node_id_tag, const size_t array_size, int *const element_array, bool add_sizes=false)
virtual ErrorCode	get_element_connect (Range::const_iterator begin, const Range::const_iterator &end, const int vertices_per_elem, const size_t array_size, EntityHandle *const element_array)
virtual ErrorCode	get_poly_connect_size (Range::const_iterator begin, const Range::const_iterator &end, int &connectivity_size)
virtual ErrorCode	get_poly_connect (Range::const_iterator &iter, const Range::const_iterator &end, const Tag node_id_tag, size_t &handle_array_len, int *const handle_array, size_t &index_array_len, int *const index_array, int &index_offset)
ErrorCode	gather_nodes_from_elements (const Range &elements, const Tag node_bit_mark_tag, Range &nodes)
	Get a set of nodes that represent a set of elements. More...
ErrorCode	assign_ids (Range &elements, Tag id_tag, const int start_id)
	Assign ids to input elements starting with start_id, written to id_tag if zero, assigns to GLOBAL_ID_TAG_NAME. More...
ErrorCode	get_adjacencies (EntityHandle entity, Tag id_tag, std::vector< int > &adj)
ErrorCode	get_adjacencies (EntityHandle entity, const EntityHandle *&adj_array, int &num_adj)
virtual ErrorCode	get_tag_list (std::vector< Tag > &result_list, const Tag *user_tag_list=0, int user_tag_list_length=0, bool include_variable_length_tags=true)
	Get list of tags to write. More...
virtual ErrorCode	get_entity_list_pointers (Range::const_iterator query_begin, Range::const_iterator query_end, EntityHandle const **output_pointer_array, EntityListType relation=CONTENTS, int *lengths=0, unsigned char *flags=0)
virtual ErrorCode	get_entity_list_pointers (EntityHandle const *entities, int num_entities, EntityHandle const **output_pointer_array, EntityListType relation=CONTENTS, int *lengths=0, unsigned char *flags=0)
Public Member Functions inherited from moab::WriteUtilIface
	WriteUtilIface ()
	Constructor. More...
virtual	~WriteUtilIface ()
	Destructor. More...

Private Attributes
Core *	mMB
	Pointer to the Core. More...

Additional Inherited Members
Public Types inherited from moab::WriteUtilIface
enum	EntityListType { CONTENTS = 0 , CHILDREN = 1 , PARENTS = 2 , TOPOLOGICAL = 1 }
Static Public Member Functions inherited from moab::WriteUtilIface
template<typename T >
static void	reorder (const int *order, T *conn, int num_elem, int node_per_elem)
	Re-order outgoing element connectivity. More...

Detailed Description

Definition at line 30 of file WriteUtil.hpp.

Constructor & Destructor Documentation

WriteUtil()

moab::WriteUtil::WriteUtil

(

Core *

mdb

)

Constructor takes Core pointer.

Definition at line 46 of file WriteUtil.cpp.

: WriteUtilIface(), mMB( mdb ) {}

~WriteUtil()

moab::WriteUtil::~WriteUtil ( )

inline

Destructor.

Definition at line 41 of file WriteUtil.hpp.

{}

Member Function Documentation

assign_ids()

ErrorCode moab::WriteUtil::assign_ids ( Range &  elements, Tag  id_tag, const int  start_id  )

virtual

Assign ids to input elements starting with start_id, written to id_tag if zero, assigns to GLOBAL_ID_TAG_NAME.

Implements moab::WriteUtilIface.

Definition at line 654 of file WriteUtil.cpp.

{
    ErrorCode result;
    if( 0 == id_tag )
    {
        // Get the global id tag
        id_tag = mMB->globalId_tag();
    }
 
    // Now assign the ids
    int i;
    Range::iterator rit;
    ErrorCode tmp_result;
    result = MB_SUCCESS;
    for( i = start_id, rit = elements.begin(); rit != elements.end(); ++rit, i++ )
    {
        tmp_result = mMB->tag_set_data( id_tag, &( *rit ), 1, &i );
        if( MB_SUCCESS != tmp_result ) result = tmp_result;
    }
 
    return result;
}

References moab::Range::begin(), moab::Range::end(), ErrorCode, moab::Core::globalId_tag(), MB_SUCCESS, mMB, and moab::Core::tag_set_data().

check_doesnt_exist()

ErrorCode moab::WriteUtil::check_doesnt_exist ( const char *  file_name )

virtual

Check if the specified file already exists. Returns MB_SUCCESS if file does not exist, MB_ALREADY_ALLOCATED if file does exist, or MB_FAILURE for some other error condition.

Implements moab::WriteUtilIface.

Definition at line 51 of file WriteUtil.cpp.

{
    struct stat s;
    if( 0 == stat( file_name, &s ) )
    {
        MB_SET_ERR( MB_ALREADY_ALLOCATED, file_name << ": file already exists" );
    }
    else if( errno == ENOENT )
        return MB_SUCCESS;
    else
        return MB_FAILURE;
}

References MB_ALREADY_ALLOCATED, MB_SET_ERR, and MB_SUCCESS.

gather_entities()

ErrorCode moab::WriteUtil::gather_entities ( Range &  all_ents, const EntityHandle *  ent_sets = NULL, const int  num_sets = 0  )

virtual

Gather all entities in the mesh, or in the sets specified.

Parameters

all_ents	range in which entities are returned
ent_sets	entity sets whose contents are to be gathered
num_sets	number of sets in list

Implements moab::WriteUtilIface.

Definition at line 65 of file WriteUtil.cpp.

{
    ErrorCode rval = MB_SUCCESS;
    if( !ent_sets || num_sets == 0 )
    {
        rval = mMB->get_entities_by_handle( 0, all_ents );
    }
    else
    {
        for( int i = 0; i < num_sets; i++ )
        {
            ErrorCode tmp_rval = mMB->get_entities_by_handle( ent_sets[i], all_ents );
            if( MB_SUCCESS != tmp_rval ) rval = tmp_rval;
        }
    }
 
    return rval;
}

References ErrorCode, moab::Core::get_entities_by_handle(), MB_SUCCESS, and mMB.

gather_nodes_from_elements()

ErrorCode moab::WriteUtil::gather_nodes_from_elements ( const Range &  elements, const Tag  node_bit_mark_tag, Range &  nodes  )

virtual

Get a set of nodes that represent a set of elements.

Implements moab::WriteUtilIface.

Definition at line 515 of file WriteUtil.cpp.

{
    bool printed_warning = false;
 
    if( elements.empty() ) return MB_SUCCESS;
 
    if( TYPE_FROM_HANDLE( elements.front() ) <= MBVERTEX || TYPE_FROM_HANDLE( elements.back() ) >= MBENTITYSET )
        return MB_TYPE_OUT_OF_RANGE;
 
    // See if we need to use our own marking tag
    Tag exporting_nodes_tag = 0;
    if( node_bit_mark_tag )
        exporting_nodes_tag = node_bit_mark_tag;
    else
    {
        mMB->tag_get_handle( "__MBWriteUtil::exporting_nodes", 1, MB_TYPE_BIT, exporting_nodes_tag, MB_TAG_CREAT );
    }
 
    // The x,y,z tag handles we need
    EntityHandle lower_bound = ~0, upper_bound = 0;
 
    std::vector< EntityHandle > tmp_conn;
 
    RangeSeqIntersectIter iter( mMB->sequence_manager() );
    for( ErrorCode rval = iter.init( elements.begin(), elements.end() ); MB_FAILURE != rval; rval = iter.step() )
    {
        if( MB_ENTITY_NOT_FOUND == rval )
        {
            if( !printed_warning )
            {
                std::cerr << "Warning: ignoring invalid element handle(s) in gather_nodes_from_elements" << std::endl;
                printed_warning = true;
            }
            continue;
        }
 
        ElementSequence* seq = static_cast< ElementSequence* >( iter.get_sequence() );
 
        // Get the connectivity array
        const EntityHandle* conn_array = seq->get_connectivity_array();
 
        // If unstructured mesh
        if( conn_array && mMB->type_from_handle( iter.get_start_handle() ) != MBPOLYHEDRON )
        {
            assert( iter.get_start_handle() >= seq->start_handle() );
            assert( iter.get_end_handle() <= seq->end_handle() );
            const EntityHandle offset   = iter.get_start_handle() - seq->start_handle();
            const EntityHandle num_elem = iter.get_end_handle() - iter.get_start_handle() + 1;
 
            conn_array += offset * seq->nodes_per_element();
            const EntityHandle num_node = num_elem * seq->nodes_per_element();
 
            // For each node
            for( EntityHandle j = 0; j < num_node; j++ )
            {
                EntityHandle node = conn_array[j];
                if( node < lower_bound ) lower_bound = node;
                if( node > upper_bound ) upper_bound = node;
                unsigned char bit = 0x1;
                rval              = mMB->tag_set_data( exporting_nodes_tag, &node, 1, &bit );
                assert( MB_SUCCESS == rval );
                if( MB_SUCCESS != rval ) return rval;
            }
        }
        // Polyhedra
        else if( conn_array && mMB->type_from_handle( iter.get_start_handle() ) == MBPOLYHEDRON )
        {
            assert( iter.get_start_handle() >= seq->start_handle() );
            assert( iter.get_end_handle() <= seq->end_handle() );
            const EntityHandle offset   = iter.get_start_handle() - seq->start_handle();
            const EntityHandle num_elem = iter.get_end_handle() - iter.get_start_handle() + 1;
 
            conn_array += offset * seq->nodes_per_element();
            int num_face = num_elem * seq->nodes_per_element();
 
            // For each node
            for( int j = 0; j < num_face; j++ )
            {
                const EntityHandle* face_conn = NULL;
                int face_num_conn             = 0;
                rval                          = mMB->get_connectivity( conn_array[j], face_conn, face_num_conn, false );
                if( MB_SUCCESS != rval ) return rval;
                for( int k = 0; k < face_num_conn; k++ )
                {
                    EntityHandle node = face_conn[k];
                    if( node < lower_bound ) lower_bound = node;
                    if( node > upper_bound ) upper_bound = node;
                    unsigned char bit = 0x1;
                    rval              = mMB->tag_set_data( exporting_nodes_tag, &node, 1, &bit );
                    assert( MB_SUCCESS == rval );
                    if( MB_SUCCESS != rval ) return rval;
                }
            }
        }
        // Structured mesh
        else
        {
            EntityHandle end_h = iter.get_end_handle() + 1;
            for( EntityHandle h = iter.get_start_handle(); h < end_h; ++h )
            {
                tmp_conn.clear();
                rval = seq->get_connectivity( h, tmp_conn, false );
                if( MB_SUCCESS != rval )
                {
                    if( node_bit_mark_tag == 0 ) mMB->tag_delete( exporting_nodes_tag );
                    return rval;
                }
 
                // For each node
                for( size_t j = 0; j < tmp_conn.size(); j++ )
                {
                    EntityHandle node = tmp_conn[j];
                    if( node < lower_bound ) lower_bound = node;
                    if( node > upper_bound ) upper_bound = node;
                    unsigned char bit = 0x1;
                    mMB->tag_set_data( exporting_nodes_tag, &node, 1, &bit );
                }
            }
        }
    }
 
    // We can get a REALLY long loop if lower_bound is zero
    assert( lower_bound != 0 );
    // Gather up all the nodes
    for( ; upper_bound >= lower_bound; --upper_bound )
    {
        unsigned char node_marked = 0;
        mMB->tag_get_data( exporting_nodes_tag, &upper_bound, 1, &node_marked );
        if( node_marked == 0x1 ) nodes.insert( upper_bound );
    }
 
    // Clean up our own marking tag
    if( node_bit_mark_tag == 0 ) mMB->tag_delete( exporting_nodes_tag );
 
    return MB_SUCCESS;
}

References moab::Range::back(), moab::Range::begin(), moab::Range::empty(), moab::Range::end(), moab::EntitySequence::end_handle(), ErrorCode, moab::Range::front(), moab::Core::get_connectivity(), moab::ElementSequence::get_connectivity(), moab::ElementSequence::get_connectivity_array(), moab::RangeSeqIntersectIter::get_end_handle(), moab::RangeSeqIntersectIter::get_sequence(), moab::RangeSeqIntersectIter::get_start_handle(), moab::RangeSeqIntersectIter::init(), moab::Range::insert(), MB_ENTITY_NOT_FOUND, MB_SUCCESS, MB_TAG_CREAT, MB_TYPE_BIT, MB_TYPE_OUT_OF_RANGE, MBENTITYSET, MBPOLYHEDRON, MBVERTEX, mMB, moab::ElementSequence::nodes_per_element(), moab::Core::sequence_manager(), moab::EntitySequence::start_handle(), moab::RangeSeqIntersectIter::step(), moab::Core::tag_delete(), moab::Core::tag_get_data(), moab::Core::tag_get_handle(), moab::Core::tag_set_data(), moab::Core::type_from_handle(), and moab::TYPE_FROM_HANDLE().

get_adjacencies() [1/2]

ErrorCode moab::WriteUtil::get_adjacencies ( EntityHandle  entity, const EntityHandle *&  adj_array, int &  num_adj  )

virtual

Implements moab::WriteUtilIface.

Definition at line 709 of file WriteUtil.cpp.

{
    return mMB->a_entity_factory()->get_adjacencies( entity, adj_array, num_adj );
}

References moab::Core::a_entity_factory(), moab::AEntityFactory::get_adjacencies(), and mMB.

get_adjacencies() [2/2]

ErrorCode moab::WriteUtil::get_adjacencies ( EntityHandle  entity, Tag  id_tag, std::vector< int > &  adj  )

virtual

Get explicit adjacencies

Get explicit adjacences stored in database. Does not create any explicit adjacencies or search for implicit ones.

Parameters

entity	The entity to retrieve adjacencies for.
id_tag	The global ID tag
adj	The output list of global IDs of adjacent entities.

Implements moab::WriteUtilIface.

Definition at line 677 of file WriteUtil.cpp.

{
    ErrorCode rval;
    const EntityHandle* adj_array;
    int num_adj, id;
 
    // Get handles of adjacent entities
    rval = mMB->a_entity_factory()->get_adjacencies( entity, adj_array, num_adj );
    if( MB_SUCCESS != rval )
    {
        adj.clear();
        return rval;
    }
 
    // Append IDs of adjacent entities -- skip meshsets
    adj.resize( num_adj );  // Pre-allocate space
    adj.clear();            // Clear used space
 
    const EntityHandle* const end = adj_array + num_adj;
    for( const EntityHandle* iter = adj_array; iter != end; ++iter )
    {
        if( TYPE_FROM_HANDLE( *iter ) != MBENTITYSET )
        {
            rval = mMB->tag_get_data( id_tag, iter, 1, &id );
            if( MB_SUCCESS != rval ) return rval;
            adj.push_back( id );
        }
    }
 
    return MB_SUCCESS;
}

References moab::Core::a_entity_factory(), ErrorCode, moab::AEntityFactory::get_adjacencies(), MB_SUCCESS, MBENTITYSET, mMB, moab::Core::tag_get_data(), and moab::TYPE_FROM_HANDLE().

get_element_connect() [1/3]

ErrorCode moab::WriteUtil::get_element_connect ( const int  num_elements, const int  verts_per_element, Tag  node_id_tag, const Range &  entities, Tag  element_id_tag, int  start_element_id, int *  array, bool  add_sizes = false  )

virtual

Get connectivity for elements

Get the connectivity list for a range of elements.

Parameters

num_elements	Number of elements for which connectivity is needed
vertices_per_elem	Number of vertices to retrieve for each element.
node_id_tag	A tag with integer values.
entities	Entities being queried
element_id_tag	If non-zero, elements are tagged with an id starting at start_element_id
start_element_id	Starting id value for element_id_tag
add_sizes	If true, writes size of connect array before connectivity in array

Implements moab::WriteUtilIface.

Definition at line 215 of file WriteUtil.cpp.

{
    // Check the data we got
    if( num_elements < 1 ) return MB_FAILURE;
    if( verts_per_element < 1 ) return MB_FAILURE;
    if( elements.empty() ) return MB_FAILURE;
    if( !element_array ) return MB_FAILURE;
 
    Range::const_iterator range_iter     = elements.begin();
    Range::const_iterator range_iter_end = elements.end();
 
    TypeSequenceManager::iterator seq_iter, seq_iter_end;
    EntityType current_type = TYPE_FROM_HANDLE( *range_iter );
 
    seq_iter     = mMB->sequence_manager()->entity_map( current_type ).begin();
    seq_iter_end = mMB->sequence_manager()->entity_map( current_type ).end();
 
    // Let's find the entity sequence which holds the first entity
    TypeSequenceManager::iterator seq_iter_lookahead = seq_iter;
    ++seq_iter_lookahead;
    for( ; seq_iter_lookahead != seq_iter_end && ( *seq_iter_lookahead )->start_handle() < *range_iter; )
    {
        ++seq_iter;
        ++seq_iter_lookahead;
    }
 
    // A look ahead iterator
    Range::const_iterator range_iter_lookahead = range_iter;
 
    // Our main loop
    for( ; range_iter != range_iter_end && seq_iter != seq_iter_end; /* ++ is handled in loop*/ )
    {
        // Find a range that fits in the current entity sequence
        for( ; range_iter_lookahead != range_iter_end && *range_iter_lookahead <= ( *seq_iter )->end_handle();
             ++range_iter_lookahead )
        {
        }
 
        if( current_type != TYPE_FROM_HANDLE( *range_iter ) )
        {
            current_type = TYPE_FROM_HANDLE( *range_iter );
            seq_iter     = mMB->sequence_manager()->entity_map( current_type ).begin();
            seq_iter_end = mMB->sequence_manager()->entity_map( current_type ).end();
 
            // Let's find the entity sequence which holds the first entity of this type
            TypeSequenceManager::const_iterator seq_iter_lookahead2 = seq_iter;
            ++seq_iter_lookahead2;
            for( ; seq_iter_lookahead2 != seq_iter_end && ( *seq_iter_lookahead2 )->start_handle() < *range_iter; )
            {
                ++seq_iter;
                ++seq_iter_lookahead2;
            }
        }
 
        int i = static_cast< ElementSequence* >( *seq_iter )->nodes_per_element();
 
        // Get the connectivity array
        EntityHandle* conn_array = static_cast< ElementSequence* >( *seq_iter )->get_connectivity_array();
 
        EntityHandle start_handle = ( *seq_iter )->start_handle();
 
        for( Range::const_iterator tmp_iter = range_iter; tmp_iter != range_iter_lookahead; ++tmp_iter )
        {
            // Set the element id tag
            mMB->tag_set_data( element_id_tag, &*tmp_iter, 1, &start_element_id );
            ++start_element_id;
 
            if( add_sizes ) *element_array++ = i;
 
            // For each node
            for( int j = 0; j < i; j++ )
            {
                EntityHandle node = *( conn_array + j + i * ( *tmp_iter - start_handle ) );
                mMB->tag_get_data( node_id_tag, &node, 1, element_array );
                element_array++;
            }
        }
 
        // Go to the next entity sequence
        ++seq_iter;
        // Start with the next entities
        range_iter = range_iter_lookahead;
    }
 
    return MB_SUCCESS;
}

References moab::Range::begin(), moab::TypeSequenceManager::begin(), moab::Range::empty(), moab::Range::end(), moab::TypeSequenceManager::end(), moab::SequenceManager::entity_map(), moab::ElementSequence::get_connectivity_array(), MB_SUCCESS, mMB, moab::ElementSequence::nodes_per_element(), moab::Core::sequence_manager(), moab::Core::tag_get_data(), moab::Core::tag_set_data(), and moab::TYPE_FROM_HANDLE().

get_element_connect() [2/3]

ErrorCode moab::WriteUtil::get_element_connect ( Range::const_iterator  begin, const Range::const_iterator &  end, const int  vertices_per_elem, const size_t  array_size, EntityHandle *const  element_array  )

virtual

Get connectivity for elements

Get the connectivity list for a range of elements.

Failure cases:

• Passed range is empty (begin == end).
• vertices_per_elem is less than one
• element_array is null.
• The range contains invalid handles (non-existent entities, not an element, etc.)
• Insufficient space in passed array.

Parameters

begin	The first element handle
end	One past the last element handle
vertices_per_elem	Number of vertices to retrieve for each element. If the element has more vertices, the element connectivity will be truncated. If vertices_per_elem is greater than the number of nodes for an element, the data will be padded with zeros.
array_size	The length of element_array
element_array	The memory location at which to store the connectivity list.

Author

Jason Kraftcheck

Implements moab::WriteUtilIface.

Definition at line 407 of file WriteUtil.cpp.

{
    // Check the data we got
    if( iter == end ) return MB_FAILURE;
    if( vertices_per_elem < 1 ) return MB_FAILURE;
    if( !element_array || elem_array_size < (unsigned)vertices_per_elem ) return MB_FAILURE;
 
    // Sequence iterators
    TypeSequenceManager::const_iterator seq_iter, seq_end;
 
    // Loop over range, getting coordinate value
    EntityType current_type        = MBMAXTYPE;
    EntityHandle* output_iter      = element_array;
    EntityHandle* const output_end = element_array + elem_array_size;
    while( iter != end )
    {
        // Make sure we have the right sequence list (and get the sequence
        // list for the first iteration.)
        EntityType type = TYPE_FROM_HANDLE( *iter );
        if( type != current_type )
        {
            if( type >= MBENTITYSET || type < MBEDGE ) return MB_FAILURE;
            seq_iter     = mMB->sequence_manager()->entity_map( type ).begin();
            seq_end      = mMB->sequence_manager()->entity_map( type ).end();
            current_type = type;
        }
 
        // Find the sequence containing the current handle
        while( seq_iter != seq_end && ( *seq_iter )->end_handle() < *iter )
            ++seq_iter;
        if( seq_iter == seq_end || *iter < ( *seq_iter )->start_handle() ) return MB_FAILURE;
 
        // Get the connectivity array
        EntityHandle* conn_array = NULL;
        int conn_size            = static_cast< ElementSequence* >( *seq_iter )->nodes_per_element();
        if( conn_size != vertices_per_elem ) return MB_FAILURE;
        conn_array = static_cast< ElementSequence* >( *seq_iter )->get_connectivity_array();
 
        // Determine how much of the sequence we want.
        Range::pair_iterator pair( iter );
        Range::const_iterator prev( end );
        --prev;
        EntityHandle range_end    = pair->second;
        EntityHandle sequence_end = ( *seq_iter )->end_handle();
        EntityHandle end_handle   = range_end > sequence_end ? sequence_end : range_end;
        if( end_handle > *prev ) end_handle = *prev;
        EntityHandle count = end_handle - *iter + 1;
 
        // Get offset in sequence to start at
        assert( *iter >= ( *seq_iter )->start_handle() );
        EntityHandle offset = *iter - ( *seq_iter )->start_handle();
 
        // Make sure sufficient space in output array
        if( output_iter + ( count * conn_size ) > output_end ) return MB_FAILURE;
 
        if( conn_array == NULL )
        {  // If it is structured mesh
            ErrorCode rval;
            int temp_buff_size = conn_size * sizeof( EntityHandle );
            for( unsigned i = 0; i < count; i++ )
            {  // Copy connectivity element by element
                std::vector< EntityHandle > connect;
                rval = static_cast< ElementSequence* >( *seq_iter )->get_connectivity( *iter, connect );
                if( MB_SUCCESS != rval )
                {
                    return rval;
                }
                memcpy( output_iter, &connect[0], temp_buff_size );
                output_iter += conn_size;
                ++iter;
            }
        }
        else
        {
            // Copy connectivity into output array
            conn_array += ( conn_size * offset );
            memcpy( output_iter, conn_array, count * conn_size * sizeof( EntityHandle ) );
            output_iter += count * conn_size;
            iter += count;
        }
    }
 
    return MB_SUCCESS;
}

References moab::TypeSequenceManager::begin(), moab::TypeSequenceManager::end(), moab::SequenceManager::entity_map(), ErrorCode, moab::ElementSequence::get_connectivity(), moab::ElementSequence::get_connectivity_array(), MB_SUCCESS, MBEDGE, MBENTITYSET, MBMAXTYPE, mMB, moab::ElementSequence::nodes_per_element(), moab::Core::sequence_manager(), and moab::TYPE_FROM_HANDLE().

get_element_connect() [3/3]

ErrorCode moab::WriteUtil::get_element_connect ( Range::const_iterator  begin, const Range::const_iterator &  end, const int  vertices_per_elem, Tag  node_id_tag, const size_t  array_size, int *const  element_array, bool  add_sizes = false  )

virtual

Get connectivity for elements

Get the connectivity list for a range of elements.

Failure cases:

• Passed range is empty (begin == end).
• vertices_per_elem is less than one
• element_array is null.
• The range contains invalid handles (non-existent entities, not an element, etc.)
• Retrieving ID tag for an entity failed.
• Insufficient space in passed array.

Parameters

begin	The first element handle
end	One past the last element handle
vertices_per_elem	Number of vertices to retrieve for each element. If the element has more vertices, the element connectivity will be truncated. If vertices_per_elem is greater than the number of nodes for an element, the data will be padded with zeros.
node_id_tag	A tag with integer values.
array_size	The length of element_array
element_array	The memory location at which to store the connectivity list.
add_sizes	If true, writes size of connect array before connectivity in array

Author

Jason Kraftcheck

Implements moab::WriteUtilIface.

Definition at line 309 of file WriteUtil.cpp.

{
    // Check the data we got
    if( iter == end ) return MB_FAILURE;
    if( vertices_per_elem < 1 ) return MB_FAILURE;
    if( !element_array || elem_array_size < (unsigned)vertices_per_elem ) return MB_FAILURE;
 
    // Sequence iterators
    TypeSequenceManager::const_iterator seq_iter, seq_end;
 
    // loop over range, getting coordinate value
    EntityType current_type = MBMAXTYPE;
    int* output_iter        = element_array;
    int* const output_end   = element_array + elem_array_size;
    while( iter != end )
    {
        // Make sure we have the right sequence list (and get the sequence
        // list for the first iteration.)
        EntityType type = TYPE_FROM_HANDLE( *iter );
        if( type != current_type )
        {
            if( type >= MBENTITYSET || type < MBEDGE ) return MB_FAILURE;
            seq_iter     = mMB->sequence_manager()->entity_map( type ).begin();
            seq_end      = mMB->sequence_manager()->entity_map( type ).end();
            current_type = type;
        }
 
        // Find the sequence containing the current handle
        while( seq_iter != seq_end && ( *seq_iter )->end_handle() < *iter )
            ++seq_iter;
        if( seq_iter == seq_end || *iter < ( *seq_iter )->start_handle() ) return MB_FAILURE;
 
        // Get the connectivity array
        EntityHandle* conn_array = NULL;
        int conn_size            = static_cast< ElementSequence* >( *seq_iter )->nodes_per_element();
        conn_array               = static_cast< ElementSequence* >( *seq_iter )->get_connectivity_array();
 
        // Determine how much of the sequence we want.
        Range::pair_iterator pair( iter );
        Range::const_iterator prev( end );
        --prev;
        EntityHandle range_end    = pair->second;
        EntityHandle sequence_end = ( *seq_iter )->end_handle();
        EntityHandle end_handle   = range_end > sequence_end ? sequence_end : range_end;
        if( end_handle > *prev ) end_handle = *prev;
        EntityHandle count = end_handle - *iter + 1;
 
        // Get offset in sequence to start at
        assert( *iter >= ( *seq_iter )->start_handle() );
        EntityHandle offset = *iter - ( *seq_iter )->start_handle();
 
        // Make sure sufficient space in output array
        if( ( !add_sizes && output_iter + ( count * conn_size ) > output_end ) ||
            ( add_sizes && output_iter + ( count * ( conn_size + 1 ) ) > output_end ) )
            return MB_FAILURE;
 
        // If the nodes per element match, do in one call
        conn_array += ( conn_size * offset );
        if( vertices_per_elem == conn_size && !add_sizes )
        {
            ErrorCode rval = mMB->tag_get_data( node_id_tag, conn_array, count * conn_size, output_iter );
            if( MB_SUCCESS != rval ) return rval;
 
            output_iter += count * conn_size;
        }
        // Otherwise need to do one at a time
        else
        {
            int min = vertices_per_elem > conn_size ? conn_size : vertices_per_elem;
            for( EntityHandle i = 0; i < count; ++i )
            {
                *output_iter++ = min;
                ErrorCode rval = mMB->tag_get_data( node_id_tag, conn_array, min, output_iter );
                if( MB_SUCCESS != rval ) return rval;
 
                output_iter += min;
                conn_array += conn_size;
 
                if( vertices_per_elem > conn_size )
                {  // Need to pad
                    memset( output_iter, 0, sizeof( int ) * ( vertices_per_elem - conn_size ) );
                    output_iter += ( vertices_per_elem - conn_size );
                }
            }
        }
 
        iter += count;
    }
 
    return MB_SUCCESS;
}

References moab::TypeSequenceManager::begin(), moab::TypeSequenceManager::end(), moab::SequenceManager::entity_map(), ErrorCode, moab::ElementSequence::get_connectivity_array(), MB_SUCCESS, MBEDGE, MBENTITYSET, MBMAXTYPE, mMB, moab::ElementSequence::nodes_per_element(), moab::Core::sequence_manager(), moab::Core::tag_get_data(), and moab::TYPE_FROM_HANDLE().

get_entity_list_pointers() [1/2]

ErrorCode moab::WriteUtil::get_entity_list_pointers ( EntityHandle const *  entities, int  num_entities, EntityHandle const **  output_pointer_array, EntityListType  relation = CONTENTS, int *  lengths = 0, unsigned char *  flags = 0  )

virtual

Implements moab::WriteUtilIface.

Definition at line 860 of file WriteUtil.cpp.

{
    SequenceManager* sm = mMB->sequence_manager();
    const EntitySequence* tmp_seq;
    ErrorCode rval = MB_SUCCESS;
    for( int i = 0; i < num_entities; i++ )
    {
        rval = sm->find( entities[i], tmp_seq );
        if( MB_SUCCESS != rval ) return rval;
 
        EntityType type = TYPE_FROM_HANDLE( entities[i] );
 
        if( MBENTITYSET == type )
        {
            const MeshSetSequence* seq = reinterpret_cast< const MeshSetSequence* >( tmp_seq );
            const MeshSet* set;
            int len = 0;
            size_t clen;
            set = seq->get_set( entities[i] );
            switch( relation )
            {
                case CONTENTS:
                    *pointers = set->get_contents( clen );
                    len       = clen;
                    break;
                case CHILDREN:
                    *pointers = set->get_children( len );
                    break;
                case PARENTS:
                    *pointers = set->get_parents( len );
                    break;
            }
            if( lengths )
            {
                *lengths = len;
                ++lengths;
            }
            if( flags )
            {
                *flags = (unsigned char)set->flags();
                ++flags;
            }
            ++pointers;
        }
        else if( MBVERTEX != type )
        {
            const bool topological = ( relation == TOPOLOGICAL );
            int len;
            const ElementSequence* seq = reinterpret_cast< const ElementSequence* >( tmp_seq );
            rval                       = seq->get_connectivity( entities[i], *pointers, len, topological );
            if( MB_SUCCESS != rval ) return rval;
            if( lengths )
            {
                *lengths = len;
                ++lengths;
            }
            if( flags )
            {
                *flags = 0;
                ++flags;
            }
            ++pointers;
        }
        else
        {
            return MB_TYPE_OUT_OF_RANGE;
        }
    }
 
    return MB_SUCCESS;
}

References moab::WriteUtilIface::CHILDREN, moab::WriteUtilIface::CONTENTS, entities, ErrorCode, moab::SequenceManager::find(), moab::MeshSet::flags(), moab::MeshSet::get_children(), moab::ElementSequence::get_connectivity(), moab::MeshSet::get_contents(), moab::MeshSet::get_parents(), moab::MeshSetSequence::get_set(), MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, MBENTITYSET, MBVERTEX, mMB, moab::WriteUtilIface::PARENTS, moab::Core::sequence_manager(), moab::WriteUtilIface::TOPOLOGICAL, and moab::TYPE_FROM_HANDLE().

get_entity_list_pointers() [2/2]

ErrorCode moab::WriteUtil::get_entity_list_pointers ( Range::const_iterator  query_begin, Range::const_iterator  query_end, EntityHandle const **  output_pointer_array, EntityListType  relation = CONTENTS, int *  lengths = 0, unsigned char *  flags = 0  )

virtual

Implements moab::WriteUtilIface.

Definition at line 776 of file WriteUtil.cpp.

{
    RangeSeqIntersectIter iter( mMB->sequence_manager() );
    ErrorCode rval = iter.init( begin, end );
    while( MB_SUCCESS == rval )
    {
        EntityType type = TYPE_FROM_HANDLE( iter.get_start_handle() );
 
        if( MBENTITYSET == type )
        {
            const MeshSetSequence* seq = reinterpret_cast< MeshSetSequence* >( iter.get_sequence() );
            const MeshSet* set;
            int len = 0;
            size_t clen;
            for( EntityHandle h = iter.get_start_handle(); h <= iter.get_end_handle(); ++h )
            {
                set = seq->get_set( h );
                switch( relation )
                {
                    case CONTENTS:
                        *pointers = set->get_contents( clen );
                        len       = clen;
                        break;
                    case CHILDREN:
                        *pointers = set->get_children( len );
                        break;
                    case PARENTS:
                        *pointers = set->get_parents( len );
                        break;
                }
                if( lengths )
                {
                    *lengths = len;
                    ++lengths;
                }
                if( flags )
                {
                    *flags = (unsigned char)set->flags();
                    ++flags;
                }
                ++pointers;
            }
        }
 
        else if( MBVERTEX != type )
        {
            const bool topological = ( relation == TOPOLOGICAL );
            int len;
            const ElementSequence* seq = reinterpret_cast< ElementSequence* >( iter.get_sequence() );
            for( EntityHandle h = iter.get_start_handle(); h <= iter.get_end_handle(); ++h )
            {
                rval = seq->get_connectivity( h, *pointers, len, topological );
                if( MB_SUCCESS != rval ) return rval;
                if( lengths )
                {
                    *lengths = len;
                    ++lengths;
                }
                if( flags )
                {
                    *flags = 0;
                    ++flags;
                }
                ++pointers;
            }
        }
        else
        {
            return MB_TYPE_OUT_OF_RANGE;
        }
 
        rval = iter.step();
    }
    if( MB_FAILURE == rval )
        return MB_SUCCESS;  // At end of list
    else
        return rval;
}

References moab::WriteUtilIface::CHILDREN, moab::WriteUtilIface::CONTENTS, ErrorCode, moab::MeshSet::flags(), moab::MeshSet::get_children(), moab::ElementSequence::get_connectivity(), moab::MeshSet::get_contents(), moab::RangeSeqIntersectIter::get_end_handle(), moab::MeshSet::get_parents(), moab::RangeSeqIntersectIter::get_sequence(), moab::MeshSetSequence::get_set(), moab::RangeSeqIntersectIter::get_start_handle(), moab::RangeSeqIntersectIter::init(), MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, MBENTITYSET, MBVERTEX, mMB, moab::WriteUtilIface::PARENTS, moab::Core::sequence_manager(), moab::RangeSeqIntersectIter::step(), moab::WriteUtilIface::TOPOLOGICAL, and moab::TYPE_FROM_HANDLE().

get_node_coords() [1/2]

ErrorCode moab::WriteUtil::get_node_coords ( const int  num_arrays, const int  num_nodes, const Range &  entities, Tag  node_id_tag, const int  start_node_id, std::vector< double * > &  arrays  )

virtual

Gets arrays for coordinate data from the MB.

Implements moab::WriteUtilIface.

Definition at line 90 of file WriteUtil.cpp.

{
    // Check the data coming into the function
    // Dimension should be proper
    if( num_arrays < 1 || num_arrays > 3 ) return MB_FAILURE;
 
    // There should be some entities
    // if (entities.empty())
    //  return MB_FAILURE;
    // The above necessitates annoying special cases for files
    // w/out vertices (e.g. a kD-tree).  Return NULL array
    // pointers instead. - kraftcheck, 3-14-08
    if( entities.empty() )
    {
        arrays.clear();
        arrays.resize( num_arrays, NULL );
        return MB_SUCCESS;
    }
 
    // Memory should already be allocated for us
    int tmp_num_arrays = 0;
    for( unsigned int i = 0; i < 3; i++ )
        if( i + 1 <= arrays.size() && NULL != arrays[i] ) tmp_num_arrays++;
    if( 0 == tmp_num_arrays ) return MB_FAILURE;
 
    // Get coordinate data
    ErrorCode result = mMB->get_coords( entities, num_arrays < 1 || arrays.size() < 1 ? NULL : arrays[0],
                                        num_arrays < 2 || arrays.size() < 2 ? NULL : arrays[1],
                                        num_arrays < 3 || arrays.size() < 3 ? NULL : arrays[2] );
 
    if( 0 == node_id_tag || MB_SUCCESS != result ) return result;
 
    // Now assign tags
    std::vector< int > ids( num_nodes );
    int node_id = start_node_id;
    for( int i = 0; i < num_nodes; i++ )
        ids[i] = node_id++;
    result = mMB->tag_set_data( node_id_tag, entities, &ids[0] );
 
    return result;
}

References entities, ErrorCode, moab::Core::get_coords(), MB_SUCCESS, mMB, and moab::Core::tag_set_data().

get_node_coords() [2/2]

ErrorCode moab::WriteUtil::get_node_coords ( const int  which_array, Range::const_iterator  begin, const Range::const_iterator &  end, const size_t  output_size, double *const  output_array  )

virtual

Get an array of coordinate values for nodes

Given a range of node handles, retrieve a single or multiple coordinate value(s) for each.

Failure conditions:

• invalid entity handles (not vertices, non-existent entity, etc.)
• range is empty (iter == end)
• output_array is null
• insufficient space in output_array

Parameters

which_array	The coordinate to retrieve (0->X, 1->Y, 2->Z, -1->all)
begin	The first node handle.
end	One past the last node handle.
output_size	The size of output_array.
output_array	The memory in which to write the node coordinates.

Author

Jason Kraftcheck

Implements moab::WriteUtilIface.

Definition at line 137 of file WriteUtil.cpp.

{
    // Check the data coming into the function
    // Dimension should be proper
    if( which_array < -1 || which_array > 2 ) return MB_FAILURE;
 
    // There should be some entities
    if( iter == end ) return MB_FAILURE;
 
    // Memory should already be allocated for us
    if( NULL == output_array || 0 == output_array_len ) return MB_FAILURE;
 
    // Sequence iterators
    TypeSequenceManager::iterator seq_iter, seq_end;
    seq_iter = mMB->sequence_manager()->entity_map( MBVERTEX ).begin();
    seq_end  = mMB->sequence_manager()->entity_map( MBVERTEX ).end();
 
    // Loop over range, getting coordinate value
    double* output_iter      = output_array;
    double* const output_end = output_array + output_array_len;
    while( iter != end )
    {
        // Find the sequence containing the current handle
        while( seq_iter != seq_end && ( *seq_iter )->end_handle() < *iter )
            ++seq_iter;
        if( seq_iter == seq_end || *iter < ( *seq_iter )->start_handle() ) return MB_FAILURE;
 
        // Determine how much of the sequence we want.
        Range::pair_iterator pair( iter );
        Range::const_iterator prev( end );
        --prev;
        EntityHandle range_end    = pair->second;
        EntityHandle sequence_end = ( *seq_iter )->end_handle();
        EntityHandle end_handle   = range_end > sequence_end ? sequence_end : range_end;
        if( end_handle > *prev ) end_handle = *prev;
        EntityHandle count = end_handle - *iter + 1;
 
        // Get offset in sequence to start at
        assert( *iter >= ( *seq_iter )->start_handle() );
        EntityHandle offset = *iter - ( *seq_iter )->start_handle();
 
        // Get coordinate arrays from sequence
        double* coord_array[3];
        static_cast< VertexSequence* >( *seq_iter )
            ->get_coordinate_arrays( coord_array[0], coord_array[1], coord_array[2] );
 
        // Copy data to output buffer
        if( -1 != which_array )
        {
            if( output_iter + count > output_end ) return MB_FAILURE;
            memcpy( output_iter, coord_array[which_array] + offset, count * sizeof( double ) );
            output_iter += count;
        }
        else
        {
            if( output_iter + 3 * count > output_end ) return MB_FAILURE;
            for( unsigned int i = 0; i < count; i++ )
            {
                *output_iter = coord_array[0][i + offset];
                output_iter++;
                *output_iter = coord_array[1][i + offset];
                output_iter++;
                *output_iter = coord_array[2][i + offset];
                output_iter++;
            }
        }
 
        // Iterate
        iter += count;
    }
 
    return MB_SUCCESS;
}

References moab::TypeSequenceManager::begin(), moab::TypeSequenceManager::end(), moab::SequenceManager::entity_map(), moab::VertexSequence::get_coordinate_arrays(), MB_SUCCESS, MBVERTEX, mMB, and moab::Core::sequence_manager().

get_poly_connect()

ErrorCode moab::WriteUtil::get_poly_connect ( Range::const_iterator &  iter, const Range::const_iterator &  end, const Tag  node_id_tag, size_t &  handle_array_len, int *const  handle_array, size_t &  index_array_len, int *const  index_array, int &  index_offset  )

virtual

Get poly (polygon or polyhedron) connectivity.

This function will add as many polys as possible to the passed arrays given the sizes of those arrays. It will then pass back position at which it stopped and the sizes of the data written to the arrays.

Parameters

iter	As input, the first element handle. As output, one past the last element handle for which data was written to the arrays.
end	The iterator at which to stop.
node_id_tag	A tag with integer values.
element_array_len	As input, length of element_array. As output, the number of entries written in that array.
element_array	The memory location at which to store the connectivity list.
index_array_len	As input, the length of index_array. As output, the number of entries written in that array.
index_array	The memory location at which to store offsets.
index_offset	Value to offset (add to) index values. As output the input value plus the amount of data written to the element array. (The value you presumably want to pass to the next call.)

Author

Jason Kraftcheck

Implements moab::WriteUtilIface.

Definition at line 503 of file WriteUtil.cpp.

{
    return MB_NOT_IMPLEMENTED;
}

References MB_NOT_IMPLEMENTED.

get_poly_connect_size()

ErrorCode moab::WriteUtil::get_poly_connect_size ( Range::const_iterator  begin, const Range::const_iterator &  end, int &  connectivity_size  )

virtual

Get poly (polygon or polyhedron) connectivity size

Parameters

begin	First iterator in range of poly
end	One past last in range of poly.
connectivity_size	The length of the connectivity list For the specified range of polyhedra.

Author

Jason Kraftcheck

Implements moab::WriteUtilIface.

Definition at line 496 of file WriteUtil.cpp.

{
    return MB_NOT_IMPLEMENTED;
}

References MB_NOT_IMPLEMENTED.

get_tag_list()

ErrorCode moab::WriteUtil::get_tag_list ( std::vector< Tag > &  result_list, const Tag *  user_tag_list = 0, int  user_tag_list_length = 0, bool  include_variable_length_tags = true  )

virtual

Get list of tags to write.

Get the list of tags to write to the file, possibly using an optional user-specified tag list. This function consolidates some common code for file writers to use to figure out what tag data to write to the file. It provides the following features: o filter list based on user-specified array of tag handles o filter internal tags (those for which the name is prefixed with two underscore characters) o filter anonymous tags o optionally filter variable-length tags.

Author

Jason Kraftcheck

Parameters

result_list	List of tag handles for which to write data
user_tag_list	Optional array of tag handles passed by user to write to file.
include_variable_length_tags	If false, return only fixed-length tags.

Implements moab::WriteUtilIface.

Definition at line 714 of file WriteUtil.cpp.

{
    ErrorCode rval;
 
    if( user_tag_list )
    {
        result_list.clear();
        result_list.reserve( user_tag_list_length );
        for( int i = 0; i < user_tag_list_length; ++i )
        {
            std::string name;
            rval = mMB->tag_get_name( user_tag_list[i], name );MB_CHK_SET_ERR( rval, "Error " << (int)rval << " getting name for tag (Invalid input tag handle?)" );
 
            if( name.empty() )
            {
                MB_SET_ERR( MB_TAG_NOT_FOUND, "Explicit request to save anonymous tag" );
            }
 
            int size;
            if( !include_variable_length_tags &&
                MB_VARIABLE_DATA_LENGTH == mMB->tag_get_length( user_tag_list[i], size ) )
            {
                MB_SET_ERR( MB_TYPE_OUT_OF_RANGE, "File format cannot store variable-length tag: \"" << name << "\"" );
            }
 
            result_list.push_back( user_tag_list[i] );
        }
    }
    else
    {
        std::vector< Tag > temp_list;
        rval = mMB->tag_get_tags( temp_list );MB_CHK_SET_ERR( rval, "Interface::tag_get_tags failed" );
 
        result_list.clear();
        result_list.reserve( temp_list.size() );
 
        std::vector< Tag >::iterator i;
        for( i = temp_list.begin(); i != temp_list.end(); ++i )
        {
            std::string name;
            rval = mMB->tag_get_name( *i, name );MB_CHK_SET_ERR( rval, "Error " << (int)rval << " getting name for tag (Stale tag handle?)" );
 
            // Skip anonymous tags
            if( name.empty() ) continue;
 
            // Skip private/internal tags
            if( name.size() >= 2 && name[0] == '_' && name[1] == '_' ) continue;
 
            // If requested, skip variable-length tags
            int size;
            if( !include_variable_length_tags && MB_VARIABLE_DATA_LENGTH == mMB->tag_get_length( *i, size ) ) continue;
 
            result_list.push_back( *i );
        }
    }
 
    return MB_SUCCESS;
}

References ErrorCode, MB_CHK_SET_ERR, MB_SET_ERR, MB_SUCCESS, MB_TAG_NOT_FOUND, MB_TYPE_OUT_OF_RANGE, MB_VARIABLE_DATA_LENGTH, mMB, size, moab::Core::tag_get_length(), moab::Core::tag_get_name(), and moab::Core::tag_get_tags().

Member Data Documentation

mMB

Core* moab::WriteUtil::mMB

private

Pointer to the Core.

Definition at line 34 of file WriteUtil.hpp.

Referenced by assign_ids(), gather_entities(), gather_nodes_from_elements(), get_adjacencies(), get_element_connect(), get_entity_list_pointers(), get_node_coords(), and get_tag_list().

---

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

• WriteUtil.hpp
• WriteUtil.cpp