moab::ReadHDF5 Class Reference

Read mesh from MOAB HDF5 (.h5m) file. More...

#include <ReadHDF5.hpp>

Inheritance diagram for moab::ReadHDF5:

Collaboration diagram for moab::ReadHDF5:

Classes
struct	HDF5ErrorHandler
	Store old HDF5 error handling function. More...
struct	IDConnectivity
	List of connectivity arrays for which conversion from file ID to handle was deferred until later. More...

Public Types
enum	SetMode { CONTENT = 0 , CHILD = 1 , PARENT = 2 }
typedef int	Comm

Public Member Functions
	ReadHDF5 (Interface *iface)
virtual	~ReadHDF5 ()
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)
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...
Interface *	moab () const
ErrorCode	convert_id_to_handle (EntityHandle *in_out_array, size_t array_length)
void	convert_id_to_handle (EntityHandle *in_out_array, size_t array_length, size_t &array_length_out) const
ErrorCode	convert_range_to_handle (const EntityHandle *ranges, size_t num_ranges, Range &merge)
ErrorCode	insert_in_id_map (const Range &file_ids, EntityHandle start_id)
ErrorCode	insert_in_id_map (long file_id, EntityHandle handle)
Public Member Functions inherited from moab::ReaderIface
virtual	~ReaderIface ()

Static Public Member Functions
static ReaderIface *	factory (Interface *)
static void	convert_id_to_handle (EntityHandle *in_out_array, size_t array_length, const RangeMap< long, EntityHandle > &id_map)
static void	convert_id_to_handle (EntityHandle *in_out_array, size_t array_length, size_t &array_length_out, const RangeMap< long, EntityHandle > &id_map)
static void	convert_range_to_handle (const EntityHandle *ranges, size_t num_ranges, const RangeMap< long, EntityHandle > &id_map, Range &merge)

Protected Types
enum	ReadTimingValues {   TOTAL_TIME = 0 , SET_META_TIME , SUBSET_IDS_TIME , GET_PARTITION_TIME ,   GET_SET_IDS_TIME , GET_SET_CONTENTS_TIME , GET_POLYHEDRA_TIME , GET_ELEMENTS_TIME ,   GET_NODES_TIME , GET_NODEADJ_TIME , GET_SIDEELEM_TIME , UPDATECONN_TIME ,   ADJACENCY_TIME , DELETE_NON_SIDEELEM_TIME , READ_SET_IDS_RECURS_TIME , FIND_SETS_CONTAINING_TIME ,   READ_SETS_TIME , READ_TAGS_TIME , STORE_FILE_IDS_TIME , READ_QA_TIME ,   NUM_TIMES }

Protected Member Functions
ErrorCode	load_file_impl (const FileOptions &opts)
ErrorCode	load_file_partial (const ReaderIface::IDTag *subset_list, int subset_list_length, int num_parts, int part_number, const FileOptions &opts)
ErrorCode	read_tag_values_all (int tag_index, std::vector< int > &results)
ErrorCode	read_tag_values_partial (int tag_index, const Range &file_ids, std::vector< int > &results)
void	print_times ()

Private Types
typedef RangeMap< long, EntityHandle >	IDMap
	Map from File ID to MOAB handle. More...

Private Member Functions
ErrorCode	init ()
int	is_error (mhdf_Status &status)
ErrorCode	read_all_set_meta ()
ErrorCode	set_up_read (const char *file_name, const FileOptions &opts)
ErrorCode	clean_up_read (const FileOptions &opts)
ErrorCode	get_subset_ids (const ReaderIface::IDTag *subset_list, int subset_list_length, Range &file_ids_out)
	Given a list of tags and values, get the file ids for the corresponding entities in the file. More...
ErrorCode	get_partition (Range &tmp_file_ids, int num_parts, int part_number)
	Remove all but the specified fraction of sets from the passed range. More...
ErrorCode	read_nodes (const Range &node_file_ids)
ErrorCode	read_elems (int index)
ErrorCode	read_elems (int index, const Range &file_ids, Range *node_ids=0)
ErrorCode	read_elems (const mhdf_ElemDesc &elems, const Range &file_ids, Range *node_ids=0)
	Read element connectivity. More...
ErrorCode	update_connectivity ()
	Update connectivity data for all element groups for which read_elems was called with a non-null node_ids argument. More...
ErrorCode	read_elems (int index, const Range &element_file_ids, Range &node_file_ids)
ErrorCode	read_node_adj_elems (const mhdf_ElemDesc &group, Range *read_entities=0)
ErrorCode	read_node_adj_elems (const mhdf_ElemDesc &group, hid_t connectivity_handle, Range *read_entities=0)
ErrorCode	read_poly (const mhdf_ElemDesc &elems, const Range &file_ids)
	Read poly(gons|hedra) More...
ErrorCode	delete_non_side_elements (const Range &side_ents)
	Clean up elements that were a) read because we had read all of the nodes and b) weren't actually sides of the top-dimension elements we were trying to read. More...
ErrorCode	read_sets (const Range &set_file_ids)
	Read sets. More...
ErrorCode	read_adjacencies (hid_t adjacency_table, long table_length)
ErrorCode	read_tag (int index)
	Create tag and read all data. More...
ErrorCode	create_tag (const mhdf_TagDesc &info, Tag &handle, hid_t &type)
	Create new tag or verify type matches existing tag. More...
ErrorCode	read_dense_tag (Tag tag_handle, const char *ent_name, hid_t hdf_read_type, hid_t data_table, long start_id, long count)
	Read dense tag for all entities. More...
ErrorCode	read_sparse_tag (Tag tag_handle, hid_t hdf_read_type, hid_t ent_table, hid_t val_table, long num_entities)
	Read sparse tag for all entities. More...
ErrorCode	read_var_len_tag (Tag tag_handle, hid_t hdf_read_type, hid_t ent_table, hid_t val_table, hid_t off_table, long num_entities, long num_values)
	Read variable-length tag for all entities. More...
ErrorCode	read_sparse_tag_indices (const char *name, hid_t id_table, EntityHandle start_offset, Range &offset_range, Range &handle_range, std::vector< EntityHandle > &handle_vect)
	Read index table for sparse tag. More...
ErrorCode	read_qa (EntityHandle file_set)
ErrorCode	search_tag_values (int tag_index, const std::vector< int > &sorted_values, Range &file_ids_out, bool sets_only=false)
	Search for entities with specified tag values. More...
ErrorCode	get_tagged_entities (int tag_index, Range &file_ids_out)
	Search for entities with specified tag. More...
ErrorCode	search_tag_values (hid_t tag_table, unsigned long table_size, const std::vector< int > &sorted_values, std::vector< EntityHandle > &value_indices)
	Search a table of tag data for a specified set of values. More...
ErrorCode	get_set_contents (const Range &sets, Range &file_ids)
	Get the file IDs for nodes and elements contained in sets. More...
ErrorCode	read_set_ids_recursive (Range &sets_in_out, bool containted_sets, bool child_sets)
ErrorCode	find_sets_containing (Range &sets_out, bool read_set_containing_parents)
ErrorCode	read_sets_partial (const Range &sets_in)
	Read sets from file into MOAB for partial read of file. More...
ErrorCode	find_sets_containing (hid_t content_handle, hid_t content_type, long content_len, bool read_set_containing_parents, Range &file_ids)
ErrorCode	read_set_data (const Range &set_file_ids, EntityHandle set_start_handle, ReadHDF5Dataset &set_data_set, SetMode which_data, Range *file_ids_out=0)
ErrorCode	store_file_ids (Tag tag)
	Store file IDS in tag values. More...
ErrorCode	store_sets_file_ids ()
	Store sets file IDS in a custom tag. More...
ErrorCode	find_int_tag (const char *name, int &index_out)
	Find index in mhdf_FileDesc* fileInfo for specified tag name. More...
void	debug_barrier_line (int lineno)

Private Attributes
int	bufferSize
	The size of the data buffer (dataBuffer). More...
char *	dataBuffer
	A memory buffer to use for all I/O operations. More...
Interface *	iFace
	Interface pointer passed to constructor. More...
mhdf_FileHandle	filePtr
	The file handle from the mhdf library. More...
mhdf_FileDesc *	fileInfo
	File summary. More...
IDMap	idMap
ReadUtilIface *	readUtil
	Cache pointer to read util. More...
hid_t	handleType
	The type of an EntityHandle. More...
std::vector< IDConnectivity >	idConnectivityList
	List of connectivity arrays for which conversion from file ID to handle was deferred until later. More...
hid_t	indepIO
	Read/write property handle indepIO -> independent IO during true parallel read collIO -> collective IO during true parallel read Both are H5P_DEFAULT for serial IO and collective when reading the entire file on all processors. More...
hid_t	collIO
ParallelComm *	myPcomm
bool	debugTrack
	Use IODebugTrack instances to verify reads. Enable with the DEBUG_OVERLAPS option. More...
DebugOutput	dbgOut
	Debug output. Verbosity controlled with DEBUG_FORMAT option. More...
bool	nativeParallel
	Doing true parallel read (PARALLEL=READ_PART) More...
Comm *	mpiComm
	MPI_Comm value (unused if !nativeParallel) More...
bool	blockedCoordinateIO
	Flags for some behavior that can be changed through reader options. More...
bool	bcastSummary
bool	bcastDuplicateReads
HDF5ErrorHandler	errorHandler
	Store old HDF5 error handling function. More...
long(*	setMeta )[4]
double	_times [NUM_TIMES]
CpuTimer *	timer
bool	cputime

Detailed Description

Read mesh from MOAB HDF5 (.h5m) file.

Author

Jason Kraftcheck

Date

18 April 2004

Definition at line 46 of file ReadHDF5.hpp.

Member Typedef Documentation

Comm

typedef int moab::ReadHDF5::Comm

Definition at line 52 of file ReadHDF5.hpp.

IDMap

typedef RangeMap< long, EntityHandle > moab::ReadHDF5::IDMap

private

Map from File ID to MOAB handle.

Definition at line 153 of file ReadHDF5.hpp.

Member Enumeration Documentation

ReadTimingValues

enum moab::ReadHDF5::ReadTimingValues

protected

Enumerator
TOTAL_TIME
SET_META_TIME
SUBSET_IDS_TIME
GET_PARTITION_TIME
GET_SET_IDS_TIME
GET_SET_CONTENTS_TIME
GET_POLYHEDRA_TIME
GET_ELEMENTS_TIME
GET_NODES_TIME
GET_NODEADJ_TIME
GET_SIDEELEM_TIME
UPDATECONN_TIME
ADJACENCY_TIME
DELETE_NON_SIDEELEM_TIME
READ_SET_IDS_RECURS_TIME
FIND_SETS_CONTAINING_TIME
READ_SETS_TIME
READ_TAGS_TIME
STORE_FILE_IDS_TIME
READ_QA_TIME
NUM_TIMES

Definition at line 101 of file ReadHDF5.hpp.

 {
 TOTAL_TIME = 0,
 SET_META_TIME,
 SUBSET_IDS_TIME,
 GET_PARTITION_TIME,
 GET_SET_IDS_TIME,
 GET_SET_CONTENTS_TIME,
 GET_POLYHEDRA_TIME,
 GET_ELEMENTS_TIME,
 GET_NODES_TIME,
 GET_NODEADJ_TIME,
 GET_SIDEELEM_TIME,
 UPDATECONN_TIME,
 ADJACENCY_TIME,
 DELETE_NON_SIDEELEM_TIME,
 READ_SET_IDS_RECURS_TIME,
 FIND_SETS_CONTAINING_TIME,
 READ_SETS_TIME,
 READ_TAGS_TIME,
 STORE_FILE_IDS_TIME,
 READ_QA_TIME,
 NUM_TIMES
 };

SetMode

enum moab::ReadHDF5::SetMode

Enumerator
CONTENT
CHILD
PARENT

Definition at line 451 of file ReadHDF5.hpp.

 {
 CONTENT = 0,
 CHILD = 1,
 PARENT = 2
 };

Constructor & Destructor Documentation

ReadHDF5()

moab::ReadHDF5::ReadHDF5

(

Interface *

iface

)

Definition at line 188 of file ReadHDF5.cpp.

 : bufferSize( READ_HDF5_BUFFER_SIZE ), dataBuffer( NULL ), iFace( iface ), filePtr( 0 ), fileInfo( NULL ),
 readUtil( NULL ), handleType( 0 ), indepIO( H5P_DEFAULT ), collIO( H5P_DEFAULT ), myPcomm( NULL ),
 debugTrack( false ), dbgOut( stderr ), nativeParallel( false ), mpiComm( NULL ),
 blockedCoordinateIO( DEFAULT_BLOCKED_COORDINATE_IO ), bcastSummary( DEFAULT_BCAST_SUMMARY ),
 bcastDuplicateReads( DEFAULT_BCAST_DUPLICATE_READS ), setMeta( 0 ), timer( NULL ), cputime( false )
{
}

Referenced by factory().

~ReadHDF5()

moab::ReadHDF5::~ReadHDF5 ( )

virtual

Definition at line 230 of file ReadHDF5.cpp.

{
 if( !readUtil ) // init() failed.
 return;
 
 delete[] setMeta;
 setMeta = 0;
 iFace->release_interface( readUtil );
 H5Tclose( handleType );
}

References handleType, iFace, readUtil, moab::Interface::release_interface(), and setMeta.

Member Function Documentation

clean_up_read()

ErrorCode moab::ReadHDF5::clean_up_read ( const FileOptions &  opts )

private

Definition at line 482 of file ReadHDF5.cpp.

{
 HDF5ErrorHandler handler;
#if defined( H5Eget_auto_vers ) && H5Eget_auto_vers > 1
 herr_t err = H5Eget_auto( H5E_DEFAULT, &handler.func, &handler.data );
#else
 herr_t err = H5Eget_auto( &handler.func, &handler.data );
#endif
 if( err >= 0 && handler.func == &handle_hdf5_error )
 {
 assert( handler.data == &errorHandler );
#if defined( H5Eget_auto_vers ) && H5Eget_auto_vers > 1
 H5Eset_auto( H5E_DEFAULT, errorHandler.func, errorHandler.data );
#else
 H5Eset_auto( errorHandler.func, errorHandler.data );
#endif
 }
 
 free( dataBuffer );
 dataBuffer = NULL;
 free( fileInfo );
 fileInfo = NULL;
 delete mpiComm;
 mpiComm = 0;
 
 if( indepIO != H5P_DEFAULT ) H5Pclose( indepIO );
 if( collIO != indepIO ) H5Pclose( collIO );
 collIO = indepIO = H5P_DEFAULT;
 
 delete[] setMeta;
 setMeta = 0;
 
 mhdf_Status status;
 mhdf_closeFile( filePtr, &status );
 filePtr = 0;
 return is_error( status ) ? MB_FAILURE : MB_SUCCESS;
}

References collIO, moab::ReadHDF5::HDF5ErrorHandler::data, dataBuffer, errorHandler, fileInfo, filePtr, moab::ReadHDF5::HDF5ErrorHandler::func, moab::handle_hdf5_error(), indepIO, is_error(), MB_SUCCESS, mhdf_closeFile(), mpiComm, and setMeta.

Referenced by load_file(), and read_tag_values().

convert_id_to_handle() [1/4]

ErrorCode moab::ReadHDF5::convert_id_to_handle	(	EntityHandle *	in_out_array,
		size_t	array_length
	)

Definition at line 3443 of file ReadHDF5.cpp.

{
 convert_id_to_handle( array, size, idMap );
 return MB_SUCCESS;
}

References idMap, MB_SUCCESS, and size.

Referenced by convert_id_to_handle(), create_tag(), read_adjacencies(), read_dense_tag(), read_elems(), read_poly(), read_set_data(), read_sparse_tag(), read_sparse_tag_indices(), read_var_len_tag(), and update_connectivity().

convert_id_to_handle() [2/4]

void moab::ReadHDF5::convert_id_to_handle ( EntityHandle *  in_out_array, size_t  array_length, const RangeMap< long, EntityHandle > &  id_map  )

static

Definition at line 3449 of file ReadHDF5.cpp.

{
 for( EntityHandle* const end = array + size; array != end; ++array )
 *array = id_map.find( *array );
}

References moab::RangeMap< KeyType, ValType, NullVal >::find(), and size.

convert_id_to_handle() [3/4]

void moab::ReadHDF5::convert_id_to_handle ( EntityHandle *  in_out_array, size_t  array_length, size_t &  array_length_out  ) const

inline

Definition at line 345 of file ReadHDF5.hpp.

 {
 return convert_id_to_handle( in_out_array, array_length, array_length_out, idMap );
 }

References convert_id_to_handle(), and idMap.

convert_id_to_handle() [4/4]

void moab::ReadHDF5::convert_id_to_handle ( EntityHandle *  in_out_array, size_t  array_length, size_t &  array_length_out, const RangeMap< long, EntityHandle > &  id_map  )

static

Definition at line 3455 of file ReadHDF5.cpp.

{
 RangeMap< long, EntityHandle >::const_iterator it;
 new_size = 0;
 for( size_t i = 0; i < size; ++i )
 {
 it = id_map.lower_bound( array[i] );
 if( it != id_map.end() && it->begin <= (long)array[i] )
 array[new_size++] = it->value + ( array[i] - it->begin );
 }
}

References moab::RangeMap< KeyType, ValType, NullVal >::begin(), moab::RangeMap< KeyType, ValType, NullVal >::end(), moab::RangeMap< KeyType, ValType, NullVal >::lower_bound(), and size.

convert_range_to_handle() [1/2]

void moab::ReadHDF5::convert_range_to_handle ( const EntityHandle *  ranges, size_t  num_ranges, const RangeMap< long, EntityHandle > &  id_map, Range &  merge  )

static

Definition at line 3470 of file ReadHDF5.cpp.

{
 RangeMap< long, EntityHandle >::iterator it = id_map.begin();
 Range::iterator hint = merge.begin();
 for( size_t i = 0; i < num_ranges; ++i )
 {
 long id = ranges[2 * i];
 const long end = id + ranges[2 * i + 1];
 // We assume that 'ranges' is sorted, but check just in case it isn't.
 if( it == id_map.end() || it->begin > id ) it = id_map.begin();
 it = id_map.lower_bound( it, id_map.end(), id );
 if( it == id_map.end() ) continue;
 if( id < it->begin ) id = it->begin;
 while( id < end )
 {
 if( id < it->begin ) id = it->begin;
 const long off = id - it->begin;
 long count = std::min( it->count - off, end - id );
 // It is possible that this new subrange is starting after the end
 // It will result in negative count, which does not make sense
 // We are done with this range, go to the next one
 if( count <= 0 ) break;
 hint = merge.insert( hint, it->value + off, it->value + off + count - 1 );
 id += count;
 if( id < end )
 {
 if( ++it == id_map.end() ) break;
 if( it->begin > end ) break;
 }
 }
 }
}

References moab::Range::begin(), moab::RangeMap< KeyType, ValType, NullVal >::begin(), moab::RangeMap< KeyType, ValType, NullVal >::end(), moab::Range::insert(), and moab::RangeMap< KeyType, ValType, NullVal >::lower_bound().

convert_range_to_handle() [2/2]

ErrorCode moab::ReadHDF5::convert_range_to_handle	(	const EntityHandle *	ranges,
		size_t	num_ranges,
		Range &	merge
	)

Definition at line 3506 of file ReadHDF5.cpp.

{
 convert_range_to_handle( array, num_ranges, idMap, range );
 return MB_SUCCESS;
}

References idMap, and MB_SUCCESS.

Referenced by read_set_data().

create_tag()

ErrorCode moab::ReadHDF5::create_tag ( const mhdf_TagDesc &  info, Tag &  handle, hid_t &  type  )

private

Create new tag or verify type matches existing tag.

Definition at line 2867 of file ReadHDF5.cpp.

{
 CHECK_OPEN_HANDLES;
 
 ErrorCode rval;
 mhdf_Status status;
 TagType storage;
 DataType mb_type;
 bool re_read_default = false;
 
 switch( info.storage )
 {
 case mhdf_DENSE_TYPE:
 storage = MB_TAG_DENSE;
 break;
 case mhdf_SPARSE_TYPE:
 storage = MB_TAG_SPARSE;
 break;
 case mhdf_BIT_TYPE:
 storage = MB_TAG_BIT;
 break;
 case mhdf_MESH_TYPE:
 storage = MB_TAG_MESH;
 break;
 default:
 MB_SET_ERR( MB_FAILURE, "Invalid storage type for tag '" << info.name << "': " << info.storage );
 }
 
 // Type-specific stuff
 if( info.type == mhdf_BITFIELD )
 {
 if( info.size < 1 || info.size > 8 )
 {
 MB_SET_ERR( MB_FAILURE, "Invalid bit tag: class is MB_TAG_BIT, num bits = " << info.size );
 }
 hdf_type = H5Tcopy( H5T_NATIVE_B8 );
 mb_type = MB_TYPE_BIT;
 if( hdf_type < 0 ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 else if( info.type == mhdf_OPAQUE )
 {
 mb_type = MB_TYPE_OPAQUE;
 
 // Check for user-provided type
 Tag type_handle;
 std::string tag_type_name = "__hdf5_tag_type_";
 tag_type_name += info.name;
 rval = iFace->tag_get_handle( tag_type_name.c_str(), sizeof( hid_t ), MB_TYPE_OPAQUE, type_handle );
 if( MB_SUCCESS == rval )
 {
 EntityHandle root = 0;
 rval = iFace->tag_get_data( type_handle, &root, 1, &hdf_type );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 hdf_type = H5Tcopy( hdf_type );
 re_read_default = true;
 }
 else if( MB_TAG_NOT_FOUND == rval )
 {
 hdf_type = 0;
 }
 else
 MB_SET_ERR( rval, "ReadHDF5 Failure" );
 
 if( hdf_type < 0 ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 else
 {
 switch( info.type )
 {
 case mhdf_INTEGER:
 hdf_type = H5T_NATIVE_INT;
 mb_type = MB_TYPE_INTEGER;
 break;
 case mhdf_FLOAT:
 hdf_type = H5T_NATIVE_DOUBLE;
 mb_type = MB_TYPE_DOUBLE;
 break;
 case mhdf_BOOLEAN:
 hdf_type = H5T_NATIVE_UINT;
 mb_type = MB_TYPE_INTEGER;
 break;
 case mhdf_ENTITY_ID:
 hdf_type = handleType;
 mb_type = MB_TYPE_HANDLE;
 break;
 default:
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 
 if( info.size > 1 )
 { // Array
 hsize_t tmpsize = info.size;
#if defined( H5Tarray_create_vers ) && H5Tarray_create_vers > 1
 hdf_type = H5Tarray_create2( hdf_type, 1, &tmpsize );
#else
 hdf_type = H5Tarray_create( hdf_type, 1, &tmpsize, NULL );
#endif
 }
 else
 {
 hdf_type = H5Tcopy( hdf_type );
 }
 if( hdf_type < 0 ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 
 // If default or global/mesh value in file, read it.
 if( info.default_value || info.global_value )
 {
 if( re_read_default )
 {
 mhdf_getTagValues( filePtr, info.name, hdf_type, info.default_value, info.global_value, &status );
 if( mhdf_isError( &status ) )
 {
 if( hdf_type ) H5Tclose( hdf_type );
 MB_SET_ERR( MB_FAILURE, mhdf_message( &status ) );
 }
 }
 
 if( MB_TYPE_HANDLE == mb_type )
 {
 if( info.default_value )
 {
 rval = convert_id_to_handle( (EntityHandle*)info.default_value, info.default_value_size );
 if( MB_SUCCESS != rval )
 {
 if( hdf_type ) H5Tclose( hdf_type );
 MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 }
 if( info.global_value )
 {
 rval = convert_id_to_handle( (EntityHandle*)info.global_value, info.global_value_size );
 if( MB_SUCCESS != rval )
 {
 if( hdf_type ) H5Tclose( hdf_type );
 MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 }
 }
 }
 
 // Get tag handle, creating if necessary
 if( info.size < 0 )
 rval = iFace->tag_get_handle( info.name, info.default_value_size, mb_type, handle,
 storage | MB_TAG_CREAT | MB_TAG_VARLEN | MB_TAG_DFTOK, info.default_value );
 else
 rval = iFace->tag_get_handle( info.name, info.size, mb_type, handle, storage | MB_TAG_CREAT | MB_TAG_DFTOK,
 info.default_value );
 if( MB_SUCCESS != rval )
 {
 if( hdf_type ) H5Tclose( hdf_type );
 MB_SET_ERR( MB_FAILURE, "Tag type in file does not match type in database for \"" << info.name << "\"" );
 }
 
 if( info.global_value )
 {
 EntityHandle root = 0;
 if( info.size > 0 )
 { // Fixed-length tag
 rval = iFace->tag_set_data( handle, &root, 1, info.global_value );
 }
 else
 {
 int tag_size = info.global_value_size;
 rval = iFace->tag_set_by_ptr( handle, &root, 1, &info.global_value, &tag_size );
 }
 if( MB_SUCCESS != rval )
 {
 if( hdf_type ) H5Tclose( hdf_type );
 MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 }
 
 return MB_SUCCESS;
}

References CHECK_OPEN_HANDLES, convert_id_to_handle(), mhdf_TagDesc::default_value, mhdf_TagDesc::default_value_size, ErrorCode, filePtr, mhdf_TagDesc::global_value, mhdf_TagDesc::global_value_size, handleType, iFace, MB_SET_ERR, MB_SUCCESS, MB_TAG_BIT, MB_TAG_CREAT, MB_TAG_DENSE, MB_TAG_MESH, MB_TAG_NOT_FOUND, MB_TAG_SPARSE, MB_TAG_VARLEN, MB_TYPE_BIT, MB_TYPE_DOUBLE, MB_TYPE_HANDLE, MB_TYPE_INTEGER, MB_TYPE_OPAQUE, mhdf_BIT_TYPE, mhdf_BITFIELD, mhdf_BOOLEAN, mhdf_DENSE_TYPE, mhdf_ENTITY_ID, mhdf_FLOAT, mhdf_getTagValues(), mhdf_INTEGER, mhdf_isError(), mhdf_MESH_TYPE, mhdf_message(), mhdf_OPAQUE, mhdf_SPARSE_TYPE, mhdf_TagDesc::name, mhdf_TagDesc::size, mhdf_TagDesc::storage, moab::Interface::tag_get_data(), moab::Interface::tag_get_handle(), moab::Interface::tag_set_by_ptr(), moab::Interface::tag_set_data(), tag_type_name(), TagType, and mhdf_TagDesc::type.

Referenced by read_tag().

debug_barrier_line()

void moab::ReadHDF5::debug_barrier_line ( int  lineno )

private

Definition at line 134 of file ReadHDF5.cpp.

{
#ifdef MOAB_HAVE_MPI
 if( mpiComm )
 {
 const unsigned threshold = 2;
 static unsigned long count = 0;
 if( dbgOut.get_verbosity() >= threshold )
 {
 dbgOut.printf( threshold, "*********** Debug Barrier %lu (@%d)***********\n", ++count, lineno );
 MPI_Barrier( *mpiComm );
 }
 }
#else
 if( lineno )
 {
 }
#endif
}

References dbgOut, moab::DebugOutput::get_verbosity(), mpiComm, and moab::DebugOutput::printf().

delete_non_side_elements()

ErrorCode moab::ReadHDF5::delete_non_side_elements ( const Range &  side_ents )

private

Clean up elements that were a) read because we had read all of the nodes and b) weren't actually sides of the top-dimension elements we were trying to read.

Definition at line 1842 of file ReadHDF5.cpp.

{
 ErrorCode rval;
 
 // Build list of entities that we need to find the sides of
 Range explicit_ents;
 Range::iterator hint = explicit_ents.begin();
 for( IDMap::iterator i = idMap.begin(); i != idMap.end(); ++i )
 {
 EntityHandle start = i->value;
 EntityHandle end = i->value + i->count - 1;
 EntityType type = TYPE_FROM_HANDLE( start );
 assert( type == TYPE_FROM_HANDLE( end ) ); // Otherwise handle space entirely full!!
 if( type != MBVERTEX && type != MBENTITYSET ) hint = explicit_ents.insert( hint, start, end );
 }
 explicit_ents = subtract( explicit_ents, side_ents );
 
 // Figure out which entities we want to delete
 Range dead_ents( side_ents );
 Range::iterator ds, de, es;
 ds = dead_ents.lower_bound( CN::TypeDimensionMap[1].first );
 de = dead_ents.lower_bound( CN::TypeDimensionMap[2].first, ds );
 if( ds != de )
 {
 // Get subset of explicit ents of dimension greater than 1
 es = explicit_ents.lower_bound( CN::TypeDimensionMap[2].first );
 Range subset, adj;
 subset.insert( es, explicit_ents.end() );
 rval = iFace->get_adjacencies( subset, 1, false, adj, Interface::UNION );
 if( MB_SUCCESS != rval ) return rval;
 dead_ents = subtract( dead_ents, adj );
 }
 ds = dead_ents.lower_bound( CN::TypeDimensionMap[2].first );
 de = dead_ents.lower_bound( CN::TypeDimensionMap[3].first, ds );
 assert( de == dead_ents.end() );
 if( ds != de )
 {
 // Get subset of explicit ents of dimension 3
 es = explicit_ents.lower_bound( CN::TypeDimensionMap[3].first );
 Range subset, adj;
 subset.insert( es, explicit_ents.end() );
 rval = iFace->get_adjacencies( subset, 2, false, adj, Interface::UNION );
 if( MB_SUCCESS != rval ) return rval;
 dead_ents = subtract( dead_ents, adj );
 }
 
 // Now delete anything remaining in dead_ents
 dbgOut.printf( 2, "Deleting %lu elements\n", (unsigned long)dead_ents.size() );
 dbgOut.print( 4, "\tDead entities: ", dead_ents );
 rval = iFace->delete_entities( dead_ents );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 
 // Remove dead entities from ID map
 while( !dead_ents.empty() )
 {
 EntityHandle start = dead_ents.front();
 EntityID count = dead_ents.const_pair_begin()->second - start + 1;
 IDMap::iterator rit;
 for( rit = idMap.begin(); rit != idMap.end(); ++rit )
 if( rit->value <= start && (EntityID)( start - rit->value ) < rit->count ) break;
 if( rit == idMap.end() ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 
 EntityID offset = start - rit->value;
 EntityID avail = rit->count - offset;
 if( avail < count ) count = avail;
 
 dead_ents.erase( dead_ents.begin(), dead_ents.begin() + count );
 idMap.erase( rit->begin + offset, count );
 }
 
 return MB_SUCCESS;
}

References moab::Range::begin(), moab::RangeMap< KeyType, ValType, NullVal >::begin(), moab::Range::const_pair_begin(), dbgOut, moab::Interface::delete_entities(), moab::Range::empty(), moab::Range::end(), moab::RangeMap< KeyType, ValType, NullVal >::end(), moab::Range::erase(), moab::RangeMap< KeyType, ValType, NullVal >::erase(), ErrorCode, moab::GeomUtil::first(), moab::Range::front(), moab::Interface::get_adjacencies(), idMap, iFace, moab::Range::insert(), moab::Range::lower_bound(), MB_SET_ERR, MB_SUCCESS, MBENTITYSET, MBVERTEX, moab::DebugOutput::print(), moab::DebugOutput::printf(), moab::Range::size(), moab::subtract(), moab::TYPE_FROM_HANDLE(), moab::CN::TypeDimensionMap, and moab::Interface::UNION.

Referenced by load_file_partial().

factory()

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

static

Definition at line 183 of file ReadHDF5.cpp.

{
 return new ReadHDF5( iface );
}

References iface, and ReadHDF5().

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

find_int_tag()

ErrorCode moab::ReadHDF5::find_int_tag ( const char *  name, int &  index_out  )

private

Find index in mhdf_FileDesc* fileInfo for specified tag name.

Given a tag name, find its index in fileInfo and verify that each tag value is a single integer.

Definition at line 677 of file ReadHDF5.cpp.

{
 for( index = 0; index < fileInfo->num_tag_desc; ++index )
 if( !strcmp( name, fileInfo->tags[index].name ) ) break;
 
 if( index == fileInfo->num_tag_desc )
 {
 MB_SET_ERR( MB_TAG_NOT_FOUND, "File does not contain subset tag '" << name << "'" );
 }
 
 if( fileInfo->tags[index].type != mhdf_INTEGER || fileInfo->tags[index].size != 1 )
 {
 MB_SET_ERR( MB_TAG_NOT_FOUND, "Tag ' " << name << "' does not contain single integer value" );
 }
 
 return MB_SUCCESS;
}

References fileInfo, MB_SET_ERR, MB_SUCCESS, MB_TAG_NOT_FOUND, mhdf_INTEGER, mhdf_TagDesc::name, mhdf_FileDesc::num_tag_desc, mhdf_TagDesc::size, mhdf_FileDesc::tags, and mhdf_TagDesc::type.

Referenced by get_subset_ids(), and read_tag_values().

find_sets_containing() [1/2]

ErrorCode moab::ReadHDF5::find_sets_containing ( hid_t  content_handle, hid_t  content_type, long  content_len, bool  read_set_containing_parents, Range &  file_ids  )

private

Find file IDs of sets containing any entities in the passed id_map

Definition at line 2196 of file ReadHDF5.cpp.

{
 CHECK_OPEN_HANDLES;
 
 // Scan all set contents data
 
 const size_t content_size = H5Tget_size( content_type );
 const long num_sets = fileInfo->sets.count;
 dbgOut.printf( 2, "Searching contents of %ld\n", num_sets );
 mhdf_Status status;
 
 int rank = 0;
 bool bcast = false;
#ifdef MOAB_HAVE_MPI
 MPI_Comm comm = 0;
 if( nativeParallel )
 {
 rank = myPcomm->proc_config().proc_rank();
 comm = myPcomm->proc_config().proc_comm();
 bcast = bcastDuplicateReads;
 }
#endif
 
 // Check offsets so that we don't read past end of table or
 // walk off end of array.
 long prev = -1;
 for( long i = 0; i < num_sets; ++i )
 {
 if( setMeta[i][CONTENT] < prev )
 {
 std::cerr << "Invalid data in set contents offsets at position " << i << ": index " << setMeta[i][CONTENT]
 << " is less than previous index " << prev << std::endl;
 std::cerr.flush();
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 prev = setMeta[i][CONTENT];
 }
 if( setMeta[num_sets - 1][CONTENT] >= contents_len )
 {
 std::cerr << "Maximum set content index " << setMeta[num_sets - 1][CONTENT]
 << " exceeds contents table length of " << contents_len << std::endl;
 std::cerr.flush();
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 
 // Set up buffer for reading set contents
 long* const content_buffer = (long*)dataBuffer;
 const long content_len = bufferSize / std::max( content_size, sizeof( long ) );
 
 // Scan set table
 Range::iterator hint = file_ids.begin();
 Range tmp_range;
 long prev_idx = -1;
 int mm = 0;
 long sets_offset = 0;
 long temp_content[4];
 while( sets_offset < num_sets )
 {
 temp_content[0] = content_len + prev_idx;
 long sets_count =
 std::lower_bound( setMeta + sets_offset, setMeta + num_sets, temp_content, SetContOffComp() ) - setMeta -
 sets_offset;
 assert( sets_count >= 0 && sets_offset + sets_count <= num_sets );
 if( !sets_count )
 { // Contents of single set don't fit in buffer
 long content_remaining = setMeta[sets_offset][CONTENT] - prev_idx;
 long content_offset = prev_idx + 1;
 while( content_remaining )
 {
 long content_count = content_len < content_remaining ? 2 * ( content_len / 2 ) : content_remaining;
 assert_range( content_buffer, content_count );
 dbgOut.printf( 3, "Reading chunk %d (%ld values) from set contents table\n", ++mm, content_count );
 if( !bcast || 0 == rank )
 {
 if( !bcast )
 mhdf_readSetDataWithOpt( contents_handle, content_offset, content_count, content_type,
 content_buffer, collIO, &status );
 else
 mhdf_readSetData( contents_handle, content_offset, content_count, content_type, content_buffer,
 &status );
 if( is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 
 H5Tconvert( content_type, H5T_NATIVE_LONG, content_count, content_buffer, 0, H5P_DEFAULT );
 }
 if( bcast )
 {
#ifdef MOAB_HAVE_MPI
 int ierr = MPI_Bcast( content_buffer, content_count, MPI_LONG, 0, comm );
 if( MPI_SUCCESS != ierr ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
#else
 assert( rank == 0 ); // If not MPI, then only one proc
#endif
 }
 
 if( read_set_containing_parents )
 {
 tmp_range.clear();
 if( setMeta[sets_offset][3] & mhdf_SET_RANGE_BIT )
 tmp_range.insert( *content_buffer, *( content_buffer + 1 ) );
 else
 std::copy( content_buffer, content_buffer + content_count, range_inserter( tmp_range ) );
 tmp_range = intersect( tmp_range, file_ids );
 }
 
 if( !tmp_range.empty() || set_map_intersect( setMeta[sets_offset][3] & mhdf_SET_RANGE_BIT,
 content_buffer, content_count, idMap ) )
 {
 long id = fileInfo->sets.start_id + sets_offset;
 hint = file_ids.insert( hint, id, id );
 if( !nativeParallel ) // Don't stop if doing READ_PART because we need to read
 // collectively
 break;
 }
 content_remaining -= content_count;
 content_offset += content_count;
 }
 prev_idx = setMeta[sets_offset][CONTENT];
 sets_count = 1;
 }
 else if( long read_num = setMeta[sets_offset + sets_count - 1][CONTENT] - prev_idx )
 {
 assert( sets_count > 0 );
 assert_range( content_buffer, read_num );
 dbgOut.printf( 3, "Reading chunk %d (%ld values) from set contents table\n", ++mm, read_num );
 if( !bcast || 0 == rank )
 {
 if( !bcast )
 mhdf_readSetDataWithOpt( contents_handle, prev_idx + 1, read_num, content_type, content_buffer,
 collIO, &status );
 else
 mhdf_readSetData( contents_handle, prev_idx + 1, read_num, content_type, content_buffer, &status );
 if( is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 
 H5Tconvert( content_type, H5T_NATIVE_LONG, read_num, content_buffer, 0, H5P_DEFAULT );
 }
 if( bcast )
 {
#ifdef MOAB_HAVE_MPI
 int ierr = MPI_Bcast( content_buffer, read_num, MPI_LONG, 0, comm );
 if( MPI_SUCCESS != ierr ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
#else
 assert( rank == 0 ); // If not MPI, then only one proc
#endif
 }
 
 long* buff_iter = content_buffer;
 for( long i = 0; i < sets_count; ++i )
 {
 long set_size = setMeta[i + sets_offset][CONTENT] - prev_idx;
 prev_idx += set_size;
 
 // Check whether contents include set already being loaded
 if( read_set_containing_parents )
 {
 tmp_range.clear();
 if( setMeta[sets_offset + i][3] & mhdf_SET_RANGE_BIT )
 {
 // put in tmp_range the contents on the set
 // file_ids contain at this points only other sets
 const long* j = buff_iter;
 const long* const end = buff_iter + set_size;
 assert( set_size % 2 == 0 );
 while( j != end )
 {
 long start = *( j++ );
 long count = *( j++ );
 tmp_range.insert( start, start + count - 1 );
 }
 }
 else
 std::copy( buff_iter, buff_iter + set_size, range_inserter( tmp_range ) );
 tmp_range = intersect( tmp_range, file_ids );
 }
 
 if( !tmp_range.empty() ||
 set_map_intersect( setMeta[sets_offset + i][3] & mhdf_SET_RANGE_BIT, buff_iter, set_size, idMap ) )
 {
 long id = fileInfo->sets.start_id + sets_offset + i;
 hint = file_ids.insert( hint, id, id );
 }
 buff_iter += set_size;
 }
 }
 
 sets_offset += sets_count;
 }
 
 return MB_SUCCESS;
}

References assert_range, bcastDuplicateReads, moab::Range::begin(), bufferSize, CHECK_OPEN_HANDLES, moab::Range::clear(), collIO, CONTENT, mhdf_EntDesc::count, dataBuffer, dbgOut, moab::Range::empty(), fileInfo, idMap, moab::Range::insert(), moab::intersect(), is_error(), MB_SET_ERR, MB_SUCCESS, mhdf_readSetData(), mhdf_readSetDataWithOpt(), mhdf_SET_RANGE_BIT, myPcomm, nativeParallel, moab::DebugOutput::printf(), moab::ProcConfig::proc_comm(), moab::ParallelComm::proc_config(), moab::ProcConfig::proc_rank(), moab::set_map_intersect(), setMeta, mhdf_FileDesc::sets, and mhdf_EntDesc::start_id.

find_sets_containing() [2/2]

ErrorCode moab::ReadHDF5::find_sets_containing ( Range &  sets_out, bool  read_set_containing_parents  )

private

Find all sets containing one or more entities read from the file and added to idMap

Definition at line 2132 of file ReadHDF5.cpp.

{
 ErrorCode rval;
 mhdf_Status status;
 
 CHECK_OPEN_HANDLES;
 
 if( !fileInfo->have_set_contents ) return MB_SUCCESS;
 assert( fileInfo->sets.count );
 
 // Open data tables
 long content_len = 0;
 hid_t content_handle = mhdf_openSetData( filePtr, &content_len, &status );
 if( is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 
 hid_t data_type = H5Dget_type( content_handle );
 
 rval = find_sets_containing( content_handle, data_type, content_len, read_set_containing_parents, sets_out );
 
 H5Tclose( data_type );
 
 mhdf_closeData( filePtr, content_handle, &status );
 if( MB_SUCCESS == rval && is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 
 return rval;
}

References CHECK_OPEN_HANDLES, mhdf_EntDesc::count, ErrorCode, fileInfo, filePtr, mhdf_FileDesc::have_set_contents, is_error(), MB_SET_ERR, MB_SUCCESS, mhdf_closeData(), mhdf_openSetData(), and mhdf_FileDesc::sets.

Referenced by load_file_partial().

get_partition()

ErrorCode moab::ReadHDF5::get_partition ( Range &  tmp_file_ids, int  num_parts, int  part_number  )

private

Remove all but the specified fraction of sets from the passed range.

Select a subset of the gathered set of file ids to read in based on communicator size and rank.

Parameters

tmp_file_ids	As input: sets to be read on all procs. As output: sets to read on this proc.
num_parts	communicator size
part_number	communicator rank

Definition at line 730 of file ReadHDF5.cpp.

{
 CHECK_OPEN_HANDLES;
 
 // Check that the tag only identified sets
 if( (unsigned long)fileInfo->sets.start_id > tmp_file_ids.front() )
 {
 dbgOut.print( 2, "Ignoring non-set entities with partition set tag\n" );
 tmp_file_ids.erase( tmp_file_ids.begin(), tmp_file_ids.lower_bound( (EntityHandle)fileInfo->sets.start_id ) );
 }
 unsigned long set_end = (unsigned long)fileInfo->sets.start_id + fileInfo->sets.count;
 if( tmp_file_ids.back() >= set_end )
 {
 dbgOut.print( 2, "Ignoring non-set entities with partition set tag\n" );
 tmp_file_ids.erase( tmp_file_ids.upper_bound( (EntityHandle)set_end ), tmp_file_ids.end() );
 }
 
 Range::iterator s = tmp_file_ids.begin();
 size_t num_per_proc = tmp_file_ids.size() / num_parts;
 size_t num_extra = tmp_file_ids.size() % num_parts;
 Range::iterator e;
 if( part_number < (long)num_extra )
 {
 s += ( num_per_proc + 1 ) * part_number;
 e = s;
 e += ( num_per_proc + 1 );
 }
 else
 {
 s += num_per_proc * part_number + num_extra;
 e = s;
 e += num_per_proc;
 }
 tmp_file_ids.erase( e, tmp_file_ids.end() );
 tmp_file_ids.erase( tmp_file_ids.begin(), s );
 
 return MB_SUCCESS;
}

References moab::Range::back(), moab::Range::begin(), CHECK_OPEN_HANDLES, mhdf_EntDesc::count, dbgOut, moab::Range::end(), moab::Range::erase(), fileInfo, moab::Range::front(), moab::Range::lower_bound(), MB_SUCCESS, moab::DebugOutput::print(), mhdf_FileDesc::sets, moab::Range::size(), mhdf_EntDesc::start_id, and moab::Range::upper_bound().

Referenced by load_file_partial().

get_set_contents()

ErrorCode moab::ReadHDF5::get_set_contents ( const Range &  sets, Range &  file_ids  )

private

Get the file IDs for nodes and elements contained in sets.

Read the contents for the specified sets and return the file IDs of all nodes and elements contained within those sets.

Parameters

sets	Container of file IDs designating entity sets.
file_ids	Output: File IDs of entities contained in sets.

Definition at line 2618 of file ReadHDF5.cpp.

{
 CHECK_OPEN_HANDLES;
 
 if( !fileInfo->have_set_contents ) return MB_SUCCESS;
 dbgOut.tprint( 2, "Reading set contained file IDs\n" );
 try
 {
 mhdf_Status status;
 long content_len;
 hid_t contents = mhdf_openSetData( filePtr, &content_len, &status );
 if( is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 ReadHDF5Dataset data( "set contents", contents, nativeParallel, mpiComm, true );
 
 return read_set_data( sets, 0, data, CONTENT, &file_ids );
 }
 catch( ReadHDF5Dataset::Exception )
 {
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
}

References CHECK_OPEN_HANDLES, CONTENT, dbgOut, fileInfo, filePtr, mhdf_FileDesc::have_set_contents, is_error(), MB_SET_ERR, MB_SUCCESS, mhdf_openSetData(), mpiComm, nativeParallel, read_set_data(), and moab::DebugOutput::tprint().

Referenced by load_file_partial().

get_subset_ids()

ErrorCode moab::ReadHDF5::get_subset_ids ( const ReaderIface::IDTag *  subset_list, int  subset_list_length, Range &  file_ids_out  )

private

Given a list of tags and values, get the file ids for the corresponding entities in the file.

Definition at line 695 of file ReadHDF5.cpp.

{
 ErrorCode rval;
 
 for( int i = 0; i < subset_list_length; ++i )
 {
 int tag_index;
 rval = find_int_tag( subset_list[i].tag_name, tag_index );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 
 Range tmp_file_ids;
 if( !subset_list[i].num_tag_values )
 {
 rval = get_tagged_entities( tag_index, tmp_file_ids );
 }
 else
 {
 std::vector< int > ids( subset_list[i].tag_values,
 subset_list[i].tag_values + subset_list[i].num_tag_values );
 std::sort( ids.begin(), ids.end() );
 rval = search_tag_values( tag_index, ids, tmp_file_ids );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 
 if( tmp_file_ids.empty() ) MB_CHK_ERR( MB_ENTITY_NOT_FOUND );
 
 if( i == 0 )
 file_ids.swap( tmp_file_ids );
 else
 file_ids = intersect( tmp_file_ids, file_ids );
 }
 
 return MB_SUCCESS;
}

References moab::Range::empty(), ErrorCode, find_int_tag(), get_tagged_entities(), moab::intersect(), MB_CHK_ERR, MB_ENTITY_NOT_FOUND, MB_SET_ERR, MB_SUCCESS, search_tag_values(), and moab::Range::swap().

Referenced by load_file_partial(), and read_tag_values().

get_tagged_entities()

ErrorCode moab::ReadHDF5::get_tagged_entities ( int  tag_index, Range &  file_ids_out  )

private

Search for entities with specified tag.

\NOTE For parallel reads, this function does collective IO.

Parameters

tag_index	Index into info->tags specifying which tag to search.
file_ids_out	File IDs for entities with specified tag values.

Definition at line 1285 of file ReadHDF5.cpp.

{
 const mhdf_TagDesc& tag = fileInfo->tags[tag_index];
 
 CHECK_OPEN_HANDLES;
 
 // Do dense data
 Range::iterator hint = file_ids.begin();
 for( int i = 0; i < tag.num_dense_indices; ++i )
 {
 int idx = tag.dense_elem_indices[i];
 mhdf_EntDesc* ents;
 if( idx == -2 )
 ents = &fileInfo->sets;
 else if( idx == -1 )
 ents = &fileInfo->nodes;
 else
 {
 if( idx < 0 || idx >= fileInfo->num_elem_desc ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 ents = &( fileInfo->elems[idx].desc );
 }
 
 EntityHandle h = (EntityHandle)ents->start_id;
 hint = file_ids.insert( hint, h, h + ents->count - 1 );
 }
 
 if( !tag.have_sparse ) return MB_SUCCESS;
 
 // Do sparse data
 
 mhdf_Status status;
 hid_t tables[2];
 long size, junk;
 mhdf_openSparseTagData( filePtr, tag.name, &size, &junk, tables, &status );
 if( is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 mhdf_closeData( filePtr, tables[1], &status );
 if( is_error( status ) )
 {
 mhdf_closeData( filePtr, tables[0], &status );
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 
 hid_t file_type = H5Dget_type( tables[0] );
 if( file_type < 0 ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 
 hint = file_ids.begin();
 EntityHandle* buffer = reinterpret_cast< EntityHandle* >( dataBuffer );
 const long buffer_size = bufferSize / std::max( sizeof( EntityHandle ), H5Tget_size( file_type ) );
 long remaining = size, offset = 0;
 while( remaining )
 {
 long count = std::min( buffer_size, remaining );
 assert_range( buffer, count );
 mhdf_readSparseTagEntitiesWithOpt( *tables, offset, count, file_type, buffer, collIO, &status );
 if( is_error( status ) )
 {
 H5Tclose( file_type );
 mhdf_closeData( filePtr, *tables, &status );
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 H5Tconvert( file_type, handleType, count, buffer, NULL, H5P_DEFAULT );
 
 std::sort( buffer, buffer + count );
 for( long i = 0; i < count; ++i )
 hint = file_ids.insert( hint, buffer[i], buffer[i] );
 
 remaining -= count;
 offset += count;
 }
 
 H5Tclose( file_type );
 mhdf_closeData( filePtr, *tables, &status );
 if( is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 
 return MB_SUCCESS;
}

References assert_range, moab::Range::begin(), buffer, bufferSize, CHECK_OPEN_HANDLES, collIO, mhdf_EntDesc::count, dataBuffer, mhdf_TagDesc::dense_elem_indices, mhdf_ElemDesc::desc, mhdf_FileDesc::elems, fileInfo, filePtr, handleType, mhdf_TagDesc::have_sparse, moab::Range::insert(), is_error(), MB_SET_ERR, MB_SUCCESS, mhdf_closeData(), mhdf_openSparseTagData(), mhdf_readSparseTagEntitiesWithOpt(), mhdf_TagDesc::name, mhdf_FileDesc::nodes, mhdf_TagDesc::num_dense_indices, mhdf_FileDesc::num_elem_desc, mhdf_FileDesc::sets, size, mhdf_EntDesc::start_id, and mhdf_FileDesc::tags.

Referenced by get_subset_ids().

init()

ErrorCode moab::ReadHDF5::init ( )

private

Definition at line 197 of file ReadHDF5.cpp.

{
 ErrorCode rval;
 
 if( readUtil ) return MB_SUCCESS;
 
 indepIO = collIO = H5P_DEFAULT;
 // WriteHDF5::register_known_tag_types(iFace);
 
 handleType = H5Tcopy( H5T_NATIVE_ULONG );
 if( handleType < 0 ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 
 if( H5Tset_size( handleType, sizeof( EntityHandle ) ) < 0 )
 {
 H5Tclose( handleType );
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 
 rval = iFace->query_interface( readUtil );
 if( MB_SUCCESS != rval )
 {
 H5Tclose( handleType );
 MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 
 idMap.clear();
 fileInfo = 0;
 debugTrack = false;
 myPcomm = 0;
 
 return MB_SUCCESS;
}

References moab::RangeMap< KeyType, ValType, NullVal >::clear(), collIO, debugTrack, ErrorCode, fileInfo, handleType, idMap, iFace, indepIO, MB_SET_ERR, MB_SUCCESS, myPcomm, moab::Interface::query_interface(), and readUtil.

Referenced by set_up_read().

insert_in_id_map() [1/2]

ErrorCode moab::ReadHDF5::insert_in_id_map	(	const Range &	file_ids,
		EntityHandle	start_id
	)

Definition at line 3512 of file ReadHDF5.cpp.

{
 IDMap tmp_map;
 bool merge = !idMap.empty() && !file_ids.empty() && idMap.back().begin > (long)file_ids.front();
 IDMap& map = merge ? tmp_map : idMap;
 Range::const_pair_iterator p;
 for( p = file_ids.const_pair_begin(); p != file_ids.const_pair_end(); ++p )
 {
 size_t count = p->second - p->first + 1;
 if( !map.insert( p->first, start_id, count ).second ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 start_id += count;
 }
 if( merge && !idMap.merge( tmp_map ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 
 return MB_SUCCESS;
}

References moab::RangeMap< KeyType, ValType, NullVal >::back(), moab::Range::begin(), moab::Range::const_pair_begin(), moab::Range::const_pair_end(), moab::Range::empty(), moab::RangeMap< KeyType, ValType, NullVal >::empty(), moab::Range::front(), idMap, moab::RangeMap< KeyType, ValType, NullVal >::insert(), MB_SET_ERR, MB_SUCCESS, and moab::RangeMap< KeyType, ValType, NullVal >::merge().

Referenced by read_elems(), read_nodes(), read_poly(), and read_sets().

insert_in_id_map() [2/2]

ErrorCode moab::ReadHDF5::insert_in_id_map	(	long	file_id,
		EntityHandle	handle
	)

Definition at line 3529 of file ReadHDF5.cpp.

{
 if( !idMap.insert( file_id, handle, 1 ).second ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 return MB_SUCCESS;
}

References idMap, moab::RangeMap< KeyType, ValType, NullVal >::insert(), MB_SET_ERR, and MB_SUCCESS.

is_error()

int moab::ReadHDF5::is_error ( mhdf_Status &  status )

inlineprivate

Definition at line 131 of file ReadHDF5.hpp.

 {
 int i;
 if( ( i = mhdf_isError( &status ) ) ) MB_SET_ERR_CONT( mhdf_message( &status ) );
 return i;
 }

References MB_SET_ERR_CONT, mhdf_isError(), and mhdf_message().

Referenced by clean_up_read(), find_sets_containing(), get_set_contents(), get_tagged_entities(), load_file_impl(), load_file_partial(), read_adjacencies(), read_all_set_meta(), read_elems(), read_node_adj_elems(), read_nodes(), read_poly(), read_set_ids_recursive(), read_sets(), read_tag(), search_tag_values(), and set_up_read().

load_file()

ErrorCode moab::ReadHDF5::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

Export specified meshsets to file

Parameters

filename	The filename to export. Must end in .mhdf
export_sets	Array of handles to sets to export, or NULL to export all.
export_set_count	Length of export_sets array.

Implements moab::ReaderIface.

Definition at line 520 of file ReadHDF5.cpp.

{
 ErrorCode rval;
 
 rval = set_up_read( filename, opts );
 if( MB_SUCCESS != rval )
 {
 clean_up_read( opts );
 return rval;
 }
 // See if we need to report times
 
 rval = opts.get_null_option( "CPUTIME" );
 if( MB_SUCCESS == rval )
 {
 cputime = true;
 timer = new CpuTimer;
 for( int i = 0; i < NUM_TIMES; i++ )
 _times[i] = 0;
 }
 
 // We read the entire set description table regardless of partial
 // or complete reads or serial vs parallel reads
 rval = read_all_set_meta();
 
 if( cputime ) _times[SET_META_TIME] = timer->time_elapsed();
 if( subset_list && MB_SUCCESS == rval )
 rval = load_file_partial( subset_list->tag_list, subset_list->tag_list_length, subset_list->num_parts,
 subset_list->part_number, opts );
 else
 rval = load_file_impl( opts );
 
 if( MB_SUCCESS == rval && file_id_tag )
 {
 dbgOut.tprint( 1, "Storing file IDs in tag\n" );
 rval = store_file_ids( *file_id_tag );
 }
 ErrorCode rval3 = opts.get_null_option( "STORE_SETS_FILEIDS" );
 if( MB_SUCCESS == rval3 )
 {
 rval = store_sets_file_ids();
 if( MB_SUCCESS != rval ) return rval;
 }
 
 if( cputime ) _times[STORE_FILE_IDS_TIME] = timer->time_elapsed();
 
 if( MB_SUCCESS == rval && 0 != file_set )
 {
 dbgOut.tprint( 1, "Reading QA records\n" );
 rval = read_qa( *file_set );
 }
 
 if( cputime ) _times[READ_QA_TIME] = timer->time_elapsed();
 dbgOut.tprint( 1, "Cleaning up\n" );
 ErrorCode rval2 = clean_up_read( opts );
 if( rval == MB_SUCCESS && rval2 != MB_SUCCESS ) rval = rval2;
 
 if( MB_SUCCESS == rval )
 dbgOut.tprint( 1, "Read finished.\n" );
 else
 {
 std::string msg;
 iFace->get_last_error( msg );
 dbgOut.tprintf( 1, "READ FAILED (ERROR CODE %s): %s\n", ErrorCodeStr[rval], msg.c_str() );
 }
 
 if( cputime )
 {
 _times[TOTAL_TIME] = timer->time_since_birth();
 print_times();
 delete timer;
 }
 if( H5P_DEFAULT != collIO ) H5Pclose( collIO );
 if( H5P_DEFAULT != indepIO ) H5Pclose( indepIO );
 collIO = indepIO = H5P_DEFAULT;
 
 return rval;
}

References _times, clean_up_read(), collIO, cputime, dbgOut, ErrorCode, moab::Interface::get_last_error(), moab::FileOptions::get_null_option(), iFace, indepIO, load_file_impl(), load_file_partial(), MB_SUCCESS, moab::ReaderIface::SubsetList::num_parts, NUM_TIMES, moab::ReaderIface::SubsetList::part_number, print_times(), read_all_set_meta(), read_qa(), READ_QA_TIME, SET_META_TIME, set_up_read(), store_file_ids(), STORE_FILE_IDS_TIME, store_sets_file_ids(), moab::ReaderIface::SubsetList::tag_list, moab::ReaderIface::SubsetList::tag_list_length, moab::CpuTimer::time_elapsed(), moab::CpuTimer::time_since_birth(), timer, TOTAL_TIME, moab::DebugOutput::tprint(), and moab::DebugOutput::tprintf().

load_file_impl()

ErrorCode moab::ReadHDF5::load_file_impl ( const FileOptions &  opts )

protected

Definition at line 603 of file ReadHDF5.cpp.

{
 ErrorCode rval;
 mhdf_Status status;
 int i;
 
 CHECK_OPEN_HANDLES;
 
 dbgOut.tprint( 1, "Reading all nodes...\n" );
 Range ids;
 if( fileInfo->nodes.count )
 {
 ids.insert( fileInfo->nodes.start_id, fileInfo->nodes.start_id + fileInfo->nodes.count - 1 );
 rval = read_nodes( ids );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 
 dbgOut.tprint( 1, "Reading all element connectivity...\n" );
 std::vector< int > polyhedra; // Need to do these last so that faces are loaded
 for( i = 0; i < fileInfo->num_elem_desc; ++i )
 {
 if( CN::EntityTypeFromName( fileInfo->elems[i].type ) == MBPOLYHEDRON )
 {
 polyhedra.push_back( i );
 continue;
 }
 
 rval = read_elems( i );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 for( std::vector< int >::iterator it = polyhedra.begin(); it != polyhedra.end(); ++it )
 {
 rval = read_elems( *it );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 
 dbgOut.tprint( 1, "Reading all sets...\n" );
 ids.clear();
 if( fileInfo->sets.count )
 {
 ids.insert( fileInfo->sets.start_id, fileInfo->sets.start_id + fileInfo->sets.count - 1 );
 rval = read_sets( ids );
 if( rval != MB_SUCCESS )
 {
 MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 }
 
 dbgOut.tprint( 1, "Reading all adjacencies...\n" );
 for( i = 0; i < fileInfo->num_elem_desc; ++i )
 {
 if( !fileInfo->elems[i].have_adj ) continue;
 
 long table_len;
 hid_t table = mhdf_openAdjacency( filePtr, fileInfo->elems[i].handle, &table_len, &status );
 if( is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 
 rval = read_adjacencies( table, table_len );
 mhdf_closeData( filePtr, table, &status );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 if( is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 
 dbgOut.tprint( 1, "Reading all tags...\n" );
 for( i = 0; i < fileInfo->num_tag_desc; ++i )
 {
 rval = read_tag( i );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 
 dbgOut.tprint( 1, "Core read finished. Cleaning up...\n" );
 return MB_SUCCESS;
}

References CHECK_OPEN_HANDLES, moab::Range::clear(), mhdf_EntDesc::count, dbgOut, mhdf_FileDesc::elems, moab::CN::EntityTypeFromName(), ErrorCode, fileInfo, filePtr, mhdf_ElemDesc::handle, mhdf_ElemDesc::have_adj, moab::Range::insert(), is_error(), MB_SET_ERR, MB_SUCCESS, MBPOLYHEDRON, mhdf_closeData(), mhdf_openAdjacency(), mhdf_FileDesc::nodes, mhdf_FileDesc::num_elem_desc, mhdf_FileDesc::num_tag_desc, read_adjacencies(), read_elems(), read_nodes(), read_sets(), read_tag(), mhdf_FileDesc::sets, mhdf_EntDesc::start_id, moab::DebugOutput::tprint(), and mhdf_ElemDesc::type.

Referenced by load_file().

load_file_partial()

ErrorCode moab::ReadHDF5::load_file_partial ( const ReaderIface::IDTag *  subset_list, int  subset_list_length, int  num_parts, int  part_number, const FileOptions &  opts  )

protected

Definition at line 769 of file ReadHDF5.cpp.

{
 mhdf_Status status;
 
 static MPEState mpe_event( "ReadHDF5", "yellow" );
 
 mpe_event.start( "gather parts" );
 
 CHECK_OPEN_HANDLES;
 
 for( int i = 0; i < subset_list_length; ++i )
 {
 dbgOut.printf( 2, "Select by \"%s\" with num_tag_values = %d\n", subset_list[i].tag_name,
 subset_list[i].num_tag_values );
 if( subset_list[i].num_tag_values )
 {
 assert( 0 != subset_list[i].tag_values );
 dbgOut.printf( 2, " \"%s\" values = { %d", subset_list[i].tag_name, subset_list[i].tag_values[0] );
 for( int j = 1; j < subset_list[i].num_tag_values; ++j )
 dbgOut.printf( 2, ", %d", subset_list[i].tag_values[j] );
 dbgOut.printf( 2, " }\n" );
 }
 }
 if( num_parts ) dbgOut.printf( 2, "Partition with num_parts = %d and part_number = %d\n", num_parts, part_number );
 
 dbgOut.tprint( 1, "RETRIEVING TAGGED ENTITIES\n" );
 
 Range file_ids;
 ErrorCode rval = get_subset_ids( subset_list, subset_list_length, file_ids );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 
 if( cputime ) _times[SUBSET_IDS_TIME] = timer->time_elapsed();
 
 if( num_parts )
 {
 /*if (num_parts>(int)file_ids.size())
 {
 MB_SET_ERR(MB_FAILURE, "Only " << file_ids.size() << " parts to distribute to " <<
 num_parts << " processes.");
 }*/
 rval = get_partition( file_ids, num_parts, part_number );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 
 if( cputime ) _times[GET_PARTITION_TIME] = timer->time_elapsed();
 
 dbgOut.print_ints( 4, "Set file IDs for partial read: ", file_ids );
 mpe_event.end();
 mpe_event.start( "gather related sets" );
 dbgOut.tprint( 1, "GATHERING ADDITIONAL ENTITIES\n" );
 
 enum RecusiveSetMode
 {
 RSM_NONE,
 RSM_SETS,
 RSM_CONTENTS
 };
 const char* const set_opts[] = { "NONE", "SETS", "CONTENTS", NULL };
 int child_mode;
 rval = opts.match_option( "CHILDREN", set_opts, child_mode );
 if( MB_ENTITY_NOT_FOUND == rval )
 child_mode = RSM_CONTENTS;
 else if( MB_SUCCESS != rval )
 {
 MB_SET_ERR( rval, "Invalid value for 'CHILDREN' option" );
 }
 int content_mode;
 rval = opts.match_option( "SETS", set_opts, content_mode );
 if( MB_ENTITY_NOT_FOUND == rval )
 content_mode = RSM_CONTENTS;
 else if( MB_SUCCESS != rval )
 {
 MB_SET_ERR( rval, "Invalid value for 'SETS' option" );
 }
 
 // If we want the contents of contained/child sets,
 // search for them now (before gathering the non-set contents
 // of the sets.)
 Range sets;
 intersect( fileInfo->sets, file_ids, sets );
 if( content_mode == RSM_CONTENTS || child_mode == RSM_CONTENTS )
 {
 dbgOut.tprint( 1, " doing read_set_ids_recursive\n" );
 rval = read_set_ids_recursive( sets, content_mode == RSM_CONTENTS, child_mode == RSM_CONTENTS );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 
 if( cputime ) _times[GET_SET_IDS_TIME] = timer->time_elapsed();
 debug_barrier();
 
 // Get elements and vertices contained in sets
 dbgOut.tprint( 1, " doing get_set_contents\n" );
 rval = get_set_contents( sets, file_ids );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 
 if( cputime ) _times[GET_SET_CONTENTS_TIME] = timer->time_elapsed();
 
 dbgOut.print_ints( 5, "File IDs for partial read: ", file_ids );
 debug_barrier();
 mpe_event.end();
 dbgOut.tprint( 1, "GATHERING NODE IDS\n" );
 
 // Figure out the maximum dimension of entity to be read
 int max_dim = 0;
 for( int i = 0; i < fileInfo->num_elem_desc; ++i )
 {
 EntityType type = CN::EntityTypeFromName( fileInfo->elems[i].type );
 if( type <= MBVERTEX || type >= MBENTITYSET )
 {
 assert( false ); // For debug code die for unknown element types
 continue; // For release code, skip unknown element types
 }
 int dim = CN::Dimension( type );
 if( dim > max_dim )
 {
 Range subset;
 intersect( fileInfo->elems[i].desc, file_ids, subset );
 if( !subset.empty() ) max_dim = dim;
 }
 }
#ifdef MOAB_HAVE_MPI
 if( nativeParallel )
 {
 int send = max_dim;
 MPI_Allreduce( &send, &max_dim, 1, MPI_INT, MPI_MAX, *mpiComm );
 }
#endif
 
 // If input contained any polyhedra, then need to get faces
 // of the polyhedra before the next loop because we need to
 // read said faces in that loop.
 for( int i = 0; i < fileInfo->num_elem_desc; ++i )
 {
 EntityType type = CN::EntityTypeFromName( fileInfo->elems[i].type );
 if( type != MBPOLYHEDRON ) continue;
 
 debug_barrier();
 dbgOut.print( 2, " Getting polyhedra faces\n" );
 mpe_event.start( "reading connectivity for ", fileInfo->elems[i].handle );
 
 Range polyhedra;
 intersect( fileInfo->elems[i].desc, file_ids, polyhedra );
 rval = read_elems( i, polyhedra, &file_ids );
 mpe_event.end( rval );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 
 if( cputime ) _times[GET_POLYHEDRA_TIME] = timer->time_elapsed();
 // Get node file ids for all elements
 Range nodes;
 intersect( fileInfo->nodes, file_ids, nodes );
 for( int i = 0; i < fileInfo->num_elem_desc; ++i )
 {
 EntityType type = CN::EntityTypeFromName( fileInfo->elems[i].type );
 if( type <= MBVERTEX || type >= MBENTITYSET )
 {
 assert( false ); // For debug code die for unknown element types
 continue; // For release code, skip unknown element types
 }
 if( MBPOLYHEDRON == type ) continue;
 
 debug_barrier();
 dbgOut.printf( 2, " Getting element node IDs for: %s\n", fileInfo->elems[i].handle );
 
 Range subset;
 intersect( fileInfo->elems[i].desc, file_ids, subset );
 mpe_event.start( "reading connectivity for ", fileInfo->elems[i].handle );
 
 // If dimension is max_dim, then we can create the elements now
 // so we don't have to read the table again later (connectivity
 // will be fixed up after nodes are created when update_connectivity())
 // is called. For elements of a smaller dimension, we just build
 // the node ID range now because a) we'll have to read the whole
 // connectivity table again later, and b) we don't want to worry
 // about accidentally creating multiple copies of the same element.
 if( CN::Dimension( type ) == max_dim )
 rval = read_elems( i, subset, &nodes );
 else
 rval = read_elems( i, subset, nodes );
 mpe_event.end( rval );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 if( cputime ) _times[GET_ELEMENTS_TIME] = timer->time_elapsed();
 debug_barrier();
 mpe_event.start( "read coords" );
 dbgOut.tprintf( 1, "READING NODE COORDINATES (%lu nodes in %lu selects)\n", (unsigned long)nodes.size(),
 (unsigned long)nodes.psize() );
 
 // Read node coordinates and create vertices in MOAB
 // NOTE: This populates the RangeMap with node file ids,
 // which is expected by read_node_adj_elems.
 rval = read_nodes( nodes );
 mpe_event.end( rval );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 
 if( cputime ) _times[GET_NODES_TIME] = timer->time_elapsed();
 
 debug_barrier();
 dbgOut.tprint( 1, "READING ELEMENTS\n" );
 
 // Decide if we need to read additional elements
 enum SideMode
 {
 SM_EXPLICIT,
 SM_NODES,
 SM_SIDES
 };
 int side_mode;
 const char* const options[] = { "EXPLICIT", "NODES", "SIDES", 0 };
 rval = opts.match_option( "ELEMENTS", options, side_mode );
 if( MB_ENTITY_NOT_FOUND == rval )
 {
 // If only nodes were specified, then default to "NODES", otherwise
 // default to "SIDES".
 if( 0 == max_dim )
 side_mode = SM_NODES;
 else
 side_mode = SM_SIDES;
 }
 else if( MB_SUCCESS != rval )
 {
 MB_SET_ERR( rval, "Invalid value for 'ELEMENTS' option" );
 }
 
 if( side_mode == SM_SIDES /*ELEMENTS=SIDES*/ && max_dim == 0 /*node-based*/ )
 {
 // Read elements until we find something. Once we find something,
 // read only elements of the same dimension. NOTE: loop termination
 // criterion changes on both sides (max_dim can be changed in loop
 // body).
 for( int dim = 3; dim >= max_dim; --dim )
 {
 for( int i = 0; i < fileInfo->num_elem_desc; ++i )
 {
 EntityType type = CN::EntityTypeFromName( fileInfo->elems[i].type );
 if( CN::Dimension( type ) == dim )
 {
 debug_barrier();
 dbgOut.tprintf( 2, " Reading node-adjacent elements for: %s\n", fileInfo->elems[i].handle );
 mpe_event.start( "reading connectivity for ", fileInfo->elems[i].handle );
 Range ents;
 rval = read_node_adj_elems( fileInfo->elems[i] );
 mpe_event.end( rval );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 if( !ents.empty() ) max_dim = 3;
 }
 }
 }
 }
 
 if( cputime ) _times[GET_NODEADJ_TIME] = timer->time_elapsed();
 Range side_entities;
 if( side_mode != SM_EXPLICIT /*ELEMENTS=NODES || ELEMENTS=SIDES*/ )
 {
 if( 0 == max_dim ) max_dim = 4;
 // Now read any additional elements for which we've already read all
 // of the nodes.
 for( int dim = max_dim - 1; dim > 0; --dim )
 {
 for( int i = 0; i < fileInfo->num_elem_desc; ++i )
 {
 EntityType type = CN::EntityTypeFromName( fileInfo->elems[i].type );
 if( CN::Dimension( type ) == dim )
 {
 debug_barrier();
 dbgOut.tprintf( 2, " Reading node-adjacent elements for: %s\n", fileInfo->elems[i].handle );
 mpe_event.start( "reading connectivity for ", fileInfo->elems[i].handle );
 rval = read_node_adj_elems( fileInfo->elems[i], &side_entities );
 mpe_event.end( rval );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 }
 }
 }
 
 // We need to do this here for polyhedra to be handled correctly.
 // We have to wait until the faces are read in the above code block,
 // but need to create the connectivity before doing update_connectivity,
 // which might otherwise delete polyhedra faces.
 if( cputime ) _times[GET_SIDEELEM_TIME] = timer->time_elapsed();
 
 debug_barrier();
 dbgOut.tprint( 1, "UPDATING CONNECTIVITY ARRAYS FOR READ ELEMENTS\n" );
 mpe_event.start( "updating connectivity for elements read before vertices" );
 rval = update_connectivity();
 mpe_event.end();
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 
 if( cputime ) _times[UPDATECONN_TIME] = timer->time_elapsed();
 
 dbgOut.tprint( 1, "READING ADJACENCIES\n" );
 for( int i = 0; i < fileInfo->num_elem_desc; ++i )
 {
 if (fileInfo->elems[i].have_adj /*&&
 idMap.intersects(fileInfo->elems[i].desc.start_id, fileInfo->elems[i].desc.count) */)
 {
 mpe_event.start( "reading adjacencies for ", fileInfo->elems[i].handle );
 long len;
 hid_t th = mhdf_openAdjacency( filePtr, fileInfo->elems[i].handle, &len, &status );
 if( is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 
 rval = read_adjacencies( th, len );
 mhdf_closeData( filePtr, th, &status );
 mpe_event.end( rval );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 }
 
 if( cputime ) _times[ADJACENCY_TIME] = timer->time_elapsed();
 
 // If doing ELEMENTS=SIDES then we need to delete any entities
 // that we read that aren't actually sides (e.g. an interior face
 // that connects two disjoint portions of the part). Both
 // update_connectivity and reading of any explicit adjacencies must
 // happen before this.
 if( side_mode == SM_SIDES )
 {
 debug_barrier();
 mpe_event.start( "cleaning up non-side lower-dim elements" );
 dbgOut.tprint( 1, "CHECKING FOR AND DELETING NON-SIDE ELEMENTS\n" );
 rval = delete_non_side_elements( side_entities );
 mpe_event.end( rval );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 
 if( cputime ) _times[DELETE_NON_SIDEELEM_TIME] = timer->time_elapsed();
 
 debug_barrier();
 dbgOut.tprint( 1, "READING SETS\n" );
 
 // If reading contained/child sets but not their contents then find
 // them now. If we were also reading their contents we would
 // have found them already.
 if( content_mode == RSM_SETS || child_mode == RSM_SETS )
 {
 dbgOut.tprint( 1, " doing read_set_ids_recursive\n" );
 mpe_event.start( "finding recursively contained sets" );
 rval = read_set_ids_recursive( sets, content_mode == RSM_SETS, child_mode == RSM_SETS );
 mpe_event.end( rval );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 
 if( cputime ) _times[READ_SET_IDS_RECURS_TIME] = timer->time_elapsed();
 
 dbgOut.tprint( 1, " doing find_sets_containing\n" );
 mpe_event.start( "finding sets containing any read entities" );
 
 // Decide whether to read set-containing parents
 bool read_set_containing_parents = true;
 std::string tmp_opt;
 rval = opts.get_option( "NO_SET_CONTAINING_PARENTS", tmp_opt );
 if( MB_SUCCESS == rval ) read_set_containing_parents = false;
 
 // Append file IDs of sets containing any of the nodes or elements
 // we've read up to this point.
 rval = find_sets_containing( sets, read_set_containing_parents );
 mpe_event.end( rval );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 
 if( cputime ) _times[FIND_SETS_CONTAINING_TIME] = timer->time_elapsed();
 
 // Now actually read all set data and instantiate sets in MOAB.
 // Get any contained sets out of file_ids.
 mpe_event.start( "reading set contents/parents/children" );
 EntityHandle first_set = fileInfo->sets.start_id;
 sets.merge( file_ids.lower_bound( first_set ), file_ids.lower_bound( first_set + fileInfo->sets.count ) );
 dbgOut.tprint( 1, " doing read_sets\n" );
 rval = read_sets( sets );
 mpe_event.end( rval );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 
 if( cputime ) _times[READ_SETS_TIME] = timer->time_elapsed();
 
 dbgOut.tprint( 1, "READING TAGS\n" );
 
 for( int i = 0; i < fileInfo->num_tag_desc; ++i )
 {
 mpe_event.start( "reading tag: ", fileInfo->tags[i].name );
 rval = read_tag( i );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 
 if( cputime ) _times[READ_TAGS_TIME] = timer->time_elapsed();
 
 dbgOut.tprint( 1, "PARTIAL READ COMPLETE.\n" );
 
 return MB_SUCCESS;
}

References _times, ADJACENCY_TIME, CHECK_OPEN_HANDLES, mhdf_EntDesc::count, cputime, dbgOut, debug_barrier, delete_non_side_elements(), DELETE_NON_SIDEELEM_TIME, mhdf_ElemDesc::desc, dim, moab::CN::Dimension(), mhdf_FileDesc::elems, moab::Range::empty(), moab::CN::EntityTypeFromName(), ErrorCode, fileInfo, filePtr, find_sets_containing(), FIND_SETS_CONTAINING_TIME, GET_ELEMENTS_TIME, GET_NODEADJ_TIME, GET_NODES_TIME, moab::FileOptions::get_option(), get_partition(), GET_PARTITION_TIME, GET_POLYHEDRA_TIME, get_set_contents(), GET_SET_CONTENTS_TIME, GET_SET_IDS_TIME, GET_SIDEELEM_TIME, get_subset_ids(), mhdf_ElemDesc::handle, mhdf_ElemDesc::have_adj, moab::intersect(), is_error(), moab::Range::lower_bound(), moab::FileOptions::match_option(), MB_ENTITY_NOT_FOUND, MB_SET_ERR, MB_SUCCESS, MBENTITYSET, MBPOLYHEDRON, moab::Range::merge(), mhdf_closeData(), mhdf_openAdjacency(), mpiComm, mhdf_TagDesc::name, nativeParallel, mhdf_FileDesc::nodes, mhdf_FileDesc::num_elem_desc, mhdf_FileDesc::num_tag_desc, moab::ReaderIface::IDTag::num_tag_values, moab::DebugOutput::print(), moab::DebugOutput::print_ints(), moab::DebugOutput::printf(), moab::Range::psize(), read_adjacencies(), read_elems(), read_node_adj_elems(), read_nodes(), READ_SET_IDS_RECURS_TIME, read_set_ids_recursive(), read_sets(), READ_SETS_TIME, read_tag(), READ_TAGS_TIME, mhdf_FileDesc::sets, moab::Range::size(), mhdf_EntDesc::start_id, SUBSET_IDS_TIME, moab::ReaderIface::IDTag::tag_values, mhdf_FileDesc::tags, moab::CpuTimer::time_elapsed(), timer, moab::DebugOutput::tprint(), moab::DebugOutput::tprintf(), mhdf_ElemDesc::type, update_connectivity(), and UPDATECONN_TIME.

Referenced by load_file().

moab()

Interface* moab::ReadHDF5::moab ( ) const

inline

Definition at line 77 of file ReadHDF5.hpp.

 {
 return iFace;
 }

References iFace.

Referenced by read_poly(), read_set_data(), and read_var_len_tag().

print_times()

void moab::ReadHDF5::print_times ( )

protected

Definition at line 3953 of file ReadHDF5.cpp.

{
#ifdef MOAB_HAVE_MPI
 if( !myPcomm )
 {
 double recv[NUM_TIMES];
 MPI_Reduce( (void*)_times, recv, NUM_TIMES, MPI_DOUBLE, MPI_MAX, 0, myPcomm->proc_config().proc_comm() );
 for( int i = 0; i < NUM_TIMES; i++ )
 _times[i] = recv[i]; // just get the max from all of them
 }
 if( 0 == myPcomm->proc_config().proc_rank() )
 {
#endif
 
 std::cout << "ReadHDF5: " << _times[TOTAL_TIME] << std::endl
 << " get set meta " << _times[SET_META_TIME] << std::endl
 << " partial subsets " << _times[SUBSET_IDS_TIME] << std::endl
 << " partition time " << _times[GET_PARTITION_TIME] << std::endl
 << " get set ids " << _times[GET_SET_IDS_TIME] << std::endl
 << " set contents " << _times[GET_SET_CONTENTS_TIME] << std::endl
 << " polyhedra " << _times[GET_POLYHEDRA_TIME] << std::endl
 << " elements " << _times[GET_ELEMENTS_TIME] << std::endl
 << " nodes " << _times[GET_NODES_TIME] << std::endl
 << " node adjacency " << _times[GET_NODEADJ_TIME] << std::endl
 << " side elements " << _times[GET_SIDEELEM_TIME] << std::endl
 << " update connectivity " << _times[UPDATECONN_TIME] << std::endl
 << " adjacency " << _times[ADJACENCY_TIME] << std::endl
 << " delete non_adj " << _times[DELETE_NON_SIDEELEM_TIME] << std::endl
 << " recursive sets " << _times[READ_SET_IDS_RECURS_TIME] << std::endl
 << " find contain_sets " << _times[FIND_SETS_CONTAINING_TIME] << std::endl
 << " read sets " << _times[READ_SETS_TIME] << std::endl
 << " read tags " << _times[READ_TAGS_TIME] << std::endl
 << " store file ids " << _times[STORE_FILE_IDS_TIME] << std::endl
 << " read qa records " << _times[READ_QA_TIME] << std::endl;
 
#ifdef MOAB_HAVE_MPI
 }
#endif
}

References _times, ADJACENCY_TIME, DELETE_NON_SIDEELEM_TIME, FIND_SETS_CONTAINING_TIME, GET_ELEMENTS_TIME, GET_NODEADJ_TIME, GET_NODES_TIME, GET_PARTITION_TIME, GET_POLYHEDRA_TIME, GET_SET_CONTENTS_TIME, GET_SET_IDS_TIME, GET_SIDEELEM_TIME, myPcomm, NUM_TIMES, moab::ProcConfig::proc_comm(), moab::ParallelComm::proc_config(), moab::ProcConfig::proc_rank(), READ_QA_TIME, READ_SET_IDS_RECURS_TIME, READ_SETS_TIME, READ_TAGS_TIME, SET_META_TIME, STORE_FILE_IDS_TIME, SUBSET_IDS_TIME, TOTAL_TIME, and UPDATECONN_TIME.

Referenced by load_file().

read_adjacencies()

ErrorCode moab::ReadHDF5::read_adjacencies ( hid_t  adjacency_table, long  table_length  )

private

Definition at line 2640 of file ReadHDF5.cpp.

{
 CHECK_OPEN_HANDLES;
 
 ErrorCode rval;
 mhdf_Status status;
 
 debug_barrier();
 
 hid_t read_type = H5Dget_type( table );
 if( read_type < 0 ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 const bool convert = !H5Tequal( read_type, handleType );
 
 EntityHandle* buffer = (EntityHandle*)dataBuffer;
 size_t chunk_size = bufferSize / H5Tget_size( read_type );
 size_t remaining = table_len;
 size_t left_over = 0;
 size_t offset = 0;
 dbgOut.printf( 3, "Reading adjacency list in %lu chunks\n",
 (unsigned long)( remaining + chunk_size - 1 ) / chunk_size );
 int nn = 0;
 while( remaining )
 {
 dbgOut.printf( 3, "Reading chunk %d of adjacency list\n", ++nn );
 
 size_t count = std::min( chunk_size, remaining );
 count -= left_over;
 remaining -= count;
 
 assert_range( buffer + left_over, count );
 mhdf_readAdjacencyWithOpt( table, offset, count, read_type, buffer + left_over, collIO, &status );
 if( is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 
 if( convert )
 {
 herr_t err = H5Tconvert( read_type, handleType, count, buffer + left_over, 0, H5P_DEFAULT );
 if( err < 0 ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 
 EntityHandle* iter = buffer;
 EntityHandle* end = buffer + count + left_over;
 while( end - iter >= 3 )
 {
 EntityHandle h = idMap.find( *iter++ );
 EntityHandle count2 = *iter++;
 if( !h )
 {
 iter += count2;
 continue;
 }
 
 if( count2 < 1 ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 
 if( end < count2 + iter )
 {
 iter -= 2;
 break;
 }
 
 size_t valid;
 convert_id_to_handle( iter, count2, valid, idMap );
 rval = iFace->add_adjacencies( h, iter, valid, false );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 
 iter += count2;
 }
 
 left_over = end - iter;
 assert_range( (char*)buffer, left_over );
 assert_range( (char*)iter, left_over );
 memmove( buffer, iter, left_over );
 }
 
 assert( !left_over ); // Unexpected truncation of data
 
 return MB_SUCCESS;
}

References moab::Interface::add_adjacencies(), assert_range, buffer, bufferSize, CHECK_OPEN_HANDLES, collIO, convert_id_to_handle(), dataBuffer, dbgOut, debug_barrier, ErrorCode, moab::RangeMap< KeyType, ValType, NullVal >::find(), handleType, idMap, iFace, is_error(), MB_SET_ERR, MB_SUCCESS, mhdf_readAdjacencyWithOpt(), and moab::DebugOutput::printf().

Referenced by load_file_impl(), and load_file_partial().

read_all_set_meta()

ErrorCode moab::ReadHDF5::read_all_set_meta ( )

private

Definition at line 1982 of file ReadHDF5.cpp.

{
 CHECK_OPEN_HANDLES;
 
 assert( !setMeta );
 const long num_sets = fileInfo->sets.count;
 if( !num_sets ) return MB_SUCCESS;
 
 mhdf_Status status;
 hid_t handle = mhdf_openSetMetaSimple( filePtr, &status );
 if( is_error( status ) )
 {
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 
 // Allocate extra space if we need it for data conversion
 hid_t meta_type = H5Dget_type( handle );
 size_t size = H5Tget_size( meta_type );
 if( size > sizeof( long ) )
 setMeta = new long[( num_sets * size + ( sizeof( long ) - 1 ) ) / sizeof( long )][4];
 else
 setMeta = new long[num_sets][4];
 
 // Set some parameters based on whether or not each proc reads the
 // table or only the root reads it and bcasts it to the others
 int rank = 0;
 bool bcast = false;
 hid_t ioprop = H5P_DEFAULT;
#ifdef MOAB_HAVE_MPI
 MPI_Comm comm = 0;
 if( nativeParallel )
 {
 rank = myPcomm->proc_config().proc_rank();
 comm = myPcomm->proc_config().proc_comm();
 bcast = bcastDuplicateReads;
 if( !bcast ) ioprop = collIO;
 }
#endif
 
 if( !bcast || 0 == rank )
 {
 mhdf_readSetMetaWithOpt( handle, 0, num_sets, meta_type, setMeta, ioprop, &status );
 if( is_error( status ) )
 {
 H5Tclose( meta_type );
 mhdf_closeData( filePtr, handle, &status );
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 
 H5Tconvert( meta_type, H5T_NATIVE_LONG, num_sets * 4, setMeta, 0, H5P_DEFAULT );
 }
 mhdf_closeData( filePtr, handle, &status );
 if( is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 H5Tclose( meta_type );
 
 if( bcast )
 {
#ifdef MOAB_HAVE_MPI
 int ierr = MPI_Bcast( (void*)setMeta, num_sets * 4, MPI_LONG, 0, comm );
 if( MPI_SUCCESS != ierr ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
#else
 assert( rank == 0 ); // If not MPI, then only one proc
#endif
 }
 
 return MB_SUCCESS;
}

References bcastDuplicateReads, CHECK_OPEN_HANDLES, collIO, mhdf_EntDesc::count, fileInfo, filePtr, is_error(), MB_SET_ERR, MB_SUCCESS, mhdf_closeData(), mhdf_openSetMetaSimple(), mhdf_readSetMetaWithOpt(), myPcomm, nativeParallel, moab::ProcConfig::proc_comm(), moab::ParallelComm::proc_config(), moab::ProcConfig::proc_rank(), setMeta, mhdf_FileDesc::sets, and size.

Referenced by load_file().

read_dense_tag()

ErrorCode moab::ReadHDF5::read_dense_tag ( Tag  tag_handle, const char *  ent_name, hid_t  hdf_read_type, hid_t  data_table, long  start_id, long  count  )

private

Read dense tag for all entities.

Definition at line 3043 of file ReadHDF5.cpp.

{
 CHECK_OPEN_HANDLES;
 
 ErrorCode rval;
 DataType mb_type;
 
 rval = iFace->tag_get_data_type( tag_handle, mb_type );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 
 int read_size;
 rval = iFace->tag_get_bytes( tag_handle, read_size );
 if( MB_SUCCESS != rval ) // Wrong function for variable-length tags
 MB_SET_ERR( rval, "ReadHDF5 Failure" );
 // if (MB_TYPE_BIT == mb_type)
 // read_size = (read_size + 7) / 8; // Convert bits to bytes, plus 7 for ceiling
 
 if( hdf_read_type )
 { // If not opaque
 hsize_t hdf_size = H5Tget_size( hdf_read_type );
 if( hdf_size != (hsize_t)read_size ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 
 // Get actual entities read from file
 Range file_ids, handles;
 Range::iterator f_ins = file_ids.begin(), h_ins = handles.begin();
 IDMap::iterator l, u;
 l = idMap.lower_bound( start_id );
 u = idMap.lower_bound( start_id + num_values - 1 );
 if( l != idMap.end() && start_id + num_values > l->begin )
 {
 if( l == u )
 {
 size_t beg = std::max( start_id, l->begin );
 size_t end = std::min( start_id + num_values, u->begin + u->count ) - 1;
 f_ins = file_ids.insert( f_ins, beg, end );
 h_ins = handles.insert( h_ins, l->value + ( beg - l->begin ), l->value + ( end - l->begin ) );
 }
 else
 {
 size_t beg = std::max( start_id, l->begin );
 f_ins = file_ids.insert( f_ins, beg, l->begin + l->count - 1 );
 h_ins = handles.insert( h_ins, l->value + ( beg - l->begin ), l->value + l->count - 1 );
 for( ++l; l != u; ++l )
 {
 f_ins = file_ids.insert( f_ins, l->begin, l->begin + l->count - 1 );
 h_ins = handles.insert( h_ins, l->value, l->value + l->count - 1 );
 }
 if( u != idMap.end() && u->begin < start_id + num_values )
 {
 size_t end = std::min( start_id + num_values, u->begin + u->count - 1 );
 f_ins = file_ids.insert( f_ins, u->begin, end );
 h_ins = handles.insert( h_ins, u->value, u->value + end - u->begin );
 }
 }
 }
 
 // Given that all of the entities for this dense tag data should
 // have been created as a single contiguous block, the resulting
 // MOAB handle range should be contiguous.
 // THE ABOVE IS NOT NECESSARILY TRUE. SOMETIMES LOWER-DIMENSION
 // ENTS ARE READ AND THEN DELETED FOR PARTIAL READS.
 // assert(handles.empty() || handles.size() == (handles.back() - handles.front() + 1));
 
 std::string tn( "<error>" );
 iFace->tag_get_name( tag_handle, tn );
 tn += " data for ";
 tn += ent_name;
 try
 {
 h_ins = handles.begin();
 ReadHDF5Dataset reader( tn.c_str(), data, nativeParallel, mpiComm, false );
 long buffer_size = bufferSize / read_size;
 reader.set_file_ids( file_ids, start_id, buffer_size, hdf_read_type );
 dbgOut.printf( 3, "Reading dense data for tag \"%s\" and group \"%s\" in %lu chunks\n", tn.c_str(), ent_name,
 reader.get_read_count() );
 int nn = 0;
 while( !reader.done() )
 {
 dbgOut.printf( 3, "Reading chunk %d of \"%s\" data\n", ++nn, tn.c_str() );
 
 size_t count;
 reader.read( dataBuffer, count );
 
 if( MB_TYPE_HANDLE == mb_type )
 {
 rval = convert_id_to_handle( (EntityHandle*)dataBuffer, count * read_size / sizeof( EntityHandle ) );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 
 Range ents;
 Range::iterator end = h_ins;
 end += count;
 ents.insert( h_ins, end );
 h_ins = end;
 
 rval = iFace->tag_set_data( tag_handle, ents, dataBuffer );
 if( MB_SUCCESS != rval )
 {
 dbgOut.printf( 1, "Internal error setting data for tag \"%s\"\n", tn.c_str() );
 MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 }
 }
 catch( ReadHDF5Dataset::Exception )
 {
 dbgOut.printf( 1, "Internal error reading dense data for tag \"%s\"\n", tn.c_str() );
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 
 return MB_SUCCESS;
}

References moab::Range::begin(), bufferSize, CHECK_OPEN_HANDLES, convert_id_to_handle(), dataBuffer, dbgOut, moab::ReadHDF5Dataset::done(), moab::RangeMap< KeyType, ValType, NullVal >::end(), ErrorCode, moab::ReadHDF5Dataset::get_read_count(), idMap, iFace, moab::Range::insert(), moab::RangeMap< KeyType, ValType, NullVal >::lower_bound(), MB_SET_ERR, MB_SUCCESS, MB_TYPE_HANDLE, mpiComm, nativeParallel, moab::DebugOutput::printf(), moab::ReadHDF5Dataset::read(), moab::ReadHDF5Dataset::set_file_ids(), moab::Interface::tag_get_bytes(), moab::Interface::tag_get_data_type(), moab::Interface::tag_get_name(), and moab::Interface::tag_set_data().

Referenced by read_tag().

read_elems() [1/4]

ErrorCode moab::ReadHDF5::read_elems ( const mhdf_ElemDesc &  elems, const Range &  file_ids, Range *  node_ids = 0  )

private

Read element connectivity.

Parameters

node_ids

If this is non-null, the union of the connectivity list for all elements is passed back as FILE IDS in this range AND the connectivity list is left in the form of file IDs (NOT NODE HANDLES).

Definition at line 1526 of file ReadHDF5.cpp.

{
 CHECK_OPEN_HANDLES;
 
 debug_barrier();
 dbgOut.tprintf( 1, "READING %s CONNECTIVITY (%lu elems in %lu selects)\n", elems.handle,
 (unsigned long)file_ids.size(), (unsigned long)file_ids.psize() );
 
 ErrorCode rval = MB_SUCCESS;
 mhdf_Status status;
 
 EntityType type = CN::EntityTypeFromName( elems.type );
 if( type == MBMAXTYPE )
 {
 MB_SET_ERR( MB_FAILURE, "Unknown element type: \"" << elems.type << "\"" );
 }
 
 const int nodes_per_elem = elems.desc.vals_per_ent;
 const size_t count = file_ids.size();
 hid_t data_id = mhdf_openConnectivitySimple( filePtr, elems.handle, &status );
 if( is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 
 EntityHandle handle;
 EntityHandle* array = 0;
 if( count > 0 ) rval = readUtil->get_element_connect( count, nodes_per_elem, type, 0, handle, array );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 
 try
 {
 EntityHandle* buffer = reinterpret_cast< EntityHandle* >( dataBuffer );
 const size_t buffer_size = bufferSize / ( sizeof( EntityHandle ) * nodes_per_elem );
 ReadHDF5Dataset reader( elems.handle, data_id, nativeParallel, mpiComm );
 reader.set_file_ids( file_ids, elems.desc.start_id, buffer_size, handleType );
 dbgOut.printf( 3, "Reading connectivity in %lu chunks for element group \"%s\"\n", reader.get_read_count(),
 elems.handle );
 EntityHandle* iter = array;
 int nn = 0;
 while( !reader.done() )
 {
 dbgOut.printf( 3, "Reading chunk %d for \"%s\"\n", ++nn, elems.handle );
 
 size_t num_read;
 reader.read( buffer, num_read );
 iter = std::copy( buffer, buffer + num_read * nodes_per_elem, iter );
 
 if( node_ids )
 {
 std::sort( buffer, buffer + num_read * nodes_per_elem );
 num_read = std::unique( buffer, buffer + num_read * nodes_per_elem ) - buffer;
 copy_sorted_file_ids( buffer, num_read, *node_ids );
 }
 }
 assert( iter - array == (ptrdiff_t)count * nodes_per_elem );
 }
 catch( ReadHDF5Dataset::Exception )
 {
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 
 if( !node_ids )
 {
 rval = convert_id_to_handle( array, count * nodes_per_elem );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 
 rval = readUtil->update_adjacencies( handle, count, nodes_per_elem, array );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 else
 {
 IDConnectivity t;
 t.handle = handle;
 t.count = count;
 t.nodes_per_elem = nodes_per_elem;
 t.array = array;
 idConnectivityList.push_back( t );
 }
 
 return insert_in_id_map( file_ids, handle );
}

References buffer, bufferSize, CHECK_OPEN_HANDLES, convert_id_to_handle(), moab::copy_sorted_file_ids(), dataBuffer, dbgOut, debug_barrier, mhdf_ElemDesc::desc, moab::ReadHDF5Dataset::done(), moab::CN::EntityTypeFromName(), ErrorCode, filePtr, moab::ReadUtilIface::get_element_connect(), moab::ReadHDF5Dataset::get_read_count(), mhdf_ElemDesc::handle, handleType, idConnectivityList, insert_in_id_map(), is_error(), MB_SET_ERR, MB_SUCCESS, MBMAXTYPE, mhdf_openConnectivitySimple(), mpiComm, nativeParallel, moab::DebugOutput::printf(), moab::Range::psize(), moab::ReadHDF5Dataset::read(), readUtil, moab::ReadHDF5Dataset::set_file_ids(), moab::Range::size(), mhdf_EntDesc::start_id, t, moab::DebugOutput::tprintf(), mhdf_ElemDesc::type, moab::ReadUtilIface::update_adjacencies(), and mhdf_EntDesc::vals_per_ent.

read_elems() [2/4]

ErrorCode moab::ReadHDF5::read_elems ( int  index )

private

Definition at line 1506 of file ReadHDF5.cpp.

{
 Range ids;
 ids.insert( fileInfo->elems[i].desc.start_id,
 fileInfo->elems[i].desc.start_id + fileInfo->elems[i].desc.count - 1 );
 return read_elems( i, ids );
}

References mhdf_EntDesc::count, mhdf_ElemDesc::desc, mhdf_FileDesc::elems, fileInfo, moab::Range::insert(), and mhdf_EntDesc::start_id.

Referenced by load_file_impl(), load_file_partial(), and read_elems().

read_elems() [3/4]

ErrorCode moab::ReadHDF5::read_elems ( int  index, const Range &  element_file_ids, Range &  node_file_ids  )

private

Definition at line 1740 of file ReadHDF5.cpp.

{
 CHECK_OPEN_HANDLES;
 
 debug_barrier();
 dbgOut.tprintf( 1, "READING %s CONNECTIVITY (%lu elems in %lu selects)\n", fileInfo->elems[i].handle,
 (unsigned long)elems_in.size(), (unsigned long)elems_in.psize() );
 
 EntityHandle* const buffer = reinterpret_cast< EntityHandle* >( dataBuffer );
 const int node_per_elem = fileInfo->elems[i].desc.vals_per_ent;
 const size_t buffer_size = bufferSize / ( node_per_elem * sizeof( EntityHandle ) );
 
 if( elems_in.empty() ) return MB_SUCCESS;
 
 assert( (long)elems_in.front() >= fileInfo->elems[i].desc.start_id );
 assert( (long)elems_in.back() - fileInfo->elems[i].desc.start_id < fileInfo->elems[i].desc.count );
 
 // We don't support version 3 style poly element data
 if( fileInfo->elems[i].desc.vals_per_ent <= 0 ) MB_CHK_ERR( MB_TYPE_OUT_OF_RANGE );
 
 mhdf_Status status;
 hid_t table = mhdf_openConnectivitySimple( filePtr, fileInfo->elems[i].handle, &status );
 if( is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 
 try
 {
 ReadHDF5Dataset reader( fileInfo->elems[i].handle, table, nativeParallel, mpiComm );
 reader.set_file_ids( elems_in, fileInfo->elems[i].desc.start_id, buffer_size, handleType );
 dbgOut.printf( 3, "Reading node list in %lu chunks for \"%s\"\n", reader.get_read_count(),
 fileInfo->elems[i].handle );
 int nn = 0;
 while( !reader.done() )
 {
 dbgOut.printf( 3, "Reading chunk %d of \"%s\" connectivity\n", ++nn, fileInfo->elems[i].handle );
 size_t num_read;
 reader.read( buffer, num_read );
 std::sort( buffer, buffer + num_read * node_per_elem );
 num_read = std::unique( buffer, buffer + num_read * node_per_elem ) - buffer;
 copy_sorted_file_ids( buffer, num_read, nodes );
 }
 }
 catch( ReadHDF5Dataset::Exception )
 {
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 
 return MB_SUCCESS;
}

References moab::Range::back(), buffer, bufferSize, CHECK_OPEN_HANDLES, moab::copy_sorted_file_ids(), mhdf_EntDesc::count, dataBuffer, dbgOut, debug_barrier, mhdf_ElemDesc::desc, moab::ReadHDF5Dataset::done(), mhdf_FileDesc::elems, moab::Range::empty(), fileInfo, filePtr, moab::Range::front(), moab::ReadHDF5Dataset::get_read_count(), mhdf_ElemDesc::handle, handleType, is_error(), MB_CHK_ERR, MB_SET_ERR, MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, mhdf_openConnectivitySimple(), mpiComm, nativeParallel, moab::DebugOutput::printf(), moab::Range::psize(), moab::ReadHDF5Dataset::read(), moab::ReadHDF5Dataset::set_file_ids(), moab::Range::size(), mhdf_EntDesc::start_id, moab::DebugOutput::tprintf(), and mhdf_EntDesc::vals_per_ent.

read_elems() [4/4]

ErrorCode moab::ReadHDF5::read_elems ( int  index, const Range &  file_ids, Range *  node_ids = 0  )

private

Definition at line 1514 of file ReadHDF5.cpp.

{
 if( fileInfo->elems[i].desc.vals_per_ent < 0 )
 {
 if( node_ids != 0 ) // Not implemented for version 3 format of poly data
 MB_CHK_ERR( MB_TYPE_OUT_OF_RANGE );
 return read_poly( fileInfo->elems[i], file_ids );
 }
 else
 return read_elems( fileInfo->elems[i], file_ids, node_ids );
}

References mhdf_ElemDesc::desc, mhdf_FileDesc::elems, fileInfo, MB_CHK_ERR, MB_TYPE_OUT_OF_RANGE, read_elems(), read_poly(), and mhdf_EntDesc::vals_per_ent.

read_node_adj_elems() [1/2]

ErrorCode moab::ReadHDF5::read_node_adj_elems ( const mhdf_ElemDesc &  group, hid_t  connectivity_handle, Range *  read_entities = 0  )

private

Definition at line 1641 of file ReadHDF5.cpp.

{
 CHECK_OPEN_HANDLES;
 
 debug_barrier();
 
 mhdf_Status status;
 ErrorCode rval;
 IODebugTrack debug_track( debugTrack, std::string( group.handle ) );
 
 // Copy data to local variables (makes other code clearer)
 const int node_per_elem = group.desc.vals_per_ent;
 long start_id = group.desc.start_id;
 long remaining = group.desc.count;
 const EntityType type = CN::EntityTypeFromName( group.type );
 
 // Figure out how many elements we can read in each pass
 long* const buffer = reinterpret_cast< long* >( dataBuffer );
 const long buffer_size = bufferSize / ( node_per_elem * sizeof( buffer[0] ) );
 // Read all element connectivity in buffer_size blocks
 long offset = 0;
 dbgOut.printf( 3, "Reading node-adjacent elements from \"%s\" in %ld chunks\n", group.handle,
 ( remaining + buffer_size - 1 ) / buffer_size );
 int nn = 0;
 Range::iterator hint;
 if( handles_out ) hint = handles_out->begin();
 while( remaining )
 {
 dbgOut.printf( 3, "Reading chunk %d of connectivity data for \"%s\"\n", ++nn, group.handle );
 
 // Read a block of connectivity data
 const long count = std::min( remaining, buffer_size );
 debug_track.record_io( offset, count );
 assert_range( buffer, count * node_per_elem );
 mhdf_readConnectivityWithOpt( table_handle, offset, count, H5T_NATIVE_LONG, buffer, collIO, &status );
 if( is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 offset += count;
 remaining -= count;
 
 // Count the number of elements in the block that we want,
 // zero connectivity for other elements
 long num_elem = 0;
 long* iter = buffer;
 for( long i = 0; i < count; ++i )
 {
 for( int j = 0; j < node_per_elem; ++j )
 {
 iter[j] = (long)idMap.find( iter[j] );
 if( !iter[j] )
 {
 iter[0] = 0;
 break;
 }
 }
 if( iter[0] ) ++num_elem;
 iter += node_per_elem;
 }
 
 if( !num_elem )
 {
 start_id += count;
 continue;
 }
 
 // Create elements
 EntityHandle handle;
 EntityHandle* array;
 rval = readUtil->get_element_connect( (int)num_elem, node_per_elem, type, 0, handle, array );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 
 // Copy all non-zero connectivity values
 iter = buffer;
 EntityHandle* iter2 = array;
 EntityHandle h = handle;
 for( long i = 0; i < count; ++i )
 {
 if( !*iter )
 {
 iter += node_per_elem;
 continue;
 }
 if( !idMap.insert( start_id + i, h++, 1 ).second ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 
 long* const end = iter + node_per_elem;
 for( ; iter != end; ++iter, ++iter2 )
 *iter2 = (EntityHandle)*iter;
 }
 assert( iter2 - array == num_elem * node_per_elem );
 start_id += count;
 
 rval = readUtil->update_adjacencies( handle, num_elem, node_per_elem, array );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 if( handles_out ) hint = handles_out->insert( hint, handle, handle + num_elem - 1 );
 }
 
 debug_track.all_reduce();
 return MB_SUCCESS;
}

References moab::IODebugTrack::all_reduce(), assert_range, moab::Range::begin(), buffer, bufferSize, CHECK_OPEN_HANDLES, collIO, mhdf_EntDesc::count, dataBuffer, dbgOut, debug_barrier, debugTrack, mhdf_ElemDesc::desc, moab::CN::EntityTypeFromName(), ErrorCode, moab::RangeMap< KeyType, ValType, NullVal >::find(), moab::ReadUtilIface::get_element_connect(), mhdf_ElemDesc::handle, idMap, moab::Range::insert(), moab::RangeMap< KeyType, ValType, NullVal >::insert(), is_error(), MB_SET_ERR, MB_SUCCESS, mhdf_readConnectivityWithOpt(), moab::DebugOutput::printf(), readUtil, moab::IODebugTrack::record_io(), mhdf_EntDesc::start_id, mhdf_ElemDesc::type, moab::ReadUtilIface::update_adjacencies(), and mhdf_EntDesc::vals_per_ent.

read_node_adj_elems() [2/2]

ErrorCode moab::ReadHDF5::read_node_adj_elems ( const mhdf_ElemDesc &  group, Range *  read_entities = 0  )

private

Definition at line 1623 of file ReadHDF5.cpp.

{
 mhdf_Status status;
 ErrorCode rval;
 
 CHECK_OPEN_HANDLES;
 
 hid_t table = mhdf_openConnectivitySimple( filePtr, group.handle, &status );
 if( is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 
 rval = read_node_adj_elems( group, table, handles_out );
 
 mhdf_closeData( filePtr, table, &status );
 if( MB_SUCCESS == rval && is_error( status ) ) MB_SET_ERR_RET_VAL( "ReadHDF5 Failure", MB_FAILURE );
 
 return rval;
}

References CHECK_OPEN_HANDLES, ErrorCode, filePtr, mhdf_ElemDesc::handle, is_error(), MB_SET_ERR, MB_SET_ERR_RET_VAL, MB_SUCCESS, mhdf_closeData(), and mhdf_openConnectivitySimple().

Referenced by load_file_partial().

read_nodes()

ErrorCode moab::ReadHDF5::read_nodes ( const Range &  node_file_ids )

private

Definition at line 1395 of file ReadHDF5.cpp.

{
 ErrorCode rval;
 mhdf_Status status;
 const int dim = fileInfo->nodes.vals_per_ent;
 Range range;
 
 CHECK_OPEN_HANDLES;
 
 if( node_file_ids.empty() && !nativeParallel ) return MB_SUCCESS;
 
 int cdim;
 rval = iFace->get_dimension( cdim );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 
 if( cdim < dim )
 {
 rval = iFace->set_dimension( dim );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 
 hid_t data_id = mhdf_openNodeCoordsSimple( filePtr, &status );
 if( is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 
 EntityHandle handle;
 std::vector< double* > arrays( dim );
 const size_t num_nodes = node_file_ids.size();
 if( num_nodes > 0 )
 {
 rval = readUtil->get_node_coords( dim, (int)num_nodes, 0, handle, arrays );
 if( MB_SUCCESS != rval )
 {
 mhdf_closeData( filePtr, data_id, &status );
 MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 }
 
 if( blockedCoordinateIO )
 {
 try
 {
 for( int d = 0; d < dim; ++d )
 {
 ReadHDF5Dataset reader( "blocked coords", data_id, nativeParallel, mpiComm, false );
 reader.set_column( d );
 reader.set_file_ids( node_file_ids, fileInfo->nodes.start_id, num_nodes, H5T_NATIVE_DOUBLE );
 dbgOut.printf( 3, "Reading %lu chunks for coordinate dimension %d\n", reader.get_read_count(), d );
 // Should normally only have one read call, unless sparse nature
 // of file_ids caused reader to do something strange
 size_t count, offset = 0;
 int nn = 0;
 while( !reader.done() )
 {
 dbgOut.printf( 3, "Reading chunk %d for dimension %d\n", ++nn, d );
 reader.read( arrays[d] + offset, count );
 offset += count;
 }
 if( offset != num_nodes )
 {
 mhdf_closeData( filePtr, data_id, &status );
 assert( false );
 return MB_FAILURE;
 }
 }
 }
 catch( ReadHDF5Dataset::Exception )
 {
 mhdf_closeData( filePtr, data_id, &status );
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 }
 else
 { // !blockedCoordinateIO
 double* buffer = (double*)dataBuffer;
 long chunk_size = bufferSize / ( 3 * sizeof( double ) );
 long coffset = 0;
 int nn = 0;
 try
 {
 ReadHDF5Dataset reader( "interleaved coords", data_id, nativeParallel, mpiComm, false );
 reader.set_file_ids( node_file_ids, fileInfo->nodes.start_id, chunk_size, H5T_NATIVE_DOUBLE );
 dbgOut.printf( 3, "Reading %lu chunks for coordinate coordinates\n", reader.get_read_count() );
 while( !reader.done() )
 {
 dbgOut.tprintf( 3, "Reading chunk %d of node coords\n", ++nn );
 
 size_t count;
 reader.read( buffer, count );
 
 for( size_t i = 0; i < count; ++i )
 for( int d = 0; d < dim; ++d )
 arrays[d][coffset + i] = buffer[dim * i + d];
 coffset += count;
 }
 }
 catch( ReadHDF5Dataset::Exception )
 {
 mhdf_closeData( filePtr, data_id, &status );
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 }
 
 dbgOut.print( 3, "Closing node coordinate table\n" );
 mhdf_closeData( filePtr, data_id, &status );
 for( int d = dim; d < cdim; ++d )
 memset( arrays[d], 0, num_nodes * sizeof( double ) );
 
 dbgOut.printf( 3, "Updating ID to handle map for %lu nodes\n", (unsigned long)node_file_ids.size() );
 return insert_in_id_map( node_file_ids, handle );
}

References blockedCoordinateIO, buffer, bufferSize, CHECK_OPEN_HANDLES, dataBuffer, dbgOut, dim, moab::ReadHDF5Dataset::done(), moab::Range::empty(), ErrorCode, fileInfo, filePtr, moab::Interface::get_dimension(), moab::ReadUtilIface::get_node_coords(), moab::ReadHDF5Dataset::get_read_count(), iFace, insert_in_id_map(), is_error(), MB_SET_ERR, MB_SUCCESS, mhdf_closeData(), mhdf_openNodeCoordsSimple(), mpiComm, nativeParallel, mhdf_FileDesc::nodes, moab::DebugOutput::print(), moab::DebugOutput::printf(), moab::ReadHDF5Dataset::read(), readUtil, moab::ReadHDF5Dataset::set_column(), moab::Interface::set_dimension(), moab::ReadHDF5Dataset::set_file_ids(), moab::Range::size(), mhdf_EntDesc::start_id, moab::DebugOutput::tprintf(), and mhdf_EntDesc::vals_per_ent.

Referenced by load_file_impl(), and load_file_partial().

read_poly()

ErrorCode moab::ReadHDF5::read_poly ( const mhdf_ElemDesc &  elems, const Range &  file_ids  )

private

Read poly(gons|hedra)

Definition at line 1789 of file ReadHDF5.cpp.

{
 class PolyReader : public ReadHDF5VarLen
 {
 private:
 const EntityType type;
 ReadHDF5* readHDF5;
 
 public:
 PolyReader( EntityType elem_type, void* buffer, size_t buffer_size, ReadHDF5* owner, DebugOutput& dbg )
 : ReadHDF5VarLen( dbg, buffer, buffer_size ), type( elem_type ), readHDF5( owner )
 {
 }
 virtual ~PolyReader() {}
 ErrorCode store_data( EntityHandle file_id, void* data, long len, bool )
 {
 size_t valid;
 EntityHandle* conn = reinterpret_cast< EntityHandle* >( data );
 readHDF5->convert_id_to_handle( conn, len, valid );
 if( valid != (size_t)len ) MB_CHK_ERR( MB_ENTITY_NOT_FOUND );
 EntityHandle handle;
 ErrorCode rval = readHDF5->moab()->create_element( type, conn, len, handle );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 
 rval = readHDF5->insert_in_id_map( file_id, handle );
 return rval;
 }
 };
 
 CHECK_OPEN_HANDLES;
 
 debug_barrier();
 
 EntityType type = CN::EntityTypeFromName( elems.type );
 if( type == MBMAXTYPE )
 {
 MB_SET_ERR( MB_FAILURE, "Unknown element type: \"" << elems.type << "\"" );
 }
 
 hid_t handles[2];
 mhdf_Status status;
 long num_poly, num_conn, first_id;
 mhdf_openPolyConnectivity( filePtr, elems.handle, &num_poly, &num_conn, &first_id, handles, &status );
 if( is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 
 std::string nm( elems.handle );
 ReadHDF5Dataset offset_reader( ( nm + " offsets" ).c_str(), handles[0], nativeParallel, mpiComm, true );
 ReadHDF5Dataset connect_reader( ( nm + " data" ).c_str(), handles[1], nativeParallel, mpiComm, true );
 
 PolyReader tool( type, dataBuffer, bufferSize, this, dbgOut );
 return tool.read( offset_reader, connect_reader, file_ids, first_id, handleType );
}

References buffer, bufferSize, CHECK_OPEN_HANDLES, convert_id_to_handle(), moab::Interface::create_element(), dataBuffer, dbgOut, debug_barrier, moab::CN::EntityTypeFromName(), ErrorCode, filePtr, mhdf_ElemDesc::handle, handleType, insert_in_id_map(), is_error(), MB_CHK_ERR, MB_ENTITY_NOT_FOUND, MB_SET_ERR, MB_SUCCESS, MBMAXTYPE, mhdf_openPolyConnectivity(), moab(), mpiComm, nativeParallel, and mhdf_ElemDesc::type.

Referenced by read_elems().

read_qa()

ErrorCode moab::ReadHDF5::read_qa ( EntityHandle  file_set )

private

FIX ME - how to put QA list on set??

Definition at line 3535 of file ReadHDF5.cpp.

{
 CHECK_OPEN_HANDLES;
 
 mhdf_Status status;
 // std::vector<std::string> qa_list;
 
 int qa_len;
 char** qa = mhdf_readHistory( filePtr, &qa_len, &status );
 if( mhdf_isError( &status ) )
 {
 MB_SET_ERR( MB_FAILURE, mhdf_message( &status ) );
 }
 // qa_list.resize(qa_len);
 for( int i = 0; i < qa_len; i++ )
 {
 // qa_list[i] = qa[i];
 free( qa[i] );
 }
 free( qa );
 
 /** FIX ME - how to put QA list on set?? */
 
 return MB_SUCCESS;
}

References CHECK_OPEN_HANDLES, filePtr, MB_SET_ERR, MB_SUCCESS, mhdf_isError(), mhdf_message(), and mhdf_readHistory().

Referenced by load_file().

read_set_data()

ErrorCode moab::ReadHDF5::read_set_data ( const Range &  set_file_ids, EntityHandle  set_start_handle, ReadHDF5Dataset &  set_data_set, SetMode  which_data, Range *  file_ids_out = 0  )

private

Definition at line 2411 of file ReadHDF5.cpp.

{
 ErrorCode rval;
 Range::const_pair_iterator pi;
 Range::iterator out_hint;
 if( file_ids_out ) out_hint = file_ids_out->begin();
 
 // Construct range of offsets into data table at which to read
 // Note: all offsets are incremented by TWEAK because Range cannot
 // store zeros.
 const long TWEAK = 1;
 Range data_offsets;
 Range::iterator hint = data_offsets.begin();
 pi = set_file_ids.const_pair_begin();
 if( (long)pi->first == fileInfo->sets.start_id )
 {
 long second = pi->second - fileInfo->sets.start_id;
 if( setMeta[second][mode] >= 0 ) hint = data_offsets.insert( hint, TWEAK, setMeta[second][mode] + TWEAK );
 ++pi;
 }
 for( ; pi != set_file_ids.const_pair_end(); ++pi )
 {
 long first = pi->first - fileInfo->sets.start_id;
 long second = pi->second - fileInfo->sets.start_id;
 long idx1 = setMeta[first - 1][mode] + 1;
 long idx2 = setMeta[second][mode];
 if( idx2 >= idx1 ) hint = data_offsets.insert( hint, idx1 + TWEAK, idx2 + TWEAK );
 }
 try
 {
 data.set_file_ids( data_offsets, TWEAK, bufferSize / sizeof( EntityHandle ), handleType );
 }
 catch( ReadHDF5Dataset::Exception )
 {
 return MB_FAILURE;
 }
 
 // We need to increment this for each processed set because
 // the sets were created in the order of the ids in file_ids.
 EntityHandle h = start_handle;
 
 const long ranged_flag = ( mode == CONTENT ) ? mhdf_SET_RANGE_BIT : 0;
 
 std::vector< EntityHandle > partial; // For when we read only part of the contents of a set/entity
 Range::const_iterator fileid_iter = set_file_ids.begin();
 EntityHandle* buffer = reinterpret_cast< EntityHandle* >( dataBuffer );
 size_t count, offset;
 
 int nn = 0;
 /*
 #ifdef MOAB_HAVE_MPI
 if (nativeParallel && mode==CONTENT && myPcomm->proc_config().proc_size()>1 &&
 data_offsets.empty())
 {
 MB_SET_ERR_CONT( "ReadHDF5 Failure: Attempt reading an empty dataset on proc " <<
 myPcomm->proc_config().proc_rank());
 MPI_Abort(myPcomm->proc_config().proc_comm(), 1);
 }
 #endif
 */
 if( ( 1 >= set_file_ids.size() ) && ( data.done() ) && moab::ReadHDF5::CONTENT == mode )
 // do at least one null read, it is needed in parallel
 data.null_read();
 
 while( !data.done() )
 {
 dbgOut.printf( 3, "Reading chunk %d of %s\n", ++nn, data.get_debug_desc() );
 try
 {
 data.read( buffer, count );
 }
 catch( ReadHDF5Dataset::Exception )
 {
 return MB_FAILURE;
 }
 
 // Assert not appropriate here - I might have treated all my file ids, but maybe
 // another proc hasn't; for me, count will be zero, so I won't do anything, but
 // I still need to go through the motions to make the read work
 
 // Handle 'special' case where we read some, but not all
 // of the data for an entity during the last iteration.
 offset = 0;
 if( !partial.empty() )
 { // Didn't read all of previous entity
 assert( fileid_iter != set_file_ids.end() );
 size_t num_prev = partial.size();
 size_t idx = *fileid_iter - fileInfo->sets.start_id;
 size_t len = idx ? setMeta[idx][mode] - setMeta[idx - 1][mode] : setMeta[idx][mode] + 1;
 offset = len - num_prev;
 if( offset > count )
 { // Still don't have all
 partial.insert( partial.end(), buffer, buffer + count );
 continue;
 }
 
 partial.insert( partial.end(), buffer, buffer + offset );
 if( file_ids_out )
 {
 out_hint = copy_set_contents( out_hint, setMeta[idx][3] & ranged_flag, &partial[0], partial.size(),
 *file_ids_out );
 }
 else
 {
 switch( mode )
 {
 size_t valid;
 case CONTENT:
 if( setMeta[idx][3] & ranged_flag )
 {
 if( len % 2 ) MB_CHK_ERR( MB_INDEX_OUT_OF_RANGE );
 Range range;
 convert_range_to_handle( &partial[0], len / 2, range );
 rval = moab()->add_entities( h, range );
 }
 else
 {
 convert_id_to_handle( &partial[0], len, valid );
 rval = moab()->add_entities( h, &partial[0], valid );
 }
 break;
 case CHILD:
 convert_id_to_handle( &partial[0], len, valid );
 rval = moab()->add_child_meshsets( h, &partial[0], valid );
 break;
 case PARENT:
 convert_id_to_handle( &partial[0], len, valid );
 rval = moab()->add_parent_meshsets( h, &partial[0], valid );
 break;
 default:
 break;
 }
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 
 ++fileid_iter;
 ++h;
 partial.clear();
 }
 
 // Process contents for all entities for which we
 // have read the complete list
 while( offset < count )
 {
 assert( fileid_iter != set_file_ids.end() );
 size_t idx = *fileid_iter - fileInfo->sets.start_id;
 size_t len = idx ? setMeta[idx][mode] - setMeta[idx - 1][mode] : setMeta[idx][mode] + 1;
 // If we did not read all of the final entity,
 // store what we did read to be processed in the
 // next iteration
 if( offset + len > count )
 {
 partial.insert( partial.end(), buffer + offset, buffer + count );
 break;
 }
 
 if( file_ids_out )
 {
 out_hint =
 copy_set_contents( out_hint, setMeta[idx][3] & ranged_flag, buffer + offset, len, *file_ids_out );
 }
 else
 {
 switch( mode )
 {
 size_t valid;
 case CONTENT:
 if( setMeta[idx][3] & ranged_flag )
 {
 if( len % 2 ) MB_CHK_ERR( MB_INDEX_OUT_OF_RANGE );
 Range range;
 convert_range_to_handle( buffer + offset, len / 2, range );
 rval = moab()->add_entities( h, range );
 }
 else
 {
 convert_id_to_handle( buffer + offset, len, valid );
 rval = moab()->add_entities( h, buffer + offset, valid );
 }
 break;
 case CHILD:
 convert_id_to_handle( buffer + offset, len, valid );
 rval = moab()->add_child_meshsets( h, buffer + offset, valid );
 break;
 case PARENT:
 convert_id_to_handle( buffer + offset, len, valid );
 rval = moab()->add_parent_meshsets( h, buffer + offset, valid );
 break;
 default:
 break;
 }
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 
 ++fileid_iter;
 ++h;
 offset += len;
 }
 }
 
 return MB_SUCCESS;
}

References moab::Interface::add_child_meshsets(), moab::Interface::add_entities(), moab::Interface::add_parent_meshsets(), moab::Range::begin(), buffer, bufferSize, CHILD, moab::Range::const_pair_begin(), moab::Range::const_pair_end(), CONTENT, convert_id_to_handle(), convert_range_to_handle(), moab::copy_set_contents(), dataBuffer, dbgOut, moab::ReadHDF5Dataset::done(), moab::Range::end(), ErrorCode, fileInfo, moab::GeomUtil::first(), moab::ReadHDF5Dataset::get_debug_desc(), handleType, moab::Range::insert(), MB_CHK_ERR, MB_INDEX_OUT_OF_RANGE, MB_SET_ERR, MB_SUCCESS, mhdf_SET_RANGE_BIT, moab(), moab::ReadHDF5Dataset::null_read(), PARENT, moab::DebugOutput::printf(), moab::ReadHDF5Dataset::read(), moab::ReadHDF5Dataset::set_file_ids(), setMeta, mhdf_FileDesc::sets, moab::Range::size(), and mhdf_EntDesc::start_id.

Referenced by get_set_contents(), read_set_ids_recursive(), and read_sets().

read_set_ids_recursive()

ErrorCode moab::ReadHDF5::read_set_ids_recursive ( Range &  sets_in_out, bool  containted_sets, bool  child_sets  )

private

Given a list of file IDs for entity sets, find all contained or child sets (at any depth) and append them to the Range of file IDs.

Definition at line 2050 of file ReadHDF5.cpp.

{
 CHECK_OPEN_HANDLES;
 mhdf_Status status;
 
 if( !fileInfo->have_set_children ) child_sets = false;
 if( !fileInfo->have_set_contents ) contained_sets = false;
 if( !child_sets && !contained_sets ) return MB_SUCCESS;
 
 // Open data tables
 if( fileInfo->sets.count == 0 )
 {
 assert( sets_in_out.empty() );
 return MB_SUCCESS;
 }
 
 if( !contained_sets && !child_sets ) return MB_SUCCESS;
 
 ReadHDF5Dataset cont( "set contents", false, mpiComm );
 ReadHDF5Dataset child( "set children", false, mpiComm );
 
 if( contained_sets )
 {
 long content_len = 0;
 hid_t content_handle = mhdf_openSetData( filePtr, &content_len, &status );
 if( is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 try
 {
 cont.init( content_handle, true );
 }
 catch( ReadHDF5Dataset::Exception )
 {
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 }
 
 if( child_sets )
 {
 long child_len = 0;
 hid_t child_handle = mhdf_openSetChildren( filePtr, &child_len, &status );
 if( is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 try
 {
 child.init( child_handle, true );
 }
 catch( ReadHDF5Dataset::Exception )
 {
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 }
 
 ErrorCode rval = MB_SUCCESS;
 Range children, new_children( sets_in_out );
 int iteration_count = 0;
 do
 {
 ++iteration_count;
 dbgOut.tprintf( 2, "Iteration %d of read_set_ids_recursive\n", iteration_count );
 children.clear();
 if( child_sets )
 {
 rval = read_set_data( new_children, 0, child, CHILD, &children );
 if( MB_SUCCESS != rval ) break;
 }
 if( contained_sets )
 {
 rval = read_set_data( new_children, 0, cont, CONTENT, &children );
 // Remove any non-set values
 Range::iterator it = children.lower_bound( fileInfo->sets.start_id );
 children.erase( children.begin(), it );
 it = children.lower_bound( fileInfo->sets.start_id + fileInfo->sets.count );
 children.erase( it, children.end() );
 if( MB_SUCCESS != rval ) break;
 }
 new_children = subtract( children, sets_in_out );
 dbgOut.print_ints( 2, "Adding additional contained/child sets", new_children );
 sets_in_out.merge( new_children );
 } while( !new_children.empty() );
 
 return MB_SUCCESS;
}

References CHECK_OPEN_HANDLES, CHILD, child, children, CONTENT, mhdf_EntDesc::count, dbgOut, moab::Range::empty(), ErrorCode, fileInfo, filePtr, mhdf_FileDesc::have_set_children, mhdf_FileDesc::have_set_contents, moab::ReadHDF5Dataset::init(), is_error(), MB_SET_ERR, MB_SUCCESS, moab::Range::merge(), mhdf_openSetChildren(), mhdf_openSetData(), mpiComm, moab::DebugOutput::print_ints(), read_set_data(), mhdf_FileDesc::sets, mhdf_EntDesc::start_id, moab::subtract(), and moab::DebugOutput::tprintf().

Referenced by load_file_partial().

read_sets()

ErrorCode moab::ReadHDF5::read_sets ( const Range &  set_file_ids )

private

Read sets.

Definition at line 1915 of file ReadHDF5.cpp.

{
 CHECK_OPEN_HANDLES;
 
 debug_barrier();
 
 mhdf_Status status;
 ErrorCode rval;
 
 const size_t num_sets = fileInfo->sets.count;
 if( !num_sets ) // If no sets at all!
 return MB_SUCCESS;
 
 // Create sets
 std::vector< unsigned > flags( file_ids.size() );
 Range::iterator si = file_ids.begin();
 for( size_t i = 0; i < flags.size(); ++i, ++si )
 flags[i] = setMeta[*si - fileInfo->sets.start_id][3] & ~(long)mhdf_SET_RANGE_BIT;
 EntityHandle start_handle;
 // the files ids could be empty, for empty partitions
 if( !file_ids.empty() )
 {
 rval = readUtil->create_entity_sets( flags.size(), &flags[0], 0, start_handle );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 rval = insert_in_id_map( file_ids, start_handle );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 
 // Read contents
 if( fileInfo->have_set_contents )
 {
 long len = 0;
 hid_t handle = mhdf_openSetData( filePtr, &len, &status );
 if( is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 
 ReadHDF5Dataset dat( "set contents", handle, nativeParallel, mpiComm, true );
 rval = read_set_data( file_ids, start_handle, dat, CONTENT );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 
 // Read set child lists
 if( fileInfo->have_set_children )
 {
 long len = 0;
 hid_t handle = mhdf_openSetChildren( filePtr, &len, &status );
 if( is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 
 ReadHDF5Dataset dat( "set children", handle, nativeParallel, mpiComm, true );
 rval = read_set_data( file_ids, start_handle, dat, CHILD );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 
 // Read set parent lists
 if( fileInfo->have_set_parents )
 {
 long len = 0;
 hid_t handle = mhdf_openSetParents( filePtr, &len, &status );
 if( is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 
 ReadHDF5Dataset dat( "set parents", handle, nativeParallel, mpiComm, true );
 rval = read_set_data( file_ids, start_handle, dat, PARENT );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 
 return MB_SUCCESS;
}

References moab::Range::begin(), CHECK_OPEN_HANDLES, CHILD, CONTENT, mhdf_EntDesc::count, moab::ReadUtilIface::create_entity_sets(), debug_barrier, moab::Range::empty(), ErrorCode, fileInfo, filePtr, mhdf_FileDesc::have_set_children, mhdf_FileDesc::have_set_contents, mhdf_FileDesc::have_set_parents, insert_in_id_map(), is_error(), MB_SET_ERR, MB_SUCCESS, mhdf_openSetChildren(), mhdf_openSetData(), mhdf_openSetParents(), mhdf_SET_RANGE_BIT, mpiComm, nativeParallel, PARENT, read_set_data(), readUtil, setMeta, mhdf_FileDesc::sets, moab::Range::size(), and mhdf_EntDesc::start_id.

Referenced by load_file_impl(), and load_file_partial().

read_sets_partial()

ErrorCode moab::ReadHDF5::read_sets_partial ( const Range &  sets_in )

private

Read sets from file into MOAB for partial read of file.

Given the file IDs for entity sets (sets_in) and elements and nodes (id_map), read in all sets containing any of the elements or nodes and all sets that are (recursively) children of any other set to be read (those in sets_in or those containing any already-read element or node.)

Parameters

sets_in

File IDs for sets to read (unconditionally)

read_sparse_tag()

ErrorCode moab::ReadHDF5::read_sparse_tag ( Tag  tag_handle, hid_t  hdf_read_type, hid_t  ent_table, hid_t  val_table, long  num_entities  )

private

Read sparse tag for all entities.

Definition at line 3243 of file ReadHDF5.cpp.

{
 CHECK_OPEN_HANDLES;
 
 // Read entire ID table and for those file IDs corresponding
 // to entities that we have read from the file add both the
 // offset into the offset range and the handle into the handle
 // range. If handles are not ordered, switch to using a vector.
 const EntityHandle base_offset = 1; // Can't put zero in a Range
 std::vector< EntityHandle > handle_vect;
 Range handle_range, offset_range;
 std::string tn( "<error>" );
 iFace->tag_get_name( tag_handle, tn );
 ErrorCode rval =
 read_sparse_tag_indices( tn.c_str(), id_table, base_offset, offset_range, handle_range, handle_vect );
 if( MB_SUCCESS != rval ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 
 DataType mbtype;
 rval = iFace->tag_get_data_type( tag_handle, mbtype );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 
 int read_size;
 rval = iFace->tag_get_bytes( tag_handle, read_size );
 if( MB_SUCCESS != rval ) // Wrong function for variable-length tags
 MB_SET_ERR( rval, "ReadHDF5 Failure" );
 // if (MB_TYPE_BIT == mbtype)
 // read_size = (read_size + 7) / 8; // Convert bits to bytes, plus 7 for ceiling
 
 if( hdf_read_type )
 { // If not opaque
 hsize_t hdf_size = H5Tget_size( hdf_read_type );
 if( hdf_size != (hsize_t)read_size ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 
 const int handles_per_tag = read_size / sizeof( EntityHandle );
 
 // Now read data values
 size_t chunk_size = bufferSize / read_size;
 try
 {
 ReadHDF5Dataset val_reader( ( tn + " values" ).c_str(), value_table, nativeParallel, mpiComm, false );
 val_reader.set_file_ids( offset_range, base_offset, chunk_size, hdf_read_type );
 dbgOut.printf( 3, "Reading sparse values for tag \"%s\" in %lu chunks\n", tn.c_str(),
 val_reader.get_read_count() );
 int nn = 0;
 size_t offset = 0;
 while( !val_reader.done() )
 {
 dbgOut.printf( 3, "Reading chunk %d of \"%s\" values\n", ++nn, tn.c_str() );
 size_t count;
 val_reader.read( dataBuffer, count );
 if( MB_TYPE_HANDLE == mbtype )
 {
 rval = convert_id_to_handle( (EntityHandle*)dataBuffer, count * handles_per_tag );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 
 if( !handle_vect.empty() )
 {
 rval = iFace->tag_set_data( tag_handle, &handle_vect[offset], count, dataBuffer );
 offset += count;
 }
 else
 {
 Range r;
 r.merge( handle_range.begin(), handle_range.begin() + count );
 handle_range.erase( handle_range.begin(), handle_range.begin() + count );
 rval = iFace->tag_set_data( tag_handle, r, dataBuffer );
 }
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 }
 catch( ReadHDF5Dataset::Exception )
 {
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 
 return MB_SUCCESS;
}

References moab::Range::begin(), bufferSize, CHECK_OPEN_HANDLES, convert_id_to_handle(), dataBuffer, dbgOut, moab::ReadHDF5Dataset::done(), moab::Range::erase(), ErrorCode, moab::ReadHDF5Dataset::get_read_count(), iFace, MB_SET_ERR, MB_SUCCESS, MB_TYPE_HANDLE, moab::Range::merge(), mpiComm, nativeParallel, moab::DebugOutput::printf(), moab::ReadHDF5Dataset::read(), read_sparse_tag_indices(), moab::ReadHDF5Dataset::set_file_ids(), moab::Interface::tag_get_bytes(), moab::Interface::tag_get_data_type(), moab::Interface::tag_get_name(), and moab::Interface::tag_set_data().

Referenced by read_tag().

read_sparse_tag_indices()

ErrorCode moab::ReadHDF5::read_sparse_tag_indices ( const char *  name, hid_t  id_table, EntityHandle  start_offset, Range &  offset_range, Range &  handle_range, std::vector< EntityHandle > &  handle_vect  )

private

Read index table for sparse tag.

Read ID table for a sparse or variable-length tag, returning the handles and offsets within the table for each file ID that corresponds to an entity we've read from the file (an entity that is in idMap).

Parameters

id_table	The MOAB handle for the tag
start_offset	Some non-zero value because ranges (in this case the offset_range) cannot contain zeros.
offset_range	Output: The offsets in the id table for which IDs that occur in idMap were found. All values are increased by start_offset to avoid putting zeros in the range.
handle_range	Output: For each valid ID read from the table, the corresponding entity handle. Note: if the IDs did not occur in handle order, then this will be empty. Use handle_vect instead.
handle_vect	Output: For each valid ID read from the table, the corresponding entity handle. Note: if the IDs occurred in handle order, then this will be empty. Use handle_range instead.

Definition at line 3165 of file ReadHDF5.cpp.

{
 CHECK_OPEN_HANDLES;
 
 offset_range.clear();
 handle_range.clear();
 handle_vect.clear();
 
 ErrorCode rval;
 Range::iterator handle_hint = handle_range.begin();
 Range::iterator offset_hint = offset_range.begin();
 
 EntityHandle* idbuf = (EntityHandle*)dataBuffer;
 size_t idbuf_size = bufferSize / sizeof( EntityHandle );
 
 std::string tn( name );
 tn += " indices";
 
 assert( start_offset > 0 ); // Can't put zero in a Range
 try
 {
 ReadHDF5Dataset id_reader( tn.c_str(), id_table, nativeParallel, mpiComm, false );
 id_reader.set_all_file_ids( idbuf_size, handleType );
 size_t offset = start_offset;
 dbgOut.printf( 3, "Reading file ids for sparse tag \"%s\" in %lu chunks\n", name, id_reader.get_read_count() );
 int nn = 0;
 while( !id_reader.done() )
 {
 dbgOut.printf( 3, "Reading chunk %d of \"%s\" IDs\n", ++nn, name );
 size_t count;
 id_reader.read( idbuf, count );
 
 rval = convert_id_to_handle( idbuf, count );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 
 // idbuf will now contain zero-valued handles for those
 // tag values that correspond to entities we are not reading
 // from the file.
 for( size_t i = 0; i < count; ++i )
 {
 if( idbuf[i] )
 {
 offset_hint = offset_range.insert( offset_hint, offset + i );
 if( !handle_vect.empty() )
 {
 handle_vect.push_back( idbuf[i] );
 }
 else if( handle_range.empty() || idbuf[i] > handle_range.back() )
 {
 handle_hint = handle_range.insert( handle_hint, idbuf[i] );
 }
 else
 {
 handle_vect.resize( handle_range.size() );
 std::copy( handle_range.begin(), handle_range.end(), handle_vect.begin() );
 handle_range.clear();
 handle_vect.push_back( idbuf[i] );
 dbgOut.print( 2, "Switching to unordered list for tag handle list\n" );
 }
 }
 }
 
 offset += count;
 }
 }
 catch( ReadHDF5Dataset::Exception )
 {
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 
 return MB_SUCCESS;
}

References moab::Range::back(), moab::Range::begin(), bufferSize, CHECK_OPEN_HANDLES, moab::Range::clear(), convert_id_to_handle(), dataBuffer, dbgOut, moab::ReadHDF5Dataset::done(), moab::Range::empty(), moab::Range::end(), ErrorCode, moab::ReadHDF5Dataset::get_read_count(), handleType, moab::Range::insert(), MB_SET_ERR, MB_SUCCESS, mpiComm, nativeParallel, moab::DebugOutput::print(), moab::DebugOutput::printf(), moab::ReadHDF5Dataset::read(), moab::ReadHDF5Dataset::set_all_file_ids(), and moab::Range::size().

Referenced by read_sparse_tag(), and read_var_len_tag().

read_tag()

ErrorCode moab::ReadHDF5::read_tag ( int  index )

private

Create tag and read all data.

Definition at line 2718 of file ReadHDF5.cpp.

{
 CHECK_OPEN_HANDLES;
 
 dbgOut.tprintf( 2, "Reading tag \"%s\"\n", fileInfo->tags[tag_index].name );
 
 debug_barrier();
 
 ErrorCode rval;
 mhdf_Status status;
 Tag tag = 0;
 hid_t read_type = -1;
 bool table_type;
 rval = create_tag( fileInfo->tags[tag_index], tag, read_type );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 
 if( fileInfo->tags[tag_index].have_sparse )
 {
 hid_t handles[3];
 long num_ent, num_val;
 mhdf_openSparseTagData( filePtr, fileInfo->tags[tag_index].name, &num_ent, &num_val, handles, &status );
 if( is_error( status ) )
 {
 if( read_type ) H5Tclose( read_type );
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 
 table_type = false;
 if( read_type == 0 )
 {
 read_type = H5Dget_type( handles[1] );
 if( read_type == 0 )
 {
 mhdf_closeData( filePtr, handles[0], &status );
 mhdf_closeData( filePtr, handles[0], &status );
 if( fileInfo->tags[tag_index].size <= 0 ) mhdf_closeData( filePtr, handles[2], &status );
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 table_type = true;
 }
 
 if( fileInfo->tags[tag_index].size > 0 )
 {
 dbgOut.printf( 2, "Reading sparse data for tag \"%s\"\n", fileInfo->tags[tag_index].name );
 rval = read_sparse_tag( tag, read_type, handles[0], handles[1], num_ent );
 }
 else
 {
 dbgOut.printf( 2, "Reading var-len sparse data for tag \"%s\"\n", fileInfo->tags[tag_index].name );
 rval = read_var_len_tag( tag, read_type, handles[0], handles[1], handles[2], num_ent, num_val );
 }
 
 if( table_type )
 {
 H5Tclose( read_type );
 read_type = 0;
 }
 
 mhdf_closeData( filePtr, handles[0], &status );
 if( MB_SUCCESS == rval && is_error( status ) ) rval = MB_FAILURE;
 mhdf_closeData( filePtr, handles[1], &status );
 if( MB_SUCCESS == rval && is_error( status ) ) rval = MB_FAILURE;
 if( fileInfo->tags[tag_index].size <= 0 )
 {
 mhdf_closeData( filePtr, handles[2], &status );
 if( MB_SUCCESS == rval && is_error( status ) ) rval = MB_FAILURE;
 }
 if( MB_SUCCESS != rval )
 {
 if( read_type ) H5Tclose( read_type );
 MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 }
 
 for( int j = 0; j < fileInfo->tags[tag_index].num_dense_indices; ++j )
 {
 long count;
 const char* name = 0;
 mhdf_EntDesc* desc;
 int elem_idx = fileInfo->tags[tag_index].dense_elem_indices[j];
 if( elem_idx == -2 )
 {
 desc = &fileInfo->sets;
 name = mhdf_set_type_handle();
 }
 else if( elem_idx == -1 )
 {
 desc = &fileInfo->nodes;
 name = mhdf_node_type_handle();
 }
 else if( elem_idx >= 0 && elem_idx < fileInfo->num_elem_desc )
 {
 desc = &fileInfo->elems[elem_idx].desc;
 name = fileInfo->elems[elem_idx].handle;
 }
 else
 {
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 
 dbgOut.printf( 2, "Read dense data block for tag \"%s\" on \"%s\"\n", fileInfo->tags[tag_index].name, name );
 
 hid_t handle = mhdf_openDenseTagData( filePtr, fileInfo->tags[tag_index].name, name, &count, &status );
 if( is_error( status ) )
 {
 rval = MB_FAILURE; // rval = error(MB_FAILURE);
 break;
 }
 
 if( count > desc->count )
 {
 mhdf_closeData( filePtr, handle, &status );
 MB_SET_ERR( MB_FAILURE,
 "Invalid data length for dense tag data: " << name << "/" << fileInfo->tags[tag_index].name );
 }
 
 table_type = false;
 if( read_type == 0 )
 {
 read_type = H5Dget_type( handle );
 if( read_type == 0 )
 {
 mhdf_closeData( filePtr, handle, &status );
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 table_type = true;
 }
 
 rval = read_dense_tag( tag, name, read_type, handle, desc->start_id, count );
 
 if( table_type )
 {
 H5Tclose( read_type );
 read_type = 0;
 }
 
 mhdf_closeData( filePtr, handle, &status );
 if( MB_SUCCESS != rval ) break;
 if( is_error( status ) )
 {
 rval = MB_FAILURE;
 break;
 }
 }
 
 if( read_type ) H5Tclose( read_type );
 return rval;
}

References CHECK_OPEN_HANDLES, mhdf_EntDesc::count, create_tag(), dbgOut, debug_barrier, mhdf_TagDesc::dense_elem_indices, mhdf_ElemDesc::desc, mhdf_FileDesc::elems, ErrorCode, fileInfo, filePtr, mhdf_ElemDesc::handle, mhdf_TagDesc::have_sparse, is_error(), MB_SET_ERR, MB_SUCCESS, mhdf_closeData(), mhdf_node_type_handle(), mhdf_openDenseTagData(), mhdf_openSparseTagData(), mhdf_set_type_handle(), mhdf_TagDesc::name, mhdf_FileDesc::nodes, mhdf_TagDesc::num_dense_indices, moab::DebugOutput::printf(), read_dense_tag(), read_sparse_tag(), read_var_len_tag(), mhdf_FileDesc::sets, mhdf_TagDesc::size, mhdf_EntDesc::start_id, mhdf_FileDesc::tags, and moab::DebugOutput::tprintf().

Referenced by load_file_impl(), and load_file_partial().

read_tag_values()

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

virtual

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 3655 of file ReadHDF5.cpp.

{
 ErrorCode rval;
 
 rval = set_up_read( file_name, opts );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 
 int tag_index;
 rval = find_int_tag( tag_name, tag_index );
 if( MB_SUCCESS != rval )
 {
 clean_up_read( opts );
 MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 
 if( subset_list )
 {
 Range file_ids;
 rval = get_subset_ids( subset_list->tag_list, subset_list->tag_list_length, file_ids );
 if( MB_SUCCESS != rval )
 {
 clean_up_read( opts );
 MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 
 rval = read_tag_values_partial( tag_index, file_ids, tag_values_out );
 if( MB_SUCCESS != rval )
 {
 clean_up_read( opts );
 MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 }
 else
 {
 rval = read_tag_values_all( tag_index, tag_values_out );
 if( MB_SUCCESS != rval )
 {
 clean_up_read( opts );
 MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 }
 
 return clean_up_read( opts );
}

References clean_up_read(), ErrorCode, find_int_tag(), get_subset_ids(), MB_SET_ERR, MB_SUCCESS, read_tag_values_all(), read_tag_values_partial(), set_up_read(), moab::ReaderIface::SubsetList::tag_list, and moab::ReaderIface::SubsetList::tag_list_length.

read_tag_values_all()

ErrorCode moab::ReadHDF5::read_tag_values_all ( int  tag_index, std::vector< int > &  results  )

protected

Definition at line 3856 of file ReadHDF5.cpp.

{
 CHECK_OPEN_HANDLES;
 
 mhdf_Status status;
 const mhdf_TagDesc& tag = fileInfo->tags[tag_index];
 long junk, num_val;
 
 // Read sparse values
 if( tag.have_sparse )
 {
 hid_t handles[3];
 mhdf_openSparseTagData( filePtr, tag.name, &junk, &num_val, handles, &status );
 if( mhdf_isError( &status ) )
 {
 MB_SET_ERR( MB_FAILURE, mhdf_message( &status ) );
 }
 
 mhdf_closeData( filePtr, handles[0], &status );
 if( mhdf_isError( &status ) )
 {
 MB_SET_ERR_CONT( mhdf_message( &status ) );
 mhdf_closeData( filePtr, handles[1], &status );
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 
 hid_t file_type = H5Dget_type( handles[1] );
 tag_values.resize( num_val );
 mhdf_readTagValuesWithOpt( handles[1], 0, num_val, file_type, &tag_values[0], collIO, &status );
 if( mhdf_isError( &status ) )
 {
 MB_SET_ERR_CONT( mhdf_message( &status ) );
 H5Tclose( file_type );
 mhdf_closeData( filePtr, handles[1], &status );
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 H5Tconvert( file_type, H5T_NATIVE_INT, num_val, &tag_values[0], 0, H5P_DEFAULT );
 H5Tclose( file_type );
 
 mhdf_closeData( filePtr, handles[1], &status );
 if( mhdf_isError( &status ) )
 {
 MB_SET_ERR( MB_FAILURE, mhdf_message( &status ) );
 }
 }
 
 std::sort( tag_values.begin(), tag_values.end() );
 tag_values.erase( std::unique( tag_values.begin(), tag_values.end() ), tag_values.end() );
 
 // Read dense values
 std::vector< int > prev_data, curr_data;
 for( int i = 0; i < tag.num_dense_indices; ++i )
 {
 int grp = tag.dense_elem_indices[i];
 const char* gname = 0;
 if( grp == -1 )
 gname = mhdf_node_type_handle();
 else if( grp == -2 )
 gname = mhdf_set_type_handle();
 else
 gname = fileInfo->elems[grp].handle;
 hid_t handle = mhdf_openDenseTagData( filePtr, tag.name, gname, &num_val, &status );
 if( mhdf_isError( &status ) )
 {
 MB_SET_ERR( MB_FAILURE, mhdf_message( &status ) );
 }
 
 hid_t file_type = H5Dget_type( handle );
 curr_data.resize( num_val );
 mhdf_readTagValuesWithOpt( handle, 0, num_val, file_type, &curr_data[0], collIO, &status );
 if( mhdf_isError( &status ) )
 {
 MB_SET_ERR_CONT( mhdf_message( &status ) );
 H5Tclose( file_type );
 mhdf_closeData( filePtr, handle, &status );
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 
 H5Tconvert( file_type, H5T_NATIVE_INT, num_val, &curr_data[0], 0, H5P_DEFAULT );
 H5Tclose( file_type );
 mhdf_closeData( filePtr, handle, &status );
 if( mhdf_isError( &status ) )
 {
 MB_SET_ERR( MB_FAILURE, mhdf_message( &status ) );
 }
 
 std::sort( curr_data.begin(), curr_data.end() );
 curr_data.erase( std::unique( curr_data.begin(), curr_data.end() ), curr_data.end() );
 
 prev_data.clear();
 tag_values.swap( prev_data );
 std::set_union( prev_data.begin(), prev_data.end(), curr_data.begin(), curr_data.end(),
 std::back_inserter( tag_values ) );
 }
 
 return MB_SUCCESS;
}

References CHECK_OPEN_HANDLES, collIO, mhdf_TagDesc::dense_elem_indices, mhdf_FileDesc::elems, fileInfo, filePtr, mhdf_ElemDesc::handle, mhdf_TagDesc::have_sparse, MB_SET_ERR, MB_SET_ERR_CONT, MB_SUCCESS, mhdf_closeData(), mhdf_isError(), mhdf_message(), mhdf_node_type_handle(), mhdf_openDenseTagData(), mhdf_openSparseTagData(), mhdf_readTagValuesWithOpt(), mhdf_set_type_handle(), mhdf_TagDesc::name, mhdf_TagDesc::num_dense_indices, and mhdf_FileDesc::tags.

Referenced by read_tag_values().

read_tag_values_partial()

ErrorCode moab::ReadHDF5::read_tag_values_partial ( int  tag_index, const Range &  file_ids, std::vector< int > &  results  )

protected

Definition at line 3704 of file ReadHDF5.cpp.

{
 CHECK_OPEN_HANDLES;
 
 mhdf_Status status;
 const mhdf_TagDesc& tag = fileInfo->tags[tag_index];
 long num_ent, num_val;
 size_t count;
 std::string tn( tag.name );
 
 // Read sparse values
 if( tag.have_sparse )
 {
 hid_t handles[3];
 mhdf_openSparseTagData( filePtr, tag.name, &num_ent, &num_val, handles, &status );
 if( mhdf_isError( &status ) )
 {
 MB_SET_ERR( MB_FAILURE, mhdf_message( &status ) );
 }
 
 try
 {
 // Read all entity handles and fill 'offsets' with ranges of
 // offsets into the data table for entities that we want.
 Range offsets;
 long* buffer = reinterpret_cast< long* >( dataBuffer );
 const long buffer_size = bufferSize / sizeof( long );
 ReadHDF5Dataset ids( ( tn + " ids" ).c_str(), handles[0], nativeParallel, mpiComm );
 ids.set_all_file_ids( buffer_size, H5T_NATIVE_LONG );
 size_t offset = 0;
 dbgOut.printf( 3, "Reading sparse IDs for tag \"%s\" in %lu chunks\n", tag.name, ids.get_read_count() );
 int nn = 0;
 while( !ids.done() )
 {
 dbgOut.printf( 3, "Reading chunk %d of IDs for \"%s\"\n", ++nn, tag.name );
 ids.read( buffer, count );
 
 std::sort( buffer, buffer + count );
 Range::iterator ins = offsets.begin();
 Range::const_iterator i = file_ids.begin();
 for( size_t j = 0; j < count; ++j )
 {
 while( i != file_ids.end() && (long)*i < buffer[j] )
 ++i;
 if( i == file_ids.end() ) break;
 if( (long)*i == buffer[j] )
 {
 ins = offsets.insert( ins, j + offset, j + offset );
 }
 }
 
 offset += count;
 }
 
 tag_values.clear();
 tag_values.reserve( offsets.size() );
 const size_t data_buffer_size = bufferSize / sizeof( int );
 int* data_buffer = reinterpret_cast< int* >( dataBuffer );
 ReadHDF5Dataset vals( ( tn + " sparse vals" ).c_str(), handles[1], nativeParallel, mpiComm );
 vals.set_file_ids( offsets, 0, data_buffer_size, H5T_NATIVE_INT );
 dbgOut.printf( 3, "Reading sparse values for tag \"%s\" in %lu chunks\n", tag.name, vals.get_read_count() );
 nn = 0;
 // Should normally only have one read call, unless sparse nature
 // of file_ids caused reader to do something strange
 while( !vals.done() )
 {
 dbgOut.printf( 3, "Reading chunk %d of values for \"%s\"\n", ++nn, tag.name );
 vals.read( data_buffer, count );
 tag_values.insert( tag_values.end(), data_buffer, data_buffer + count );
 }
 }
 catch( ReadHDF5Dataset::Exception )
 {
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 }
 
 std::sort( tag_values.begin(), tag_values.end() );
 tag_values.erase( std::unique( tag_values.begin(), tag_values.end() ), tag_values.end() );
 
 // Read dense values
 std::vector< int > prev_data, curr_data;
 for( int i = 0; i < tag.num_dense_indices; ++i )
 {
 int grp = tag.dense_elem_indices[i];
 const char* gname = 0;
 mhdf_EntDesc* desc = 0;
 if( grp == -1 )
 {
 gname = mhdf_node_type_handle();
 desc = &fileInfo->nodes;
 }
 else if( grp == -2 )
 {
 gname = mhdf_set_type_handle();
 desc = &fileInfo->sets;
 }
 else
 {
 assert( grp >= 0 && grp < fileInfo->num_elem_desc );
 gname = fileInfo->elems[grp].handle;
 desc = &fileInfo->elems[grp].desc;
 }
 
 Range::iterator s = file_ids.lower_bound( (EntityHandle)( desc->start_id ) );
 Range::iterator e = Range::lower_bound( s, file_ids.end(), (EntityHandle)( desc->start_id ) + desc->count );
 Range subset;
 subset.merge( s, e );
 
 hid_t handle = mhdf_openDenseTagData( filePtr, tag.name, gname, &num_val, &status );
 if( mhdf_isError( &status ) )
 {
 MB_SET_ERR( MB_FAILURE, mhdf_message( &status ) );
 }
 
 try
 {
 curr_data.clear();
 tag_values.reserve( subset.size() );
 const size_t data_buffer_size = bufferSize / sizeof( int );
 int* data_buffer = reinterpret_cast< int* >( dataBuffer );
 
 ReadHDF5Dataset reader( ( tn + " dense vals" ).c_str(), handle, nativeParallel, mpiComm );
 reader.set_file_ids( subset, desc->start_id, data_buffer_size, H5T_NATIVE_INT );
 dbgOut.printf( 3, "Reading dense data for tag \"%s\" and group \"%s\" in %lu chunks\n", tag.name,
 fileInfo->elems[grp].handle, reader.get_read_count() );
 int nn = 0;
 // Should normally only have one read call, unless sparse nature
 // of file_ids caused reader to do something strange
 while( !reader.done() )
 {
 dbgOut.printf( 3, "Reading chunk %d of \"%s\"/\"%s\"\n", ++nn, tag.name, fileInfo->elems[grp].handle );
 reader.read( data_buffer, count );
 curr_data.insert( curr_data.end(), data_buffer, data_buffer + count );
 }
 }
 catch( ReadHDF5Dataset::Exception )
 {
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 
 std::sort( curr_data.begin(), curr_data.end() );
 curr_data.erase( std::unique( curr_data.begin(), curr_data.end() ), curr_data.end() );
 prev_data.clear();
 tag_values.swap( prev_data );
 std::set_union( prev_data.begin(), prev_data.end(), curr_data.begin(), curr_data.end(),
 std::back_inserter( tag_values ) );
 }
 
 return MB_SUCCESS;
}

References moab::Range::begin(), buffer, bufferSize, CHECK_OPEN_HANDLES, mhdf_EntDesc::count, dataBuffer, dbgOut, mhdf_TagDesc::dense_elem_indices, mhdf_ElemDesc::desc, moab::ReadHDF5Dataset::done(), mhdf_FileDesc::elems, moab::Range::end(), fileInfo, filePtr, moab::ReadHDF5Dataset::get_read_count(), mhdf_ElemDesc::handle, mhdf_TagDesc::have_sparse, moab::Range::insert(), moab::Range::lower_bound(), MB_SET_ERR, MB_SUCCESS, moab::Range::merge(), mhdf_isError(), mhdf_message(), mhdf_node_type_handle(), mhdf_openDenseTagData(), mhdf_openSparseTagData(), mhdf_set_type_handle(), mpiComm, mhdf_TagDesc::name, nativeParallel, mhdf_FileDesc::nodes, mhdf_TagDesc::num_dense_indices, moab::DebugOutput::printf(), moab::ReadHDF5Dataset::read(), moab::ReadHDF5Dataset::set_all_file_ids(), moab::ReadHDF5Dataset::set_file_ids(), mhdf_FileDesc::sets, moab::Range::size(), mhdf_EntDesc::start_id, and mhdf_FileDesc::tags.

Referenced by read_tag_values().

read_var_len_tag()

ErrorCode moab::ReadHDF5::read_var_len_tag ( Tag  tag_handle, hid_t  hdf_read_type, hid_t  ent_table, hid_t  val_table, hid_t  off_table, long  num_entities, long  num_values  )

private

Read variable-length tag for all entities.

Definition at line 3327 of file ReadHDF5.cpp.

{
 CHECK_OPEN_HANDLES;
 
 ErrorCode rval;
 DataType mbtype;
 
 rval = iFace->tag_get_data_type( tag_handle, mbtype );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 
 // Can't do variable-length bit tags
 if( MB_TYPE_BIT == mbtype ) MB_CHK_ERR( MB_VARIABLE_DATA_LENGTH );
 
 // If here, MOAB tag must be variable-length
 int mbsize;
 if( MB_VARIABLE_DATA_LENGTH != iFace->tag_get_bytes( tag_handle, mbsize ) )
 {
 assert( false );MB_CHK_ERR( MB_VARIABLE_DATA_LENGTH );
 }
 
 int read_size;
 if( hdf_read_type )
 {
 hsize_t hdf_size = H5Tget_size( hdf_read_type );
 if( hdf_size < 1 ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 read_size = hdf_size;
 }
 else
 {
 // Opaque
 read_size = 1;
 }
 
 std::string tn( "<error>" );
 iFace->tag_get_name( tag_handle, tn );
 
 // Read entire ID table and for those file IDs corresponding
 // to entities that we have read from the file add both the
 // offset into the offset range and the handle into the handle
 // range. If handles are not ordered, switch to using a vector.
 const EntityHandle base_offset = 1; // Can't put zero in a Range
 std::vector< EntityHandle > handle_vect;
 Range handle_range, offset_range;
 rval = read_sparse_tag_indices( tn.c_str(), ent_table, base_offset, offset_range, handle_range, handle_vect );
 
 // This code only works if the id_table is an ordered list.
 // This assumption was also true for the previous iteration
 // of this code, but wasn't checked. MOAB's file writer
 // always writes an ordered list for id_table.
 if( !handle_vect.empty() )
 {
 MB_SET_ERR( MB_FAILURE, "Unordered file ids for variable length tag not supported" );
 }
 
 class VTReader : public ReadHDF5VarLen
 {
 Tag tagHandle;
 bool isHandle;
 size_t readSize;
 ReadHDF5* readHDF5;
 
 public:
 ErrorCode store_data( EntityHandle file_id, void* data, long count, bool )
 {
 ErrorCode rval1;
 if( isHandle )
 {
 if( readSize != sizeof( EntityHandle ) ) MB_CHK_SET_ERR( MB_FAILURE, "Invalid read size" );
 rval1 = readHDF5->convert_id_to_handle( (EntityHandle*)data, count );MB_CHK_ERR( rval1 );
 }
 int n = count;
 return readHDF5->moab()->tag_set_by_ptr( tagHandle, &file_id, 1, &data, &n );
 }
 VTReader( DebugOutput& debug_output,
 void* buffer,
 size_t buffer_size,
 Tag tag,
 bool is_handle_tag,
 size_t read_size1,
 ReadHDF5* owner )
 : ReadHDF5VarLen( debug_output, buffer, buffer_size ), tagHandle( tag ), isHandle( is_handle_tag ),
 readSize( read_size1 ), readHDF5( owner )
 {
 }
 };
 
 VTReader tool( dbgOut, dataBuffer, bufferSize, tag_handle, MB_TYPE_HANDLE == mbtype, read_size, this );
 try
 {
 // Read offsets into value table.
 std::vector< unsigned > counts;
 Range offsets;
 ReadHDF5Dataset off_reader( ( tn + " offsets" ).c_str(), off_table, nativeParallel, mpiComm, false );
 rval = tool.read_offsets( off_reader, offset_range, base_offset, base_offset, offsets, counts );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 
 // Read tag values
 Range empty;
 ReadHDF5Dataset val_reader( ( tn + " values" ).c_str(), val_table, nativeParallel, mpiComm, false );
 rval = tool.read_data( val_reader, offsets, base_offset, hdf_read_type, handle_range, counts, empty );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 catch( ReadHDF5Dataset::Exception )
 {
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 
 return MB_SUCCESS;
}

References buffer, bufferSize, CHECK_OPEN_HANDLES, convert_id_to_handle(), dataBuffer, dbgOut, ErrorCode, iFace, MB_CHK_ERR, MB_CHK_SET_ERR, MB_SET_ERR, MB_SUCCESS, MB_TYPE_BIT, MB_TYPE_HANDLE, MB_VARIABLE_DATA_LENGTH, moab(), mpiComm, nativeParallel, read_sparse_tag_indices(), moab::Interface::tag_get_bytes(), moab::Interface::tag_get_data_type(), moab::Interface::tag_get_name(), and moab::Interface::tag_set_by_ptr().

Referenced by read_tag().

search_tag_values() [1/2]

ErrorCode moab::ReadHDF5::search_tag_values ( hid_t  tag_table, unsigned long  table_size, const std::vector< int > &  sorted_values, std::vector< EntityHandle > &  value_indices  )

private

Search a table of tag data for a specified set of values.

Search a table of tag values, returning the indices into the table at which matches were found. \NOTE For parallel reads, this function does collective IO.

Parameters

info	Summary of data contained in file.
tag_table	HDF5/mhdf handle for tag values
table_size	Number of values in table
sorted_values	Sorted list of values to search for.
value_indices	Output: Offsets into the table of data at which matching values were found.

Definition at line 1362 of file ReadHDF5.cpp.

{
 debug_barrier();
 
 CHECK_OPEN_HANDLES;
 
 mhdf_Status status;
 size_t chunk_size = bufferSize / sizeof( int );
 int* buffer = reinterpret_cast< int* >( dataBuffer );
 size_t remaining = table_size, offset = 0;
 while( remaining )
 {
 // Get a block of tag values
 size_t count = std::min( chunk_size, remaining );
 assert_range( buffer, count );
 mhdf_readTagValuesWithOpt( tag_table, offset, count, H5T_NATIVE_INT, buffer, collIO, &status );
 if( is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 
 // Search tag values
 for( size_t i = 0; i < count; ++i )
 if( std::binary_search( sorted_values.begin(), sorted_values.end(), (int)buffer[i] ) )
 value_indices.push_back( i + offset );
 
 offset += count;
 remaining -= count;
 }
 
 return MB_SUCCESS;
}

References assert_range, buffer, bufferSize, CHECK_OPEN_HANDLES, collIO, dataBuffer, debug_barrier, is_error(), MB_SET_ERR, MB_SUCCESS, and mhdf_readTagValuesWithOpt().

search_tag_values() [2/2]

ErrorCode moab::ReadHDF5::search_tag_values ( int  tag_index, const std::vector< int > &  sorted_values, Range &  file_ids_out, bool  sets_only = false  )

private

Search for entities with specified tag values.

\NOTE For parallel reads, this function does collective IO.

Parameters

tag_index	Index into info->tags specifying which tag to search.
sorted_values	List of tag values to check for, in ascending sorted order.
file_ids_out	File IDs for entities with specified tag values.

Definition at line 1162 of file ReadHDF5.cpp.

{
 ErrorCode rval;
 mhdf_Status status;
 std::vector< EntityHandle >::iterator iter;
 const mhdf_TagDesc& tag = fileInfo->tags[tag_index];
 long size;
 long start_id;
 
 CHECK_OPEN_HANDLES;
 
 debug_barrier();
 
 // Do dense data
 
 hid_t table;
 const char* name;
 std::vector< EntityHandle > indices;
 // These are probably in order of dimension, so iterate
 // in reverse order to make Range insertions more efficient.
 std::vector< int > grp_indices( tag.dense_elem_indices, tag.dense_elem_indices + tag.num_dense_indices );
 for( std::vector< int >::reverse_iterator i = grp_indices.rbegin(); i != grp_indices.rend(); ++i )
 {
 int idx = *i;
 if( idx == -2 )
 {
 name = mhdf_set_type_handle();
 start_id = fileInfo->sets.start_id;
 }
 else if( sets_only )
 {
 continue;
 }
 else if( idx == -1 )
 {
 name = mhdf_node_type_handle();
 start_id = fileInfo->nodes.start_id;
 }
 else
 {
 if( idx < 0 || idx >= fileInfo->num_elem_desc ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 name = fileInfo->elems[idx].handle;
 start_id = fileInfo->elems[idx].desc.start_id;
 }
 table = mhdf_openDenseTagData( filePtr, tag.name, name, &size, &status );
 if( is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 rval = search_tag_values( table, size, sorted_values, indices );
 mhdf_closeData( filePtr, table, &status );
 if( MB_SUCCESS != rval || is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 // Convert from table indices to file IDs and add to result list
 std::sort( indices.begin(), indices.end(), std::greater< EntityHandle >() );
 std::transform( indices.begin(), indices.end(), range_inserter( file_ids ),
 // std::bind1st(std::plus<long>(), start_id));
 std::bind( std::plus< long >(), start_id, std::placeholders::_1 ) );
 indices.clear();
 }
 
 if( !tag.have_sparse ) return MB_SUCCESS;
 
 // Do sparse data
 
 hid_t tables[2];
 long junk; // Redundant value for non-variable-length tags
 mhdf_openSparseTagData( filePtr, tag.name, &size, &junk, tables, &status );
 if( is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 rval = search_tag_values( tables[1], size, sorted_values, indices );
 mhdf_closeData( filePtr, tables[1], &status );
 if( MB_SUCCESS != rval || is_error( status ) )
 {
 mhdf_closeData( filePtr, tables[0], &status );
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 // Convert to ranges
 std::sort( indices.begin(), indices.end() );
 std::vector< EntityHandle > ranges;
 iter = indices.begin();
 while( iter != indices.end() )
 {
 ranges.push_back( *iter );
 EntityHandle last = *iter;
 for( ++iter; iter != indices.end() && ( last + 1 ) == *iter; ++iter, ++last )
 ;
 ranges.push_back( last );
 }
 // Read file ids
 iter = ranges.begin();
 unsigned long offset = 0;
 while( iter != ranges.end() )
 {
 long begin = *iter;
 ++iter;
 long end = *iter;
 ++iter;
 mhdf_readSparseTagEntitiesWithOpt( tables[0], begin, end - begin + 1, handleType, &indices[offset], indepIO,
 &status );
 if( is_error( status ) )
 {
 mhdf_closeData( filePtr, tables[0], &status );
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 offset += end - begin + 1;
 }
 mhdf_closeData( filePtr, tables[0], &status );
 if( is_error( status ) ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 assert( offset == indices.size() );
 std::sort( indices.begin(), indices.end() );
 
 if( sets_only )
 {
 iter = std::lower_bound( indices.begin(), indices.end(),
 (EntityHandle)( fileInfo->sets.start_id + fileInfo->sets.count ) );
 indices.erase( iter, indices.end() );
 iter = std::lower_bound( indices.begin(), indices.end(), fileInfo->sets.start_id );
 indices.erase( indices.begin(), iter );
 }
 copy_sorted_file_ids( &indices[0], indices.size(), file_ids );
 
 return MB_SUCCESS;
}

References CHECK_OPEN_HANDLES, moab::copy_sorted_file_ids(), mhdf_EntDesc::count, debug_barrier, mhdf_TagDesc::dense_elem_indices, mhdf_ElemDesc::desc, mhdf_FileDesc::elems, ErrorCode, fileInfo, filePtr, mhdf_ElemDesc::handle, handleType, mhdf_TagDesc::have_sparse, indepIO, is_error(), MB_SET_ERR, MB_SUCCESS, mhdf_closeData(), mhdf_node_type_handle(), mhdf_openDenseTagData(), mhdf_openSparseTagData(), mhdf_readSparseTagEntitiesWithOpt(), mhdf_set_type_handle(), mhdf_TagDesc::name, mhdf_FileDesc::nodes, mhdf_TagDesc::num_dense_indices, mhdf_FileDesc::num_elem_desc, mhdf_FileDesc::sets, size, mhdf_EntDesc::start_id, and mhdf_FileDesc::tags.

Referenced by get_subset_ids().

set_up_read()

ErrorCode moab::ReadHDF5::set_up_read ( const char *  file_name, const FileOptions &  opts  )

private

Definition at line 241 of file ReadHDF5.cpp.

{
 ErrorCode rval;
 mhdf_Status status;
 indepIO = collIO = H5P_DEFAULT;
 mpiComm = 0;
 
 if( MB_SUCCESS != init() ) MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 
#if defined( H5Eget_auto_vers ) && H5Eget_auto_vers > 1
 herr_t err = H5Eget_auto( H5E_DEFAULT, &errorHandler.func, &errorHandler.data );
#else
 herr_t err = H5Eget_auto( &errorHandler.func, &errorHandler.data );
#endif
 if( err < 0 )
 {
 errorHandler.func = 0;
 errorHandler.data = 0;
 }
 else
 {
#if defined( H5Eset_auto_vers ) && H5Eset_auto_vers > 1
 err = H5Eset_auto( H5E_DEFAULT, &handle_hdf5_error, &errorHandler );
#else
 err = H5Eset_auto( &handle_hdf5_error, &errorHandler );
#endif
 if( err < 0 )
 {
 errorHandler.func = 0;
 errorHandler.data = 0;
 }
 }
 
 // Set up debug output
 int tmpval;
 if( MB_SUCCESS == opts.get_int_option( "DEBUG_IO", 1, tmpval ) )
 {
 dbgOut.set_verbosity( tmpval );
 dbgOut.set_prefix( "H5M " );
 }
 dbgOut.limit_output_to_first_N_procs( 32 );
 
 // Enable some extra checks for reads. Note: amongst other things this
 // will print errors if the entire file is not read, so if doing a
 // partial read that is not a parallel read, this should be disabled.
 debugTrack = ( MB_SUCCESS == opts.get_null_option( "DEBUG_BINIO" ) );
 
 opts.get_toggle_option( "BLOCKED_COORDINATE_IO", DEFAULT_BLOCKED_COORDINATE_IO, blockedCoordinateIO );
 opts.get_toggle_option( "BCAST_SUMMARY", DEFAULT_BCAST_SUMMARY, bcastSummary );
 opts.get_toggle_option( "BCAST_DUPLICATE_READS", DEFAULT_BCAST_DUPLICATE_READS, bcastDuplicateReads );
 
 // Handle parallel options
 bool use_mpio = ( MB_SUCCESS == opts.get_null_option( "USE_MPIO" ) );
 rval = opts.match_option( "PARALLEL", "READ_PART" );
 bool parallel = ( rval != MB_ENTITY_NOT_FOUND );
 nativeParallel = ( rval == MB_SUCCESS );
 if( use_mpio && !parallel )
 {
 MB_SET_ERR( MB_NOT_IMPLEMENTED, "'USE_MPIO' option specified w/out 'PARALLEL' option" );
 }
 
 // This option is intended for testing purposes only, and thus
 // is not documented anywhere. Decreasing the buffer size can
 // expose bugs that would otherwise only be seen when reading
 // very large files.
 rval = opts.get_int_option( "BUFFER_SIZE", bufferSize );
 if( MB_SUCCESS != rval )
 {
 bufferSize = READ_HDF5_BUFFER_SIZE;
 }
 else if( bufferSize < (int)std::max( sizeof( EntityHandle ), sizeof( void* ) ) )
 {
 MB_CHK_ERR( MB_INVALID_SIZE );
 }
 
 dataBuffer = (char*)malloc( bufferSize );
 if( !dataBuffer ) MB_CHK_ERR( MB_MEMORY_ALLOCATION_FAILED );
 
 if( use_mpio || nativeParallel )
 {
 
#ifndef MOAB_HAVE_HDF5_PARALLEL
 free( dataBuffer );
 dataBuffer = NULL;
 MB_SET_ERR( MB_NOT_IMPLEMENTED, "MOAB not configured with parallel HDF5 support" );
#else
 MPI_Info info = MPI_INFO_NULL;
 std::string cb_size;
 rval = opts.get_str_option( "CB_BUFFER_SIZE", cb_size );
 if( MB_SUCCESS == rval )
 {
 MPI_Info_create( &info );
 MPI_Info_set( info, const_cast< char* >( "cb_buffer_size" ), const_cast< char* >( cb_size.c_str() ) );
 }
 
 int pcomm_no = 0;
 rval = opts.get_int_option( "PARALLEL_COMM", pcomm_no );
 if( rval == MB_TYPE_OUT_OF_RANGE )
 {
 MB_SET_ERR( rval, "Invalid value for PARALLEL_COMM option" );
 }
 myPcomm = ParallelComm::get_pcomm( iFace, pcomm_no );
 if( 0 == myPcomm )
 {
 myPcomm = new ParallelComm( iFace, MPI_COMM_WORLD );
 }
 const int rank = myPcomm->proc_config().proc_rank();
 dbgOut.set_rank( rank );
 dbgOut.limit_output_to_first_N_procs( 32 );
 mpiComm = new MPI_Comm( myPcomm->proc_config().proc_comm() );
 
#ifndef H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS
 dbgOut.print( 1, "H5_MPI_COMPLEX_DERIVED_DATATYPE_WORKS is not defined\n" );
#endif
 
 // Open the file in serial on root to read summary
 dbgOut.tprint( 1, "Getting file summary\n" );
 fileInfo = 0;
 
 hid_t file_prop;
 if( bcastSummary )
 {
 unsigned long size = 0;
 if( rank == 0 )
 {
 file_prop = H5Pcreate( H5P_FILE_ACCESS );
 err = H5Pset_fapl_mpio( file_prop, MPI_COMM_SELF, MPI_INFO_NULL );
 assert( file_prop >= 0 );
 assert( err >= 0 );
 filePtr = mhdf_openFileWithOpt( filename, 0, NULL, handleType, file_prop, &status );
 H5Pclose( file_prop );
 
 if( filePtr )
 {
 fileInfo = mhdf_getFileSummary( filePtr, handleType, &status,
 0 ); // no extra set info
 if( !is_error( status ) )
 {
 size = fileInfo->total_size;
 fileInfo->offset = (unsigned char*)fileInfo;
 }
 }
 mhdf_closeFile( filePtr, &status );
 if( fileInfo && mhdf_isError( &status ) )
 {
 free( fileInfo );
 fileInfo = NULL;
 }
 }
 
 dbgOut.tprint( 1, "Communicating file summary\n" );
 int mpi_err = MPI_Bcast( &size, 1, MPI_UNSIGNED_LONG, 0, myPcomm->proc_config().proc_comm() );
 if( mpi_err || !size ) return MB_FAILURE;
 
 if( rank != 0 ) fileInfo = reinterpret_cast< mhdf_FileDesc* >( malloc( size ) );
 
 MPI_Bcast( fileInfo, size, MPI_BYTE, 0, myPcomm->proc_config().proc_comm() );
 
 if( rank != 0 ) mhdf_fixFileDesc( fileInfo, reinterpret_cast< mhdf_FileDesc* >( fileInfo->offset ) );
 }
 
 file_prop = H5Pcreate( H5P_FILE_ACCESS );
 err = H5Pset_fapl_mpio( file_prop, myPcomm->proc_config().proc_comm(), info );
 assert( file_prop >= 0 );
 assert( err >= 0 );
 
 collIO = H5Pcreate( H5P_DATASET_XFER );
 assert( collIO > 0 );
 err = H5Pset_dxpl_mpio( collIO, H5FD_MPIO_COLLECTIVE );
 assert( err >= 0 );
 indepIO = nativeParallel ? H5P_DEFAULT : collIO;
 
 // Re-open file in parallel
 dbgOut.tprintf( 1, "Opening \"%s\" for parallel IO\n", filename );
 filePtr = mhdf_openFileWithOpt( filename, 0, NULL, handleType, file_prop, &status );
 
 H5Pclose( file_prop );
 if( !filePtr )
 {
 free( dataBuffer );
 dataBuffer = NULL;
 H5Pclose( indepIO );
 if( collIO != indepIO ) H5Pclose( collIO );
 collIO = indepIO = H5P_DEFAULT;
 MB_SET_ERR( MB_FAILURE, mhdf_message( &status ) );
 }
 
 if( !bcastSummary )
 {
 fileInfo = mhdf_getFileSummary( filePtr, handleType, &status, 0 );
 if( is_error( status ) )
 {
 free( dataBuffer );
 dataBuffer = NULL;
 mhdf_closeFile( filePtr, &status );
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 }
#endif // HDF5_PARALLEL
 }
 else
 {
 // Open the file
 filePtr = mhdf_openFile( filename, 0, NULL, handleType, &status );
 if( !filePtr )
 {
 free( dataBuffer );
 dataBuffer = NULL;
 MB_SET_ERR( MB_FAILURE, mhdf_message( &status ) );
 }
 
 // Get file info
 fileInfo = mhdf_getFileSummary( filePtr, handleType, &status, 0 );
 if( is_error( status ) )
 {
 free( dataBuffer );
 dataBuffer = NULL;
 mhdf_closeFile( filePtr, &status );
 MB_SET_ERR( MB_FAILURE, "ReadHDF5 Failure" );
 }
 }
 
 ReadHDF5Dataset::default_hyperslab_selection_limit();
 int hslimit;
 rval = opts.get_int_option( "HYPERSLAB_SELECT_LIMIT", hslimit );
 if( MB_SUCCESS == rval && hslimit > 0 )
 ReadHDF5Dataset::set_hyperslab_selection_limit( hslimit );
 else
 ReadHDF5Dataset::default_hyperslab_selection_limit();
 if( MB_SUCCESS != opts.get_null_option( "HYPERSLAB_OR" ) &&
 ( MB_SUCCESS == opts.get_null_option( "HYPERSLAB_APPEND" ) || HDF5_can_append_hyperslabs() ) )
 {
 ReadHDF5Dataset::append_hyperslabs();
 if( MB_SUCCESS != opts.get_int_option( "HYPERSLAB_SELECT_LIMIT", hslimit ) )
 ReadHDF5Dataset::set_hyperslab_selection_limit( std::numeric_limits< int >::max() );
 dbgOut.print( 1, "Using H5S_APPEND for hyperslab selection\n" );
 }
 
 return MB_SUCCESS;
}

References moab::ReadHDF5Dataset::append_hyperslabs(), bcastDuplicateReads, bcastSummary, blockedCoordinateIO, bufferSize, collIO, moab::ReadHDF5::HDF5ErrorHandler::data, dataBuffer, dbgOut, debugTrack, moab::DEFAULT_BCAST_DUPLICATE_READS, moab::DEFAULT_BCAST_SUMMARY, moab::DEFAULT_BLOCKED_COORDINATE_IO, moab::ReadHDF5Dataset::default_hyperslab_selection_limit(), ErrorCode, errorHandler, fileInfo, filePtr, moab::ReadHDF5::HDF5ErrorHandler::func, moab::FileOptions::get_int_option(), moab::FileOptions::get_null_option(), moab::ParallelComm::get_pcomm(), moab::FileOptions::get_str_option(), moab::FileOptions::get_toggle_option(), moab::handle_hdf5_error(), handleType, moab::HDF5_can_append_hyperslabs(), iFace, indepIO, init(), is_error(), moab::DebugOutput::limit_output_to_first_N_procs(), moab::FileOptions::match_option(), MB_CHK_ERR, MB_ENTITY_NOT_FOUND, MB_INVALID_SIZE, MB_MEMORY_ALLOCATION_FAILED, MB_NOT_IMPLEMENTED, MB_SET_ERR, MB_SUCCESS, MB_TYPE_OUT_OF_RANGE, mhdf_closeFile(), mhdf_fixFileDesc(), mhdf_getFileSummary(), mhdf_isError(), mhdf_message(), mhdf_openFile(), mhdf_openFileWithOpt(), mpiComm, myPcomm, nativeParallel, mhdf_FileDesc::offset, moab::DebugOutput::print(), moab::ProcConfig::proc_comm(), moab::ParallelComm::proc_config(), moab::ProcConfig::proc_rank(), READ_HDF5_BUFFER_SIZE, moab::ReadHDF5Dataset::set_hyperslab_selection_limit(), moab::DebugOutput::set_prefix(), moab::DebugOutput::set_rank(), moab::DebugOutput::set_verbosity(), size, mhdf_FileDesc::total_size, moab::DebugOutput::tprint(), and moab::DebugOutput::tprintf().

Referenced by load_file(), and read_tag_values().

store_file_ids()

ErrorCode moab::ReadHDF5::store_file_ids ( Tag  tag )

private

Store file IDS in tag values.

Copy file ID from IDMap for each entity read from file into a tag value on the entity.

Definition at line 3561 of file ReadHDF5.cpp.

{
 CHECK_OPEN_HANDLES;
 
 // typedef int tag_type;
 typedef long tag_type;
 // change it to be able to read much bigger files (long is 64 bits ...)
 
 tag_type* buffer = reinterpret_cast< tag_type* >( dataBuffer );
 const long buffer_size = bufferSize / sizeof( tag_type );
 for( IDMap::iterator i = idMap.begin(); i != idMap.end(); ++i )
 {
 IDMap::Range range = *i;
 
 // Make sure the values will fit in the tag type
 IDMap::key_type rv = range.begin + ( range.count - 1 );
 tag_type tv = (tag_type)rv;
 if( (IDMap::key_type)tv != rv )
 {
 assert( false );
 return MB_INDEX_OUT_OF_RANGE;
 }
 
 while( range.count )
 {
 long count = buffer_size < range.count ? buffer_size : range.count;
 
 Range handles;
 handles.insert( range.value, range.value + count - 1 );
 range.value += count;
 range.count -= count;
 for( long j = 0; j < count; ++j )
 buffer[j] = (tag_type)range.begin++;
 
 ErrorCode rval = iFace->tag_set_data( tag, handles, buffer );
 if( MB_SUCCESS != rval ) return rval;
 }
 }
 
 return MB_SUCCESS;
}

References moab::RangeMap< KeyType, ValType, NullVal >::begin(), buffer, bufferSize, CHECK_OPEN_HANDLES, dataBuffer, moab::RangeMap< KeyType, ValType, NullVal >::end(), ErrorCode, idMap, iFace, moab::Range::insert(), MB_INDEX_OUT_OF_RANGE, MB_SUCCESS, and moab::Interface::tag_set_data().

Referenced by load_file().

store_sets_file_ids()

ErrorCode moab::ReadHDF5::store_sets_file_ids ( )

private

Store sets file IDS in a custom tag.

Copy sets file ID from IDMap for each set read from file into a custom tag on the sets needed now for the VisIt plugin, to identify sets read

Definition at line 3603 of file ReadHDF5.cpp.

{
 CHECK_OPEN_HANDLES;
 
 // create a tag that will not be saved, but it will be
 // used by visit plugin to match the sets and their file ids
 // it is the same type as the tag defined in ReadParallelcpp, for file id
 Tag setFileIdTag;
 long default_val = 0;
 ErrorCode rval = iFace->tag_get_handle( "__FILE_ID_FOR_SETS", sizeof( long ), MB_TYPE_OPAQUE, setFileIdTag,
 ( MB_TAG_DENSE | MB_TAG_CREAT ), &default_val );
 
 if( MB_SUCCESS != rval || 0 == setFileIdTag ) return rval;
 // typedef int tag_type;
 typedef long tag_type;
 // change it to be able to read much bigger files (long is 64 bits ...)
 
 tag_type* buffer = reinterpret_cast< tag_type* >( dataBuffer );
 const long buffer_size = bufferSize / sizeof( tag_type );
 for( IDMap::iterator i = idMap.begin(); i != idMap.end(); ++i )
 {
 IDMap::Range range = *i;
 EntityType htype = iFace->type_from_handle( range.value );
 if( MBENTITYSET != htype ) continue;
 // work only with entity sets
 // Make sure the values will fit in the tag type
 IDMap::key_type rv = range.begin + ( range.count - 1 );
 tag_type tv = (tag_type)rv;
 if( (IDMap::key_type)tv != rv )
 {
 assert( false );
 return MB_INDEX_OUT_OF_RANGE;
 }
 
 while( range.count )
 {
 long count = buffer_size < range.count ? buffer_size : range.count;
 
 Range handles;
 handles.insert( range.value, range.value + count - 1 );
 range.value += count;
 range.count -= count;
 for( long j = 0; j < count; ++j )
 buffer[j] = (tag_type)range.begin++;
 
 rval = iFace->tag_set_data( setFileIdTag, handles, buffer );
 if( MB_SUCCESS != rval ) return rval;
 }
 }
 return MB_SUCCESS;
}

References moab::RangeMap< KeyType, ValType, NullVal >::begin(), buffer, bufferSize, CHECK_OPEN_HANDLES, dataBuffer, moab::RangeMap< KeyType, ValType, NullVal >::end(), ErrorCode, idMap, iFace, moab::Range::insert(), MB_INDEX_OUT_OF_RANGE, MB_SUCCESS, MB_TAG_CREAT, MB_TAG_DENSE, MB_TYPE_OPAQUE, MBENTITYSET, moab::Interface::tag_get_handle(), moab::Interface::tag_set_data(), and moab::Interface::type_from_handle().

Referenced by load_file().

update_connectivity()

ErrorCode moab::ReadHDF5::update_connectivity ( )

private

Update connectivity data for all element groups for which read_elems was called with a non-null node_ids argument.

Definition at line 1606 of file ReadHDF5.cpp.

{
 ErrorCode rval;
 std::vector< IDConnectivity >::iterator i;
 for( i = idConnectivityList.begin(); i != idConnectivityList.end(); ++i )
 {
 rval = convert_id_to_handle( i->array, i->count * i->nodes_per_elem );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 
 rval = readUtil->update_adjacencies( i->handle, i->count, i->nodes_per_elem, i->array );
 if( MB_SUCCESS != rval ) MB_SET_ERR( rval, "ReadHDF5 Failure" );
 }
 idConnectivityList.clear();
 
 return MB_SUCCESS;
}

References convert_id_to_handle(), ErrorCode, idConnectivityList, MB_SET_ERR, MB_SUCCESS, readUtil, and moab::ReadUtilIface::update_adjacencies().

Referenced by load_file_partial().

Member Data Documentation

_times

double moab::ReadHDF5::_times[NUM_TIMES]

private

Definition at line 205 of file ReadHDF5.hpp.

Referenced by load_file(), load_file_partial(), and print_times().

bcastDuplicateReads

bool moab::ReadHDF5::bcastDuplicateReads

private

Definition at line 198 of file ReadHDF5.hpp.

Referenced by find_sets_containing(), read_all_set_meta(), and set_up_read().

bcastSummary

bool moab::ReadHDF5::bcastSummary

private

Definition at line 197 of file ReadHDF5.hpp.

Referenced by set_up_read().

blockedCoordinateIO

bool moab::ReadHDF5::blockedCoordinateIO

private

Flags for some behavior that can be changed through reader options.

Definition at line 196 of file ReadHDF5.hpp.

Referenced by read_nodes(), and set_up_read().

bufferSize

int moab::ReadHDF5::bufferSize

private

The size of the data buffer (dataBuffer).

Definition at line 139 of file ReadHDF5.hpp.

Referenced by find_sets_containing(), get_tagged_entities(), read_adjacencies(), read_dense_tag(), read_elems(), read_node_adj_elems(), read_nodes(), read_poly(), read_set_data(), read_sparse_tag(), read_sparse_tag_indices(), read_tag_values_partial(), read_var_len_tag(), search_tag_values(), set_up_read(), store_file_ids(), and store_sets_file_ids().

collIO

hid_t moab::ReadHDF5::collIO

private

Definition at line 180 of file ReadHDF5.hpp.

Referenced by clean_up_read(), find_sets_containing(), get_tagged_entities(), init(), load_file(), read_adjacencies(), read_all_set_meta(), read_node_adj_elems(), read_tag_values_all(), search_tag_values(), and set_up_read().

cputime

bool moab::ReadHDF5::cputime

private

Definition at line 207 of file ReadHDF5.hpp.

Referenced by load_file(), and load_file_partial().

dataBuffer

char* moab::ReadHDF5::dataBuffer

private

A memory buffer to use for all I/O operations.

Definition at line 141 of file ReadHDF5.hpp.

Referenced by clean_up_read(), find_sets_containing(), get_tagged_entities(), read_adjacencies(), read_dense_tag(), read_elems(), read_node_adj_elems(), read_nodes(), read_poly(), read_set_data(), read_sparse_tag(), read_sparse_tag_indices(), read_tag_values_partial(), read_var_len_tag(), search_tag_values(), set_up_read(), store_file_ids(), and store_sets_file_ids().

dbgOut

DebugOutput moab::ReadHDF5::dbgOut

private

Debug output. Verbosity controlled with DEBUG_FORMAT option.

Definition at line 188 of file ReadHDF5.hpp.

Referenced by debug_barrier_line(), delete_non_side_elements(), find_sets_containing(), get_partition(), get_set_contents(), load_file(), load_file_impl(), load_file_partial(), read_adjacencies(), read_dense_tag(), read_elems(), read_node_adj_elems(), read_nodes(), read_poly(), read_set_data(), read_set_ids_recursive(), read_sparse_tag(), read_sparse_tag_indices(), read_tag(), read_tag_values_partial(), read_var_len_tag(), and set_up_read().

debugTrack

bool moab::ReadHDF5::debugTrack

private

Use IODebugTrack instances to verify reads. Enable with the DEBUG_OVERLAPS option.

Definition at line 186 of file ReadHDF5.hpp.

Referenced by init(), read_node_adj_elems(), and set_up_read().

errorHandler

HDF5ErrorHandler moab::ReadHDF5::errorHandler

private

Store old HDF5 error handling function.

Definition at line 201 of file ReadHDF5.hpp.

Referenced by clean_up_read(), and set_up_read().

fileInfo

mhdf_FileDesc* moab::ReadHDF5::fileInfo

private

File summary.

Definition at line 150 of file ReadHDF5.hpp.

Referenced by clean_up_read(), find_int_tag(), find_sets_containing(), get_partition(), get_set_contents(), get_tagged_entities(), init(), load_file_impl(), load_file_partial(), read_all_set_meta(), read_elems(), read_nodes(), read_set_data(), read_set_ids_recursive(), read_sets(), read_tag(), read_tag_values_all(), read_tag_values_partial(), search_tag_values(), and set_up_read().

filePtr

mhdf_FileHandle moab::ReadHDF5::filePtr

private

The file handle from the mhdf library.

Definition at line 147 of file ReadHDF5.hpp.

Referenced by clean_up_read(), create_tag(), find_sets_containing(), get_set_contents(), get_tagged_entities(), load_file_impl(), load_file_partial(), read_all_set_meta(), read_elems(), read_node_adj_elems(), read_nodes(), read_poly(), read_qa(), read_set_ids_recursive(), read_sets(), read_tag(), read_tag_values_all(), read_tag_values_partial(), search_tag_values(), and set_up_read().

handleType

hid_t moab::ReadHDF5::handleType

private

The type of an EntityHandle.

Definition at line 160 of file ReadHDF5.hpp.

Referenced by create_tag(), get_tagged_entities(), init(), read_adjacencies(), read_elems(), read_poly(), read_set_data(), read_sparse_tag_indices(), search_tag_values(), set_up_read(), and ~ReadHDF5().

idConnectivityList

std::vector< IDConnectivity > moab::ReadHDF5::idConnectivityList

private

List of connectivity arrays for which conversion from file ID to handle was deferred until later.

Definition at line 173 of file ReadHDF5.hpp.

Referenced by read_elems(), and update_connectivity().

idMap

IDMap moab::ReadHDF5::idMap

private

Definition at line 154 of file ReadHDF5.hpp.

Referenced by convert_id_to_handle(), convert_range_to_handle(), delete_non_side_elements(), find_sets_containing(), init(), insert_in_id_map(), read_adjacencies(), read_dense_tag(), read_node_adj_elems(), store_file_ids(), and store_sets_file_ids().

iFace

Interface* moab::ReadHDF5::iFace

private

Interface pointer passed to constructor.

Definition at line 144 of file ReadHDF5.hpp.

Referenced by create_tag(), delete_non_side_elements(), init(), load_file(), moab(), read_adjacencies(), read_dense_tag(), read_nodes(), read_sparse_tag(), read_var_len_tag(), set_up_read(), store_file_ids(), store_sets_file_ids(), and ~ReadHDF5().

indepIO

hid_t moab::ReadHDF5::indepIO

private

Read/write property handle indepIO -> independent IO during true parallel read collIO -> collective IO during true parallel read Both are H5P_DEFAULT for serial IO and collective when reading the entire file on all processors.

Definition at line 180 of file ReadHDF5.hpp.

Referenced by clean_up_read(), init(), load_file(), search_tag_values(), and set_up_read().

mpiComm

Comm* moab::ReadHDF5::mpiComm

private

MPI_Comm value (unused if !nativeParallel)

Definition at line 192 of file ReadHDF5.hpp.

Referenced by clean_up_read(), debug_barrier_line(), get_set_contents(), load_file_partial(), read_dense_tag(), read_elems(), read_nodes(), read_poly(), read_set_ids_recursive(), read_sets(), read_sparse_tag(), read_sparse_tag_indices(), read_tag_values_partial(), read_var_len_tag(), and set_up_read().

myPcomm

ParallelComm* moab::ReadHDF5::myPcomm

private

Definition at line 182 of file ReadHDF5.hpp.

Referenced by find_sets_containing(), init(), print_times(), read_all_set_meta(), and set_up_read().

nativeParallel

bool moab::ReadHDF5::nativeParallel

private

Doing true parallel read (PARALLEL=READ_PART)

Definition at line 190 of file ReadHDF5.hpp.

Referenced by find_sets_containing(), get_set_contents(), load_file_partial(), read_all_set_meta(), read_dense_tag(), read_elems(), read_nodes(), read_poly(), read_sets(), read_sparse_tag(), read_sparse_tag_indices(), read_tag_values_partial(), read_var_len_tag(), and set_up_read().

readUtil

ReadUtilIface* moab::ReadHDF5::readUtil

private

Cache pointer to read util.

Definition at line 157 of file ReadHDF5.hpp.

Referenced by init(), read_elems(), read_node_adj_elems(), read_nodes(), read_sets(), update_connectivity(), and ~ReadHDF5().

setMeta

long( * moab::ReadHDF5::setMeta)[4]

private

Definition at line 203 of file ReadHDF5.hpp.

Referenced by clean_up_read(), find_sets_containing(), read_all_set_meta(), read_set_data(), read_sets(), and ~ReadHDF5().

timer

CpuTimer* moab::ReadHDF5::timer

private

Definition at line 206 of file ReadHDF5.hpp.

Referenced by load_file(), and load_file_partial().

---

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

• ReadHDF5.hpp
• ReadHDF5.cpp