hid_t
mhdf_openConnectivitySimple( mhdf_FileHandle file_handle,
const char* elem_handle,
mhdf_Status* status )
{
FileHandle* file_ptr;
hid_t elem_id, table_id;
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;
table_id = mhdf_open_table_simple( elem_id, CONNECTIVITY_NAME, status );
H5Gclose( elem_id );
if (table_id < 0)
return -1;
file_ptr->open_handle_count++;
mhdf_setOkay( status );
API_END_H(1);
return table_id;
}
void
mhdf_closeData( mhdf_FileHandle file, hid_t handle, mhdf_Status* status )
{
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 );
}
}
void
mhdf_closeFile( mhdf_FileHandle handle,
mhdf_Status* status )
{
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 );
}
int
mhdf_checkOpenHandles( mhdf_FileHandle handle,
mhdf_Status* status )
{
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;
}
void
mhdf_openPolyConnectivity( mhdf_FileHandle file_handle,
const char* element_handle,
long* num_poly_out,
long* data_list_length_out,
long* first_poly_id_out,
hid_t handles_out[2],
mhdf_Status* status )
{
FileHandle* file_ptr;
hid_t elem_id, table_id, index_id;
hsize_t row_count;
API_BEGIN;
file_ptr = (FileHandle*)(file_handle);
if (!mhdf_check_valid_file( file_ptr, status ))
return ;
if (!num_poly_out || !data_list_length_out || !first_poly_id_out)
{
mhdf_setFail( status, "Invalid argument." );
return ;
}
elem_id = mhdf_elem_group_from_handle( file_ptr, element_handle, status );
if (elem_id < 0) return ;
index_id = mhdf_open_table( elem_id, POLY_INDEX_NAME,
1, &row_count, status );
if (index_id < 0)
{ H5Gclose(elem_id); return ; }
*num_poly_out = (int)row_count;
table_id = mhdf_open_table( elem_id, CONNECTIVITY_NAME,
1, &row_count, status );
H5Gclose( elem_id );
if (table_id < 0)
{
H5Dclose( index_id );
return ;
}
*data_list_length_out = (long)row_count;
if (!mhdf_read_scalar_attrib( table_id, START_ID_ATTRIB, H5T_NATIVE_LONG,
first_poly_id_out, status ))
{
H5Dclose( table_id );
H5Dclose( index_id );
return ;
}
file_ptr->open_handle_count++;
handles_out[0] = index_id;
handles_out[1] = table_id;
mhdf_setOkay( status );
API_END_H(2);
}
void
mhdf_writeHistory( mhdf_FileHandle file_handle,
const char** strings,
int num_strings,
mhdf_Status* status )
{
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;
}
void
mhdf_getElemTypeName( mhdf_FileHandle file_handle,
const char* elem_handle,
char* buffer, size_t buf_len,
mhdf_Status* status )
{
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 ;
}
void
mhdf_getNextStartId( mhdf_FileHandle file,
mhdf_index_t* start_id_out,
mhdf_Status* status )
{
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;
}
hid_t
mhdf_createAdjacency( mhdf_FileHandle file,
const char* elem_handle,
long adj_list_size,
mhdf_Status* status )
{
FileHandle* file_ptr;
hid_t elem_id, table_id;
hsize_t dim = (hsize_t)adj_list_size;
API_BEGIN;
file_ptr = (FileHandle*)(file);
if (!mhdf_check_valid_file( file_ptr, status ))
return -1;
if (adj_list_size < 1)
{
mhdf_setFail( status, "Invalid argument.\n" );
return -1;
}
if (elem_handle == mhdf_node_type_handle())
{
table_id = mhdf_create_table( file_ptr->hdf_handle,
NODE_ADJCY_PATH,
file_ptr->id_type,
1, &dim,
status );
}
else
{
elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status );
if (elem_id < 0) return -1;
table_id = mhdf_create_table( elem_id,
ADJACENCY_NAME,
file_ptr->id_type,
1, &dim,
status );
H5Gclose( elem_id );
}
API_END_H(1);
return table_id;
}
void
mhdf_getElemName( mhdf_FileHandle file_handle,
unsigned int type_index,
char* buffer,
size_t buf_size,
mhdf_Status* status )
{
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;
}
hid_t
mhdf_openConnectivity( mhdf_FileHandle file_handle,
const char* elem_handle,
int* num_nodes_per_elem_out,
long* num_elements_out,
long* first_elem_id_out,
mhdf_Status* status )
{
FileHandle* file_ptr;
hid_t elem_id, table_id;
hsize_t dims[2];
API_BEGIN;
file_ptr = (FileHandle*)(file_handle);
if (!mhdf_check_valid_file( file_ptr, status ))
return -1;
if (!num_nodes_per_elem_out || !num_elements_out || !first_elem_id_out)
{
mhdf_setFail( status, "Invalid argument." );
return -1;
}
elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status );
if (elem_id < 0) return -1;
table_id = mhdf_open_table2( elem_id, CONNECTIVITY_NAME,
2, dims,
first_elem_id_out, status );
H5Gclose( elem_id );
if (table_id < 0)
return -1;
*num_elements_out = dims[0];
*num_nodes_per_elem_out = dims[1];
file_ptr->open_handle_count++;
mhdf_setOkay( status );
API_END_H(1);
return table_id;
}
int
mhdf_haveAdjacency( mhdf_FileHandle file,
const char* elem_group,
mhdf_Status* status )
{
FileHandle* file_ptr;
hid_t elem_id;
int result;
API_BEGIN;
file_ptr = (FileHandle*)(file);
if (!mhdf_check_valid_file( file_ptr, status ))
return -1;
if (elem_group == mhdf_node_type_handle())
{
#if defined(H5Gopen_vers) && H5Gopen_vers > 1
elem_id = H5Gopen( file_ptr->hdf_handle, NODE_GROUP, H5P_DEFAULT );
#else
elem_id = H5Gopen( file_ptr->hdf_handle, NODE_GROUP );
#endif
if (elem_id < 0)
{
mhdf_setFail( status, "H5Gopen( \"%s\" ) failed.\n", NODE_GROUP );
return -1;
}
}
else
{
elem_id = mhdf_elem_group_from_handle( file_ptr, elem_group, status );
if (elem_id < 0)
return -1;
}
result = mhdf_is_in_group( elem_id, ADJACENCY_NAME, status );
H5Gclose( elem_id );
mhdf_setOkay( status );
API_END;
return result;
}
int
mhdf_isPolyElement( mhdf_FileHandle file_handle,
const char* elem_handle,
mhdf_Status* status )
{
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;
}
hid_t
mhdf_createConnectivity( mhdf_FileHandle file_handle,
const char* elem_handle,
int nodes_per_elem,
long count,
long* first_id_out,
mhdf_Status* status )
{
FileHandle* file_ptr;
hid_t elem_id, table_id;
hsize_t dims[2];
long first_id;
API_BEGIN;
file_ptr = (FileHandle*)(file_handle);
if (!mhdf_check_valid_file( file_ptr, status ))
return -1;
if (nodes_per_elem <= 0 || count < 0 || !first_id_out)
{
mhdf_setFail( status, "Invalid argument." );
return -1;
}
elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status );
if (elem_id < 0) return -1;
dims[0] = (hsize_t)count;
dims[1] = (hsize_t)nodes_per_elem;
table_id = mhdf_create_table( elem_id,
CONNECTIVITY_NAME,
file_ptr->id_type,
2, dims,
status );
H5Gclose( elem_id );
if (table_id < 0)
return -1;
first_id = file_ptr->max_id + 1;
if (!mhdf_create_scalar_attrib( table_id,
START_ID_ATTRIB,
H5T_NATIVE_LONG,
&first_id,
status ))
{
H5Dclose( table_id );
return -1;
}
*first_id_out = first_id;
file_ptr->max_id += count;
if (!mhdf_write_max_id( file_ptr, status))
{
H5Dclose( table_id );
return -1;
}
file_ptr->open_handle_count++;
mhdf_setOkay( status );
API_END_H(1);
return table_id;
}
void
mhdf_createPolyConnectivity( mhdf_FileHandle file_handle,
const char* elem_type,
long num_poly,
long data_list_length,
long* first_id_out,
hid_t handles_out[2],
mhdf_Status* status )
{
FileHandle* file_ptr;
hid_t elem_id, index_id, conn_id;
hsize_t dim;
long first_id;
API_BEGIN;
file_ptr = (FileHandle*)(file_handle);
if (!mhdf_check_valid_file( file_ptr, status ))
return;
if (num_poly <= 0 || data_list_length <= 0 || !first_id_out)
{
mhdf_setFail( status, "Invalid argument." );
return;
}
if (data_list_length < 3*num_poly)
{
/* Could check agains 4*num_poly, but allow degenerate polys
(1 for count plus 2 dim-1 defining entities, where > 2
defining entities is a normal poly, 2 defining entities
is a degenerate poly and 1 defning entity is not valid.)
*/
mhdf_setFail( status, "Invalid polygon data: data length of %ld is "
"insufficient for %ld poly(gons/hedra).\n",
data_list_length, num_poly );
return;
}
elem_id = mhdf_elem_group_from_handle( file_ptr, elem_type, status );
if (elem_id < 0) return;
dim = (hsize_t)num_poly;
index_id = mhdf_create_table( elem_id,
POLY_INDEX_NAME,
MHDF_INDEX_TYPE,
1, &dim,
status );
if (index_id < 0)
{ H5Gclose(elem_id); return; }
dim = (hsize_t)data_list_length;
conn_id = mhdf_create_table( elem_id,
CONNECTIVITY_NAME,
file_ptr->id_type,
1, &dim,
status );
H5Gclose( elem_id );
if (conn_id < 0)
{
H5Dclose(index_id);
return;
}
first_id = file_ptr->max_id + 1;
if (!mhdf_create_scalar_attrib( conn_id,
START_ID_ATTRIB,
H5T_NATIVE_LONG,
&first_id,
status ))
{
H5Dclose(index_id);
H5Dclose( conn_id );
return;
}
*first_id_out = first_id;
file_ptr->max_id += num_poly;
if (!mhdf_write_max_id( file_ptr, status))
{
H5Dclose(index_id);
H5Dclose( conn_id );
return;
}
file_ptr->open_handle_count++;
mhdf_setOkay( status );
handles_out[0] = index_id;
handles_out[1] = conn_id;
API_END_H(2);
}
void
mhdf_addElement( mhdf_FileHandle file_handle,
const char* name,
unsigned int elem_type,
mhdf_Status* status )
{
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;
}
