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_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_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 ;
}
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;
}
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);
}
