ReadCCMIO.cpp

Go to the documentation of this file.

#include <cstdlib>  // For exit()
#include <vector>
#include <map>
#include <iostream>
#include <string>
#include <algorithm>
 
#include "moab/CN.hpp"
#include "moab/Range.hpp"
#include "moab/Interface.hpp"
#include "MBTagConventions.hpp"
#include "Internals.hpp"
#include "moab/ReadUtilIface.hpp"
#include "moab/FileOptions.hpp"
#include "ReadCCMIO.hpp"
#include "moab/MeshTopoUtil.hpp"
 
#include "ccmio.h"
 
/*
 * CCMIO file structure
 *
 * Root
 *   State(kCCMIOState)
 *     Processor*
 *       Vertices
 *         ->ReadVerticesx, ReadMap
 *       Topology
 *         Boundary faces*(kCCMIOBoundaryFaces)
 *            ->ReadFaces, ReadFaceCells, ReadMap
 *         Internal faces(kCCMIOInternalFaces)
 *         Cells (kCCMIOCells)
 *            ->ReadCells (mapID), ReadMap, ReadCells (cellTypes)
 *       Solution
 *         Phase
 *           Field
 *             FieldData
 *   Problem(kCCMIOProblemDescription)
 *     CellType* (kCCMIOCellType)
 *       Index (GetEntityIndex), MaterialId(ReadOpti), MaterialType(ReadOptstr),
 *         PorosityId(ReadOpti), SpinId(ReadOpti), GroupId(ReadOpti)
 *
 * MaterialType (CCMIOReadOptstr in readexample)
 * constants (see readexample)
 * lagrangian data (CCMIOReadLagrangianData)
 * vertices label (CCMIOEntityDescription)
 * restart info: char solver[], iteratoins, time, char timeUnits[], angle
 *      (CCMIOReadRestartInfo, kCCMIORestartData), reference data?
 * phase:
 *   field: char name[], dims, CCMIODataType datatype, char units[]
 *       dims = kCCMIOScalar (CCMIOReadFieldDataf),
 *              kCCMIOVector (CCMIOReadMultiDimensionalFieldData),
 *              kCCMIOTensor
 * MonitoringSets: num, name (CellSet, VertexSet, BoundarySet, BlockSet, SplineSet, CoupleSet)
 *      CCMIOGetProstarSet, CCMIOReadOpt1i,
 */
 
enum DataType
{
    kScalar,
    kVector,
    kVertex,
    kCell,
    kInternalFace,
    kBoundaryFace,
    kBoundaryData,
    kBoundaryFaceData,
    kCellType
};
 
namespace moab
{
 
static int const kNValues         = 10;  // Number of values of each element to print
static char const kDefaultState[] = "default";
static char const kUnitsName[]    = "Units";
static int const kVertOffset      = 2;
static int const kCellInc         = 4;
 
#define CHK_SET_CCMERR( ccm_err_code, ccm_err_msg )                                   \
    {                                                                                 \
        if( kCCMIONoErr != ( ccm_err_code ) && kCCMIONoFileErr != ( ccm_err_code ) && \
            kCCMIONoNodeErr != ( ccm_err_code ) )                                     \
            MB_SET_ERR( MB_FAILURE, ccm_err_msg );                                    \
    }
 
ReaderIface* ReadCCMIO::factory( Interface* iface )
{
    return new ReadCCMIO( iface );
}
 
ReadCCMIO::ReadCCMIO( Interface* impl )
    : mMaterialIdTag( 0 ), mMaterialTypeTag( 0 ), mRadiationTag( 0 ), mPorosityIdTag( 0 ), mSpinIdTag( 0 ),
      mGroupIdTag( 0 ), mColorIdxTag( 0 ), mProcessorIdTag( 0 ), mLightMaterialTag( 0 ), mFreeSurfaceMaterialTag( 0 ),
      mThicknessTag( 0 ), mProstarRegionNumberTag( 0 ), mBoundaryTypeTag( 0 ), mCreatingProgramTag( 0 ), mbImpl( impl ),
      hasSolution( false )
{
    assert( impl != NULL );
 
    impl->query_interface( readMeshIface );
 
    // Initialize in case tag_get_handle fails below
    mMaterialSetTag  = 0;
    mDirichletSetTag = 0;
    mNeumannSetTag   = 0;
    mHasMidNodesTag  = 0;
    mGlobalIdTag     = 0;
    mNameTag         = 0;
 
    //! Get and cache predefined tag handles
    const int negone = -1;
    ErrorCode result = impl->tag_get_handle( MATERIAL_SET_TAG_NAME, 1, MB_TYPE_INTEGER, mMaterialSetTag,
                                             MB_TAG_CREAT | MB_TAG_SPARSE, &negone );
    MB_CHK_SET_ERR_RET( result, "Failed to get MATERIAL_SET tag" );
 
    result = impl->tag_get_handle( DIRICHLET_SET_TAG_NAME, 1, MB_TYPE_INTEGER, mDirichletSetTag,
                                   MB_TAG_CREAT | MB_TAG_SPARSE, &negone );
    MB_CHK_SET_ERR_RET( result, "Failed to get DIRICHLET_SET tag" );
 
    result = impl->tag_get_handle( NEUMANN_SET_TAG_NAME, 1, MB_TYPE_INTEGER, mNeumannSetTag,
                                   MB_TAG_CREAT | MB_TAG_SPARSE, &negone );
    MB_CHK_SET_ERR_RET( result, "Failed to get NEUMANN_SET tag" );
 
    const int negonearr[] = { -1, -1, -1, -1 };
    result                = impl->tag_get_handle( HAS_MID_NODES_TAG_NAME, 4, MB_TYPE_INTEGER, mHasMidNodesTag,
                                                  MB_TAG_CREAT | MB_TAG_SPARSE, negonearr );
    MB_CHK_SET_ERR_RET( result, "Failed to get HAS_MID_NODES tag" );
 
    mGlobalIdTag = impl->globalId_tag();
 
    result =
        impl->tag_get_handle( NAME_TAG_NAME, NAME_TAG_SIZE, MB_TYPE_OPAQUE, mNameTag, MB_TAG_CREAT | MB_TAG_SPARSE );
    MB_CHK_SET_ERR_RET( result, "Failed to get NAME tag" );
}
 
ReadCCMIO::~ReadCCMIO()
{
    mbImpl->release_interface( readMeshIface );
}
 
ErrorCode ReadCCMIO::load_file( const char* file_name,
                                const EntityHandle* file_set,
                                const FileOptions& /* opts */,
                                const ReaderIface::SubsetList* subset_list,
                                const Tag* /* file_id_tag */ )
{
    CCMIOID rootID, problemID, stateID, processorID, verticesID, topologyID, solutionID;
    CCMIOError error = kCCMIONoErr;
 
    if( subset_list )
    {
        MB_SET_ERR( MB_UNSUPPORTED_OPERATION, "Reading subset of files not supported for CCMOI data" );
    }
 
    CCMIOOpenFile( &error, file_name, kCCMIORead, &rootID );
    CHK_SET_CCMERR( error, "Problem opening file" );
 
    // Get the file state
    MB_CHK_SET_ERR( get_state( rootID, problemID, stateID ), "Failed to get state" );
 
    // Get processors
    std::vector< CCMIOSize_t > procs;
    bool has_solution = false;
    MB_CHK_SET_ERR( get_processors( stateID, processorID, verticesID, topologyID, solutionID, procs, has_solution ),
                    "Failed to get processors" );
 
    std::vector< CCMIOSize_t >::iterator vit;
    Range new_ents, *new_ents_ptr = NULL;
    if( file_set ) new_ents_ptr = &new_ents;
 
    for( vit = procs.begin(); vit != procs.end(); ++vit )
    {
        MB_CHK_SET_ERR( read_processor( stateID, problemID, processorID, verticesID, topologyID, *vit, new_ents_ptr ),
                        "Failed to read processors" );
    }
 
    // Load some meta-data
    MB_CHK_SET_ERR( load_metadata( rootID, problemID, stateID, processorID, file_set ),
                    "Failed to load some meta-data" );
 
    // Now, put all this into the file set, if there is one
    if( file_set )
    {
        MB_CHK_SET_ERR( mbImpl->add_entities( *file_set, new_ents ), "Failed to add new entities to file set" );
    }
 
    return rval;
}
 
ErrorCode ReadCCMIO::get_state( CCMIOID rootID, CCMIOID& problemID, CCMIOID& stateID )
{
    CCMIOError error = kCCMIONoErr;
 
    // First try default
    CCMIOGetState( &error, rootID, "default", &problemID, &stateID );
    if( kCCMIONoErr != error )
    {
        CCMIOSize_t i        = CCMIOSIZEC( 0 );
        CCMIOError tmp_error = kCCMIONoErr;
        CCMIONextEntity( &tmp_error, rootID, kCCMIOState, &i, &stateID );
        if( kCCMIONoErr == tmp_error ) CCMIONextEntity( &error, rootID, kCCMIOProblemDescription, &i, &problemID );
    }
    CHK_SET_CCMERR( error, "Couldn't find state" );
 
    return MB_SUCCESS;
}
 
ErrorCode ReadCCMIO::load_metadata( CCMIOID rootID,
                                    CCMIOID problemID,
                                    CCMIOID /* stateID */,
                                    CCMIOID processorID,
                                    const EntityHandle* file_set )
{
    // Read the simulation title.
    CCMIOError error = kCCMIONoErr;
    ErrorCode rval   = MB_SUCCESS;
    CCMIONode rootNode;
    if( kCCMIONoErr == CCMIOGetEntityNode( &error, rootID, &rootNode ) )
    {
        char* name = NULL;
        CCMIOGetTitle( &error, rootNode, &name );
 
        if( NULL != name && strlen( name ) != 0 )
        {
            // Make a tag for it and tag the read set
            Tag simname;
            MB_CHK_SET_ERR( mbImpl->tag_get_handle( "Title", strlen( name ), MB_TYPE_OPAQUE, simname,
                                                    MB_TAG_CREAT | MB_TAG_SPARSE ),
                            "Simulation name tag not found or created" );
            EntityHandle set = file_set ? *file_set : 0;
            MB_CHK_SET_ERR( mbImpl->tag_set_data( simname, &set, 1, name ), "Problem setting simulation name tag" );
        }
        if( name ) free( name );
    }
 
    // Creating program
    EntityHandle dumh = ( file_set ? *file_set : 0 );
    MB_CHK_SET_ERR( get_str_option( "CreatingProgram", dumh, mCreatingProgramTag, processorID ),
                    "Trouble getting CreatingProgram tag" );
 
    MB_CHK_SET_ERR( load_matset_data( problemID ), "Failure loading matset data" );
 
    MB_CHK_SET_ERR( load_neuset_data( problemID ), "Failure loading neuset data" );
 
    return rval;
}
 
ErrorCode ReadCCMIO::load_matset_data( CCMIOID problemID )
{
    // Make sure there are matsets
    if( newMatsets.empty() ) return MB_SUCCESS;
 
    // ... walk through each cell type
    CCMIOSize_t i = CCMIOSIZEC( 0 );
    CCMIOID next;
    CCMIOError error = kCCMIONoErr;
 
    while( CCMIONextEntity( NULL, problemID, kCCMIOCellType, &i, &next ) == kCCMIONoErr )
    {
        // Get index, corresponding set, and label with material set tag
        int mindex;
        CCMIOGetEntityIndex( &error, next, &mindex );
        std::map< int, EntityHandle >::iterator mit = newMatsets.find( mindex );
        if( mit == newMatsets.end() )
            // No actual faces for this matset; continue to next
            continue;
 
        EntityHandle dum_ent = mit->second;
        MB_CHK_SET_ERR( mbImpl->tag_set_data( mMaterialSetTag, &dum_ent, 1, &mindex ),
                        "Trouble setting material set tag" );
 
        // Set name
        CCMIOSize_t len;
        CCMIOEntityLabel( &error, next, &len, NULL );
        std::vector< char > opt_string2( GETINT32( len ) + 1, '\0' );
        CCMIOEntityLabel( &error, next, NULL, &opt_string2[0] );
        if( opt_string2.size() >= NAME_TAG_SIZE )
            opt_string2[NAME_TAG_SIZE - 1] = '\0';
        else
            ( opt_string2.resize( NAME_TAG_SIZE, '\0' ) );
        MB_CHK_SET_ERR( mbImpl->tag_set_data( mNameTag, &dum_ent, 1, &opt_string2[0] ),
                        "Trouble setting name tag for material set" );
 
        // Material id
        MB_CHK_SET_ERR( get_int_option( "MaterialId", dum_ent, mMaterialIdTag, next ),
                        "Trouble getting MaterialId tag" );
 
        MB_CHK_SET_ERR( get_str_option( "MaterialType", dum_ent, mMaterialTypeTag, next ),
                        "Trouble getting MaterialType tag" );
 
        MB_CHK_SET_ERR( get_int_option( "Radiation", dum_ent, mRadiationTag, next ),
                        "Trouble getting Radiation option" );
 
        MB_CHK_SET_ERR( get_int_option( "PorosityId", dum_ent, mPorosityIdTag, next ),
                        "Trouble getting PorosityId option" );
 
        MB_CHK_SET_ERR( get_int_option( "SpinId", dum_ent, mSpinIdTag, next ), "Trouble getting SpinId option" );
 
        MB_CHK_SET_ERR( get_int_option( "GroupId", dum_ent, mGroupIdTag, next ), "Trouble getting GroupId option" );
 
        MB_CHK_SET_ERR( get_int_option( "ColorIdx", dum_ent, mColorIdxTag, next ), "Trouble getting ColorIdx option" );
 
        MB_CHK_SET_ERR( get_int_option( "ProcessorId", dum_ent, mProcessorIdTag, next ),
                        "Trouble getting ProcessorId option" );
 
        MB_CHK_SET_ERR( get_int_option( "LightMaterial", dum_ent, mLightMaterialTag, next ),
                        "Trouble getting LightMaterial option" );
 
        MB_CHK_SET_ERR( get_int_option( "FreeSurfaceMaterial", dum_ent, mFreeSurfaceMaterialTag, next ),
                        "Trouble getting FreeSurfaceMaterial option" );
 
        MB_CHK_SET_ERR( get_dbl_option( "Thickness", dum_ent, mThicknessTag, next ),
                        "Trouble getting Thickness option" );
    }
 
    return MB_SUCCESS;
}
 
ErrorCode ReadCCMIO::get_int_option( const char* opt_str, EntityHandle seth, Tag& tag, CCMIOID node )
{
    int idum;
    ErrorCode rval;
    if( kCCMIONoErr == CCMIOReadOpti( NULL, node, opt_str, &idum ) )
    {
        if( !tag )
        {
            MB_CHK_SET_ERR( mbImpl->tag_get_handle( opt_str, 1, MB_TYPE_INTEGER, tag, MB_TAG_SPARSE | MB_TAG_CREAT ),
                            "Failed to get tag handle" );
        }
 
        MB_CHK_SET_ERR( mbImpl->tag_set_data( tag, &seth, 1, &idum ), "Failed to set tag data" );
    }
 
    return MB_SUCCESS;
}
 
ErrorCode ReadCCMIO::get_dbl_option( const char* opt_str, EntityHandle seth, Tag& tag, CCMIOID node )
{
    float fdum;
    if( kCCMIONoErr == CCMIOReadOptf( NULL, node, opt_str, &fdum ) )
    {
        ErrorCode rval;
        if( !tag )
        {
            MB_CHK_SET_ERR( mbImpl->tag_get_handle( opt_str, 1, MB_TYPE_DOUBLE, tag, MB_TAG_SPARSE | MB_TAG_CREAT ),
                            "Failed to get tag handle" );
        }
 
        double dum_dbl = fdum;
        MB_CHK_SET_ERR( mbImpl->tag_set_data( tag, &seth, 1, &dum_dbl ), "Failed to set tag data" );
    }
 
    return MB_SUCCESS;
}
 
ErrorCode ReadCCMIO::get_str_option( const char* opt_str,
                                     EntityHandle seth,
                                     Tag& tag,
                                     CCMIOID node,
                                     const char* other_tag_name )
{
    int len;
    CCMIOError error = kCCMIONoErr;
    std::vector< char > opt_string;
    if( kCCMIONoErr != CCMIOReadOptstr( NULL, node, opt_str, &len, NULL ) ) return MB_SUCCESS;
 
    opt_string.resize( len );
    CCMIOReadOptstr( &error, node, opt_str, &len, &opt_string[0] );
    ErrorCode rval = MB_SUCCESS;
    if( !tag )
    {
        MB_CHK_SET_ERR( mbImpl->tag_get_handle( other_tag_name ? other_tag_name : opt_str, NAME_TAG_SIZE,
                                                MB_TYPE_OPAQUE, tag, MB_TAG_SPARSE | MB_TAG_CREAT ),
                        "Failed to get tag handle" );
    }
 
    if( opt_string.size() > NAME_TAG_SIZE )
        opt_string[NAME_TAG_SIZE - 1] = '\0';
    else
        ( opt_string.resize( NAME_TAG_SIZE, '\0' ) );
 
    MB_CHK_SET_ERR( mbImpl->tag_set_data( tag, &seth, 1, &opt_string[0] ), "Failed to set tag data" );
 
    return MB_SUCCESS;
}
 
ErrorCode ReadCCMIO::load_neuset_data( CCMIOID problemID )
{
    CCMIOSize_t i = CCMIOSIZEC( 0 );
    CCMIOID next;
 
    // Make sure there are matsets
    if( newNeusets.empty() ) return MB_SUCCESS;
 
    while( CCMIONextEntity( NULL, problemID, kCCMIOBoundaryRegion, &i, &next ) == kCCMIONoErr )
    {
        // Get index, corresponding set, and label with neumann set tag
        int mindex;
        CCMIOError error = kCCMIONoErr;
        CCMIOGetEntityIndex( &error, next, &mindex );
        std::map< int, EntityHandle >::iterator mit = newNeusets.find( mindex );
        if( mit == newNeusets.end() )
            // No actual faces for this neuset; continue to next
            continue;
 
        EntityHandle dum_ent = mit->second;
        MB_CHK_SET_ERR( mbImpl->tag_set_data( mNeumannSetTag, &dum_ent, 1, &mindex ),
                        "Trouble setting neumann set tag" );
 
        // Set name
        MB_CHK_SET_ERR( get_str_option( "BoundaryName", dum_ent, mNameTag, next, NAME_TAG_NAME ),
                        "Trouble creating BoundaryName tag" );
 
        // BoundaryType
        MB_CHK_SET_ERR( get_str_option( "BoundaryType", dum_ent, mBoundaryTypeTag, next ),
                        "Trouble creating BoundaryType tag" );
 
        // ProstarRegionNumber
        MB_CHK_SET_ERR( get_int_option( "ProstarRegionNumber", dum_ent, mProstarRegionNumberTag, next ),
                        "Trouble creating ProstarRegionNumber tag" );
    }
 
    return MB_SUCCESS;
}
 
ErrorCode ReadCCMIO::read_processor( CCMIOID /* stateID */,
                                     CCMIOID problemID,
                                     CCMIOID processorID,
                                     CCMIOID verticesID,
                                     CCMIOID topologyID,
                                     CCMIOSize_t proc,
                                     Range* new_ents )
{
    ErrorCode rval;
 
    // vert_map fields: s: none, i: gid, ul: vert handle, r: none
    // TupleList vert_map(0, 1, 1, 0, 0);
    TupleList vert_map;
    MB_CHK_SET_ERR( read_vertices( proc, processorID, verticesID, topologyID, new_ents, vert_map ),
                    "Failed to read vertices" );
 
    MB_CHK_SET_ERR( read_cells( proc, problemID, verticesID, topologyID, vert_map, new_ents ), "Failed to read cells" );
 
    return rval;
}
 
ErrorCode ReadCCMIO::read_cells( CCMIOSize_t /* proc */,
                                 CCMIOID problemID,
                                 CCMIOID /* verticesID */,
                                 CCMIOID topologyID,
                                 TupleList& vert_map,
                                 Range* new_ents )
{
    // Read the faces.
    // face_map fields: s:forward/reverse, i: cell id, ul: face handle, r: none
    ErrorCode rval;
#ifdef TUPLE_LIST
    TupleList face_map( 1, 1, 1, 0, 0 );
#else
    TupleList face_map;
    SenseList sense_map;
#endif
    MB_CHK_SET_ERR( read_all_faces( topologyID, vert_map, face_map,
#ifndef TUPLE_LIST
                                    sense_map,
#endif
                                    new_ents ),
                    "Failed to read all cells" );
 
    // Read the cell topology types, if any exist in the file
    std::map< int, int > cell_topo_types;
    MB_CHK_SET_ERR( read_topology_types( topologyID, cell_topo_types ), "Problem reading cell topo types" );
 
    // Now construct the cells; sort the face map by cell ids first
#ifdef TUPLE_LIST
    MB_CHK_SET_ERR( face_map.sort( 1 ), "Couldn't sort face map by cell id" );
#endif
    std::vector< EntityHandle > new_cells;
    MB_CHK_SET_ERR( construct_cells( face_map,
#ifndef TUPLE_LIST
                                     sense_map,
#endif
                                     vert_map, cell_topo_types, new_cells ),
                    "Failed to construct cells" );
    if( new_ents )
    {
        Range::iterator rit = new_ents->end();
        std::vector< EntityHandle >::reverse_iterator vit;
        for( vit = new_cells.rbegin(); vit != new_cells.rend(); ++vit )
            rit = new_ents->insert( rit, *vit );
    }
 
    MB_CHK_SET_ERR( read_gids_and_types( problemID, topologyID, new_cells ), "Failed to read gids and types" );
 
    return MB_SUCCESS;
}
 
ErrorCode ReadCCMIO::read_topology_types( CCMIOID& topologyID, std::map< int, int >& cell_topo_types )
{
    CCMIOError error = kCCMIONoErr;
    CCMIOID cellID, mapID;
    CCMIOSize_t ncells;
    CCMIOGetEntity( &error, topologyID, kCCMIOCells, 0, &cellID );
    CCMIOEntitySize( &error, cellID, &ncells, NULL );
    int num_cells = GETINT32( ncells );
 
    // First, do a dummy read to see if we even have topo types in this mesh
    int dum_int;
    CCMIOReadOpt1i( &error, cellID, "CellTopologyType", &dum_int, CCMIOINDEXC( kCCMIOStart ),
                    CCMIOINDEXC( kCCMIOStart ) + 1 );
    if( kCCMIONoErr != error ) return MB_SUCCESS;
 
    // OK, we have topo types; first get the map node
    std::vector< int > dum_ints( num_cells );
    CCMIOReadCells( &error, cellID, &mapID, &dum_ints[0], CCMIOINDEXC( kCCMIOStart ), CCMIOINDEXC( kCCMIOStart ) + 1 );
    CHK_SET_CCMERR( error, "Failed to get the map node" );
 
    // Now read the map
    CCMIOReadMap( &error, mapID, &dum_ints[0], CCMIOINDEXC( kCCMIOStart ), CCMIOINDEXC( kCCMIOEnd ) );
    CHK_SET_CCMERR( error, "Failed to get cell ids" );
    int i;
    for( i = 0; i < num_cells; i++ )
        cell_topo_types[dum_ints[i]] = 0;
 
    // Now read the cell topo types for real, reusing cell_topo_types
    std::vector< int > topo_types( num_cells );
    CCMIOReadOpt1i( &error, cellID, "CellTopologyType", &topo_types[0], CCMIOINDEXC( kCCMIOStart ),
                    CCMIOINDEXC( kCCMIOEnd ) );
    CHK_SET_CCMERR( error, "Failed to get cell topo types" );
    for( i = 0; i < num_cells; i++ )
        cell_topo_types[dum_ints[i]] = topo_types[i];
 
    return MB_SUCCESS;
}
 
ErrorCode ReadCCMIO::read_gids_and_types( CCMIOID /* problemID */,
                                          CCMIOID topologyID,
                                          std::vector< EntityHandle >& cells )
{
    // Get the cells entity and number of cells
    CCMIOSize_t dum_cells;
    int num_cells;
    CCMIOError error = kCCMIONoErr;
    CCMIOID cellsID, mapID;
    CCMIOGetEntity( &error, topologyID, kCCMIOCells, 0, &cellsID );
    CCMIOEntitySize( &error, cellsID, &dum_cells, NULL );
    num_cells = GETINT32( dum_cells );
 
    // Check the number of cells against how many are in the cell array
    if( num_cells != (int)cells.size() ) MB_SET_ERR( MB_FAILURE, "Number of cells doesn't agree" );
 
    // Read the gid map and set global ids
    std::vector< int > cell_gids( num_cells );
    CCMIOReadCells( &error, cellsID, &mapID, NULL, CCMIOINDEXC( kCCMIOStart ), CCMIOINDEXC( kCCMIOEnd ) );
    CHK_SET_CCMERR( error, "Couldn't read cells" );
    CCMIOReadMap( &error, mapID, &cell_gids[0], CCMIOINDEXC( kCCMIOStart ), CCMIOINDEXC( kCCMIOEnd ) );
    CHK_SET_CCMERR( error, "Couldn't read cell id map" );
 
    MB_CHK_SET_ERR( mbImpl->tag_set_data( mGlobalIdTag, &cells[0], cells.size(), &cell_gids[0] ),
                    "Couldn't set gids tag" );
 
    // Now read cell material types; reuse cell_gids
    CCMIOReadCells( &error, cellsID, NULL, &cell_gids[0], CCMIOINDEXC( kCCMIOStart ), CCMIOINDEXC( kCCMIOEnd ) );
    CHK_SET_CCMERR( error, "Trouble reading cell types" );
 
    // Create the matsets
    std::map< int, Range > matset_ents;
    for( int i = 0; i < num_cells; i++ )
        matset_ents[cell_gids[i]].insert( cells[i] );
 
    for( std::map< int, Range >::iterator mit = matset_ents.begin(); mit != matset_ents.end(); ++mit )
    {
        EntityHandle matset;
        MB_CHK_SET_ERR( mbImpl->create_meshset( MESHSET_SET, matset ), "Couldn't create material set" );
        newMatsets[mit->first] = matset;
 
        MB_CHK_SET_ERR( mbImpl->add_entities( matset, mit->second ), "Couldn't add entities to material set" );
    }
 
    return MB_SUCCESS;
}
 
ErrorCode ReadCCMIO::construct_cells( TupleList& face_map,
#ifndef TUPLE_LIST
                                      SenseList& sense_map,
#endif
                                      TupleList& /* vert_map */,
                                      std::map< int, int >& cell_topo_types,
                                      std::vector< EntityHandle >& new_cells )
{
    std::vector< EntityHandle > facehs;
    std::vector< int > senses;
    EntityHandle cell;
    ErrorCode tmp_rval, rval = MB_SUCCESS;
    EntityType this_type = MBMAXTYPE;
    bool has_mid_nodes   = false;
#ifdef TUPLE_LIST
    unsigned int i = 0;
    while( i < face_map.n )
    {
        // Pull out face handles bounding the same cell
        facehs.clear();
        int this_id        = face_map.get_int( i );
        unsigned int inext = i;
        while( face_map.get_int( inext ) == this_id && inext <= face_map.n )
        {
            inext++;
            EntityHandle face = face_map.get_ulong( inext );
            facehs.push_back( face );
            senses.push_back( face_map.get_short( inext ) );
        }
        this_type     = MBMAXTYPE;
        has_mid_nodes = false;
#else
    std::map< int, std::vector< EntityHandle > >::iterator fmit;
    std::map< int, std::vector< int > >::iterator smit;
    std::map< int, int >::iterator typeit;
    for( fmit = face_map.begin(), smit = sense_map.begin(); fmit != face_map.end(); ++fmit, ++smit )
    {
        // Pull out face handles bounding the same cell
        facehs.clear();
        int this_id = ( *fmit ).first;
        facehs      = ( *fmit ).second;
        senses.clear();
        senses = ( *smit ).second;
        typeit = cell_topo_types.find( this_id );
        if( typeit != cell_topo_types.end() )
        {
            rval = ccmio_to_moab_type( typeit->second, this_type, has_mid_nodes );
        }
        else
        {
            this_type     = MBMAXTYPE;
            has_mid_nodes = false;
        }
#endif
        tmp_rval = create_cell_from_faces( facehs, senses, this_type, has_mid_nodes, cell );
        if( MB_SUCCESS != tmp_rval )
            rval = tmp_rval;
        else
        {
            new_cells.push_back( cell );
            // Tag cell with global id
            tmp_rval = mbImpl->tag_set_data( mGlobalIdTag, &cell, 1, &this_id );
            if( MB_SUCCESS != tmp_rval ) rval = tmp_rval;
        }
    }
 
    return rval;
}
 
ErrorCode ReadCCMIO::ccmio_to_moab_type( int ccm_type, EntityType& moab_type, bool& has_mid_nodes )
{
    switch( ccm_type )
    {
        case 1:
            moab_type = MBVERTEX;
            break;
        case 2:
        case 28:
            moab_type = MBEDGE;
            break;
        case 29:
            moab_type = MBMAXTYPE;
            break;
        case 3:
        case 4:
            moab_type = MBQUAD;
            break;
        case 11:
        case 21:
            moab_type = MBHEX;
            break;
        case 12:
        case 22:
            moab_type = MBPRISM;
            break;
        case 13:
        case 23:
            moab_type = MBTET;
            break;
        case 14:
        case 24:
            moab_type = MBPYRAMID;
            break;
        case 255:
            moab_type = MBPOLYHEDRON;
            break;
        default:
            moab_type = MBMAXTYPE;
    }
 
    switch( ccm_type )
    {
        case 28:
        case 4:
        case 21:
        case 22:
        case 23:
        case 24:
            has_mid_nodes = true;
            break;
        default:
            break;
    }
 
    return MB_SUCCESS;
}
 
ErrorCode ReadCCMIO::create_cell_from_faces( std::vector< EntityHandle >& facehs,
                                             std::vector< int >& senses,
                                             EntityType this_type,
                                             bool /* has_mid_nodes */,
                                             EntityHandle& cell )
{
    ErrorCode rval;
 
    // Test up front to see if they're one type
    EntityType face_type = mbImpl->type_from_handle( facehs[0] );
    bool same_type       = true;
    for( std::vector< EntityHandle >::iterator vit = facehs.begin(); vit != facehs.end(); ++vit )
    {
        if( face_type != mbImpl->type_from_handle( *vit ) )
        {
            same_type = false;
            break;
        }
    }
 
    std::vector< EntityHandle > verts;
    EntityType input_type = this_type;
    std::vector< EntityHandle > storage;
    MeshTopoUtil mtu( mbImpl );
 
    // Preset this to maxtype, so we get an affirmative choice in loop
    this_type = MBMAXTYPE;
 
    if( ( MBTET == input_type || MBMAXTYPE == input_type ) && same_type && face_type == MBTRI && facehs.size() == 4 )
    {
        // Try to get proper connectivity for tet
 
        // Get connectivity of first face, and reverse it if sense is forward, since
        // base face always points into entity
        MB_CHK_SET_ERR( mbImpl->get_connectivity( &facehs[0], 1, verts ), "Couldn't get connectivity" );
        if( senses[0] > 0 ) std::reverse( verts.begin(), verts.end() );
 
        // Get the 4th vertex through the next tri
        const EntityHandle* conn;
        int conn_size;
        MB_CHK_SET_ERR( mbImpl->get_connectivity( facehs[1], conn, conn_size, true, &storage ),
                        "Couldn't get connectivity" );
        int i = 0;
        while( std::find( verts.begin(), verts.end(), conn[i] ) != verts.end() && i < conn_size )
            i++;
 
        // If i is not at the end of the verts, found the apex; otherwise fall back to polyhedron
        if( conn_size != i )
        {
            this_type = MBTET;
            verts.push_back( conn[i] );
        }
    }
    else if( ( MBHEX == input_type || MBMAXTYPE == input_type ) && same_type && MBQUAD == face_type &&
             facehs.size() == 6 )
    {
        // Build hex from quads
        // Algorithm:
        // - verts = vertices from 1st quad
        // - Find quad q1 sharing verts[0] and verts[1]
        // - Find quad q2 sharing other 2 verts in q1
        // - Find v1 = opposite vert from verts[1] in q1 , v2 = opposite from verts[0]
        // - Get i = offset of v1 in verts2 of q2, rotate verts2 by i
        // - If verts2[(i + 1) % 4] != v2, flip verts2 by switching verts2[1] and verts2[3]
        // - append verts2 to verts
 
        // Get the other vertices for this hex; need to find the quad with no common vertices
        Range tmp_faces, tmp_verts;
        // Get connectivity of first face, and reverse it if sense is forward, since
        // base face always points into entity
        MB_CHK_SET_ERR( mbImpl->get_connectivity( &facehs[0], 1, verts ), "Couldn't get connectivity" );
        if( senses[0] > 0 ) std::reverse( verts.begin(), verts.end() );
 
        // Get q1, which shares 2 vertices with q0
        std::copy( facehs.begin(), facehs.end(), range_inserter( tmp_faces ) );
        rval = mbImpl->get_adjacencies( &verts[0], 2, 2, false, tmp_faces );
        if( MB_SUCCESS != rval || tmp_faces.size() != 2 ) MB_SET_ERR( MB_FAILURE, "Couldn't get adj face" );
        tmp_faces.erase( facehs[0] );
        EntityHandle q1 = *tmp_faces.begin();
        // Get other 2 verts of q1
        MB_CHK_SET_ERR( mbImpl->get_connectivity( &q1, 1, tmp_verts ), "Couldn't get adj verts" );
        tmp_verts.erase( verts[0] );
        tmp_verts.erase( verts[1] );
        // Get q2
        std::copy( facehs.begin(), facehs.end(), range_inserter( tmp_faces ) );
        rval = mbImpl->get_adjacencies( tmp_verts, 2, false, tmp_faces );
        if( MB_SUCCESS != rval || tmp_faces.size() != 2 ) MB_SET_ERR( MB_FAILURE, "Couldn't get adj face" );
        tmp_faces.erase( q1 );
        EntityHandle q2 = *tmp_faces.begin();
        // Get verts in q2
        MB_CHK_SET_ERR( mbImpl->get_connectivity( &q2, 1, storage ), "Couldn't get adj vertices" );
 
        // Get verts in q1 opposite from v[1] and v[0] in q0
        EntityHandle v0 = 0, v1 = 0;
        MB_CHK_SET_ERR( mtu.opposite_entity( q1, verts[1], v0 ), "Couldn't get the opposite side entity" );
        MB_CHK_SET_ERR( mtu.opposite_entity( q1, verts[0], v1 ), "Couldn't get the opposite side entity" );
        if( v0 && v1 )
        {
            // Offset of v0 in q2, then rotate and flip
            unsigned int ioff = std::find( storage.begin(), storage.end(), v0 ) - storage.begin();
            if( 4 == ioff ) MB_SET_ERR( MB_FAILURE, "Trouble finding offset" );
 
            if( storage[( ioff + 1 ) % 4] != v1 )
            {
                std::reverse( storage.begin(), storage.end() );
                ioff = std::find( storage.begin(), storage.end(), v0 ) - storage.begin();
            }
            if( 0 != ioff ) std::rotate( storage.begin(), storage.begin() + ioff, storage.end() );
 
            // Copy into verts, and make hex
            std::copy( storage.begin(), storage.end(), std::back_inserter( verts ) );
            this_type = MBHEX;
        }
    }
 
    if( MBMAXTYPE == this_type && facehs.size() == 5 )
    {
        // Some preliminaries
        std::vector< EntityHandle > tris, quads;
        for( unsigned int i = 0; i < 5; i++ )
        {
            if( MBTRI == mbImpl->type_from_handle( facehs[i] ) )
                tris.push_back( facehs[i] );
            else if( MBQUAD == mbImpl->type_from_handle( facehs[i] ) )
                quads.push_back( facehs[i] );
        }
 
        // Check for prisms
        if( 2 == tris.size() && 3 == quads.size() )
        {
            // OK, we have the right number of tris and quads; try to find the proper verts
 
            // Get connectivity of first tri, and reverse if necessary
            int index = std::find( facehs.begin(), facehs.end(), tris[0] ) - facehs.begin();
            MB_CHK_SET_ERR( mbImpl->get_connectivity( &tris[0], 1, verts ), "Couldn't get connectivity" );
            if( senses[index] > 0 ) std::reverse( verts.begin(), verts.end() );
 
            // Now align vertices of other tri, through a quad, similar to how we did hexes
            // Get q1, which shares 2 vertices with t0
            Range tmp_faces, tmp_verts;
            std::copy( facehs.begin(), facehs.end(), range_inserter( tmp_faces ) );
            rval = mbImpl->get_adjacencies( &verts[0], 2, 2, false, tmp_faces );
            if( MB_SUCCESS != rval || tmp_faces.size() != 2 ) MB_SET_ERR( MB_FAILURE, "Couldn't get adj face" );
            tmp_faces.erase( tris[0] );
            EntityHandle q1 = *tmp_faces.begin();
            // Get verts in q1
            MB_CHK_SET_ERR( mbImpl->get_connectivity( &q1, 1, storage ), "Couldn't get adj vertices" );
 
            // Get verts in q1 opposite from v[1] and v[0] in q0
            EntityHandle v0 = 0, v1 = 0;
            MB_CHK_SET_ERR( mtu.opposite_entity( q1, verts[1], v0 ), "Couldn't get the opposite side entity" );
            MB_CHK_SET_ERR( mtu.opposite_entity( q1, verts[0], v1 ), "Couldn't get the opposite side entity" );
            if( v0 && v1 )
            {
                // Offset of v0 in t2, then rotate and flip
                storage.clear();
                MB_CHK_SET_ERR( mbImpl->get_connectivity( &tris[1], 1, storage ), "Couldn't get connectivity" );
 
                index = std::find( facehs.begin(), facehs.end(), tris[1] ) - facehs.begin();
                if( senses[index] < 0 ) std::reverse( storage.begin(), storage.end() );
                unsigned int ioff = std::find( storage.begin(), storage.end(), v0 ) - storage.begin();
                if( 3 == ioff ) MB_SET_ERR( MB_FAILURE, "Trouble finding offset" );
                for( unsigned int i = 0; i < 3; i++ )
                    verts.push_back( storage[( ioff + i ) % 3] );
 
                this_type = MBPRISM;
            }
        }
        else if( tris.size() == 4 && quads.size() == 1 )
        {
            // Check for pyramid
            // Get connectivity of first tri, and reverse if necessary
            int index = std::find( facehs.begin(), facehs.end(), quads[0] ) - facehs.begin();
            MB_CHK_SET_ERR( mbImpl->get_connectivity( &quads[0], 1, verts ), "Couldn't get connectivity" );
            if( senses[index] > 0 ) std::reverse( verts.begin(), verts.end() );
 
            // Get apex node
            MB_CHK_SET_ERR( mbImpl->get_connectivity( &tris[0], 1, storage ), "Couldn't get connectivity" );
            for( unsigned int i = 0; i < 3; i++ )
            {
                if( std::find( verts.begin(), verts.end(), storage[i] ) == verts.end() )
                {
                    verts.push_back( storage[i] );
                    break;
                }
            }
 
            if( 5 == verts.size() ) this_type = MBPYRAMID;
        }
        else
        {
            // Dummy else clause to stop in debugger
            this_type = MBMAXTYPE;
        }
    }
 
    if( MBMAXTYPE != input_type && input_type != this_type && this_type != MBMAXTYPE )
        std::cerr << "Warning: types disagree (cell_topo_type = " << CN::EntityTypeName( input_type )
                  << ", faces indicate type " << CN::EntityTypeName( this_type ) << std::endl;
 
    if( MBMAXTYPE != input_type && this_type == MBMAXTYPE && input_type != MBPOLYHEDRON )
        std::cerr << "Warning: couldn't find proper connectivity for specified topo_type = "
                  << CN::EntityTypeName( input_type ) << std::endl;
 
    // Now make the element; if we fell back to polyhedron, use faces, otherwise use verts
    if( MBPOLYHEDRON == this_type || MBMAXTYPE == this_type )
    {
        MB_CHK_SET_ERR( mbImpl->create_element( MBPOLYHEDRON, &facehs[0], facehs.size(), cell ),
                        "create_element failed" );
    }
    else
    {
        MB_CHK_SET_ERR( mbImpl->create_element( this_type, &verts[0], verts.size(), cell ), "create_element failed" );
    }
 
    return MB_SUCCESS;
}
 
ErrorCode ReadCCMIO::read_all_faces( CCMIOID topologyID,
                                     TupleList& vert_map,
                                     TupleList& face_map,
#ifndef TUPLE_LIST
                                     SenseList& sense_map,
#endif
                                     Range* new_faces )
{
    CCMIOSize_t index;
    CCMIOID faceID;
    ErrorCode rval;
    CCMIOError error = kCCMIONoErr;
 
    // Get total # internal/bdy faces, size the face map accordingly
#ifdef TUPLE_LIST
    index          = CCMIOSIZEC( 0 );
    int nbdy_faces = 0;
    CCMIOSize_t nf;
    error = kCCMIONoErr;
    while( kCCMIONoErr == CCMIONextEntity( NULL, topologyID, kCCMIOBoundaryFaces, &index, &faceID ) )
    {
        CCMIOEntitySize( &error, faceID, &nf, NULL );
        nbdy_faces += nf;
    }
    CCMIOGetEntity( &error, topologyID, kCCMIOInternalFaces, 0, &faceID );
    CCMIOEntitySize( &error, faceID, &nf, NULL );
 
    int nint_faces = nf;
    face_map.resize( 2 * nint_faces + nbdy_faces );
#endif
 
    // Get multiple blocks of bdy faces
    index = CCMIOSIZEC( 0 );
    while( kCCMIONoErr == CCMIONextEntity( NULL, topologyID, kCCMIOBoundaryFaces, &index, &faceID ) )
    {
        MB_CHK_SET_ERR( read_faces( faceID, kCCMIOBoundaryFaces, vert_map, face_map,
#ifndef TUPLE_LIST
                                    sense_map,
#endif
                                    new_faces ),
                        "Trouble reading boundary faces" );
    }
 
    // Now get internal faces
    CCMIOGetEntity( &error, topologyID, kCCMIOInternalFaces, 0, &faceID );
    CHK_SET_CCMERR( error, "Couldn't get internal faces" );
 
    MB_CHK_SET_ERR( read_faces( faceID, kCCMIOInternalFaces, vert_map, face_map,
#ifndef TUPLE_LIST
                                sense_map,
#endif
                                new_faces ),
                    "Trouble reading internal faces" );
 
    return rval;
}
 
ErrorCode ReadCCMIO::read_faces( CCMIOID faceID,
                                 CCMIOEntity bdy_or_int,
                                 TupleList& vert_map,
                                 TupleList& face_map,
#ifndef TUPLE_LIST
                                 SenseList& sense_map,
#endif
                                 Range* new_faces )
{
    if( kCCMIOInternalFaces != bdy_or_int && kCCMIOBoundaryFaces != bdy_or_int )
        MB_SET_ERR( MB_FAILURE, "Face type isn't boundary or internal" );
 
    CCMIOSize_t dum_faces;
    CCMIOError error = kCCMIONoErr;
    CCMIOEntitySize( &error, faceID, &dum_faces, NULL );
    int num_faces = GETINT32( dum_faces );
 
    // Get the size of the face connectivity array (not really a straight connect
    // array, has n, connect(n), ...)
    CCMIOSize_t farray_size = CCMIOSIZEC( 0 );
    CCMIOReadFaces( &error, faceID, bdy_or_int, NULL, &farray_size, NULL, CCMIOINDEXC( kCCMIOStart ),
                    CCMIOINDEXC( kCCMIOEnd ) );
    CHK_SET_CCMERR( error, "Trouble reading face connectivity length" );
 
    // Allocate vectors for holding farray and cells for each face; use new for finer
    // control of de-allocation
    int num_sides = ( kCCMIOInternalFaces == bdy_or_int ? 2 : 1 );
    int* farray   = new int[GETINT32( farray_size )];
 
    // Read farray and make the faces
    CCMIOID mapID;
    CCMIOReadFaces( &error, faceID, bdy_or_int, &mapID, NULL, farray, CCMIOINDEXC( kCCMIOStart ),
                    CCMIOINDEXC( kCCMIOEnd ) );
    CHK_SET_CCMERR( error, "Trouble reading face connectivity" );
 
    std::vector< EntityHandle > face_handles;
    MB_CHK_SET_ERR( make_faces( farray, vert_map, face_handles, num_faces ), "Failed to make the faces" );
 
    // Read face cells and make tuples
    int* face_cells;
    if( num_sides * num_faces < farray_size )
        face_cells = new int[num_sides * num_faces];
    else
        face_cells = farray;
    CCMIOReadFaceCells( &error, faceID, bdy_or_int, face_cells, CCMIOINDEXC( kCCMIOStart ), CCMIOINDEXC( kCCMIOEnd ) );
    CHK_SET_CCMERR( error, "Trouble reading face cells" );
 
    int* tmp_ptr = face_cells;
    for( unsigned int i = 0; i < face_handles.size(); i++ )
    {
#ifdef TUPLE_LIST
        short forward = 1, reverse = -1;
        face_map.push_back( &forward, tmp_ptr++, &face_handles[i], NULL );
        if( 2 == num_sides ) face_map.push_back( &reverse, tmp_ptr++, &face_handles[i], NULL );
#else
        face_map[*tmp_ptr].push_back( face_handles[i] );
        sense_map[*tmp_ptr++].push_back( 1 );
        if( 2 == num_sides )
        {
            face_map[*tmp_ptr].push_back( face_handles[i] );
            sense_map[*tmp_ptr++].push_back( -1 );
        }
#endif
    }
 
    // Now read & set face gids, reuse face_cells 'cuz we know it's big enough
    CCMIOReadMap( &error, mapID, face_cells, CCMIOINDEXC( kCCMIOStart ), CCMIOINDEXC( kCCMIOEnd ) );
    CHK_SET_CCMERR( error, "Trouble reading face gids" );
 
    MB_CHK_SET_ERR( mbImpl->tag_set_data( mGlobalIdTag, &face_handles[0], face_handles.size(), face_cells ),
                    "Couldn't set face global ids" );
 
    // Make a neumann set for these faces if they're all in a boundary face set
    if( kCCMIOBoundaryFaces == bdy_or_int )
    {
        EntityHandle neuset;
        MB_CHK_SET_ERR( mbImpl->create_meshset( MESHSET_SET, neuset ), "Failed to create neumann set" );
 
        // Don't trust entity index passed in
        int index;
        CCMIOGetEntityIndex( &error, faceID, &index );
        newNeusets[index] = neuset;
 
        MB_CHK_SET_ERR( mbImpl->add_entities( neuset, &face_handles[0], face_handles.size() ),
                        "Failed to add faces to neumann set" );
 
        // Now tag as neumann set; will add id later
        int dum_val = 0;
        MB_CHK_SET_ERR( mbImpl->tag_set_data( mNeumannSetTag, &neuset, 1, &dum_val ), "Failed to tag neumann set" );
    }
 
    if( new_faces )
    {
        std::sort( face_handles.begin(), face_handles.end() );
        std::copy( face_handles.rbegin(), face_handles.rend(), range_inserter( *new_faces ) );
    }
 
    return MB_SUCCESS;
}
 
ErrorCode ReadCCMIO::make_faces( int* farray,
                                 TupleList& vert_map,
                                 std::vector< EntityHandle >& new_faces,
                                 int num_faces )
{
    std::vector< EntityHandle > verts;
    ErrorCode tmp_rval = MB_SUCCESS, rval = MB_SUCCESS;
 
    for( int i = 0; i < num_faces; i++ )
    {
        int num_verts = *farray++;
        verts.resize( num_verts );
 
        // Fill in connectivity by looking up by gid in vert tuple_list
        for( int j = 0; j < num_verts; j++ )
        {
#ifdef TUPLE_LIST
            int tindex = vert_map.find( 1, farray[j] );
            if( -1 == tindex )
            {
                tmp_rval = MB_FAILURE;
                break;
            }
            verts[j] = vert_map.get_ulong( tindex, 0 );
#else
            verts[j] = ( vert_map[farray[j]] )[0];
#endif
        }
        farray += num_verts;
 
        if( MB_SUCCESS == tmp_rval )
        {
            // Make face
            EntityType ftype = ( 3 == num_verts ? MBTRI : ( 4 == num_verts ? MBQUAD : MBPOLYGON ) );
            EntityHandle faceh;
            tmp_rval = mbImpl->create_element( ftype, &verts[0], num_verts, faceh );
            if( faceh ) new_faces.push_back( faceh );
        }
 
        if( MB_SUCCESS != tmp_rval ) rval = tmp_rval;
    }
 
    return rval;
}
 
ErrorCode ReadCCMIO::read_vertices( CCMIOSize_t /* proc */,
                                    CCMIOID /* processorID */,
                                    CCMIOID verticesID,
                                    CCMIOID /* topologyID */,
                                    Range* verts,
                                    TupleList& vert_map )
{
    CCMIOError error = kCCMIONoErr;
 
    // Pre-read the number of vertices, so we can pre-allocate & read directly in
    CCMIOSize_t nverts = CCMIOSIZEC( 0 );
    CCMIOEntitySize( &error, verticesID, &nverts, NULL );
    CHK_SET_CCMERR( error, "Couldn't get number of vertices" );
 
    // Get # dimensions
    CCMIOSize_t dims;
    float scale;
    CCMIOReadVerticesf( &error, verticesID, &dims, NULL, NULL, NULL, CCMIOINDEXC( 0 ), CCMIOINDEXC( 1 ) );
    CHK_SET_CCMERR( error, "Couldn't get number of dimensions" );
 
    // Allocate vertex space
    EntityHandle node_handle = 0;
    std::vector< double* > arrays;
    readMeshIface->get_node_coords( 3, GETINT32( nverts ), MB_START_ID, node_handle, arrays );
 
    // Read vertex coords
    CCMIOID mapID;
    std::vector< double > tmp_coords( GETINT32( dims ) * GETINT32( nverts ) );
    CCMIOReadVerticesd( &error, verticesID, &dims, &scale, &mapID, &tmp_coords[0], CCMIOINDEXC( 0 ),
                        CCMIOINDEXC( 0 + nverts ) );
    CHK_SET_CCMERR( error, "Trouble reading vertex coordinates" );
 
    // Copy interleaved coords into moab blocked coordinate space
    int i = 0, threei = 0;
    for( ; i < nverts; i++ )
    {
        arrays[0][i] = tmp_coords[threei++];
        arrays[1][i] = tmp_coords[threei++];
        if( 3 == GETINT32( dims ) )
            arrays[2][i] = tmp_coords[threei++];
        else
            arrays[2][i] = 0.0;
    }
 
    // Scale, if necessary
    if( 1.0 != scale )
    {
        for( i = 0; i < nverts; i++ )
        {
            arrays[0][i] *= scale;
            arrays[1][i] *= scale;
            if( 3 == GETINT32( dims ) ) arrays[2][i] *= scale;
        }
    }
 
    // Read gids for vertices
    std::vector< int > gids( GETINT32( nverts ) );
    CCMIOReadMap( &error, mapID, &gids[0], CCMIOINDEXC( kCCMIOStart ), CCMIOINDEXC( kCCMIOEnd ) );
    CHK_SET_CCMERR( error, "Trouble reading vertex global ids" );
 
    // Put new vertex handles into range, and set gids for them
    Range new_verts( node_handle, node_handle + nverts - 1 );
    MB_CHK_SET_ERR( mbImpl->tag_set_data( mGlobalIdTag, new_verts, &gids[0] ), "Couldn't set gids on vertices" );
 
    // Pack vert_map with global ids and handles for these vertices
#ifdef TUPLE_LIST
    vert_map.resize( GETINT32( nverts ) );
    for( i = 0; i < GETINT32( nverts ); i++ )
    {
        vert_map.push_back( NULL, &gids[i], &node_handle, NULL );
#else
    for( i = 0; i < GETINT32( nverts ); i++ )
    {
        ( vert_map[gids[i]] ).push_back( node_handle );
#endif
        node_handle += 1;
    }
 
    if( verts ) verts->merge( new_verts );
 
    return MB_SUCCESS;
}
 
ErrorCode ReadCCMIO::get_processors( CCMIOID stateID,
                                     CCMIOID& processorID,
                                     CCMIOID& verticesID,
                                     CCMIOID& topologyID,
                                     CCMIOID& solutionID,
                                     std::vector< CCMIOSize_t >& procs,
                                     bool& /* has_solution */ )
{
    CCMIOSize_t proc = CCMIOSIZEC( 0 );
    CCMIOError error = kCCMIONoErr;
 
    CCMIONextEntity( &error, stateID, kCCMIOProcessor, &proc, &processorID );
    CHK_SET_CCMERR( error, "CCMIONextEntity() failed" );
    if( CCMIOReadProcessor( NULL, processorID, &verticesID, &topologyID, NULL, &solutionID ) != kCCMIONoErr )
    {
        // Maybe no solution; try again
        CCMIOReadProcessor( &error, processorID, &verticesID, &topologyID, NULL, NULL );
        CHK_SET_CCMERR( error, "CCMIOReadProcessor() failed" );
        hasSolution = false;
    }
 
    procs.push_back( proc );
 
    return MB_SUCCESS;
}
 
ErrorCode ReadCCMIO::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;
}
 
}  // namespace moab