ReadDamsel.cpp

Go to the documentation of this file.

/** MOAB Damsel file reader
 * For description of the Damsel-MOAB data model mapping, see WriteDamsel.cpp.
 *
 */
 
#include "moab/ParallelComm.hpp"
 
#include "ReadDamsel.hpp"
 
#include <cassert>
#include "moab/Interface.hpp"
#include "moab/Core.hpp"
#include "moab/Range.hpp"
#include "moab/Error.hpp"
#include "moab/ReadUtilIface.hpp"
#include "moab/FileOptions.hpp"
#include "MBTagConventions.hpp"
#include "EntitySequence.hpp"
#include "Internals.hpp"
#include "DenseTag.hpp"
 
namespace moab
{
 
ReaderIface* ReadDamsel::factory( Interface* iface )
{
    return new ReadDamsel( iface );
}
 
ReadDamsel::ReadDamsel( Interface* impl )
    : mbImpl( impl ), readMeshIface( NULL ), nativeParallel( false ), myPcomm( NULL ), mGlobalIdTag( 0 ), dU()
{
    init();
}
 
ReadDamsel::~ReadDamsel()
{
    if( readMeshIface ) mbImpl->release_interface( readMeshIface );
 
    DMSLlib_finalize( dU.dmslLib );
}
 
ErrorCode ReadDamsel::init()
{
    mbImpl->query_interface( readMeshIface );
    assert( readMeshIface );
 
    return MB_SUCCESS;
}
 
ErrorCode ReadDamsel::parse_options( const FileOptions& opts, bool& parallel )
{
    // Handle parallel options
    bool use_mpio  = ( MB_SUCCESS == opts.get_null_option( "USE_MPIO" ) );
    ErrorCode rval = opts.match_option( "PARALLEL", "READ_PART" );
    parallel       = ( rval != MB_ENTITY_NOT_FOUND );
    nativeParallel = ( rval == MB_SUCCESS );
    if( use_mpio && !parallel )
    {
        MB_SET_ERR( MB_NOT_IMPLEMENTED, "'USE_MPIO' option specified w/out 'PARALLEL' option" );
    }
 
    return MB_SUCCESS;
}
 
// ASSUMPTIONS:
// Partition collection is a *flat* collection of handles for entities and other collections that
// will be represented on a part
 
ErrorCode ReadDamsel::load_file( const char* filename,
                                 const EntityHandle* file_set,
                                 const FileOptions& opts,
                                 const ReaderIface::SubsetList* subset_list,
                                 const Tag* file_id_tag )
{
    ErrorCode rval;
 
    rval = parse_options( opts, nativeParallel );
    if( MB_SUCCESS != rval ) return rval;
 
    // Initialize damsel
    dU.dmslLib = DMSLlib_init();
 
    // Create a damsel model
    dU.dmslModel =
        DMSLmodel_create( sizeof( EntityHandle ) == 8 ? DAMSEL_HANDLE_TYPE_HANDLE64 : DAMSEL_HANDLE_TYPE_HANDLE32 );
 
    // Model attach - need model id from make model, filename
#ifdef MOAB_HAVE_MPI
    MPI_Comm comm = MPI_COMM_WORLD;
    if( nativeParallel )
    {
        comm = myPcomm->proc_config().proc_comm();
    }
#endif
 
    damsel_err_t err;
    err = DMSLmodel_attach( dU.dmslModel, filename, comm, NULL );
    CHK_DMSL_ERR( err, "DMSLmodel_attach failed" );
    err = DMSLmodel_populate( dU.dmslModel );
    CHK_DMSL_ERR( err, "DMSLmodel_populate failed" );
 
    // STEP 0: GET COLLECTION, TAG, ENTITY INFOS FOR GLOBAL MODEL
    int num_containers = 0, num_tag_infos = 0, num_ent_infos = 0;
    DMSLmodel_get_tuple_count( dU.dmslModel, &num_containers, &num_tag_infos );
    num_ent_infos      = DMSLmodel_get_entity_count( dU.dmslModel );
    int num_coll_infos = DMSLmodel_get_collection_count( dU.dmslModel );
    CHK_DMSL_ERR( err, "DMSLmodel_get_collection_count failed" );
    if( -1 == num_containers || -1 == num_tag_infos || -1 == num_ent_infos )
        MB_SET_ERR( MB_FAILURE, "Bad count for containers/tags/ents" );
 
    std::vector< damsel_entity_buf_type > ent_infos( num_ent_infos );
    std::vector< damsel_collection_buf_type > coll_infos( num_coll_infos );
    std::vector< damsel_tag_buf_type > tag_infos( num_tag_infos );
    std::vector< damsel_container_buf_type > cont_infos( num_containers );
    err = DMSLmodel_get_entity_infos( dU.dmslModel, &ent_infos[0] );
    CHK_DMSL_ERR( err, "Failure getting entity infos" );
    err = DMSLmodel_get_collection_infos( dU.dmslModel, &coll_infos[0] );
    CHK_DMSL_ERR( err, "Failure getting collection infos" );
    err = DMSLmodel_get_tag_infos( dU.dmslModel, &tag_infos[0] );
    CHK_DMSL_ERR( err, "Failure getting tag infos" );
    err = DMSLmodel_get_container_infos( dU.dmslModel, &cont_infos[0] );
    CHK_DMSL_ERR( err, "Failure getting container infos" );
 
    // Create MOAB-side tags for all damsel tags except pre-defined ones
    MB_CHK_SET_ERR( process_tags( tag_infos ), "Error processing tags" );
 
    /*
      if (nativeParallel) {
        // STEP 1: GET COLLECTION(S) REPRESENTING PARTITION:
        // Input: tag name, optionally value;
        // Output: container with file-side handles of collections satisfying those criteria
        // - Get all handles/values for tag
        // - Select handles matching criteria for tag value (will be collection handles)
        std::string partn_tag_name("PARALLEL_PARTITION");
        damsel_handle partn_tag = DMSLselect_tag_by_name(dU.dmslModel, partn_tag_name.c_str());
        // Get all the parts with that tag regardless of value
        damsel_container part_handles = DMSLselect_handles_with_values(dU.dmslModel, partn_tag);
 
        // STEP 2: GET HANDLES FOR TAGS WE NEED FOR THIS READER:
        // - "SET_CHARACTERISTIC"
        damsel_handle setchar_tag = DMSLselect_tag_by_name(dU.dmslModel, "SET_CHARACTERISTIC");
        // - "PARENT_LIST"
        //damsel_handle plist_tag = DMSLselect_tag_by_name(dU.dmslModel, "PARENT_LIST");
        // - "CHILD_LIST"
        //damsel_handle clist_tag = DMSLselect_tag_by_name(dU.dmslModel, "CHILD_LIST");
 
        // STEP 3: GET VALUES FOR "SET_CHARACTERISTIC" TAG ON PARTITION COLLECTIONS,
        //         GET VECTOR- OR SET-TYPE FLAGS FOR PARTITION COLLECTIONS
        // (gives tracking flag for moab)
        int num_handles = DMSLcontainer_count(part_handles);
        std::vector<unsigned> char_tagvals(num_handles);
        // Map the set chars
        err = DMSLmodel_map_tag(&char_tagvals[0], part_handles, &setchar_tag);CHK_DMSL_ERR(err,
      "Problem calling DMSLmodel_map_tag");
 
        // Execute the transfer
        err = DMSLmodel_transfer_sync(dU.dmslModel, DAMSEL_TRANSFER_TYPE_READ);CHK_DMSL_ERR(err,
      "Problem calling DMSLmodel_transfer_sync");
 
        // STEP 4: READ/PROCESS PARTITION COLLECTION(S)
        // Decide the handles I am responsible using round-robin for now
        // - GET TYPE, CONTENTS OF COLLECTION CONTENTS CONTAINER
        // - Allocate moab-side container (using count from container)
        // - MAP storage TO CONTAINER
        // - EXECUTE
        // ==> have list of all handles (entities + collections) represented on this proc
 
        int tmp_num = num_handles / proc_size, extra = num_handles % proc_size;
        if (extra) tmp_num++;
        int my_num_handles = tmp_num;
        if (proc_rank >= extra) my_num_handles--;
        int first_ind = std::min(proc_rank, extra) * tmp_num +
            std::max(proc_rank - extra, 0) * (tmp_num - 1);
 
        // - Create moab entity sets for partition collection(s)
        EntityHandle start_handle;
        MB_CHK_SET_ERR( readMeshIface->create_entity_sets(my_num_handles, &char_tagvals[first_ind], 0,
      start_handle), "Problem creating entity sets" );
      }
      else {
    */
    // Initialize just by entity; each call to process_ent_info will:
    // a. Create moab-side representation to read into
    // b. Map those handles to damsel handles
    // c. Map coords / connectivity storage to damsel equivalent
    // d. For each tag, map moab storage to damsel storage
    std::vector< damsel_entity_buf_type >::iterator eiit;
 
    // Process verts info first
    for( eiit = ent_infos.begin(); eiit != ent_infos.end(); ++eiit )
    {
        if( ( *eiit ).entity_type == DAMSEL_ENTITY_TYPE_VERTEX )
        {
            MB_CHK_ERR( process_ent_info( *eiit ) );
        }
    }
 
    for( eiit = ent_infos.begin(); eiit != ent_infos.end(); ++eiit )
    {
        if( ( *eiit ).entity_type != DAMSEL_ENTITY_TYPE_VERTEX )
        {
            MB_CHK_ERR( process_ent_info( *eiit ) );
        }
    }
 
    /*
      }
 
      // Process collections
      MB_CHK_ERR( process_coll_infos(coll_infos) );
 
      // STEP 5: Process into list of local info structs, each represents file-side struct and
      // portion of that struct
      // ASSUMPTION: Each local info struct represents single entity type & # vertices or collection
 
      // STEP 6: For each local info struct:
 
      // STEP 6b: READ CONTAINER INTO LOCAL BUFFER
      // STEP 6c: Create app representation of entities/vertices/collection, and damsel container
      for them,
      //    and MAP APP HANDLE CONTAINER TO DAMSEL CONTAINER
      // STEP 6d: Process vertices/entities/collection
      //    6d1: If vertices, continue
      //    6d2: If entities:
      //    - MAP LOCAL CONNECTIVITY REP'N TO DAMSEL (might be tag, don't know yet)
      //    6d3: If collection:
      //    - (everything in STEP 4 for this collection except for EXECUTE)
      //    - might need to filter out things not represented on this rank
      //    6d4: If sparse tag:
      //    - Create app-side representation of sparse tag
      //    - READ CONTAINER OF MODEL HANDLES INTO LOCAL BUFFER
      //    - Allocate app-side storage for tag values
      //    - MAP APP STORAGE TO MODEL TAG + (implicit?) CONTAINER
 
      // STEP 6e: Process dense tags for the local info struct; for each dense tag:
      //   - Get app tag handle for model tag handle
      //   - Get app storage for app tag handle + container
      //   - MAP APP STORAGE TO MODEL TAG + CONTAINER
 
      // STEP 7: EXECUTE
      //   - Assign all mapped data
      //   - Translate all damsel handles to app handles
      // uninit damsel
 
    */
 
    return MB_SUCCESS;
}
 
ErrorCode ReadDamsel::read_tag_values( const char* file_name,
                                       const char* tag_name,
                                       const FileOptions& opts,
                                       std::vector< int >& tag_values_out,
                                       const SubsetList* subset_list )
{
    return MB_FAILURE;
}
 
ErrorCode ReadDamsel::process_tags( std::vector< damsel_tag_buf_type >& tag_infos )
{
    Tag tagh;
    ErrorCode rval = MB_SUCCESS, tmp_rval;
    for( std::vector< damsel_tag_buf_type >::iterator tit = tag_infos.begin(); tit != tag_infos.end(); ++tit )
    {
        if( DamselUtil::dtom_data_type[( *tit ).tag_datatype] == MB_TYPE_OPAQUE )
        {
            std::cout << "Damsel reader encountered opaque tag." << std::endl;
            continue;
        }
 
        tmp_rval = mbImpl->tag_get_handle( ( *tit ).name, 1, DamselUtil::dtom_data_type[( *tit ).tag_datatype], tagh,
                                           MB_TAG_CREAT | MB_TAG_DENSE );
        if( MB_SUCCESS != tmp_rval )
            rval = tmp_rval;
        else
        {
            dU.tagMap.push_back( DamselUtil::tinfo( tagh, 0, MB_TAG_DENSE ) );
            // Also store predefined tags specially...
            if( !strncmp( ( *tit ).name, "mbdmsl_", 7 ) )
            {
                // Predefined tag name, store the handle
                if( !strcmp( ( *tit ).name, "mbdmsl_XCOORDS" ) )
                    dU.xcoordsTag = dU.tagMap.back();
                else if( !strcmp( ( *tit ).name, "mbdmsl_YCOORDS" ) )
                {
                    dU.ycoordsTag = dU.tagMap.back();
                }
                else if( !strcmp( ( *tit ).name, "mbdmsl_ZCOORDS" ) )
                {
                    dU.zcoordsTag = dU.tagMap.back();
                }
                else if( !strcmp( ( *tit ).name, "mbdmsl_COLL_FLAGS" ) )
                {
                    dU.collFlagsTag = dU.tagMap.back();
                }
                else if( !strcmp( ( *tit ).name, "mbdmsl_PARENTS" ) )
                {
                    dU.parentsTag = dU.tagMap.back();
                }
                else if( !strcmp( ( *tit ).name, "mbdmsl_CHILDREN" ) )
                {
                    dU.childrenTag = dU.tagMap.back();
                }
                else
                {
                    rval = MB_FAILURE;
                    continue;
                }
            }
        }
    }
 
    return rval;
}
 
ErrorCode ReadDamsel::process_ent_info( const damsel_entity_buf_type& einfo )
{
    // Create this chunk of entities
    EntityHandle *connect, start_handle;
    ErrorCode rval;
    damsel_err_t err;
    damsel_container app_cont;
    Range these_ents;
 
    // Check that there's only one contiguous run of file-side handles, fail if there isn't
#ifndef NDEBUG
    Range fside_handles;
    rval = DamselUtil::container_to_range( dU.dmslModel, const_cast< damsel_container& >( einfo.entity_container ),
                                           fside_handles );
    if( MB_SUCCESS != rval || fside_handles.size() != einfo.count || fside_handles.psize() != 1 ) return MB_FAILURE;
#endif
 
    if( einfo.entity_type != DAMSEL_ENTITY_TYPE_VERTEX )
    {
        // Create the moab entities
        MB_CHK_ERR( readMeshIface->get_element_connect( einfo.count, einfo.vertices_per_entity,
                                                        DamselUtil::dtom_entity_type[einfo.entity_type], 0,
                                                        start_handle, connect ) );
        these_ents.insert( start_handle, start_handle + einfo.count - 1 );
 
        // Create an app-side sequence and map to file-side container
        app_cont = DMSLcontainer_create_sequence( dU.dmslModel, einfo.count, start_handle, 1 );
        err      = DMSLmodel_map_handles( app_cont, einfo.entity_container );
        CHK_DMSL_ERR( err, "Error returned mapping entity handles" );
 
        // Map connectivity
        assert( DMSLcontainer_count( einfo.vertex_container ) == (int)( einfo.vertices_per_entity * einfo.count ) );
        MB_CHK_SET_ERR( get_contents( dU.dmslModel, einfo.vertex_container, connect ),
                        "Error returned mapping connectivity" );
    }
    else
    {
        // Get the number of coordinate arrays
        int num_ctags             = 0;
        damsel_handle xcoord_dtag = DMSLselect_tag_by_name( dU.dmslModel, "mbdmsl_XCOORDS" );
        if( xcoord_dtag ) num_ctags++;
        damsel_handle ycoord_dtag = DMSLselect_tag_by_name( dU.dmslModel, "mbdmsl_YCOORDS" );
        if( ycoord_dtag ) num_ctags++;
        damsel_handle zcoord_dtag = DMSLselect_tag_by_name( dU.dmslModel, "mbdmsl_ZCOORDS" );
        if( zcoord_dtag ) num_ctags++;
 
        // Should have one vertex per entity
        assert( einfo.vertices_per_entity == 1 );
        std::vector< double* > coord_arrays;
        MB_CHK_ERR( readMeshIface->get_node_coords( num_ctags, einfo.count, 0, start_handle, coord_arrays ) );
 
        these_ents.insert( start_handle, start_handle + einfo.count - 1 );
 
        // Create an app-side sequence and map to file-side container
        app_cont = DMSLcontainer_create_sequence( dU.dmslModel, start_handle, einfo.count, 1 );
        err      = DMSLmodel_map_handles( app_cont, einfo.entity_container );
        CHK_DMSL_ERR( err, "Trouble mapping entity handles" );
 
        // Map the coords storage
        if( xcoord_dtag != 0 )
        {
            err = DMSLmodel_map_tag( coord_arrays[0], app_cont, (damsel_handle_ptr)&dU.xcoordsTag.mTagh );
            CHK_DMSL_ERR( err, "Trouble mapping x coordinate tag" );
        }
        if( ycoord_dtag != 0 )
        {
            err = DMSLmodel_map_tag( coord_arrays[1], app_cont, (damsel_handle_ptr)&dU.ycoordsTag.mTagh );
            CHK_DMSL_ERR( err, "Trouble mapping y coordinate tag" );
        }
        if( zcoord_dtag != 0 )
        {
            err = DMSLmodel_map_tag( coord_arrays[2], app_cont, (damsel_handle_ptr)&dU.zcoordsTag.mTagh );
            CHK_DMSL_ERR( err, "Trouble mapping z coordinate tag" );
        }
    }
 
    // Save mapping from moab entity to einfo
    dmHandleRMap.insert( DMSLcontainer_handle_at_position( einfo.entity_container, 0 ), start_handle, einfo.count );
 
    rval = process_entity_tags( einfo.tag_count, einfo.tag_handle_container, app_cont, these_ents );
 
    return rval;
}
 
ErrorCode ReadDamsel::process_entity_tags( int count,
                                           damsel_container tag_container,
                                           damsel_container app_cont,
                                           Range& these_ents )
{
    // Process tags on these entities
    ErrorCode rval = MB_SUCCESS;
    for( int i = 0; i < count; i++ )
    {
        damsel_handle dtagh = DMSLcontainer_handle_at_position( tag_container, i );
 
        // Don't do conventional tags here
        std::vector< DamselUtil::tinfo >::iterator vit =
            std::find_if( dU.tagMap.begin(), dU.tagMap.end(), DamselUtil::DtagP< DamselUtil::tinfo >( dtagh ) );
 
        if( ( *vit ).tagType == MB_TAG_ANY )
            continue;
        else if( vit == dU.tagMap.end() )
            MB_SET_ERR( MB_FAILURE, "Failed to find tag" );
 
        Tag tagh = ( *vit ).mTagh;
        assert( tagh );
        void* tag_data;
        int ecount = these_ents.size();
        MB_CHK_SET_ERR( mbImpl->tag_iterate( tagh, these_ents.begin(), these_ents.end(), ecount, tag_data ),
                        "Problem getting tag iterator" );
        assert( ecount == (int)these_ents.size() );
        damsel_err_t err = DMSLmodel_map_tag( tag_data, app_cont, (damsel_handle_ptr)&tagh );
        CHK_DMSL_ERR( err, "Problem calling DMSLmodel_map_tag" );
    }
 
    return rval;
}
 
ErrorCode ReadDamsel::get_contents( damsel_model m, damsel_container c, Range& ents )
{
    EntityHandle eh;
    if( DMSLcontainer_get_type( c ) == DAMSEL_HANDLE_CONTAINER_TYPE_SEQUENCE )
    {
        damsel_handle start;
        size_t count, stride;
        damsel_err_t err = DMSLcontainer_sequence_get_contents( m, c, &start, &count, &stride );
        CHK_DMSL_ERR( err, "DMSLcontainer_sequence_get_contents" );
        if( stride == 1 )
        {
            while( count )
            {
                // Get start in rangemap
                RangeMap< damsel_handle, EntityHandle, 0 >::iterator beg = dmHandleRMap.lower_bound( start );
                if( beg == dmHandleRMap.end() ) return MB_SUCCESS;
                unsigned long diff = std::max( ( *beg ).begin - start, (damsel_handle)0 );
                unsigned long num  = std::min( count - diff, (size_t)( *beg ).count );
                ents.insert( ( *beg ).begin + diff, ( *beg ).begin + diff + num - 1 );
                count -= ( diff + num );
                ++beg;
            }
        }
        else
        {
            for( int i = count - 1; i >= 0; i-- )
            {
                if( dmHandleRMap.find( start + i, eh ) ) ents.insert( eh );
            }
        }
    }
    else if( DMSLcontainer_get_type( c ) == DAMSEL_HANDLE_CONTAINER_TYPE_VECTOR )
    {
        damsel_handle* handle_ptr;
        size_t count;
        damsel_err_t err = DMSLcontainer_vector_get_contents( m, c, &handle_ptr, &count );
        CHK_DMSL_ERR( err, "Trouble getting vector contents" );
        for( int i = count - 1; i >= 0; i-- )
        {
            if( dmHandleRMap.find( handle_ptr[i], eh ) ) ents.insert( eh );
        }
    }
    else if( DMSLcontainer_get_type( c ) == DAMSEL_HANDLE_CONTAINER_TYPE_TREE )
    {
        damsel_handle_ptr node_ptr = NULL;
        damsel_container cont      = NULL;
        while( DMSLcontainer_tree_get_contents( m, c, &node_ptr, &cont ) == DMSL_OK && cont )
        {
            ErrorCode rval = get_contents( m, c, ents );
            if( MB_SUCCESS != rval ) return rval;
        }
    }
 
    return MB_SUCCESS;
}
 
ErrorCode ReadDamsel::get_contents( damsel_model m, damsel_container c, EntityHandle* ents )
{
    EntityHandle eh;
    int ind = 0;
 
    if( DMSLcontainer_get_type( c ) == DAMSEL_HANDLE_CONTAINER_TYPE_SEQUENCE )
    {
        damsel_handle start;
        size_t count, stride;
        damsel_err_t err = DMSLcontainer_sequence_get_contents( m, c, &start, &count, &stride );
        CHK_DMSL_ERR( err, "Problem calling DMSLcontainer_sequence_get_contents" );
        if( stride == 1 )
        {
            while( count )
            {
                // Get start in rangemap
                RangeMap< damsel_handle, EntityHandle, 0 >::iterator beg = dmHandleRMap.lower_bound( start );
                if( beg == dmHandleRMap.end() ) return MB_SUCCESS;
                unsigned int diff = std::max( ( *beg ).begin - start, (damsel_handle)0 );
                unsigned int num  = std::min( count - diff, (size_t)( *beg ).count );
                for( EntityHandle hdl = ( *beg ).begin + diff; hdl <= (int)( *beg ).begin + diff + num - 1; hdl++ )
                    ents[ind++] = hdl;
                count -= ( diff + num );
                ++beg;
            }
        }
        else
        {
            for( int i = count - 1; i >= 0; i-- )
            {
                if( dmHandleRMap.find( start + i, eh ) ) ents[i] = eh;
            }
        }
    }
    else if( DMSLcontainer_get_type( c ) == DAMSEL_HANDLE_CONTAINER_TYPE_VECTOR )
    {
        damsel_handle_ptr handle_ptr;
        size_t count;
        damsel_err_t err = DMSLcontainer_vector_get_contents( m, c, &handle_ptr, &count );
        CHK_DMSL_ERR( err, "Failed to get vector contents" );
        for( int i = count - 1; i >= 0; i-- )
        {
            if( dmHandleRMap.find( handle_ptr[i], eh ) ) ents[i] = eh;
        }
    }
    else if( DMSLcontainer_get_type( c ) == DAMSEL_HANDLE_CONTAINER_TYPE_TREE )
    {
        damsel_handle_ptr node_ptr = NULL;
        damsel_container cont      = NULL;
        while( DMSLcontainer_tree_get_contents( m, c, &node_ptr, &cont ) == DMSL_OK && cont )
        {
            ErrorCode rval = get_contents( m, cont, ents );
            if( MB_SUCCESS != rval ) return rval;
            unsigned int num = DMSLcontainer_count( cont );
            ents += num;
        }
    }
 
    return MB_SUCCESS;
}
 
/*
ErrorCode ReadDamsel::process_coll_infos(std::vector<damsel_collection_buf_type> &coll_infos)
{
  ErrorCode rval = MB_SUCCESS, tmp_rval;
  EntityHandle seth;
  std::vector<subrange> handle_subranges;
  for (std::vector<damsel_collection_buf_type>::iterator cit = coll_infos.begin(); cit !=
coll_infos.end(); ++cit) {
    // Make the set
    tmp_rval = mbImpl->create_meshset(((*cit).type ==  DAMSEL_HANDLE_COLLECTION_TYPE_SET ?
MESHSET_SET : MESHSET_ORDERED), seth); if (MB_SUCCESS != tmp_rval) rval = tmp_rval;
    // Make datastructures to pass things to process_entity_tags
    Range tmp_range(seth, seth);
    damsel_container ch = DMSLcontainer_create_sequence(dU.dmslModel, seth, 1, 1);
 
    // Get the tags on this set
    tmp_rval = process_entity_tags((*cit).tag_count, (*cit).tag_handle_container, ch, tmp_range);
    if (MB_SUCCESS != tmp_rval)
      rval = tmp_rval;
 
    // Process the set contents
    if ((*cit).type == DAMSEL_HANDLE_COLLECTION_TYPE_SET) {
      Range ents;
      tmp_rval = get_contents(dU.dmslModel, (*cit).contents, ents);
      if (MB_SUCCESS != tmp_rval)
        rval = tmp_rval;
      else if (!ents.empty()) {
        tmp_rval = mbImpl->add_entities(seth, ents);
        if (MB_SUCCESS != tmp_rval)
          rval = tmp_rval;
      }
    }
    else {
      std::vector<EntityHandle> ents(DMSLcontainer_count((*cit).contents));
      tmp_rval = get_contents(dU.dmslModel, (*cit).contents, &ents[0]);
      if (MB_SUCCESS != tmp_rval)
        rval = tmp_rval;
      else if (!ents.empty()) {
        tmp_rval = mbImpl->add_entities(seth, &ents[0], ents.size());
        if (MB_SUCCESS != tmp_rval)
          rval = tmp_rval;
      }
    }
 
    // Get the file handle for this collection, and map it to moab's set handle
    damsel_handle collh = (damsel_handle)(*((*cit).collection_handle));
    if (handle_subranges.empty() || seth != (*handle_subranges.rbegin()).seth + 1 ||
        collh != (*handle_subranges.rbegin()).collh + 1) {
      handle_subranges.push_back(subrange(collh, seth, 1));
    }
    else (*handle_subranges.rbegin()).count++;
  }
 
  for (std::vector<subrange>::iterator vit = handle_subranges.begin(); vit !=
handle_subranges.end(); ++vit) dmHandleRMap.insert((*vit).collh, (*vit).seth, (*vit).count);
 
  return rval;
}
*/
 
}  // namespace moab