moab::ReadCCMIO Class Reference

#include <ReadCCMIO.hpp>

Inheritance diagram for moab::ReadCCMIO:

Collaboration diagram for moab::ReadCCMIO:

Public Types
typedef std::map< int, std::vector< EntityHandle > >	TupleList
typedef std::map< int, std::vector< int > >	SenseList

Public Member Functions
	ReadCCMIO (Interface *impl)
	Constructor. More...
virtual	~ReadCCMIO ()
	Destructor. More...
ErrorCode	load_file (const char *file_name, const EntityHandle *file_set, const FileOptions &opts, const SubsetList *subset_list=0, const Tag *file_id_tag=0)
	Load mesh from a file. More...
Public Member Functions inherited from moab::ReaderIface
virtual	~ReaderIface ()

Static Public Member Functions
static ReaderIface *	factory (Interface *)

Private Member Functions
ErrorCode	read_processor (CCMIOID rootID, CCMIOID problemID, CCMIOID processorID, CCMIOID verticesID, CCMIOID topologyID, CCMIOSize_t proc, Range *new_ents)
ErrorCode	read_cells (CCMIOSize_t proc, CCMIOID processorID, CCMIOID verticesID, CCMIOID topologyID, TupleList &vert_map, Range *new_cells)
ErrorCode	construct_cells (TupleList &face_map, SenseList &sense_map, TupleList &vert_map, std::map< int, int > &cell_topo_types, std::vector< EntityHandle > &new_cells)
ErrorCode	ccmio_to_moab_type (int ccm_type, EntityType &moab_type, bool &has_mid_nodes)
ErrorCode	create_cell_from_faces (std::vector< EntityHandle > &facehs, std::vector< int > &senses, EntityType this_type, bool has_mid_nodes, EntityHandle &cell)
ErrorCode	read_gids_and_types (CCMIOID problemID, CCMIOID topologyID, std::vector< EntityHandle > &cells)
ErrorCode	read_all_faces (CCMIOID topologyID, TupleList &vert_map, TupleList &face_map, SenseList &sense_map, Range *new_faces)
ErrorCode	read_faces (CCMIOID faceID, CCMIOEntity bdy_or_int, TupleList &vert_map, TupleList &face_map, SenseList &sense_map, Range *new_faces)
ErrorCode	make_faces (int *farray, TupleList &vert_map, std::vector< EntityHandle > &new_faces, int num_faces)
ErrorCode	read_vertices (CCMIOSize_t proc, CCMIOID processorID, CCMIOID verticesID, CCMIOID topologyID, Range *verts, TupleList &vert_map)
ErrorCode	get_processors (CCMIOID stateID, CCMIOID &processorID, CCMIOID &verticesID, CCMIOID &topologyID, CCMIOID &solutionID, std::vector< CCMIOSize_t > &procs, bool &has_solution)
ErrorCode	get_state (CCMIOID rootID, CCMIOID &problemID, CCMIOID &stateID)
ErrorCode	read_tag_values (const char *file_name, const char *tag_name, const FileOptions &opts, std::vector< int > &tag_values_out, const SubsetList *subset_list=0)
	Read tag values from a file. More...
ErrorCode	load_matset_data (CCMIOID problemID)
ErrorCode	load_neuset_data (CCMIOID problemID)
ErrorCode	load_metadata (CCMIOID rootID, CCMIOID problemID, CCMIOID stateID, CCMIOID processorID, const EntityHandle *file_set)
ErrorCode	read_topology_types (CCMIOID &topologyID, std::map< int, int > &cell_topo_types)
ErrorCode	get_int_option (const char *opt_str, EntityHandle seth, Tag &tag, CCMIOID node)
ErrorCode	get_dbl_option (const char *opt_str, EntityHandle seth, Tag &tag, CCMIOID node)
ErrorCode	get_str_option (const char *opt_str, EntityHandle seth, Tag &tag, CCMIOID node, const char *tag_name=NULL)

Private Attributes
Tag	mMaterialSetTag
	Cached tags for reading. Note that all these tags are defined when the core is initialized. More...
Tag	mDirichletSetTag
Tag	mNeumannSetTag
Tag	mHasMidNodesTag
Tag	mGlobalIdTag
Tag	mNameTag
Tag	mMaterialIdTag
Tag	mMaterialTypeTag
Tag	mRadiationTag
Tag	mPorosityIdTag
Tag	mSpinIdTag
Tag	mGroupIdTag
Tag	mColorIdxTag
Tag	mProcessorIdTag
Tag	mLightMaterialTag
Tag	mFreeSurfaceMaterialTag
Tag	mThicknessTag
Tag	mProstarRegionNumberTag
Tag	mBoundaryTypeTag
Tag	mCreatingProgramTag
Interface *	mbImpl
ReadUtilIface *	readMeshIface
std::map< int, EntityHandle >	newMatsets
std::map< int, EntityHandle >	newNeusets
bool	hasSolution

Detailed Description

Definition at line 27 of file ReadCCMIO.hpp.

Member Typedef Documentation

SenseList

typedef std::map< int, std::vector< int > > moab::ReadCCMIO::SenseList

Definition at line 32 of file ReadCCMIO.hpp.

TupleList

typedef std::map< int, std::vector< EntityHandle > > moab::ReadCCMIO::TupleList

Definition at line 31 of file ReadCCMIO.hpp.

Constructor & Destructor Documentation

ReadCCMIO()

moab::ReadCCMIO::ReadCCMIO

(

Interface *

impl

)

Constructor.

Get and cache predefined tag handles

Definition at line 92 of file ReadCCMIO.cpp.

 : 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" );
}

References DIRICHLET_SET_TAG_NAME, ErrorCode, moab::Interface::globalId_tag(), HAS_MID_NODES_TAG_NAME, MATERIAL_SET_TAG_NAME, MB_CHK_SET_ERR_RET, MB_TAG_CREAT, MB_TAG_SPARSE, MB_TYPE_INTEGER, MB_TYPE_OPAQUE, mDirichletSetTag, mGlobalIdTag, mHasMidNodesTag, mMaterialSetTag, mNameTag, mNeumannSetTag, NAME_TAG_NAME, NAME_TAG_SIZE, NEUMANN_SET_TAG_NAME, moab::Interface::query_interface(), readMeshIface, and moab::Interface::tag_get_handle().

Referenced by factory().

~ReadCCMIO()

moab::ReadCCMIO::~ReadCCMIO ( )

virtual

Destructor.

Definition at line 131 of file ReadCCMIO.cpp.

{
 mbImpl->release_interface( readMeshIface );
}

References mbImpl, readMeshIface, and moab::Interface::release_interface().

Member Function Documentation

ccmio_to_moab_type()

ErrorCode moab::ReadCCMIO::ccmio_to_moab_type ( int  ccm_type, EntityType &  moab_type, bool &  has_mid_nodes  )

private

Definition at line 621 of file ReadCCMIO.cpp.

{
 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;
}

References MB_SUCCESS, MBEDGE, MBHEX, MBMAXTYPE, MBPOLYHEDRON, MBPRISM, MBPYRAMID, MBQUAD, MBTET, and MBVERTEX.

Referenced by construct_cells().

construct_cells()

ErrorCode moab::ReadCCMIO::construct_cells ( TupleList &  face_map, SenseList &  sense_map, TupleList &  vert_map, std::map< int, int > &  cell_topo_types, std::vector< EntityHandle > &  new_cells  )

private

Definition at line 552 of file ReadCCMIO.cpp.

{
 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;
}

References ccmio_to_moab_type(), create_cell_from_faces(), ErrorCode, MB_SUCCESS, mbImpl, MBMAXTYPE, mGlobalIdTag, and moab::Interface::tag_set_data().

Referenced by read_cells().

create_cell_from_faces()

ErrorCode moab::ReadCCMIO::create_cell_from_faces ( std::vector< EntityHandle > &  facehs, std::vector< int > &  senses, EntityType  this_type, bool  has_mid_nodes, EntityHandle &  cell  )

private

Definition at line 679 of file ReadCCMIO.cpp.

{
 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
 rval = mbImpl->get_connectivity( &facehs[0], 1, verts );MB_CHK_SET_ERR( rval, "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;
 rval = mbImpl->get_connectivity( facehs[1], conn, conn_size, true, &storage );MB_CHK_SET_ERR( rval, "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
 rval = mbImpl->get_connectivity( &facehs[0], 1, verts );MB_CHK_SET_ERR( rval, "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
 rval = mbImpl->get_connectivity( &q1, 1, tmp_verts );MB_CHK_SET_ERR( rval, "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
 rval = mbImpl->get_connectivity( &q2, 1, storage );MB_CHK_SET_ERR( rval, "Couldn't get adj vertices" );
 
 // Get verts in q1 opposite from v[1] and v[0] in q0
 EntityHandle v0 = 0, v1 = 0;
 rval = mtu.opposite_entity( q1, verts[1], v0 );MB_CHK_SET_ERR( rval, "Couldn't get the opposite side entity" );
 rval = mtu.opposite_entity( q1, verts[0], v1 );MB_CHK_SET_ERR( rval, "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();
 rval = mbImpl->get_connectivity( &tris[0], 1, verts );MB_CHK_SET_ERR( rval, "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
 rval = mbImpl->get_connectivity( &q1, 1, storage );MB_CHK_SET_ERR( rval, "Couldn't get adj vertices" );
 
 // Get verts in q1 opposite from v[1] and v[0] in q0
 EntityHandle v0 = 0, v1 = 0;
 rval = mtu.opposite_entity( q1, verts[1], v0 );MB_CHK_SET_ERR( rval, "Couldn't get the opposite side entity" );
 rval = mtu.opposite_entity( q1, verts[0], v1 );MB_CHK_SET_ERR( rval, "Couldn't get the opposite side entity" );
 if( v0 && v1 )
 {
 // Offset of v0 in t2, then rotate and flip
 storage.clear();
 rval = mbImpl->get_connectivity( &tris[1], 1, storage );MB_CHK_SET_ERR( rval, "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();
 rval = mbImpl->get_connectivity( &quads[0], 1, verts );MB_CHK_SET_ERR( rval, "Couldn't get connectivity" );
 if( senses[index] > 0 ) std::reverse( verts.begin(), verts.end() );
 
 // Get apex node
 rval = mbImpl->get_connectivity( &tris[0], 1, storage );MB_CHK_SET_ERR( rval, "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 )
 {
 rval = mbImpl->create_element( MBPOLYHEDRON, &facehs[0], facehs.size(), cell );MB_CHK_SET_ERR( rval, "create_element failed" );
 }
 else
 {
 rval = mbImpl->create_element( this_type, &verts[0], verts.size(), cell );MB_CHK_SET_ERR( rval, "create_element failed" );
 }
 
 return MB_SUCCESS;
}

References moab::Range::begin(), moab::Interface::create_element(), moab::CN::EntityTypeName(), moab::Range::erase(), ErrorCode, moab::Interface::get_adjacencies(), moab::Interface::get_connectivity(), MB_CHK_SET_ERR, MB_SET_ERR, MB_SUCCESS, MBHEX, mbImpl, MBMAXTYPE, MBPOLYHEDRON, MBPRISM, MBPYRAMID, MBQUAD, MBTET, MBTRI, moab::MeshTopoUtil::opposite_entity(), moab::Range::size(), and moab::Interface::type_from_handle().

Referenced by construct_cells().

factory()

ReaderIface * moab::ReadCCMIO::factory ( Interface *  iface )

static

Definition at line 87 of file ReadCCMIO.cpp.

{
 return new ReadCCMIO( iface );
}

References iface, and ReadCCMIO().

Referenced by moab::ReaderWriterSet::ReaderWriterSet().

get_dbl_option()

ErrorCode moab::ReadCCMIO::get_dbl_option ( const char *  opt_str, EntityHandle  seth, Tag &  tag, CCMIOID  node  )

private

Definition at line 316 of file ReadCCMIO.cpp.

{
 float fdum;
 if( kCCMIONoErr == CCMIOReadOptf( NULL, node, opt_str, &fdum ) )
 {
 ErrorCode rval;
 if( !tag )
 {
 rval = mbImpl->tag_get_handle( opt_str, 1, MB_TYPE_DOUBLE, tag, MB_TAG_SPARSE | MB_TAG_CREAT );MB_CHK_SET_ERR( rval, "Failed to get tag handle" );
 }
 
 double dum_dbl = fdum;
 rval = mbImpl->tag_set_data( tag, &seth, 1, &dum_dbl );MB_CHK_SET_ERR( rval, "Failed to set tag data" );
 }
 
 return MB_SUCCESS;
}

References ErrorCode, MB_CHK_SET_ERR, MB_SUCCESS, MB_TAG_CREAT, MB_TAG_SPARSE, MB_TYPE_DOUBLE, mbImpl, moab::Interface::tag_get_handle(), and moab::Interface::tag_set_data().

Referenced by load_matset_data().

get_int_option()

ErrorCode moab::ReadCCMIO::get_int_option ( const char *  opt_str, EntityHandle  seth, Tag &  tag, CCMIOID  node  )

private

Definition at line 299 of file ReadCCMIO.cpp.

{
 int idum;
 ErrorCode rval;
 if( kCCMIONoErr == CCMIOReadOpti( NULL, node, opt_str, &idum ) )
 {
 if( !tag )
 {
 rval = mbImpl->tag_get_handle( opt_str, 1, MB_TYPE_INTEGER, tag, MB_TAG_SPARSE | MB_TAG_CREAT );MB_CHK_SET_ERR( rval, "Failed to get tag handle" );
 }
 
 rval = mbImpl->tag_set_data( tag, &seth, 1, &idum );MB_CHK_SET_ERR( rval, "Failed to set tag data" );
 }
 
 return MB_SUCCESS;
}

References ErrorCode, MB_CHK_SET_ERR, MB_SUCCESS, MB_TAG_CREAT, MB_TAG_SPARSE, MB_TYPE_INTEGER, mbImpl, moab::Interface::tag_get_handle(), and moab::Interface::tag_set_data().

Referenced by load_matset_data(), and load_neuset_data().

get_processors()

ErrorCode moab::ReadCCMIO::get_processors ( CCMIOID  stateID, CCMIOID &  processorID, CCMIOID &  verticesID, CCMIOID &  topologyID, CCMIOID &  solutionID, std::vector< CCMIOSize_t > &  procs, bool &  has_solution  )

private

Definition at line 1176 of file ReadCCMIO.cpp.

{
 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;
}

References CHK_SET_CCMERR, moab::error(), hasSolution, and MB_SUCCESS.

Referenced by load_file().

get_state()

ErrorCode moab::ReadCCMIO::get_state ( CCMIOID  rootID, CCMIOID &  problemID, CCMIOID &  stateID  )

private

Definition at line 182 of file ReadCCMIO.cpp.

{
 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;
}

References CHK_SET_CCMERR, moab::error(), and MB_SUCCESS.

Referenced by load_file().

get_str_option()

ErrorCode moab::ReadCCMIO::get_str_option ( const char *  opt_str, EntityHandle  seth, Tag &  tag, CCMIOID  node, const char *  tag_name = NULL  )

private

Definition at line 334 of file ReadCCMIO.cpp.

{
 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 )
 {
 rval = 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 );MB_CHK_SET_ERR( rval, "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' ) );
 
 rval = mbImpl->tag_set_data( tag, &seth, 1, &opt_string[0] );MB_CHK_SET_ERR( rval, "Failed to set tag data" );
 
 return MB_SUCCESS;
}

References moab::error(), ErrorCode, MB_CHK_SET_ERR, MB_SUCCESS, MB_TAG_CREAT, MB_TAG_SPARSE, MB_TYPE_OPAQUE, mbImpl, NAME_TAG_SIZE, moab::Interface::tag_get_handle(), and moab::Interface::tag_set_data().

Referenced by load_matset_data(), load_metadata(), and load_neuset_data().

load_file()

ErrorCode moab::ReadCCMIO::load_file ( const char *  file_name, const EntityHandle *  file_set, const FileOptions &  opts, const SubsetList *  subset_list = 0, const Tag *  file_id_tag = 0  )

virtual

Load mesh from a file.

Method all readers must provide to import a mesh.

Parameters

file_name	The file to read.
file_set	Optional pointer to entity set representing file. If this is not NULL, reader may optionally tag the pointed-to set with format-specific meta-data.
subset_list	An optional struct pointer specifying the tags identifying entity sets to be read.
file_id_tag	If specified, reader should store for each entity it reads, a unique integer ID for this tag.

Author

Jason Kraftcheck

Implements moab::ReaderIface.

Definition at line 136 of file ReadCCMIO.cpp.

{
 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
 ErrorCode rval = get_state( rootID, problemID, stateID );MB_CHK_SET_ERR( rval, "Failed to get state" );
 
 // Get processors
 std::vector< CCMIOSize_t > procs;
 bool has_solution = false;
 rval = get_processors( stateID, processorID, verticesID, topologyID, solutionID, procs, has_solution );MB_CHK_SET_ERR( rval, "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 )
 {
 rval = read_processor( stateID, problemID, processorID, verticesID, topologyID, *vit, new_ents_ptr );MB_CHK_SET_ERR( rval, "Failed to read processors" );
 }
 
 // Load some meta-data
 rval = load_metadata( rootID, problemID, stateID, processorID, file_set );MB_CHK_SET_ERR( rval, "Failed to load some meta-data" );
 
 // Now, put all this into the file set, if there is one
 if( file_set )
 {
 rval = mbImpl->add_entities( *file_set, new_ents );MB_CHK_SET_ERR( rval, "Failed to add new entities to file set" );
 }
 
 return rval;
}

References moab::Interface::add_entities(), CHK_SET_CCMERR, moab::error(), ErrorCode, get_processors(), get_state(), load_metadata(), MB_CHK_SET_ERR, MB_SET_ERR, MB_UNSUPPORTED_OPERATION, mbImpl, and read_processor().

load_matset_data()

ErrorCode moab::ReadCCMIO::load_matset_data ( CCMIOID  problemID )

private

Definition at line 238 of file ReadCCMIO.cpp.

{
 // 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;
 ErrorCode rval = mbImpl->tag_set_data( mMaterialSetTag, &dum_ent, 1, &mindex );MB_CHK_SET_ERR( rval, "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' ) );
 rval = mbImpl->tag_set_data( mNameTag, &dum_ent, 1, &opt_string2[0] );MB_CHK_SET_ERR( rval, "Trouble setting name tag for material set" );
 
 // Material id
 rval = get_int_option( "MaterialId", dum_ent, mMaterialIdTag, next );MB_CHK_SET_ERR( rval, "Trouble getting MaterialId tag" );
 
 rval = get_str_option( "MaterialType", dum_ent, mMaterialTypeTag, next );MB_CHK_SET_ERR( rval, "Trouble getting MaterialType tag" );
 
 rval = get_int_option( "Radiation", dum_ent, mRadiationTag, next );MB_CHK_SET_ERR( rval, "Trouble getting Radiation option" );
 
 rval = get_int_option( "PorosityId", dum_ent, mPorosityIdTag, next );MB_CHK_SET_ERR( rval, "Trouble getting PorosityId option" );
 
 rval = get_int_option( "SpinId", dum_ent, mSpinIdTag, next );MB_CHK_SET_ERR( rval, "Trouble getting SpinId option" );
 
 rval = get_int_option( "GroupId", dum_ent, mGroupIdTag, next );MB_CHK_SET_ERR( rval, "Trouble getting GroupId option" );
 
 rval = get_int_option( "ColorIdx", dum_ent, mColorIdxTag, next );MB_CHK_SET_ERR( rval, "Trouble getting ColorIdx option" );
 
 rval = get_int_option( "ProcessorId", dum_ent, mProcessorIdTag, next );MB_CHK_SET_ERR( rval, "Trouble getting ProcessorId option" );
 
 rval = get_int_option( "LightMaterial", dum_ent, mLightMaterialTag, next );MB_CHK_SET_ERR( rval, "Trouble getting LightMaterial option" );
 
 rval = get_int_option( "FreeSurfaceMaterial", dum_ent, mFreeSurfaceMaterialTag, next );MB_CHK_SET_ERR( rval, "Trouble getting FreeSurfaceMaterial option" );
 
 rval = get_dbl_option( "Thickness", dum_ent, mThicknessTag, next );MB_CHK_SET_ERR( rval, "Trouble getting Thickness option" );
 }
 
 return MB_SUCCESS;
}

References moab::error(), ErrorCode, get_dbl_option(), get_int_option(), get_str_option(), MB_CHK_SET_ERR, MB_SUCCESS, mbImpl, mColorIdxTag, mFreeSurfaceMaterialTag, mGroupIdTag, mLightMaterialTag, mMaterialIdTag, mMaterialSetTag, mMaterialTypeTag, mNameTag, mPorosityIdTag, mProcessorIdTag, mRadiationTag, mSpinIdTag, mThicknessTag, NAME_TAG_SIZE, newMatsets, and moab::Interface::tag_set_data().

Referenced by load_metadata().

load_metadata()

ErrorCode moab::ReadCCMIO::load_metadata ( CCMIOID  rootID, CCMIOID  problemID, CCMIOID  stateID, CCMIOID  processorID, const EntityHandle *  file_set  )

private

Definition at line 200 of file ReadCCMIO.cpp.

{
 // 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;
 rval = mbImpl->tag_get_handle( "Title", strlen( name ), MB_TYPE_OPAQUE, simname,
 MB_TAG_CREAT | MB_TAG_SPARSE );MB_CHK_SET_ERR( rval, "Simulation name tag not found or created" );
 EntityHandle set = file_set ? *file_set : 0;
 rval = mbImpl->tag_set_data( simname, &set, 1, name );MB_CHK_SET_ERR( rval, "Problem setting simulation name tag" );
 }
 if( name ) free( name );
 }
 
 // Creating program
 EntityHandle dumh = ( file_set ? *file_set : 0 );
 rval = get_str_option( "CreatingProgram", dumh, mCreatingProgramTag, processorID );MB_CHK_SET_ERR( rval, "Trouble getting CreatingProgram tag" );
 
 rval = load_matset_data( problemID );MB_CHK_SET_ERR( rval, "Failure loading matset data" );
 
 rval = load_neuset_data( problemID );MB_CHK_SET_ERR( rval, "Failure loading neuset data" );
 
 return rval;
}

References moab::error(), ErrorCode, get_str_option(), load_matset_data(), load_neuset_data(), MB_CHK_SET_ERR, MB_SUCCESS, MB_TAG_CREAT, MB_TAG_SPARSE, MB_TYPE_OPAQUE, mbImpl, mCreatingProgramTag, moab::Interface::tag_get_handle(), and moab::Interface::tag_set_data().

Referenced by load_file().

load_neuset_data()

ErrorCode moab::ReadCCMIO::load_neuset_data ( CCMIOID  problemID )

private

Definition at line 364 of file ReadCCMIO.cpp.

{
 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;
 ErrorCode rval = mbImpl->tag_set_data( mNeumannSetTag, &dum_ent, 1, &mindex );MB_CHK_SET_ERR( rval, "Trouble setting neumann set tag" );
 
 // Set name
 rval = get_str_option( "BoundaryName", dum_ent, mNameTag, next, NAME_TAG_NAME );MB_CHK_SET_ERR( rval, "Trouble creating BoundaryName tag" );
 
 // BoundaryType
 rval = get_str_option( "BoundaryType", dum_ent, mBoundaryTypeTag, next );MB_CHK_SET_ERR( rval, "Trouble creating BoundaryType tag" );
 
 // ProstarRegionNumber
 rval = get_int_option( "ProstarRegionNumber", dum_ent, mProstarRegionNumberTag, next );MB_CHK_SET_ERR( rval, "Trouble creating ProstarRegionNumber tag" );
 }
 
 return MB_SUCCESS;
}

References moab::error(), ErrorCode, get_int_option(), get_str_option(), MB_CHK_SET_ERR, MB_SUCCESS, mbImpl, mBoundaryTypeTag, mNameTag, mNeumannSetTag, mProstarRegionNumberTag, NAME_TAG_NAME, newNeusets, and moab::Interface::tag_set_data().

Referenced by load_metadata().

make_faces()

ErrorCode moab::ReadCCMIO::make_faces ( int *  farray, TupleList &  vert_map, std::vector< EntityHandle > &  new_faces, int  num_faces  )

private

Definition at line 1048 of file ReadCCMIO.cpp.

{
 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;
}

References moab::Interface::create_element(), ErrorCode, MB_SUCCESS, mbImpl, MBPOLYGON, MBQUAD, and MBTRI.

Referenced by read_faces().

read_all_faces()

ErrorCode moab::ReadCCMIO::read_all_faces ( CCMIOID  topologyID, TupleList &  vert_map, TupleList &  face_map, SenseList &  sense_map, Range *  new_faces  )

private

Definition at line 895 of file ReadCCMIO.cpp.

{
 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 ) )
 {
 rval = read_faces( faceID, kCCMIOBoundaryFaces, vert_map, face_map,
#ifndef TUPLE_LIST
 sense_map,
#endif
 new_faces );MB_CHK_SET_ERR( rval, "Trouble reading boundary faces" );
 }
 
 // Now get internal faces
 CCMIOGetEntity( &error, topologyID, kCCMIOInternalFaces, 0, &faceID );
 CHK_SET_CCMERR( error, "Couldn't get internal faces" );
 
 rval = read_faces( faceID, kCCMIOInternalFaces, vert_map, face_map,
#ifndef TUPLE_LIST
 sense_map,
#endif
 new_faces );MB_CHK_SET_ERR( rval, "Trouble reading internal faces" );
 
 return rval;
}

References CHK_SET_CCMERR, moab::error(), ErrorCode, MB_CHK_SET_ERR, and read_faces().

Referenced by read_cells().

read_cells()

ErrorCode moab::ReadCCMIO::read_cells ( CCMIOSize_t  proc, CCMIOID  processorID, CCMIOID  verticesID, CCMIOID  topologyID, TupleList &  vert_map, Range *  new_cells  )

private

Definition at line 419 of file ReadCCMIO.cpp.

{
 // 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
 rval = read_all_faces( topologyID, vert_map, face_map,
#ifndef TUPLE_LIST
 sense_map,
#endif
 new_ents );MB_CHK_SET_ERR( rval, "Failed to read all cells" );
 
 // Read the cell topology types, if any exist in the file
 std::map< int, int > cell_topo_types;
 rval = read_topology_types( topologyID, cell_topo_types );MB_CHK_SET_ERR( rval, "Problem reading cell topo types" );
 
 // Now construct the cells; sort the face map by cell ids first
#ifdef TUPLE_LIST
 rval = face_map.sort( 1 );MB_CHK_SET_ERR( rval, "Couldn't sort face map by cell id" );
#endif
 std::vector< EntityHandle > new_cells;
 rval = construct_cells( face_map,
#ifndef TUPLE_LIST
 sense_map,
#endif
 vert_map, cell_topo_types, new_cells );MB_CHK_SET_ERR( rval, "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 );
 }
 
 rval = read_gids_and_types( problemID, topologyID, new_cells );MB_CHK_SET_ERR( rval, "Failed to read gids and types" );
 
 return MB_SUCCESS;
}

References construct_cells(), moab::Range::end(), ErrorCode, moab::Range::insert(), MB_CHK_SET_ERR, MB_SUCCESS, read_all_faces(), read_gids_and_types(), and read_topology_types().

Referenced by read_processor().

read_faces()

ErrorCode moab::ReadCCMIO::read_faces ( CCMIOID  faceID, CCMIOEntity  bdy_or_int, TupleList &  vert_map, TupleList &  face_map, SenseList &  sense_map, Range *  new_faces  )

private

Definition at line 950 of file ReadCCMIO.cpp.

{
 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;
 ErrorCode rval = make_faces( farray, vert_map, face_handles, num_faces );MB_CHK_SET_ERR( rval, "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" );
 
 rval = mbImpl->tag_set_data( mGlobalIdTag, &face_handles[0], face_handles.size(), face_cells );MB_CHK_SET_ERR( rval, "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;
 rval = mbImpl->create_meshset( MESHSET_SET, neuset );MB_CHK_SET_ERR( rval, "Failed to create neumann set" );
 
 // Don't trust entity index passed in
 int index;
 CCMIOGetEntityIndex( &error, faceID, &index );
 newNeusets[index] = neuset;
 
 rval = mbImpl->add_entities( neuset, &face_handles[0], face_handles.size() );MB_CHK_SET_ERR( rval, "Failed to add faces to neumann set" );
 
 // Now tag as neumann set; will add id later
 int dum_val = 0;
 rval = mbImpl->tag_set_data( mNeumannSetTag, &neuset, 1, &dum_val );MB_CHK_SET_ERR( rval, "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;
}

References moab::Interface::add_entities(), CHK_SET_CCMERR, moab::Interface::create_meshset(), moab::error(), ErrorCode, make_faces(), MB_CHK_SET_ERR, MB_SET_ERR, MB_SUCCESS, mbImpl, MESHSET_SET, mGlobalIdTag, mNeumannSetTag, newNeusets, and moab::Interface::tag_set_data().

Referenced by read_all_faces().

read_gids_and_types()

ErrorCode moab::ReadCCMIO::read_gids_and_types ( CCMIOID  problemID, CCMIOID  topologyID, std::vector< EntityHandle > &  cells  )

private

Definition at line 506 of file ReadCCMIO.cpp.

{
 // 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" );
 
 ErrorCode rval = mbImpl->tag_set_data( mGlobalIdTag, &cells[0], cells.size(), &cell_gids[0] );MB_CHK_SET_ERR( rval, "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;
 rval = mbImpl->create_meshset( MESHSET_SET, matset );MB_CHK_SET_ERR( rval, "Couldn't create material set" );
 newMatsets[mit->first] = matset;
 
 rval = mbImpl->add_entities( matset, mit->second );MB_CHK_SET_ERR( rval, "Couldn't add entities to material set" );
 }
 
 return MB_SUCCESS;
}

References moab::Interface::add_entities(), CHK_SET_CCMERR, moab::Interface::create_meshset(), moab::error(), ErrorCode, MB_CHK_SET_ERR, MB_SET_ERR, MB_SUCCESS, mbImpl, MESHSET_SET, mGlobalIdTag, newMatsets, and moab::Interface::tag_set_data().

Referenced by read_cells().

read_processor()

ErrorCode moab::ReadCCMIO::read_processor ( CCMIOID  rootID, CCMIOID  problemID, CCMIOID  processorID, CCMIOID  verticesID, CCMIOID  topologyID, CCMIOSize_t  proc, Range *  new_ents  )

private

Definition at line 399 of file ReadCCMIO.cpp.

{
 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;
 rval = read_vertices( proc, processorID, verticesID, topologyID, new_ents, vert_map );MB_CHK_SET_ERR( rval, "Failed to read vertices" );
 
 rval = read_cells( proc, problemID, verticesID, topologyID, vert_map, new_ents );MB_CHK_SET_ERR( rval, "Failed to read cells" );
 
 return rval;
}

References ErrorCode, MB_CHK_SET_ERR, read_cells(), and read_vertices().

Referenced by load_file().

read_tag_values()

ErrorCode moab::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 = 0  )

privatevirtual

Read tag values from a file.

Read the list if all integer tag values from the file for a tag that is a single integer value per entity.

Parameters

file_name	The file to read.
tag_name	The tag for which to read values
tag_values_out	Output: The list of tag values.
subset_list	An array of tag name and value sets specifying the subset of the file to read. If multiple tags are specified, the sets that match all tags (intersection) should be read.
subset_list_length	The length of the 'subset_list' array.

Implements moab::ReaderIface.

Definition at line 1202 of file ReadCCMIO.cpp.

{
 return MB_FAILURE;
}

read_topology_types()

ErrorCode moab::ReadCCMIO::read_topology_types ( CCMIOID &  topologyID, std::map< int, int > &  cell_topo_types  )

private

Definition at line 468 of file ReadCCMIO.cpp.

{
 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;
}

References CHK_SET_CCMERR, moab::error(), and MB_SUCCESS.

Referenced by read_cells().

read_vertices()

ErrorCode moab::ReadCCMIO::read_vertices ( CCMIOSize_t  proc, CCMIOID  processorID, CCMIOID  verticesID, CCMIOID  topologyID, Range *  verts, TupleList &  vert_map  )

private

Definition at line 1093 of file ReadCCMIO.cpp.

{
 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 );
 ErrorCode rval = mbImpl->tag_set_data( mGlobalIdTag, new_verts, &gids[0] );MB_CHK_SET_ERR( rval, "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;
}

References CHK_SET_CCMERR, moab::error(), ErrorCode, moab::ReadUtilIface::get_node_coords(), MB_CHK_SET_ERR, MB_START_ID, MB_SUCCESS, mbImpl, moab::Range::merge(), mGlobalIdTag, readMeshIface, and moab::Interface::tag_set_data().

Referenced by read_processor().

Member Data Documentation

hasSolution

bool moab::ReadCCMIO::hasSolution

private

Definition at line 169 of file ReadCCMIO.hpp.

Referenced by get_processors().

mbImpl

Interface* moab::ReadCCMIO::mbImpl

private

Definition at line 163 of file ReadCCMIO.hpp.

Referenced by construct_cells(), create_cell_from_faces(), get_dbl_option(), get_int_option(), get_str_option(), load_file(), load_matset_data(), load_metadata(), load_neuset_data(), make_faces(), read_faces(), read_gids_and_types(), read_vertices(), and ~ReadCCMIO().

mBoundaryTypeTag

Tag moab::ReadCCMIO::mBoundaryTypeTag

private

Definition at line 161 of file ReadCCMIO.hpp.

Referenced by load_neuset_data().

mColorIdxTag

Tag moab::ReadCCMIO::mColorIdxTag

private

Definition at line 159 of file ReadCCMIO.hpp.

Referenced by load_matset_data().

mCreatingProgramTag

Tag moab::ReadCCMIO::mCreatingProgramTag

private

Definition at line 161 of file ReadCCMIO.hpp.

Referenced by load_metadata().

mDirichletSetTag

Tag moab::ReadCCMIO::mDirichletSetTag

private

Definition at line 153 of file ReadCCMIO.hpp.

Referenced by ReadCCMIO().

mFreeSurfaceMaterialTag

Tag moab::ReadCCMIO::mFreeSurfaceMaterialTag

private

Definition at line 160 of file ReadCCMIO.hpp.

Referenced by load_matset_data().

mGlobalIdTag

Tag moab::ReadCCMIO::mGlobalIdTag

private

Definition at line 156 of file ReadCCMIO.hpp.

Referenced by construct_cells(), read_faces(), read_gids_and_types(), read_vertices(), and ReadCCMIO().

mGroupIdTag

Tag moab::ReadCCMIO::mGroupIdTag

private

Definition at line 159 of file ReadCCMIO.hpp.

Referenced by load_matset_data().

mHasMidNodesTag

Tag moab::ReadCCMIO::mHasMidNodesTag

private

Definition at line 155 of file ReadCCMIO.hpp.

Referenced by ReadCCMIO().

mLightMaterialTag

Tag moab::ReadCCMIO::mLightMaterialTag

private

Definition at line 159 of file ReadCCMIO.hpp.

Referenced by load_matset_data().

mMaterialIdTag

Tag moab::ReadCCMIO::mMaterialIdTag

private

Definition at line 158 of file ReadCCMIO.hpp.

Referenced by load_matset_data().

mMaterialSetTag

Tag moab::ReadCCMIO::mMaterialSetTag

private

Cached tags for reading. Note that all these tags are defined when the core is initialized.

Definition at line 152 of file ReadCCMIO.hpp.

Referenced by load_matset_data(), and ReadCCMIO().

mMaterialTypeTag

Tag moab::ReadCCMIO::mMaterialTypeTag

private

Definition at line 158 of file ReadCCMIO.hpp.

Referenced by load_matset_data().

mNameTag

Tag moab::ReadCCMIO::mNameTag

private

Definition at line 157 of file ReadCCMIO.hpp.

Referenced by load_matset_data(), load_neuset_data(), and ReadCCMIO().

mNeumannSetTag

Tag moab::ReadCCMIO::mNeumannSetTag

private

Definition at line 154 of file ReadCCMIO.hpp.

Referenced by load_neuset_data(), read_faces(), and ReadCCMIO().

mPorosityIdTag

Tag moab::ReadCCMIO::mPorosityIdTag

private

Definition at line 159 of file ReadCCMIO.hpp.

Referenced by load_matset_data().

mProcessorIdTag

Tag moab::ReadCCMIO::mProcessorIdTag

private

Definition at line 159 of file ReadCCMIO.hpp.

Referenced by load_matset_data().

mProstarRegionNumberTag

Tag moab::ReadCCMIO::mProstarRegionNumberTag

private

Definition at line 161 of file ReadCCMIO.hpp.

Referenced by load_neuset_data().

mRadiationTag

Tag moab::ReadCCMIO::mRadiationTag

private

Definition at line 159 of file ReadCCMIO.hpp.

Referenced by load_matset_data().

mSpinIdTag

Tag moab::ReadCCMIO::mSpinIdTag

private

Definition at line 159 of file ReadCCMIO.hpp.

Referenced by load_matset_data().

mThicknessTag

Tag moab::ReadCCMIO::mThicknessTag

private

Definition at line 161 of file ReadCCMIO.hpp.

Referenced by load_matset_data().

newMatsets

std::map< int, EntityHandle > moab::ReadCCMIO::newMatsets

private

Definition at line 167 of file ReadCCMIO.hpp.

Referenced by load_matset_data(), and read_gids_and_types().

newNeusets

std::map< int, EntityHandle > moab::ReadCCMIO::newNeusets

private

Definition at line 167 of file ReadCCMIO.hpp.

Referenced by load_neuset_data(), and read_faces().

readMeshIface

ReadUtilIface* moab::ReadCCMIO::readMeshIface

private

Definition at line 165 of file ReadCCMIO.hpp.

Referenced by read_vertices(), ReadCCMIO(), and ~ReadCCMIO().

---

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

• ReadCCMIO.hpp
• ReadCCMIO.cpp