file.c File Reference

#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <H5Fpublic.h>
#include <H5Ppublic.h>
#include <H5Gpublic.h>
#include <H5Spublic.h>
#include <H5Tpublic.h>
#include <H5Apublic.h>
#include "mhdf.h"
#include "status.h"
#include "names-and-paths.h"
#include "util.h"
#include "file-handle.h"

Include dependency graph for file.c:

Go to the source code of this file.

Functions
static int	make_hdf_group (const char *path, hid_t file, size_t size, mhdf_Status *status)
mhdf_FileHandle	mhdf_createFile (const char *filename, int overwrite, const char **elem_type_list, size_t elem_list_len, hid_t id_type, mhdf_Status *status)
	Create a new file. More...
mhdf_FileHandle	mhdf_openFile (const char *filename, int writeable, unsigned long *max_id_out, hid_t id_type, mhdf_Status *status)
	Open an existing file. More...
int	mhdf_countOpenHandles (mhdf_FileHandle file_handle)
	Get number of open HDF5 objects from file. More...
static herr_t	get_max_id (hid_t group_id, const char *subgroup, const char *datatable, unsigned long *data)
static herr_t	max_id_iter (hid_t group_id, const char *name, void *data)
static int	scan_for_max_id (FileHandle *file_ptr, mhdf_Status *status)
mhdf_FileHandle	mhdf_openFileWithOpt (const char *filename, int writable, unsigned long *max_id_out, hid_t id_type, hid_t access_prop, mhdf_Status *status)
	Open an existing file with options. More...
void	mhdf_getElemName (mhdf_FileHandle file_handle, unsigned int type_index, char *buffer, size_t buf_size, mhdf_Status *status)
	Given an element type Id, get the name. Fails if buffer is not of sufficient size. More...
int	mhdf_checkOpenHandles (mhdf_FileHandle handle, mhdf_Status *status)
void	mhdf_closeFile (mhdf_FileHandle handle, mhdf_Status *status)
	Close the file. More...
void	mhdf_closeData (mhdf_FileHandle file, hid_t handle, mhdf_Status *status)
	Common close function for all data handle types. More...
void	mhdf_addElement (mhdf_FileHandle file_handle, const char *name, unsigned int elem_type, mhdf_Status *status)
	Add a new table of element data to the file. More...
char **	mhdf_getElemHandles (mhdf_FileHandle file_handle, unsigned int *count_out, mhdf_Status *status)
	Get the list of element groups in the file. More...
void	mhdf_getElemTypeName (mhdf_FileHandle file_handle, const char *elem_handle, char *buffer, size_t buf_len, mhdf_Status *status)
	Get the element type name for a given element group handle. More...
const char *	mhdf_node_type_handle (void)
	Get an mhdf_ElemHandle object for the node data. More...
const char *	mhdf_set_type_handle (void)
	Return a special element group handle used to specify the set group. More...
int	mhdf_isPolyElement (mhdf_FileHandle file_handle, const char *elem_handle, mhdf_Status *status)
	Check if an element group contains polygon or polyhedron. More...
void	mhdf_writeHistory (mhdf_FileHandle file_handle, const char **strings, int num_strings, mhdf_Status *status)
	Write the file history as a list of strings. More...
char **	mhdf_readHistory (mhdf_FileHandle file_handle, int *num_strings, mhdf_Status *status)
	Read the file history as a list of strings. More...
void	mhdf_getNextStartId (mhdf_FileHandle file, mhdf_index_t *start_id_out, mhdf_Status *status)
	Get start ID that will be assigned to next created dataset. More...

Function Documentation

get_max_id()

static herr_t get_max_id ( hid_t  group_id, const char *  subgroup, const char *  datatable, unsigned long *  data  )

static

Definition at line 155 of file file.c.

{
 unsigned long id;
 hid_t elem_id, conn_id, attr_id, space_id;
 herr_t rval;
 int rank;
 hsize_t dims[2];
 
#if defined( H5Gopen_vers ) && H5Gopen_vers > 1
 elem_id = H5Gopen2( group_id, subgroup, H5P_DEFAULT );
#else
 elem_id = H5Gopen( group_id, subgroup );
#endif
 if( elem_id < 0 ) return (herr_t)-1;
 
#if defined( H5Dopen_vers ) && H5Dopen_vers > 1
 conn_id = H5Dopen2( elem_id, datatable, H5P_DEFAULT );
#else
 conn_id = H5Dopen( elem_id, datatable );
#endif
 H5Gclose( elem_id );
 if( conn_id < 0 ) return (herr_t)-1;
 
 space_id = H5Dget_space( conn_id );
 if( space_id < 0 )
 {
 H5Dclose( conn_id );
 return -1;
 }
 
 rank = H5Sget_simple_extent_ndims( space_id );
 if( rank <= 0 || rank > 2 )
 {
 H5Dclose( conn_id );
 H5Sclose( space_id );
 return -1;
 }
 
 rval = H5Sget_simple_extent_dims( space_id, dims, NULL );
 H5Sclose( space_id );
 if( rval < 0 )
 {
 H5Dclose( conn_id );
 return -1;
 }
 
 attr_id = H5Aopen_name( conn_id, START_ID_ATTRIB );
 H5Dclose( conn_id );
 if( attr_id < 0 ) return (herr_t)-1;
 
 rval = H5Aread( attr_id, H5T_NATIVE_ULONG, &id );
 H5Aclose( attr_id );
 if( rval < 0 ) return rval;
 
 id += dims[0];
 if( id > *data ) *data = id;
 return 0;
}

References START_ID_ATTRIB.

Referenced by max_id_iter(), and scan_for_max_id().

make_hdf_group()

static int make_hdf_group ( const char *  path, hid_t  file, size_t  size, mhdf_Status *  status  )

static

MOAB, a Mesh-Oriented datABase, is a software component for creating, storing and accessing finite element mesh data.

Copyright 2004 Sandia Corporation. Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains certain rights in this software.

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

Definition at line 713 of file file.c.

{
#if defined( H5Gcreate_vers ) && H5Gcreate_vers > 1
 hid_t handle = H5Gcreate2( file, path, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT );
 /* empty statement to avoid compiler warning */
 if( sz )
 {
 }
#else
 hid_t handle = H5Gcreate( file, path, sz );
#endif
 if( handle < 0 )
 {
 mhdf_setFail( status, "Failed to create \"%s\" group.", path );
 return 0;
 }
 else
 {
 H5Gclose( handle );
 return 1;
 }
}

References mhdf_setFail().

Referenced by mhdf_createFile().

max_id_iter()

static herr_t max_id_iter ( hid_t  group_id, const char *  name, void *  data  )

static

Definition at line 214 of file file.c.

{
 return get_max_id( group_id, name, CONNECTIVITY_NAME, (unsigned long*)data );
}

References CONNECTIVITY_NAME, and get_max_id().

Referenced by scan_for_max_id().

mhdf_addElement()

void mhdf_addElement	(	mhdf_FileHandle	file_handle,
		const char *	elem_handle,
		unsigned int	named_elem_type,
		mhdf_Status *	status
	)

Add a new table of element data to the file.

Add a element group to the file. An element group is the data for a block of elements with the same TSTT type and same number of nodes in their connectivity data. (e.g. all the MBHEX20 elements). This function is also used to create the groups for general polygon data and general polyhedron data. The requirement that all elements have the same number of nodes in their connectivity does not apply for poly(gons|hedra).

Parameters

file_handle	File in which to create the element type.
elem_handle	The name to use for the element data. This name is used as an identifier to reference the data for this element type later. The selected name also appears explicitly in the file and therefore should be something descriptive of the element type such as the 'base type' and number of nodes (e.g. "Hex20").
named_elem_type	An index into the list of named element types passed to mhdf_createFile .
status	Passed back status of API call.

Definition at line 507 of file file.c.

{
 FileHandle* file_ptr = (FileHandle*)file_handle;
 hid_t group_id, tag_id, enum_id;
 char *path, *ptr;
 size_t name_len;
 herr_t rval;
 API_BEGIN;
 
 if( !mhdf_check_valid_file( file_ptr, status ) ) return;
 
 name_len = mhdf_name_to_path( name, NULL, 0 );
 name_len += strlen( ELEMENT_GROUP ) + 1;
 path = (char*)mhdf_malloc( name_len, status );
 if( !path ) return;
 
 strcpy( path, ELEMENT_GROUP );
 ptr = path + strlen( ELEMENT_GROUP );
 if( !mhdf_path_to_name( name, ptr ) )
 {
 mhdf_setFail( status, "Invalid character string in internal file path: \"%s\"\n", name );
 return;
 }
 
#if defined( H5Gcreate_vers ) && H5Gcreate_vers > 1
 group_id = H5Gcreate2( file_ptr->hdf_handle, path, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT );
#else
 group_id = H5Gcreate( file_ptr->hdf_handle, path, 3 );
#endif
 if( group_id < 0 )
 {
 mhdf_setFail( status, "Creation of \"%s\" group failed.\n", path );
 free( path );
 return;
 }
 free( path );
 
#if defined( H5Gcreate_vers ) && H5Gcreate_vers > 1
 tag_id = H5Gcreate2( group_id, DENSE_TAG_SUBGROUP, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT );
#else
 tag_id = H5Gcreate( group_id, DENSE_TAG_SUBGROUP, 0 );
#endif
 if( tag_id < 0 )
 {
 H5Gclose( group_id );
 mhdf_setFail( status, "Creation of tag subgroup failed.\n" );
 return;
 }
 H5Gclose( tag_id );
 
 enum_id = get_elem_type_enum( file_ptr, status );
 if( enum_id < 0 )
 {
 H5Gclose( group_id );
 return;
 }
 
 rval = H5Tconvert( H5T_NATIVE_UINT, H5Tget_super( enum_id ), 1, &elem_type, NULL, H5P_DEFAULT );
 if( rval < 0 )
 {
 H5Gclose( group_id );
 H5Tclose( enum_id );
 mhdf_setFail( status, "Internal error converting to enum type." );
 return;
 }
 
 rval = mhdf_create_scalar_attrib( group_id, ELEM_TYPE_ATTRIB, enum_id, &elem_type, status );
 H5Tclose( enum_id );
 if( rval < 0 )
 {
 H5Gclose( group_id );
 return;
 }
 
 H5Gclose( group_id );
 mhdf_setOkay( status );
 API_END;
}

References API_BEGIN, API_END, DENSE_TAG_SUBGROUP, ELEM_TYPE_ATTRIB, ELEMENT_GROUP, get_elem_type_enum(), struct_FileHandle::hdf_handle, mhdf_check_valid_file(), mhdf_create_scalar_attrib(), mhdf_malloc(), mhdf_name_to_path(), mhdf_path_to_name(), mhdf_setFail(), and mhdf_setOkay().

Referenced by moab::WriteHDF5::create_elem_table().

mhdf_checkOpenHandles()

int mhdf_checkOpenHandles	(	mhdf_FileHandle	handle,
		mhdf_Status *	status
	)

Definition at line 409 of file file.c.

{
 FileHandle* file_ptr;
 int result;
 API_BEGIN;
 
 file_ptr = (FileHandle*)( handle );
 if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
 
 /* Check for open handles. HDF5 will not actually close the
 file until all handles are closed. */
 result = H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_ALL );
 if( result != 1 )
 {
 mhdf_setFail( status,
 "Cannot close file with open handles: "
 "%d file, %d data, %d group, %d type, %d attr\n",
 H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_FILE ) - 1,
 H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_DATASET ),
 H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_GROUP ),
 H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_DATATYPE ),
 H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_ATTR ) );
 return result - 1;
 }
 
 API_END_H( 0 );
 return 0;
}

References API_BEGIN, API_END_H, struct_FileHandle::hdf_handle, mhdf_check_valid_file(), and mhdf_setFail().

Referenced by mhdf_closeFile().

mhdf_closeData()

void mhdf_closeData	(	mhdf_FileHandle	file,
		hid_t	handle,
		mhdf_Status *	status
	)

Common close function for all data handle types.

Close an hid_t-type handle returned from any of the following functions. Any hid_t passed-back or returned must be closed via this function to avoid resource loss.

Parameters

file	The file the object pointed to by the passed data handled exists int.
handle	The data object to close.
status	Passed back status of API call.

Definition at line 470 of file file.c.

{
 FileHandle* file_ptr;
 herr_t rval = -1;
 
 file_ptr = (FileHandle*)( file );
 if( !mhdf_check_valid_file( file_ptr, status ) ) return;
 
 switch( H5Iget_type( handle ) )
 {
 case H5I_GROUP:
 rval = H5Gclose( handle );
 break;
 case H5I_DATATYPE:
 rval = H5Tclose( handle );
 break;
 case H5I_DATASPACE:
 rval = H5Sclose( handle );
 break;
 case H5I_DATASET:
 rval = H5Dclose( handle );
 break;
 default:
 rval = -1;
 }
 
 if( rval < 0 )
 {
 mhdf_setFail( status, "H5Xclose failed. Invalid handle?\n" );
 }
 else
 {
 file_ptr->open_handle_count--;
 mhdf_setOkay( status );
 }
}

References mhdf_check_valid_file(), mhdf_setFail(), mhdf_setOkay(), and struct_FileHandle::open_handle_count.

Referenced by check_valid_adjacencies(), check_valid_elem_conn(), check_valid_poly_conn(), check_valid_sets(), check_valid_tag(), check_valid_var_len_tag(), moab::WriteHDF5Parallel::create_adjacency_tables(), moab::WriteHDF5::create_elem_table(), moab::WriteHDF5Parallel::create_node_table(), moab::WriteHDF5::create_set_meta(), moab::WriteHDF5::create_set_tables(), moab::WriteHDF5::create_tag(), moab::ReadHDF5::find_sets_containing(), get_elem_desc(), moab::ReadHDF5::get_tagged_entities(), moab::ReadHDF5::load_file_impl(), moab::ReadHDF5::load_file_partial(), main(), mhdf_getFileSummary(), moab::ReadHDF5::read_all_set_meta(), moab::ReadHDF5::read_node_adj_elems(), moab::ReadHDF5::read_nodes(), moab::ReadHDF5::read_tag(), moab::ReadHDF5::read_tag_values_all(), moab::ReadHDF5::search_tag_values(), moab::WriteHDF5::serial_create_file(), moab::WriteHDF5::write_adjacencies(), moab::WriteHDF5::write_dense_tag(), moab::WriteHDF5::write_elems(), moab::WriteHDF5::write_nodes(), moab::WriteHDF5::write_sets(), moab::WriteHDF5::write_sparse_tag(), and moab::WriteHDF5::write_var_len_tag().

mhdf_closeFile()

void mhdf_closeFile	(	mhdf_FileHandle	handle,
		mhdf_Status *	status
	)

Close the file.

Parameters

handle	The file to close.
status	Passed back status of API call.

Definition at line 438 of file file.c.

{
 FileHandle* file_ptr;
 API_BEGIN;
 
 file_ptr = (FileHandle*)( handle );
 if( !mhdf_check_valid_file( file_ptr, status ) ) return;
 /*
 if (file_ptr->open_handle_count)
 {
 mhdf_setError( status, "Cannot close file with %d open data handles.",
 file_ptr->open_handle_count );
 return;
 }
 */
 
 /* Check for open handles. HDF5 will not actually close the
 file until all handles are closed. */
 if( mhdf_checkOpenHandles( handle, status ) ) return;
 
 if( 0 > H5Fclose( file_ptr->hdf_handle ) )
 {
 mhdf_setFail( status, "H5FClose failed. Invalid handle?" );
 return;
 }
 
 memset( file_ptr, 0, sizeof( FileHandle ) );
 free( file_ptr );
 mhdf_setOkay( status );
 API_END_H( -1 );
}

References API_BEGIN, API_END_H, struct_FileHandle::hdf_handle, mhdf_check_valid_file(), mhdf_checkOpenHandles(), mhdf_setFail(), and mhdf_setOkay().

Referenced by moab::ReadHDF5::clean_up_read(), iMOAB_ReadHeaderInfo(), main(), moab::WriteHDF5Parallel::parallel_create_file(), moab::ReadHDF5::set_up_read(), and moab::WriteHDF5::write_file().

mhdf_countOpenHandles()

int mhdf_countOpenHandles

(

mhdf_FileHandle

file_handle

)

Get number of open HDF5 objects from file.

Definition at line 150 of file file.c.

{
 return H5Fget_obj_count( ( (FileHandle*)file_handle )->hdf_handle, H5F_OBJ_ALL );
}

Referenced by moab::CheckOpenReadHDF5Handles::~CheckOpenReadHDF5Handles(), and moab::CheckOpenWriteHDF5Handles::~CheckOpenWriteHDF5Handles().

mhdf_createFile()

mhdf_FileHandle mhdf_createFile	(	const char *	filename,
		int	overwrite,
		const char **	elem_type_list,
		size_t	elem_type_list_len,
		hid_t	id_type,
		mhdf_Status *	status
	)

Create a new file.

Create a new HDF mesh file. This handle must be closed with mhdf_closeFile to avoid resource loss.

Parameters

filename	The path and name of the file to create
overwrite	If zero, will fail if the specified file already exists. If non-zero, will overwrite an existing file.
elem_type_list	The list of element types that will be stored in the file. If the element name exits as a pre- defined constant (mhdf_type), that constant should be used. If a constant does not exist for the type, a similar naming pattern should be used (accepted name for type, first character uppercase, subsequent characters lowercase.) The element type index passed to mhdf_addElement is then an index into this list. The array may contain null entries to allow the caller some control over the assigned indices without creating dummy types which may confuse readers.
elem_type_list_len	The length of elem_type_list.
id_type	Type to use when creating datasets containing file IDs
status	Passed back status of API call.

Returns

An opaque handle to the file.

Definition at line 37 of file file.c.

{
 FileHandle* file_ptr;
 unsigned int flags;
 unsigned char idx;
 size_t i;
 hid_t enum_id, group_id;
 int rval;
 API_BEGIN;
 
 if( elem_list_len > 255 )
 {
 mhdf_setFail( status, "Element type list too long." );
 return NULL;
 }
 mhdf_setOkay( status );
 
 /* Create struct to hold working data */
 file_ptr = mhdf_alloc_FileHandle( 0, id_type, status );
 if( !file_ptr ) return NULL;
 
 /* Create the file */
 flags = overwrite ? H5F_ACC_TRUNC : H5F_ACC_EXCL;
 file_ptr->hdf_handle = H5Fcreate( filename, flags, H5P_DEFAULT, H5P_DEFAULT );
 if( file_ptr->hdf_handle < 0 )
 {
 mhdf_setFail( status, "Failed to create file \"%s\"", filename );
 free( file_ptr );
 return NULL;
 }
 
 /* Create file structure */
 if( !make_hdf_group( ROOT_GROUP, file_ptr->hdf_handle, 6, status ) ||
 !make_hdf_group( TAG_GROUP, file_ptr->hdf_handle, 0, status ) ||
 !make_hdf_group( ELEMENT_GROUP, file_ptr->hdf_handle, 8, status ) ||
 !make_hdf_group( NODE_GROUP, file_ptr->hdf_handle, 3, status ) ||
 !make_hdf_group( SET_GROUP, file_ptr->hdf_handle, 5, status ) ||
 !make_hdf_group( NODE_TAG_GROUP, file_ptr->hdf_handle, 0, status ) ||
 !make_hdf_group( SET_TAG_GROUP, file_ptr->hdf_handle, 0, status ) )
 {
 H5Fclose( file_ptr->hdf_handle );
 free( file_ptr );
 return NULL;
 }
 
 /* Store the max ID as an attribite on the /tstt/ group */
#if defined( H5Gopen_vers ) && H5Gopen_vers > 1
 group_id = H5Gopen2( file_ptr->hdf_handle, ROOT_GROUP, H5P_DEFAULT );
#else
 group_id = H5Gopen( file_ptr->hdf_handle, ROOT_GROUP );
#endif
 rval = mhdf_create_scalar_attrib( group_id, MAX_ID_ATTRIB, H5T_NATIVE_ULONG, &file_ptr->max_id, status );
 H5Gclose( group_id );
 if( !rval )
 {
 H5Fclose( file_ptr->hdf_handle );
 free( file_ptr );
 return NULL;
 }
 
 /* Create the type name list in file */
 enum_id = H5Tenum_create( H5T_NATIVE_UCHAR );
 if( enum_id < 0 )
 {
 mhdf_setFail( status, "Failed to store elem type list." );
 H5Fclose( file_ptr->hdf_handle );
 free( file_ptr );
 return NULL;
 }
 for( i = 0; i < elem_list_len; ++i )
 {
 if( !elem_type_list[i] || !*elem_type_list[i] ) continue;
 
 idx = (unsigned char)i;
 if( H5Tenum_insert( enum_id, elem_type_list[i], &idx ) < 0 )
 {
 mhdf_setFail( status, "Failed to store elem type list." );
 H5Fclose( file_ptr->hdf_handle );
 free( file_ptr );
 return NULL;
 }
 }
#if defined( H5Tcommit_vers ) && H5Tcommit_vers > 1
 if( H5Tcommit2( file_ptr->hdf_handle, TYPE_ENUM_PATH, enum_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT ) < 0 )
#else
 if( H5Tcommit( file_ptr->hdf_handle, TYPE_ENUM_PATH, enum_id ) < 0 )
#endif
 {
 mhdf_setFail( status, "Failed to store elem type list." );
 H5Fclose( file_ptr->hdf_handle );
 free( file_ptr );
 return NULL;
 }
 H5Tclose( enum_id );
 
 API_END_H( 1 );
 return file_ptr;
}

References API_BEGIN, API_END_H, ELEMENT_GROUP, struct_FileHandle::hdf_handle, make_hdf_group(), struct_FileHandle::max_id, MAX_ID_ATTRIB, mhdf_alloc_FileHandle(), mhdf_create_scalar_attrib(), mhdf_setFail(), mhdf_setOkay(), NODE_GROUP, NODE_TAG_GROUP, ROOT_GROUP, SET_GROUP, SET_TAG_GROUP, TAG_GROUP, and TYPE_ENUM_PATH.

Referenced by moab::WriteHDF5Parallel::parallel_create_file(), and moab::WriteHDF5::serial_create_file().

mhdf_getElemHandles()

char** mhdf_getElemHandles	(	mhdf_FileHandle	file_handle,
		unsigned int *	count_out,
		mhdf_Status *	status
	)

Get the list of element groups in the file.

Get the list of element groups in the file. An element group is the data for a block of elements with the same TSTT type and same number of nodes in their connectivity data. (e.g. all the MBHEX20 elements). This function is also used to retrieve the groups for general polygon data and general polyhedron data. The requirement that all elements have the same number of nodes in their connectivity does not apply for poly(gons|hedra).

Parameters

file_handle	The file.
count_out	Memory location at which to store the length of the returned array.
status	Passed back status of API call.

Returns

An array of pointers to element group names. This array is allocated as a single memory block and should be freed with one call to free().

Definition at line 586 of file file.c.

{
 hsize_t count, length, i;
 char** buffer;
 char* current;
 hid_t group_id;
 herr_t rval;
 ssize_t rlen = 0;
 size_t remaining;
 FileHandle* file_ptr = (FileHandle*)file_handle;
 if( !mhdf_check_valid_file( file_ptr, status ) ) return NULL;
 
#if defined( H5Gopen_vers ) && H5Gopen_vers > 1
 group_id = H5Gopen2( file_ptr->hdf_handle, ELEMENT_GROUP, H5P_DEFAULT );
#else
 group_id = H5Gopen( file_ptr->hdf_handle, ELEMENT_GROUP );
#endif
 if( group_id < 0 )
 {
 mhdf_setFail( status, "Invalid file -- element group does not exist." );
 return NULL;
 }
 
 rval = H5Gget_num_objs( group_id, &count );
 if( rval < 0 )
 {
 H5Gclose( group_id );
 mhdf_setFail( status, "Internal error calling H5Gget_num_objs." );
 return NULL;
 }
 *count_out = count;
 
 for( i = 0; i < count; ++i )
 {
 rlen += H5Gget_objname_by_idx( group_id, i, NULL, 0 ) + 1;
 }
 
 length = count * sizeof( char* ) + rlen;
 buffer = (char**)mhdf_malloc( length, status );
 if( !buffer )
 {
 H5Gclose( group_id );
 return NULL;
 }
 current = (char*)( buffer + count );
 remaining = rlen;
 
 for( i = 0; i < count; ++i )
 {
 buffer[i] = current;
 rlen = H5Gget_objname_by_idx( group_id, i, current, remaining ) + 1;
 if( rlen < 0 )
 {
 H5Gclose( group_id );
 free( buffer );
 mhdf_setFail( status, "Internal error calling H5Gget_objname_by_idx." );
 return NULL;
 }
 
 mhdf_path_to_name( current, current );
 remaining -= rlen;
 current += rlen;
 }
 
 H5Gclose( group_id );
 mhdf_setOkay( status );
 return buffer;
}

References buffer, ELEMENT_GROUP, struct_FileHandle::hdf_handle, length(), mhdf_check_valid_file(), mhdf_malloc(), mhdf_path_to_name(), mhdf_setFail(), and mhdf_setOkay().

Referenced by main(), and mhdf_getFileSummary().

mhdf_getElemName()

void mhdf_getElemName	(	mhdf_FileHandle	file_handle,
		unsigned int	type_index,
		char *	buffer,
		size_t	buffer_size,
		mhdf_Status *	status
	)

Given an element type Id, get the name. Fails if buffer is not of sufficient size.

Parameters

file_handle	The file.
type_index	The type index. Corresponds to indices into the element type list passed to mhdf_createFile.
buffer	The buffer into which to copy the name.
buffer_size	The length of buffer.
status	Passed back status of API call.

Definition at line 368 of file file.c.

{
 FileHandle* file_ptr;
 herr_t rval;
 hid_t enum_id;
 API_BEGIN;
 
 if( type_index > 255 )
 {
 mhdf_setFail( status, "Type index out of bounds." );
 return;
 }
 
 file_ptr = (FileHandle*)( file_handle );
 if( !mhdf_check_valid_file( file_ptr, status ) ) return;
 
 enum_id = get_elem_type_enum( file_ptr, status );
 if( enum_id < 0 ) return;
 
 rval = H5Tconvert( H5T_NATIVE_UINT, H5Tget_super( enum_id ), 1, &type_index, NULL, H5P_DEFAULT );
 if( rval < 0 )
 {
 H5Tclose( enum_id );
 mhdf_setFail( status, "Internal error converting to enum type." );
 return;
 }
 
 rval = H5Tenum_nameof( enum_id, &type_index, buffer, buf_size );
 H5Tclose( enum_id );
 if( rval < 0 )
 mhdf_setFail( status, "H5Tenum_nameof failed. Invalid type index?" );
 else
 mhdf_setOkay( status );
 
 API_END;
}

References API_BEGIN, API_END, buffer, get_elem_type_enum(), mhdf_check_valid_file(), mhdf_setFail(), and mhdf_setOkay().

mhdf_getElemTypeName()

void mhdf_getElemTypeName	(	mhdf_FileHandle	file_handle,
		const char *	elem_handle,
		char *	buffer,
		size_t	buf_len,
		mhdf_Status *	status
	)

Get the element type name for a given element group handle.

Fails if name is longer than buf_len.

Parameters

file_handle	The file.
elem_handle	One of the group names passed back from mhdf_getElemHandles
buffer	A buffer to copy the name into.
buf_len	The length of buffer.
status	Passed back status of API call.

Definition at line 655 of file file.c.

{
 FileHandle* file_ptr;
 hid_t elem_id, type_id, attr_id;
 char bytes[16];
 herr_t rval;
 API_BEGIN;
 
 if( NULL == buffer || buf_len < 2 )
 {
 mhdf_setFail( status, "invalid input" );
 return;
 }
 buffer[0] = '\0';
 
 file_ptr = (FileHandle*)( file_handle );
 if( !mhdf_check_valid_file( file_ptr, status ) ) return;
 
 elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status );
 if( elem_id < 0 ) return;
 
 attr_id = H5Aopen_name( elem_id, ELEM_TYPE_ATTRIB );
 H5Gclose( elem_id );
 if( attr_id < 0 )
 {
 mhdf_setFail( status, "Missing element type attribute. Invalid file." );
 return;
 }
 
 type_id = H5Aget_type( attr_id );
 assert( type_id > 0 );
 
 rval = H5Aread( attr_id, type_id, bytes );
 H5Aclose( attr_id );
 if( rval < 0 )
 {
 H5Tclose( type_id );
 mhdf_setFail( status, "Failed to read element type attribute. Invalid file." );
 return;
 }
 
 rval = H5Tenum_nameof( type_id, bytes, buffer, buf_len );
 H5Tclose( type_id );
 if( rval < 0 )
 {
 mhdf_setFail( status, "Invalid datatype for element type attribute. Invalid file." );
 return;
 }
 
 mhdf_setOkay( status );
 API_END;
 return;
}

References API_BEGIN, API_END, buffer, ELEM_TYPE_ATTRIB, mhdf_check_valid_file(), mhdf_elem_group_from_handle(), mhdf_setFail(), and mhdf_setOkay().

Referenced by get_elem_desc(), and main().

mhdf_getNextStartId()

void mhdf_getNextStartId	(	mhdf_FileHandle	file,
		mhdf_index_t *	start_id_out,
		mhdf_Status *	status
	)

Get start ID that will be assigned to next created dataset.

Get the first_id parameter that will be returned from the next call to any of mhdf_createNodeCoords, mhdf_createConnectivity, mhdf_createPolyConnectivity, or mhdf_createSetMeta

Definition at line 925 of file file.c.

{
 FileHandle* file_ptr = (FileHandle*)file;
 API_BEGIN;
 
 mhdf_setOkay( status );
 if( mhdf_check_valid_file( file_ptr, status ) ) *start_id_out = file_ptr->max_id + 1;
 
 API_END;
}

References API_BEGIN, API_END, struct_FileHandle::max_id, mhdf_check_valid_file(), and mhdf_setOkay().

mhdf_isPolyElement()

int mhdf_isPolyElement	(	mhdf_FileHandle	file_handle,
		const char *	elem_handle,
		mhdf_Status *	status
	)

Check if an element group contains polygon or polyhedron.

Check if an element group contains general polygon or polyhedrons rather than typically fixed-connectivity elements.

Parameters

file_handle	The file.
elem_handle	The element group.
status	Passed back status of API call.

Returns

Zero if normal fixed-connectivity element data. Non-zero if poly(gon/hedron) general-connectivity data.

Definition at line 748 of file file.c.

{
 FileHandle* file_ptr;
 hid_t elem_id;
 int rval;
 API_BEGIN;
 
 file_ptr = (FileHandle*)( file_handle );
 if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
 
 elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status );
 if( elem_id < 0 ) return -1;
 
 mhdf_setOkay( status );
 rval = mhdf_is_in_group( elem_id, POLY_INDEX_NAME, status );
 H5Gclose( elem_id );
 API_END;
 return rval;
}

References API_BEGIN, API_END, mhdf_check_valid_file(), mhdf_elem_group_from_handle(), mhdf_is_in_group(), mhdf_setOkay(), and POLY_INDEX_NAME.

Referenced by get_elem_desc().

mhdf_node_type_handle()

const char* mhdf_node_type_handle

(

void

)

Get an mhdf_ElemHandle object for the node data.

MOAB, a Mesh-Oriented datABase, is a software component for creating, storing and accessing finite element mesh data.

Copyright 2004 Sandia Corporation. Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains certain rights in this software.

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. MHDF API for reading/writing MOAB-format HDF5 mesh files. Error handling Element group handle

Returns

A special element group handle used when specifying adjacency or tag data for nodes.

Definition at line 736 of file file.c.

{
 static const char rval[] = "nodes";
 return rval;
}

Referenced by check_valid_tag(), main(), mhdf_createAdjacency(), mhdf_createDenseTagData(), mhdf_getFileSummary(), mhdf_haveAdjacency(), mhdf_haveDenseTag(), mhdf_openAdjacency(), mhdf_openDenseTagData(), moab::WriteHDF5::ExportSet::name(), moab::ReadHDF5::read_tag(), moab::ReadHDF5::read_tag_values_all(), moab::ReadHDF5::read_tag_values_partial(), moab::ReadHDF5::search_tag_values(), and moab::WriteHDF5::serial_create_file().

mhdf_openFile()

mhdf_FileHandle mhdf_openFile	(	const char *	filename,
		int	writable,
		unsigned long *	max_id,
		hid_t	id_type,
		mhdf_Status *	status
	)

Open an existing file.

Open an existing HDF mesh file. This handle must be closed with mhdf_closeFile to avoid resource loss.

Parameters

filename	The path and name of the file to open
writable	If non-zero, open read-write. Otherwise read-only.
status	Passed back status of API call.
max_id	Used to pass back the maximum global ID used in the file. Provided as an indication to the caller of the size of the mesh. This parameter is optional. NULL may be passed.
id_type	Type to use when creating datasets containing file IDs

Returns

An opaque handle to the file.

Definition at line 141 of file file.c.

{
 return mhdf_openFileWithOpt( filename, writeable, max_id_out, id_type, H5P_DEFAULT, status );
}

References mhdf_openFileWithOpt().

Referenced by iMOAB_ReadHeaderInfo(), main(), and moab::ReadHDF5::set_up_read().

mhdf_openFileWithOpt()

mhdf_FileHandle mhdf_openFileWithOpt	(	const char *	filename,
		int	writable,
		unsigned long *	max_id,
		hid_t	id_type,
		hid_t	options,
		mhdf_Status *	status
	)

Open an existing file with options.

Open an existing HDF mesh file. This handle must be closed with mhdf_closeFile to avoid resource loss. This function allows the calling application to specify the HDF5 access property list that is passed to the HDF5 H5Fopen API. If this is passed as H5P_DEFAULT, the behavior is the same as mhdf_openFile . This argument is typically used to specify a parallel context for for writing the file in parallel.

Parameters

filename	The path and name of the file to open
writable	If non-zero, open read-write. Otherwise read-only.
status	Passed back status of API call.
max_id	Used to pass back the maximum global ID used in the file. Provided as an indication to the caller of the size of the mesh. This parameter is optional. NULL may be passed.
options	The HDF5 access property list to use when opening the file. See the HDF5 documentation for H5Fopen.
id_type	Type to use when creating datasets containing file IDs

Returns

An opaque handle to the file.

Definition at line 277 of file file.c.

{
 FileHandle* file_ptr;
 unsigned int flags;
 hid_t group_id;
 int check_is_hdf5 = 1;
#ifdef MOAB_HAVE_HDF5_PARALLEL
 herr_t err;
 MPI_Comm comm;
 MPI_Info info;
#endif
 API_BEGIN;
 
 /* Check if file is HDF5 */
 /* Don't do this because it can't handle MPI-IO driver code that
 passes options via prefixes on the file name. */
#ifdef MOAB_HAVE_HDF5_PARALLEL
 if( access_prop != H5P_DEFAULT )
 {
 err = H5Pget_fapl_mpio( access_prop, &comm, &info );
 if( err >= 0 )
 {
 check_is_hdf5 = 0;
 /* MPI Documentation is inconsistent with regards to whether
 or not the above call dup's these, but my testing with 1.8.3
 indicates that at least for that version they are not.
 MPI_Comm_free(&comm);
 MPI_Info_free(&info); */
 }
 }
#endif
 if( check_is_hdf5 && H5Fis_hdf5( filename ) <= 0 )
 {
 mhdf_setFail( status, "%s: File is not HDF5", filename );
 return NULL;
 }
 
 /* Create struct to hold working data */
 file_ptr = mhdf_alloc_FileHandle( 0, id_type, status );
 if( !file_ptr )
 {
 mhdf_setFail( status, "Memory allocation failed" );
 return NULL;
 }
 
 /* Create the file */
 flags = writable ? H5F_ACC_RDWR : H5F_ACC_RDONLY;
 file_ptr->hdf_handle = H5Fopen( filename, flags, access_prop );
 if( file_ptr->hdf_handle < 0 )
 {
 mhdf_setFail( status, "Failed to open file \"%s\"", filename );
 free( file_ptr );
 return NULL;
 }
 
 /* Check for TSTT data in file */
#if defined( H5Gopen_vers ) && H5Gopen_vers > 1
 group_id = H5Gopen2( file_ptr->hdf_handle, ROOT_GROUP, H5P_DEFAULT );
#else
 group_id = H5Gopen( file_ptr->hdf_handle, ROOT_GROUP );
#endif
 if( group_id < 0 )
 {
 mhdf_setFail( status, "Invalid file \"%s\"\n", filename );
 H5Fclose( file_ptr->hdf_handle );
 free( file_ptr );
 return NULL;
 }
 H5Gclose( group_id );
 
 /* Get max id */
 if( !scan_for_max_id( file_ptr, status ) )
 {
 H5Fclose( file_ptr->hdf_handle );
 mhdf_setFail( status, "Internal error reading file" );
 free( file_ptr );
 return NULL;
 }
 
 if( max_id_out ) *max_id_out = file_ptr->max_id;
 
 mhdf_setOkay( status );
 API_END_H( 1 );
 return file_ptr;
}

References API_BEGIN, API_END_H, struct_FileHandle::hdf_handle, struct_FileHandle::max_id, mhdf_alloc_FileHandle(), mhdf_setFail(), mhdf_setOkay(), ROOT_GROUP, and scan_for_max_id().

Referenced by mhdf_openFile(), moab::WriteHDF5Parallel::parallel_create_file(), and moab::ReadHDF5::set_up_read().

mhdf_readHistory()

char** mhdf_readHistory	(	mhdf_FileHandle	file,
		int *	num_records_out,
		mhdf_Status *	status
	)

Read the file history as a list of strings.

Each entry is composed of four strings: application, version, date, and time.

Strings and array are allocated with malloc. Caller must release them by calling free

Parameters

file	The file.
num_records_out	The length of the returned array.
status	Passed back status of API call.

Returns

An array of null-terminates strings.

Definition at line 823 of file file.c.

{
 FileHandle* file_ptr;
 hid_t data_id, type_id, space_id, group_id;
 hsize_t dim;
 herr_t rval;
 char** array;
 API_BEGIN;
 
 file_ptr = (FileHandle*)( file_handle );
 if( !mhdf_check_valid_file( file_ptr, status ) ) return NULL;
 
 /* check if file contains history data */
#if defined( H5Gopen_vers ) && H5Gopen_vers > 1
 group_id = H5Gopen2( file_ptr->hdf_handle, ROOT_GROUP, H5P_DEFAULT );
#else
 group_id = H5Gopen( file_ptr->hdf_handle, ROOT_GROUP );
#endif
 if( group_id < 0 )
 {
 mhdf_setFail( status, "Could not open root group. Invalid file." );
 return NULL;
 }
 
 rval = mhdf_is_in_group( group_id, HISTORY_NAME, status );
 if( rval < 1 )
 {
 H5Gclose( group_id );
 *num_strings = 0;
 if( 0 == rval ) mhdf_setOkay( status );
 return NULL;
 }
 
#if defined( H5Dopen_vers ) && H5Dopen_vers > 1
 data_id = H5Dopen2( group_id, HISTORY_NAME, H5P_DEFAULT );
#else
 data_id = H5Dopen( group_id, HISTORY_NAME );
#endif
 H5Gclose( group_id );
 if( data_id < 0 )
 {
 mhdf_setFail( status, "Failed to open \"%s\".", HISTORY_PATH );
 return NULL;
 }
 
 space_id = H5Dget_space( data_id );
 if( space_id < 0 )
 {
 H5Dclose( data_id );
 mhdf_setFail( status, "Internal error calling H5Dget_space." );
 return NULL;
 }
 
 if( 1 != H5Sget_simple_extent_ndims( space_id ) || 1 != H5Sget_simple_extent_dims( space_id, &dim, NULL ) )
 {
 H5Dclose( data_id );
 mhdf_setFail( status, "Invalid dimension for \"%s\".", HISTORY_PATH );
 return NULL;
 }
 H5Sclose( space_id );
 
 if( 0 == dim )
 {
 H5Dclose( data_id );
 *num_strings = 0;
 mhdf_setOkay( status );
 return NULL;
 }
 
 array = (char**)mhdf_malloc( dim * sizeof( char* ), status );
 if( !array )
 {
 H5Dclose( data_id );
 return NULL;
 }
 
 type_id = H5Tcopy( H5T_C_S1 );
 if( type_id < 0 || H5Tset_size( type_id, H5T_VARIABLE ) < 0 )
 {
 H5Dclose( data_id );
 if( type_id >= 0 ) H5Tclose( type_id );
 mhdf_setFail( status, "Could not create variable length string type." );
 free( array );
 return NULL;
 }
 
 rval = H5Dread( data_id, type_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, array );
 H5Tclose( type_id );
 H5Dclose( data_id );
 if( rval < 0 )
 {
 free( array );
 mhdf_setFail( status, "H5Dread failed." );
 return NULL;
 }
 
 *num_strings = dim;
 mhdf_setOkay( status );
 API_END;
 return array;
}

References API_BEGIN, API_END, dim, struct_FileHandle::hdf_handle, HISTORY_NAME, HISTORY_PATH, mhdf_check_valid_file(), mhdf_is_in_group(), mhdf_malloc(), mhdf_setFail(), mhdf_setOkay(), and ROOT_GROUP.

Referenced by moab::ReadHDF5::read_qa().

mhdf_set_type_handle()

const char* mhdf_set_type_handle

(

void

)

Return a special element group handle used to specify the set group.

Returns

A special element group handle used to specify the set group for reading/writing tag data on sets.

Definition at line 742 of file file.c.

{
 static const char rval[] = "sets";
 return rval;
}

Referenced by check_valid_tag(), mhdf_createDenseTagData(), mhdf_getFileSummary(), mhdf_haveDenseTag(), mhdf_openDenseTagData(), moab::WriteHDF5::ExportSet::name(), moab::ReadHDF5::read_tag(), moab::ReadHDF5::read_tag_values_all(), moab::ReadHDF5::read_tag_values_partial(), and moab::ReadHDF5::search_tag_values().

mhdf_writeHistory()

void mhdf_writeHistory	(	mhdf_FileHandle	file,
		const char **	strings,
		int	num_strings,
		mhdf_Status *	status
	)

Write the file history as a list of strings.

Each entry is composed of four strings: application, version, date, and time.

Parameters

file	The file.
strings	An array of null-terminated strings.
num_strings	The length of strings
status	Passed back status of API call.

Definition at line 768 of file file.c.

{
 FileHandle* file_ptr;
 hid_t data_id, type_id, space_id;
 hsize_t dim = (hsize_t)num_strings;
 herr_t rval;
 API_BEGIN;
 
 file_ptr = (FileHandle*)( file_handle );
 if( !mhdf_check_valid_file( file_ptr, status ) ) return;
 
 type_id = H5Tcopy( H5T_C_S1 );
 if( type_id < 0 || H5Tset_size( type_id, H5T_VARIABLE ) < 0 )
 {
 if( type_id >= 0 ) H5Tclose( type_id );
 mhdf_setFail( status, "Could not create variable length string type." );
 return;
 }
 
 space_id = H5Screate_simple( 1, &dim, NULL );
 if( space_id < 0 )
 {
 H5Tclose( type_id );
 mhdf_setFail( status, "H5Screate_simple failed." );
 return;
 }
 
#if defined( H5Dcreate_vers ) && H5Dcreate_vers > 1
 data_id =
 H5Dcreate2( file_ptr->hdf_handle, HISTORY_PATH, type_id, space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT );
#else
 data_id = H5Dcreate( file_ptr->hdf_handle, HISTORY_PATH, type_id, space_id, H5P_DEFAULT );
#endif
 H5Sclose( space_id );
 if( data_id < 0 )
 {
 H5Tclose( type_id );
 mhdf_setFail( status, "Failed to create \"%s\".", HISTORY_PATH );
 return;
 }
 
 rval = H5Dwrite( data_id, type_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, strings );
 H5Dclose( data_id );
 H5Tclose( type_id );
 if( rval < 0 )
 {
 H5Gunlink( file_ptr->hdf_handle, HISTORY_PATH );
 mhdf_setFail( status, "Failed to write history data." );
 return;
 }
 
 mhdf_setOkay( status );
 API_END;
}

References API_BEGIN, API_END, dim, struct_FileHandle::hdf_handle, HISTORY_PATH, mhdf_check_valid_file(), mhdf_setFail(), and mhdf_setOkay().

Referenced by moab::WriteHDF5::write_qa().

scan_for_max_id()

static int scan_for_max_id ( FileHandle *  file_ptr, mhdf_Status *  status  )

static

Definition at line 219 of file file.c.

{
 hid_t group_id;
 herr_t rval;
 
 /* Check for new format, with max_id as attrib of root group */
#if defined( H5Gopen_vers ) && H5Gopen_vers > 1
 group_id = H5Gopen2( file_ptr->hdf_handle, ROOT_GROUP, H5P_DEFAULT );
#else
 group_id = H5Gopen( file_ptr->hdf_handle, ROOT_GROUP );
#endif
 if( group_id < 0 )
 {
 mhdf_setFail( status, "Internal error - invalid file." );
 return 0;
 }
 if( mhdf_read_scalar_attrib( group_id, MAX_ID_ATTRIB, H5T_NATIVE_ULONG, &file_ptr->max_id, status ) )
 {
 H5Gclose( group_id );
 return 1;
 }
 
 /* Didn't find it, scan the elements group */
 rval = H5Giterate( group_id, ELEMENT_GROUP_NAME, 0, &max_id_iter, &file_ptr->max_id );
 if( rval )
 {
 H5Gclose( group_id );
 mhdf_setFail( status, "Internal error -- invalid file." );
 return 0;
 }
 
 /* Check node table too */
 rval = get_max_id( group_id, NODE_GROUP_NAME, "coordinates", (unsigned long*)( &file_ptr->max_id ) );
 if( rval )
 {
 H5Gclose( group_id );
 mhdf_setFail( status, "Internal error -- invalid file." );
 return 0;
 }
 
 /* Check set table, if it exists */
 rval = mhdf_is_in_group( group_id, SET_GROUP_NAME, status );
 if( rval < 1 )
 {
 H5Gclose( group_id );
 return !rval;
 }
 rval = get_max_id( group_id, SET_GROUP_NAME, SET_META_NAME, (unsigned long*)( &file_ptr->max_id ) );
 H5Gclose( group_id );
 if( rval )
 {
 mhdf_setFail( status, "Internal error -- invalid file." );
 return 0;
 }
 
 return 1;
}

References ELEMENT_GROUP_NAME, get_max_id(), struct_FileHandle::hdf_handle, struct_FileHandle::max_id, MAX_ID_ATTRIB, max_id_iter(), mhdf_is_in_group(), mhdf_read_scalar_attrib(), mhdf_setFail(), NODE_GROUP_NAME, ROOT_GROUP, SET_GROUP_NAME, and SET_META_NAME.

Referenced by mhdf_openFileWithOpt().