file-desc.c

Go to the documentation of this file.

#include "mhdf.h"
#include "util.h"
#include "status.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <H5Tpublic.h>
#include <H5Dpublic.h>
#include <H5Ppublic.h>
 
static struct mhdf_FileDesc* alloc_file_desc( mhdf_Status* status );
static void* realloc_data( struct mhdf_FileDesc** data, size_t append_bytes, mhdf_Status* status, int alignment );
static char buffer[512];
 
static struct mhdf_FileDesc* alloc_file_desc( mhdf_Status* status )
{
 struct mhdf_FileDesc* result;
 /* allocate a little short of a page */
 result = (struct mhdf_FileDesc*)mhdf_malloc( 4000, status );
 if( mhdf_isError( status ) ) return 0;
 
 memset( result, 0, sizeof( struct mhdf_FileDesc ) );
 result->total_size = 4000;
 result->offset = ( (unsigned char*)result ) + sizeof( struct mhdf_FileDesc );
 return result;
}
 
static void* realloc_data( struct mhdf_FileDesc** data, size_t append_bytes, mhdf_Status* status, int alignment)
{
 void* result_ptr;
 struct mhdf_FileDesc* const input_ptr = *data;
 unsigned char* mem_ptr = (unsigned char*)input_ptr;
 
 size_t new_size, occupied_size = input_ptr->offset - mem_ptr;
 
 int append_bytes_padded = append_bytes + alignment - 1;
 /* if the end of the allocated space is before the end of the required space */
 if( mem_ptr + input_ptr->total_size < input_ptr->offset + append_bytes_padded )
 {
 if( append_bytes_padded < input_ptr->total_size )
 new_size = 2 * input_ptr->total_size;
 else
 new_size = input_ptr->total_size + append_bytes_padded;
 *data = (struct mhdf_FileDesc*)mhdf_realloc( *data, new_size, status );
 if( mhdf_isError( status ) ) return 0;
 
 /* if realloc moved us to a different location in memory,
 * we need to update all of the internal pointers to
 * new locations relative to the start of the struct */
 if( *data != input_ptr )
 {
 mhdf_fixFileDesc( *data, input_ptr );
 mem_ptr = (unsigned char*)( *data );
 ( *data )->offset = mem_ptr + occupied_size;
 }
 ( *data )->total_size = new_size;
 }
 
 result_ptr = ( *data )->offset;
 /* need to make this return pointer aligned */
 uintptr_t addr = (uintptr_t)(( *data )->offset);
 int pad = addr%alignment;
 if (pad > 0)
 {
 ( *data )->offset += (alignment-pad);
 result_ptr = ( *data )->offset;
 }
 /*printf("new address %p \n", result_ptr);*/
 ( *data )->offset += append_bytes;
 return result_ptr;
}
 
#define FIX_OFFSET( TYPE, FIELD ) \
 if( copy_ptr->FIELD != NULL ) \
 copy_ptr->FIELD = (TYPE)( ( (char*)( copy_ptr->FIELD ) - (char*)orig_addr ) + (char*)copy_ptr )
 
void mhdf_fixFileDesc( struct mhdf_FileDesc* copy_ptr, const struct mhdf_FileDesc* orig_addr )
{
 int i;
 
 API_BEGIN;
 FIX_OFFSET( int*, nodes.dense_tag_indices );
 FIX_OFFSET( int*, sets.dense_tag_indices );
 FIX_OFFSET( struct mhdf_ElemDesc*, elems );
 FIX_OFFSET( struct mhdf_TagDesc*, tags );
 
 FIX_OFFSET( int*, numEntSets );
 FIX_OFFSET( int**, defTagsEntSets );
 FIX_OFFSET( int**, defTagsVals );
 
 for( i = 0; i < 5; i++ )
 {
 if( copy_ptr->defTagsEntSets ) FIX_OFFSET( int*, defTagsEntSets[i] );
 if( copy_ptr->defTagsVals ) FIX_OFFSET( int*, defTagsVals[i] );
 }
 
 if( copy_ptr->elems != NULL )
 {
 for( i = 0; i < copy_ptr->num_elem_desc; ++i )
 {
 FIX_OFFSET( const char*, elems[i].handle );
 FIX_OFFSET( const char*, elems[i].type );
 FIX_OFFSET( int*, elems[i].desc.dense_tag_indices );
 }
 }
 
 if( copy_ptr->tags != NULL )
 {
 for( i = 0; i < copy_ptr->num_tag_desc; ++i )
 {
 FIX_OFFSET( const char*, tags[i].name );
 FIX_OFFSET( void*, tags[i].default_value );
 FIX_OFFSET( void*, tags[i].global_value );
 FIX_OFFSET( int*, tags[i].dense_elem_indices );
 }
 }
 API_END;
}
 
static struct mhdf_FileDesc* get_elem_desc( mhdf_FileHandle file_handle,
 struct mhdf_FileDesc* result,
 const char* elem_handle,
 int idx,
 mhdf_Status* status )
{
 hid_t id_pair[2];
 int poly;
 void* ptr;
 long junk;
 
 ptr = realloc_data( &result, strlen( elem_handle ) + 1, status, sizeof(char) );
 if( !ptr ) return NULL;
 strcpy( ptr, elem_handle );
 result->elems[idx].handle = ptr;
 
 mhdf_getElemTypeName( file_handle, elem_handle, buffer, sizeof( buffer ), status );
 if( mhdf_isError( status ) )
 {
 free( result );
 return NULL;
 }
 
 ptr = realloc_data( &result, strlen( buffer ) + 1, status, sizeof(char) );
 if( !ptr ) return NULL;
 strcpy( ptr, buffer );
 result->elems[idx].type = ptr;
 
 poly = mhdf_isPolyElement( file_handle, elem_handle, status );
 if( mhdf_isError( status ) )
 {
 free( result );
 return NULL;
 }
 
 if( !poly )
 {
 id_pair[0] = mhdf_openConnectivity( file_handle, elem_handle, &result->elems[idx].desc.vals_per_ent,
 &result->elems[idx].desc.count, &result->elems[idx].desc.start_id, status );
 if( id_pair[0] < 0 )
 {
 free( result );
 return NULL;
 }
 mhdf_closeData( file_handle, id_pair[0], status );
 }
 else
 {
 result->elems[idx].desc.vals_per_ent = -1;
 mhdf_openPolyConnectivity( file_handle, elem_handle, &result->elems[idx].desc.count, &junk,
 &result->elems[idx].desc.start_id, id_pair, status );
 if( id_pair[0] < 0 )
 {
 free( result );
 return NULL;
 }
 mhdf_closeData( file_handle, id_pair[0], status );
 mhdf_closeData( file_handle, id_pair[1], status );
 }
 
 result->elems[idx].desc.dense_tag_indices = NULL;
 result->elems[idx].desc.num_dense_tags = 0;
 result->elems[idx].have_adj = mhdf_haveAdjacency( file_handle, result->elems[idx].handle, status );
 if( mhdf_isError( status ) )
 {
 free( result );
 return 0;
 }
 
 return result;
}
 
static unsigned get_file_id_size( hid_t file_id_type, mhdf_Status* status )
{
 if( H5Tget_class( file_id_type ) != H5T_INTEGER )
 {
 mhdf_setFail( status, "Invalid handle or type class for file ID type." );
 return 0;
 }
 
 return H5Tget_size( file_id_type );
}
 
static struct mhdf_FileDesc* get_tag_desc( mhdf_FileHandle file_handle,
 struct mhdf_FileDesc* result,
 const char* name,
 int idx,
 hid_t type,
 mhdf_Status* status )
{
 void* ptr;
 int have_default, have_global;
 int valsize, size, close_type = 0;
 hsize_t array_len;
 
 ptr = realloc_data( &result, strlen( name ) + 1, status, sizeof(char) );
 if( NULL == ptr ) return NULL;
 strcpy( ptr, name );
 result->tags[idx].name = ptr;
 
 mhdf_getTagInfo( file_handle, name, &result->tags[idx].type, &result->tags[idx].size, &result->tags[idx].storage,
 &have_default, &have_global, &result->tags[idx].have_sparse, status );
 if( mhdf_isError( status ) )
 {
 free( result );
 return NULL;
 }
 
 /* For variable length tags, have_default and have_global will
 contain the size of the respective values. For fixed-length
 tags, they are either zero or one. Simplify later code by
 making them contain the size for both cases. */
 valsize = result->tags[idx].size;
 if( result->tags[idx].size >= 0 )
 {
 if( have_default ) have_default = valsize;
 if( have_global ) have_global = valsize;
 }
 
 result->tags[idx].default_value = NULL;
 result->tags[idx].default_value_size = have_default;
 result->tags[idx].global_value = NULL;
 result->tags[idx].global_value_size = have_global;
 
 switch( result->tags[idx].type )
 {
 case mhdf_OPAQUE:
 type = 0;
 break;
 case mhdf_BOOLEAN:
 type = H5T_NATIVE_UCHAR;
 break;
 case mhdf_INTEGER:
 type = H5T_NATIVE_INT;
 have_default *= sizeof( int );
 have_global *= sizeof( int );
 valsize *= sizeof( int );
 break;
 case mhdf_FLOAT:
 type = H5T_NATIVE_DOUBLE;
 have_default *= sizeof( double );
 have_global *= sizeof( double );
 valsize *= sizeof( double );
 break;
 case mhdf_BITFIELD:
 have_default = ( have_default + 7 ) / 8;
 have_global = ( have_global + 7 ) / 8;
 valsize = ( valsize + 7 ) / 8;
 switch( valsize )
 {
 case 1:
 type = H5Tcopy( H5T_NATIVE_B8 );
 break;
 case 2:
 type = H5Tcopy( H5T_NATIVE_B16 );
 break;
 case 3:
 case 4:
 valsize += 4 - valsize; // to avoid fallthrough warning
 type = H5Tcopy( H5T_NATIVE_B32 );
 break;
 case 5:
 case 6:
 case 7:
 case 8:
 valsize += 8 - valsize; // to avoid fallthrough warning
 type = H5Tcopy( H5T_NATIVE_B64 );
 break;
 default:
 free( result );
 mhdf_setFail( status, "Cannot create a bit tag larger than 64-bits. %d bits requested.\n",
 (int)valsize );
 return NULL;
 }
 close_type = 1;
 break;
 case mhdf_ENTITY_ID:
 if( 0 == type ) type = H5T_NATIVE_ULONG;
 size = get_file_id_size( type, status );
 if( !size )
 {
 free( result );
 return NULL;
 }
 have_default *= size;
 have_global *= size;
 valsize *= size;
 break;
 default:
 mhdf_setFail( status, "Unknown mhdf_TagDataType value (%d) for tag (\"%s\")", (int)result->tags[idx].type,
 name );
 free( result );
 return NULL;
 }
 result->tags[idx].bytes = valsize;
 
 if( result->tags[idx].type != mhdf_OPAQUE && result->tags[idx].type != mhdf_BITFIELD && result->tags[idx].size > 1 )
 {
 close_type = 1;
 array_len = result->tags[idx].size;
#if defined( H5Tarray_create_vers ) && H5Tarray_create_vers > 1
 type = H5Tarray_create2( type, 1, &array_len );
#else
 type = H5Tarray_create( type, 1, &array_len, 0 );
#endif
 if( type < 0 )
 {
 mhdf_setFail( status, "H5Tarray_create failed for tag (\"%s\")", name );
 free( result );
 return NULL;
 }
 }
 
 if( have_default || have_global )
 {
 if( have_default )
 {
 ptr = realloc_data( &result, have_default, status, sizeof(int) );
 if( NULL == ptr )
 {
 if( close_type )
 {
 H5Tclose( type );
 }
 return NULL;
 }
 result->tags[idx].default_value = ptr;
 }
 if( have_global )
 {
 ptr = realloc_data( &result, have_global, status, sizeof(int) );
 if( NULL == ptr )
 {
 if( close_type )
 {
 H5Tclose( type );
 }
 return NULL;
 }
 result->tags[idx].global_value = ptr;
 }
 mhdf_getTagValues( file_handle, name, type, result->tags[idx].default_value, result->tags[idx].global_value,
 status );
 if( close_type )
 {
 H5Tclose( type );
 }
 if( mhdf_isError( status ) )
 {
 free( result );
 return NULL;
 }
 }
 
 return result;
}
 
static void free_string_list( char** list, int count )
{
 int i;
 for( i = 0; i < count; ++i )
 free( list[i] );
 free( list );
}
 
struct mhdf_FileDesc* mhdf_getFileSummary( mhdf_FileHandle file_handle,
 hid_t file_id_type,
 mhdf_Status* status,
 int extraSetInfo )
{
 struct mhdf_FileDesc* result;
 hid_t table_id;
 int i, i1, numtags, j, k, size, *indices, have, num_tag_names = 0;
 unsigned int ui;
 void* ptr;
 char **elem_handles = 0, **tag_names = 0;
 unsigned char *array, *matrix;
 const char* pname[5] = { "PARALLEL_PARTITION", "MATERIAL_SET", "NEUMANN_SET", "DIRICHLET_SET", "GEOM_DIMENSION" };
 
 long* id_list;
 struct mhdf_TagDesc* tag_desc;
 long int nval, junk;
 hid_t table[3];
 hid_t data_type;
 
 API_BEGIN;
 
 mhdf_setOkay( status );
 result = alloc_file_desc( status );
 if( NULL == result ) return NULL;
 
 /* get node info */
 have = mhdf_haveNodes( file_handle, status );
 if( mhdf_isError( status ) )
 {
 free( result );
 return NULL;
 }
 if( have )
 {
 table_id = mhdf_openNodeCoords( file_handle, &result->nodes.count, &result->nodes.vals_per_ent,
 &result->nodes.start_id, status );
 if( table_id < 0 )
 {
 free( result );
 return NULL;
 }
 mhdf_closeData( file_handle, table_id, status );
 }
 else
 {
 result->nodes.count = 0;
 result->nodes.vals_per_ent = 0;
 result->nodes.start_id = 0;
 }
 
 /* get set info */
 result->sets.vals_per_ent = -1;
 have = mhdf_haveSets( file_handle, &result->have_set_contents, &result->have_set_children,
 &result->have_set_parents, status );
 if( mhdf_isError( status ) )
 {
 free( result );
 return NULL;
 }
 if( have )
 {
 table_id = mhdf_openSetMeta( file_handle, &result->sets.count, &result->sets.start_id, status );
 if( table_id < 0 )
 {
 free( result );
 return NULL;
 }
 mhdf_closeData( file_handle, table_id, status );
 }
 else
 {
 result->sets.count = 0;
 result->sets.start_id = 0;
 }
 
 /* get element list */
 elem_handles = mhdf_getElemHandles( file_handle, &ui, status );
 if( elem_handles == NULL )
 {
 free( result );
 return NULL;
 }
 result->num_elem_desc = ui;
 
 /* allocate array of element descriptors */
 size = result->num_elem_desc * sizeof( struct mhdf_ElemDesc );
 ptr = realloc_data( &result, size, status, sizeof( char* ) );
 if( NULL == ptr )
 {
 free( elem_handles );
 return NULL;
 }
 memset( ptr, 0, size );
 result->elems = ptr;
 
 /* Initialize each element descriptor */
 for( i = 0; i < result->num_elem_desc; ++i )
 {
 result = get_elem_desc( file_handle, result, elem_handles[i], i, status );
 if( NULL == result )
 {
 free( elem_handles );
 return NULL;
 }
 }
 
 /* get tag list */
 tag_names = mhdf_getTagNames( file_handle, &num_tag_names, status );
 if( mhdf_isError( status ) )
 {
 free( elem_handles );
 free( result );
 return NULL;
 }
 
 /* allocate array of tag descriptors */
 size = num_tag_names * sizeof( struct mhdf_TagDesc );
 ptr = realloc_data( &result, size, status, sizeof( char* ) );
 if( NULL == ptr )
 {
 free( elem_handles );
 free_string_list( tag_names, result->num_tag_desc );
 return NULL;
 }
 memset( ptr, 0, size );
 result->tags = ptr;
 result->num_tag_desc = num_tag_names;
 memset( result->tags, 0, size );
 
 /* Initialize each tag descriptor */
 for( i = 0; i < result->num_tag_desc; ++i )
 {
 result = get_tag_desc( file_handle, result, tag_names[i], i, file_id_type, status );
 if( NULL == result )
 {
 free( elem_handles );
 free_string_list( tag_names, num_tag_names );
 return NULL;
 }
 }
 
 /* Determine which dense tags are present */
 
 size = ( 2 + result->num_elem_desc ) * result->num_tag_desc;
 array = mhdf_malloc( size, status );
 if( NULL == array )
 {
 free( elem_handles );
 free_string_list( tag_names, num_tag_names );
 free( result );
 return NULL;
 }
 memset( array, 0, size );
 matrix = array + ( 2 * result->num_tag_desc );
 
 for( j = 0; j < result->num_tag_desc; ++j )
 {
 if( mhdf_haveDenseTag( file_handle, tag_names[j], mhdf_node_type_handle(), status ) )
 matrix[-1 * result->num_tag_desc + j] = 1;
 if( mhdf_haveDenseTag( file_handle, tag_names[j], mhdf_set_type_handle(), status ) )
 matrix[-2 * result->num_tag_desc + j] = 1;
 for( i = 0; i < result->num_elem_desc; ++i )
 if( mhdf_haveDenseTag( file_handle, tag_names[j], elem_handles[i], status ) )
 matrix[i * result->num_tag_desc + j] = 1;
 }
 free( elem_handles );
 free_string_list( tag_names, result->num_tag_desc );
 
 /* Populate dense tag lists for element types */
 for( i = -2; i < result->num_elem_desc; ++i )
 {
 size = 0;
 for( j = 0; j < result->num_tag_desc; ++j )
 size += matrix[i * result->num_tag_desc + j];
 if( !size )
 {
 indices = NULL;
 }
 else
 {
 indices = realloc_data( &result, size * sizeof( int ), status, sizeof( int ) );
 if( NULL == indices )
 {
 free( array );
 return NULL;
 }
 
 k = 0;
 for( j = 0; j < result->num_tag_desc; ++j )
 if( matrix[i * result->num_tag_desc + j] ) indices[k++] = j;
 assert( k == size );
 }
 
 if( i == -2 )
 {
 result->sets.dense_tag_indices = indices;
 result->sets.num_dense_tags = size;
 }
 else if( i == -1 )
 {
 result->nodes.dense_tag_indices = indices;
 result->nodes.num_dense_tags = size;
 }
 else
 {
 result->elems[i].desc.dense_tag_indices = indices;
 result->elems[i].desc.num_dense_tags = size;
 }
 }
 
 /* Populate dense tag lists for each tag */
 for( j = 0; j < result->num_tag_desc; ++j )
 {
 size = 0;
 for( i = -2; i < result->num_elem_desc; ++i )
 size += matrix[i * result->num_tag_desc + j];
 if( !size )
 {
 indices = 0;
 }
 else
 {
 indices = realloc_data( &result, size * sizeof( int ), status, sizeof( int ) );
 if( NULL == ptr )
 {
 free( array );
 return NULL;
 }
 
 k = 0;
 for( i = -2; i < result->num_elem_desc; ++i )
 if( matrix[i * result->num_tag_desc + j] ) indices[k++] = i;
 assert( k == size );
 }
 
 result->tags[j].num_dense_indices = size;
 result->tags[j].dense_elem_indices = indices;
 }
 
 if( extraSetInfo )
 {
 /* open the table for parallel partitions, material sets, neumann sets,
 * dirichlet sets
 * to determine number of parts, etc
 * this is needed for iMOAB and VisIt plugin */
 const int NPRIMARY_SETS = 5;
 ptr = realloc_data( &result, NPRIMARY_SETS * sizeof( int ), status, sizeof( int ) );
 if( NULL == ptr || mhdf_isError( status ) )
 {
 free( array );
 return NULL;
 }
 result->numEntSets = ptr;
 for( i = 0; i < NPRIMARY_SETS; ++i )
 result->numEntSets[i] = 0;
 
 ptr = realloc_data( &result, NPRIMARY_SETS * sizeof( int* ), status, sizeof( int* ) );
 if( NULL == ptr || mhdf_isError( status ) )
 {
 free( array );
 return NULL;
 }
 result->defTagsEntSets = ptr;
 
 ptr = realloc_data( &result, NPRIMARY_SETS * sizeof( int* ), status, sizeof( int* ) );
 if( NULL == ptr || mhdf_isError( status ) )
 {
 free( array );
 return NULL;
 }
 result->defTagsVals = ptr;
 numtags = result->num_tag_desc;
 
 for( i = 0; i < numtags; i++ )
 {
 tag_desc = &( result->tags[i] );
 for( k = 0; k < NPRIMARY_SETS; k++ ) /* number of default tags to consider */
 {
 if( strcmp( pname[k], tag_desc->name ) == 0 )
 {
 if( tag_desc->have_sparse )
 {
 mhdf_openSparseTagData( file_handle, pname[k], &nval, &junk, table, status );
 if( mhdf_isError( status ) )
 {
 free( array );
 return NULL;
 }
 /* for sparse tags, read */
 result->numEntSets[k] = nval;
 if( nval <= 0 ) continue; /* do not do anything */
 
 ptr = realloc_data( &result, nval * sizeof( int ), status, sizeof( int ) );
 if( NULL == ptr || mhdf_isError( status ) )
 {
 free( array );
 return NULL;
 }
 memset( ptr, 0, nval * sizeof( int ) );
 result->defTagsEntSets[k] = ptr;
 tag_desc = &( result->tags[i] );
 
 ptr = realloc_data( &result, nval * sizeof( int ), status, sizeof( int ) );
 if( NULL == ptr || mhdf_isError( status ) )
 {
 free( array );
 return NULL;
 }
 memset( ptr, 0, nval * sizeof( int ) );
 result->defTagsVals[k] = ptr;
 tag_desc = &( result->tags[i] ); /* this is because the tag might point to
 something else*/
 
 /* make room for the long array type
 is it long or something else? */
 id_list = mhdf_malloc( nval * sizeof( long ), status );
 /* fill the id with values, then convert to int type (-set start)
 
 mhdf_read_data( table_id, offset, count, int_type, id_list, H5P_DEFAULT,
 status );*/
 
 data_type = H5Dget_type( table[0] );
 
 mhdf_read_data( table[0], 0, nval, data_type, id_list, H5P_DEFAULT, status );
 if( mhdf_isError( status ) )
 {
 free( array );
 return NULL;
 }
 H5Tclose( data_type );
 
 for( i1 = 0; i1 < nval; i1++ )
 result->defTagsEntSets[k][i1] = (int)( id_list[i1] - result->sets.start_id + 1 );
 /* now read values, integer type */
 data_type = H5Dget_type( table[1] );
 mhdf_read_data( table[1], 0, nval, data_type, result->defTagsVals[k], H5P_DEFAULT, status );
 if( mhdf_isError( status ) )
 {
 free( array );
 return NULL;
 }
 H5Tclose( data_type );
 mhdf_closeData( file_handle, table[0], status );
 if( mhdf_isError( status ) )
 {
 free( array );
 return NULL;
 }
 mhdf_closeData( file_handle, table[1], status );
 if( mhdf_isError( status ) )
 {
 free( array );
 return NULL;
 }
 free( id_list );
 }
 else if( 0 == k || 1 == k )
 { /* parallel partition or material sets should still work if dense
 could be dense tags on sets */
 if( !mhdf_haveDenseTag( file_handle, pname[k], mhdf_set_type_handle(), status ) ) continue;
 table[0] =
 mhdf_openDenseTagData( file_handle, pname[k], mhdf_set_type_handle(), &nval, status );
 if( mhdf_isError( status ) )
 {
 continue; /* do not error out if not a dense tag either */
 }
 result->numEntSets[k] = nval;
 if( nval <= 0 ) continue; /* do not do anything */
 
 /*
 * if dense parallel partition or material set, we know what to expect
 */
 result->numEntSets[k] = nval; /* k could be 0 or 1 */
 if( nval <= 0 ) continue; /* do not do anything */
 
 ptr = realloc_data( &result, nval * sizeof( int ), status, sizeof( int ) );
 if( NULL == ptr || mhdf_isError( status ) )
 {
 free( array );
 return NULL;
 }
 memset( ptr, 0, nval * sizeof( int ) );
 result->defTagsEntSets[k] = ptr;
 tag_desc = &( result->tags[i] );
 
 ptr = realloc_data( &result, nval * sizeof( int ), status, sizeof( int ) );
 if( NULL == ptr || mhdf_isError( status ) )
 {
 free( array );
 return NULL;
 }
 memset( ptr, 0, nval * sizeof( int ) );
 result->defTagsVals[k] = ptr;
 tag_desc = &( result->tags[i] ); /* this is because the tag might point to
 something else*/
 
 for( i1 = 0; i1 < nval; i1++ )
 {
 result->defTagsEntSets[k][i1] = i1 + 1;
 /*result -> defTagsVals[k][i1] = i1; we know how the partition looks
 * like */
 }
 /* fill in the data with the dense tag values
 because dense, sets will be in order
 
 we know it has to be integer */
 mhdf_readTagValues( table[0], 0, nval, H5T_NATIVE_INT, result->defTagsVals[k], status );
 if( mhdf_isError( status ) )
 {
 free( array );
 return NULL;
 }
 mhdf_closeData( file_handle, table[0], status );
 if( mhdf_isError( status ) )
 {
 free( array );
 return NULL;
 }
 }
 }
 }
 }
 }
 /* Compact memory and return */
 free( array );
 result->total_size = result->offset - (unsigned char*)result;
 
 API_END;
 return result;
}