Mesh Oriented datABase  (version 5.5.1)
An array-based unstructured mesh library
file.c
Go to the documentation of this file.
1 /**
2  * MOAB, a Mesh-Oriented datABase, is a software component for creating,
3  * storing and accessing finite element mesh data.
4  *
5  * Copyright 2004 Sandia Corporation. Under the terms of Contract
6  * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
7  * retains certain rights in this software.
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  */
15 
16 #include <stdlib.h>
17 #include <string.h>
18 #include <assert.h>
19 #include <H5Fpublic.h>
20 #include <H5Ppublic.h>
21 #include <H5Gpublic.h>
22 #include <H5Spublic.h>
23 #include <H5Tpublic.h>
24 #include <H5Apublic.h>
25 #ifdef MOAB_HAVE_HDF5_PARALLEL
26 #include <H5FDmpi.h>
27 #include <H5FDmpio.h>
28 #endif
29 #include "mhdf.h"
30 #include "status.h"
31 #include "names-and-paths.h"
32 #include "util.h"
33 #include "file-handle.h"
34 
35 static int make_hdf_group( const char* path, hid_t file, size_t size, mhdf_Status* status );
36 
37 mhdf_FileHandle mhdf_createFile( const char* filename,
38  int overwrite,
39  const char** elem_type_list,
40  size_t elem_list_len,
41  hid_t id_type,
42  mhdf_Status* status )
43 {
44  FileHandle* file_ptr;
45  unsigned int flags;
46  unsigned char idx;
47  size_t i;
48  hid_t enum_id, group_id;
49  int rval;
50  API_BEGIN;
51 
52  if( elem_list_len > 255 )
53  {
54  mhdf_setFail( status, "Element type list too long." );
55  return NULL;
56  }
57  mhdf_setOkay( status );
58 
59  /* Create struct to hold working data */
60  file_ptr = mhdf_alloc_FileHandle( 0, id_type, status );
61  if( !file_ptr ) return NULL;
62 
63  /* Create the file */
64  flags = overwrite ? H5F_ACC_TRUNC : H5F_ACC_EXCL;
65  file_ptr->hdf_handle = H5Fcreate( filename, flags, H5P_DEFAULT, H5P_DEFAULT );
66  if( file_ptr->hdf_handle < 0 )
67  {
68  mhdf_setFail( status, "Failed to create file \"%s\"", filename );
69  free( file_ptr );
70  return NULL;
71  }
72 
73  /* Create file structure */
74  if( !make_hdf_group( ROOT_GROUP, file_ptr->hdf_handle, 6, status ) ||
75  !make_hdf_group( TAG_GROUP, file_ptr->hdf_handle, 0, status ) ||
76  !make_hdf_group( ELEMENT_GROUP, file_ptr->hdf_handle, 8, status ) ||
77  !make_hdf_group( NODE_GROUP, file_ptr->hdf_handle, 3, status ) ||
78  !make_hdf_group( SET_GROUP, file_ptr->hdf_handle, 5, status ) ||
79  !make_hdf_group( NODE_TAG_GROUP, file_ptr->hdf_handle, 0, status ) ||
80  !make_hdf_group( SET_TAG_GROUP, file_ptr->hdf_handle, 0, status ) )
81  {
82  H5Fclose( file_ptr->hdf_handle );
83  free( file_ptr );
84  return NULL;
85  }
86 
87  /* Store the max ID as an attribite on the /tstt/ group */
88 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
89  group_id = H5Gopen2( file_ptr->hdf_handle, ROOT_GROUP, H5P_DEFAULT );
90 #else
91  group_id = H5Gopen( file_ptr->hdf_handle, ROOT_GROUP );
92 #endif
93  rval = mhdf_create_scalar_attrib( group_id, MAX_ID_ATTRIB, H5T_NATIVE_ULONG, &file_ptr->max_id, status );
94  H5Gclose( group_id );
95  if( !rval )
96  {
97  H5Fclose( file_ptr->hdf_handle );
98  free( file_ptr );
99  return NULL;
100  }
101 
102  /* Create the type name list in file */
103  enum_id = H5Tenum_create( H5T_NATIVE_UCHAR );
104  if( enum_id < 0 )
105  {
106  mhdf_setFail( status, "Failed to store elem type list." );
107  H5Fclose( file_ptr->hdf_handle );
108  free( file_ptr );
109  return NULL;
110  }
111  for( i = 0; i < elem_list_len; ++i )
112  {
113  if( !elem_type_list[i] || !*elem_type_list[i] ) continue;
114 
115  idx = (unsigned char)i;
116  if( H5Tenum_insert( enum_id, elem_type_list[i], &idx ) < 0 )
117  {
118  mhdf_setFail( status, "Failed to store elem type list." );
119  H5Fclose( file_ptr->hdf_handle );
120  free( file_ptr );
121  return NULL;
122  }
123  }
124 #if defined( H5Tcommit_vers ) && H5Tcommit_vers > 1
125  if( H5Tcommit2( file_ptr->hdf_handle, TYPE_ENUM_PATH, enum_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT ) < 0 )
126 #else
127  if( H5Tcommit( file_ptr->hdf_handle, TYPE_ENUM_PATH, enum_id ) < 0 )
128 #endif
129  {
130  mhdf_setFail( status, "Failed to store elem type list." );
131  H5Fclose( file_ptr->hdf_handle );
132  free( file_ptr );
133  return NULL;
134  }
135  H5Tclose( enum_id );
136 
137  API_END_H( 1 );
138  return file_ptr;
139 }
140 
141 mhdf_FileHandle mhdf_openFile( const char* filename,
142  int writeable,
143  unsigned long* max_id_out,
144  hid_t id_type,
145  mhdf_Status* status )
146 {
147  return mhdf_openFileWithOpt( filename, writeable, max_id_out, id_type, H5P_DEFAULT, status );
148 }
149 
150 int mhdf_countOpenHandles( mhdf_FileHandle file_handle )
151 {
152  return H5Fget_obj_count( ( (FileHandle*)file_handle )->hdf_handle, H5F_OBJ_ALL );
153 }
154 
155 static herr_t get_max_id( hid_t group_id, const char* subgroup, const char* datatable, unsigned long* data )
156 {
157  unsigned long id;
158  hid_t elem_id, conn_id, attr_id, space_id;
159  herr_t rval;
160  int rank;
161  hsize_t dims[2];
162 
163 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
164  elem_id = H5Gopen2( group_id, subgroup, H5P_DEFAULT );
165 #else
166  elem_id = H5Gopen( group_id, subgroup );
167 #endif
168  if( elem_id < 0 ) return (herr_t)-1;
169 
170 #if defined( H5Dopen_vers ) && H5Dopen_vers > 1
171  conn_id = H5Dopen2( elem_id, datatable, H5P_DEFAULT );
172 #else
173  conn_id = H5Dopen( elem_id, datatable );
174 #endif
175  H5Gclose( elem_id );
176  if( conn_id < 0 ) return (herr_t)-1;
177 
178  space_id = H5Dget_space( conn_id );
179  if( space_id < 0 )
180  {
181  H5Dclose( conn_id );
182  return -1;
183  }
184 
185  rank = H5Sget_simple_extent_ndims( space_id );
186  if( rank <= 0 || rank > 2 )
187  {
188  H5Dclose( conn_id );
189  H5Sclose( space_id );
190  return -1;
191  }
192 
193  rval = H5Sget_simple_extent_dims( space_id, dims, NULL );
194  H5Sclose( space_id );
195  if( rval < 0 )
196  {
197  H5Dclose( conn_id );
198  return -1;
199  }
200 
201  attr_id = H5Aopen_name( conn_id, START_ID_ATTRIB );
202  H5Dclose( conn_id );
203  if( attr_id < 0 ) return (herr_t)-1;
204 
205  rval = H5Aread( attr_id, H5T_NATIVE_ULONG, &id );
206  H5Aclose( attr_id );
207  if( rval < 0 ) return rval;
208 
209  id += dims[0];
210  if( id > *data ) *data = id;
211  return 0;
212 }
213 
214 static herr_t max_id_iter( hid_t group_id, const char* name, void* data )
215 {
216  return get_max_id( group_id, name, CONNECTIVITY_NAME, (unsigned long*)data );
217 }
218 
219 static int scan_for_max_id( FileHandle* file_ptr, mhdf_Status* status )
220 {
221  hid_t group_id;
222  herr_t rval;
223 
224  /* Check for new format, with max_id as attrib of root group */
225 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
226  group_id = H5Gopen2( file_ptr->hdf_handle, ROOT_GROUP, H5P_DEFAULT );
227 #else
228  group_id = H5Gopen( file_ptr->hdf_handle, ROOT_GROUP );
229 #endif
230  if( group_id < 0 )
231  {
232  mhdf_setFail( status, "Internal error - invalid file." );
233  return 0;
234  }
235  if( mhdf_read_scalar_attrib( group_id, MAX_ID_ATTRIB, H5T_NATIVE_ULONG, &file_ptr->max_id, status ) )
236  {
237  H5Gclose( group_id );
238  return 1;
239  }
240 
241  /* Didn't find it, scan the elements group */
242  rval = H5Giterate( group_id, ELEMENT_GROUP_NAME, 0, &max_id_iter, &file_ptr->max_id );
243  if( rval )
244  {
245  H5Gclose( group_id );
246  mhdf_setFail( status, "Internal error -- invalid file." );
247  return 0;
248  }
249 
250  /* Check node table too */
251  rval = get_max_id( group_id, NODE_GROUP_NAME, "coordinates", (unsigned long*)( &file_ptr->max_id ) );
252  if( rval )
253  {
254  H5Gclose( group_id );
255  mhdf_setFail( status, "Internal error -- invalid file." );
256  return 0;
257  }
258 
259  /* Check set table, if it exists */
260  rval = mhdf_is_in_group( group_id, SET_GROUP_NAME, status );
261  if( rval < 1 )
262  {
263  H5Gclose( group_id );
264  return !rval;
265  }
266  rval = get_max_id( group_id, SET_GROUP_NAME, SET_META_NAME, (unsigned long*)( &file_ptr->max_id ) );
267  H5Gclose( group_id );
268  if( rval )
269  {
270  mhdf_setFail( status, "Internal error -- invalid file." );
271  return 0;
272  }
273 
274  return 1;
275 }
276 
277 mhdf_FileHandle mhdf_openFileWithOpt( const char* filename,
278  int writable,
279  unsigned long* max_id_out,
280  hid_t id_type,
281  hid_t access_prop,
282  mhdf_Status* status )
283 {
284  FileHandle* file_ptr;
285  unsigned int flags;
286  hid_t group_id;
287  int check_is_hdf5 = 1;
288 #ifdef MOAB_HAVE_HDF5_PARALLEL
289  herr_t err;
290  MPI_Comm comm;
291  MPI_Info info;
292 #endif
293  API_BEGIN;
294 
295  /* Check if file is HDF5 */
296  /* Don't do this because it can't handle MPI-IO driver code that
297  passes options via prefixes on the file name. */
298 #ifdef MOAB_HAVE_HDF5_PARALLEL
299  if( access_prop != H5P_DEFAULT )
300  {
301  err = H5Pget_fapl_mpio( access_prop, &comm, &info );
302  if( err >= 0 )
303  {
304  check_is_hdf5 = 0;
305  /* MPI Documentation is inconsistent with regards to whether
306  or not the above call dup's these, but my testing with 1.8.3
307  indicates that at least for that version they are not.
308  MPI_Comm_free(&comm);
309  MPI_Info_free(&info); */
310  }
311  }
312 #endif
313  if( check_is_hdf5 && H5Fis_hdf5( filename ) <= 0 )
314  {
315  mhdf_setFail( status, "%s: File is not HDF5", filename );
316  return NULL;
317  }
318 
319  /* Create struct to hold working data */
320  file_ptr = mhdf_alloc_FileHandle( 0, id_type, status );
321  if( !file_ptr )
322  {
323  mhdf_setFail( status, "Memory allocation failed" );
324  return NULL;
325  }
326 
327  /* Create the file */
328  flags = writable ? H5F_ACC_RDWR : H5F_ACC_RDONLY;
329  file_ptr->hdf_handle = H5Fopen( filename, flags, access_prop );
330  if( file_ptr->hdf_handle < 0 )
331  {
332  mhdf_setFail( status, "Failed to open file \"%s\"", filename );
333  free( file_ptr );
334  return NULL;
335  }
336 
337  /* Check for TSTT data in file */
338 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
339  group_id = H5Gopen2( file_ptr->hdf_handle, ROOT_GROUP, H5P_DEFAULT );
340 #else
341  group_id = H5Gopen( file_ptr->hdf_handle, ROOT_GROUP );
342 #endif
343  if( group_id < 0 )
344  {
345  mhdf_setFail( status, "Invalid file \"%s\"\n", filename );
346  H5Fclose( file_ptr->hdf_handle );
347  free( file_ptr );
348  return NULL;
349  }
350  H5Gclose( group_id );
351 
352  /* Get max id */
353  if( !scan_for_max_id( file_ptr, status ) )
354  {
355  H5Fclose( file_ptr->hdf_handle );
356  mhdf_setFail( status, "Internal error reading file" );
357  free( file_ptr );
358  return NULL;
359  }
360 
361  if( max_id_out ) *max_id_out = file_ptr->max_id;
362 
363  mhdf_setOkay( status );
364  API_END_H( 1 );
365  return file_ptr;
366 }
367 
368 void mhdf_getElemName( mhdf_FileHandle file_handle,
369  unsigned int type_index,
370  char* buffer,
371  size_t buf_size,
372  mhdf_Status* status )
373 {
374  FileHandle* file_ptr;
375  herr_t rval;
376  hid_t enum_id;
377  API_BEGIN;
378 
379  if( type_index > 255 )
380  {
381  mhdf_setFail( status, "Type index out of bounds." );
382  return;
383  }
384 
385  file_ptr = (FileHandle*)( file_handle );
386  if( !mhdf_check_valid_file( file_ptr, status ) ) return;
387 
388  enum_id = get_elem_type_enum( file_ptr, status );
389  if( enum_id < 0 ) return;
390 
391  rval = H5Tconvert( H5T_NATIVE_UINT, H5Tget_super( enum_id ), 1, &type_index, NULL, H5P_DEFAULT );
392  if( rval < 0 )
393  {
394  H5Tclose( enum_id );
395  mhdf_setFail( status, "Internal error converting to enum type." );
396  return;
397  }
398 
399  rval = H5Tenum_nameof( enum_id, &type_index, buffer, buf_size );
400  H5Tclose( enum_id );
401  if( rval < 0 )
402  mhdf_setFail( status, "H5Tenum_nameof failed. Invalid type index?" );
403  else
404  mhdf_setOkay( status );
405 
406  API_END;
407 }
408 
409 int mhdf_checkOpenHandles( mhdf_FileHandle handle, mhdf_Status* status )
410 {
411  FileHandle* file_ptr;
412  int result;
413  API_BEGIN;
414 
415  file_ptr = (FileHandle*)( handle );
416  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
417 
418  /* Check for open handles. HDF5 will not actually close the
419  file until all handles are closed. */
420  result = H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_ALL );
421  if( result != 1 )
422  {
423  mhdf_setFail( status,
424  "Cannot close file with open handles: "
425  "%d file, %d data, %d group, %d type, %d attr\n",
426  H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_FILE ) - 1,
427  H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_DATASET ),
428  H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_GROUP ),
429  H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_DATATYPE ),
430  H5Fget_obj_count( file_ptr->hdf_handle, H5F_OBJ_ATTR ) );
431  return result - 1;
432  }
433 
434  API_END_H( 0 );
435  return 0;
436 }
437 
438 void mhdf_closeFile( mhdf_FileHandle handle, mhdf_Status* status )
439 {
440  FileHandle* file_ptr;
441  API_BEGIN;
442 
443  file_ptr = (FileHandle*)( handle );
444  if( !mhdf_check_valid_file( file_ptr, status ) ) return;
445  /*
446  if (file_ptr->open_handle_count)
447  {
448  mhdf_setError( status, "Cannot close file with %d open data handles.",
449  file_ptr->open_handle_count );
450  return;
451  }
452  */
453 
454  /* Check for open handles. HDF5 will not actually close the
455  file until all handles are closed. */
456  if( mhdf_checkOpenHandles( handle, status ) ) return;
457 
458  if( 0 > H5Fclose( file_ptr->hdf_handle ) )
459  {
460  mhdf_setFail( status, "H5FClose failed. Invalid handle?" );
461  return;
462  }
463 
464  memset( file_ptr, 0, sizeof( FileHandle ) );
465  free( file_ptr );
466  mhdf_setOkay( status );
467  API_END_H( -1 );
468 }
469 
470 void mhdf_closeData( mhdf_FileHandle file, hid_t handle, mhdf_Status* status )
471 {
472  FileHandle* file_ptr;
473  herr_t rval = -1;
474 
475  file_ptr = (FileHandle*)( file );
476  if( !mhdf_check_valid_file( file_ptr, status ) ) return;
477 
478  switch( H5Iget_type( handle ) )
479  {
480  case H5I_GROUP:
481  rval = H5Gclose( handle );
482  break;
483  case H5I_DATATYPE:
484  rval = H5Tclose( handle );
485  break;
486  case H5I_DATASPACE:
487  rval = H5Sclose( handle );
488  break;
489  case H5I_DATASET:
490  rval = H5Dclose( handle );
491  break;
492  default:
493  rval = -1;
494  }
495 
496  if( rval < 0 )
497  {
498  mhdf_setFail( status, "H5Xclose failed. Invalid handle?\n" );
499  }
500  else
501  {
502  file_ptr->open_handle_count--;
503  mhdf_setOkay( status );
504  }
505 }
506 
507 void mhdf_addElement( mhdf_FileHandle file_handle, const char* name, unsigned int elem_type, mhdf_Status* status )
508 {
509  FileHandle* file_ptr = (FileHandle*)file_handle;
510  hid_t group_id, tag_id, enum_id;
511  char *path, *ptr;
512  size_t name_len;
513  herr_t rval;
514  API_BEGIN;
515 
516  if( !mhdf_check_valid_file( file_ptr, status ) ) return;
517 
518  name_len = mhdf_name_to_path( name, NULL, 0 );
519  name_len += strlen( ELEMENT_GROUP ) + 1;
520  path = (char*)mhdf_malloc( name_len, status );
521  if( !path ) return;
522 
523  strcpy( path, ELEMENT_GROUP );
524  ptr = path + strlen( ELEMENT_GROUP );
525  if( !mhdf_path_to_name( name, ptr ) )
526  {
527  mhdf_setFail( status, "Invalid character string in internal file path: \"%s\"\n", name );
528  return;
529  }
530 
531 #if defined( H5Gcreate_vers ) && H5Gcreate_vers > 1
532  group_id = H5Gcreate2( file_ptr->hdf_handle, path, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT );
533 #else
534  group_id = H5Gcreate( file_ptr->hdf_handle, path, 3 );
535 #endif
536  if( group_id < 0 )
537  {
538  mhdf_setFail( status, "Creation of \"%s\" group failed.\n", path );
539  free( path );
540  return;
541  }
542  free( path );
543 
544 #if defined( H5Gcreate_vers ) && H5Gcreate_vers > 1
545  tag_id = H5Gcreate2( group_id, DENSE_TAG_SUBGROUP, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT );
546 #else
547  tag_id = H5Gcreate( group_id, DENSE_TAG_SUBGROUP, 0 );
548 #endif
549  if( tag_id < 0 )
550  {
551  H5Gclose( group_id );
552  mhdf_setFail( status, "Creation of tag subgroup failed.\n" );
553  return;
554  }
555  H5Gclose( tag_id );
556 
557  enum_id = get_elem_type_enum( file_ptr, status );
558  if( enum_id < 0 )
559  {
560  H5Gclose( group_id );
561  return;
562  }
563 
564  rval = H5Tconvert( H5T_NATIVE_UINT, H5Tget_super( enum_id ), 1, &elem_type, NULL, H5P_DEFAULT );
565  if( rval < 0 )
566  {
567  H5Gclose( group_id );
568  H5Tclose( enum_id );
569  mhdf_setFail( status, "Internal error converting to enum type." );
570  return;
571  }
572 
573  rval = mhdf_create_scalar_attrib( group_id, ELEM_TYPE_ATTRIB, enum_id, &elem_type, status );
574  H5Tclose( enum_id );
575  if( rval < 0 )
576  {
577  H5Gclose( group_id );
578  return;
579  }
580 
581  H5Gclose( group_id );
582  mhdf_setOkay( status );
583  API_END;
584 }
585 
586 char** mhdf_getElemHandles( mhdf_FileHandle file_handle, unsigned int* count_out, mhdf_Status* status )
587 {
588  hsize_t count, length, i;
589  char** buffer;
590  char* current;
591  hid_t group_id;
592  herr_t rval;
593  ssize_t rlen = 0;
594  size_t remaining;
595  FileHandle* file_ptr = (FileHandle*)file_handle;
596  if( !mhdf_check_valid_file( file_ptr, status ) ) return NULL;
597 
598 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
599  group_id = H5Gopen2( file_ptr->hdf_handle, ELEMENT_GROUP, H5P_DEFAULT );
600 #else
601  group_id = H5Gopen( file_ptr->hdf_handle, ELEMENT_GROUP );
602 #endif
603  if( group_id < 0 )
604  {
605  mhdf_setFail( status, "Invalid file -- element group does not exist." );
606  return NULL;
607  }
608 
609  rval = H5Gget_num_objs( group_id, &count );
610  if( rval < 0 )
611  {
612  H5Gclose( group_id );
613  mhdf_setFail( status, "Internal error calling H5Gget_num_objs." );
614  return NULL;
615  }
616  *count_out = count;
617 
618  for( i = 0; i < count; ++i )
619  {
620  rlen += H5Gget_objname_by_idx( group_id, i, NULL, 0 ) + 1;
621  }
622 
623  length = count * sizeof( char* ) + rlen;
624  buffer = (char**)mhdf_malloc( length, status );
625  if( !buffer )
626  {
627  H5Gclose( group_id );
628  return NULL;
629  }
630  current = (char*)( buffer + count );
631  remaining = rlen;
632 
633  for( i = 0; i < count; ++i )
634  {
635  buffer[i] = current;
636  rlen = H5Gget_objname_by_idx( group_id, i, current, remaining ) + 1;
637  if( rlen < 0 )
638  {
639  H5Gclose( group_id );
640  free( buffer );
641  mhdf_setFail( status, "Internal error calling H5Gget_objname_by_idx." );
642  return NULL;
643  }
644 
645  mhdf_path_to_name( current, current );
646  remaining -= rlen;
647  current += rlen;
648  }
649 
650  H5Gclose( group_id );
651  mhdf_setOkay( status );
652  return buffer;
653 }
654 
655 void mhdf_getElemTypeName( mhdf_FileHandle file_handle,
656  const char* elem_handle,
657  char* buffer,
658  size_t buf_len,
659  mhdf_Status* status )
660 {
661  FileHandle* file_ptr;
662  hid_t elem_id, type_id, attr_id;
663  char bytes[16];
664  herr_t rval;
665  API_BEGIN;
666 
667  if( NULL == buffer || buf_len < 2 )
668  {
669  mhdf_setFail( status, "invalid input" );
670  return;
671  }
672  buffer[0] = '\0';
673 
674  file_ptr = (FileHandle*)( file_handle );
675  if( !mhdf_check_valid_file( file_ptr, status ) ) return;
676 
677  elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status );
678  if( elem_id < 0 ) return;
679 
680  attr_id = H5Aopen_name( elem_id, ELEM_TYPE_ATTRIB );
681  H5Gclose( elem_id );
682  if( attr_id < 0 )
683  {
684  mhdf_setFail( status, "Missing element type attribute. Invalid file." );
685  return;
686  }
687 
688  type_id = H5Aget_type( attr_id );
689  assert( type_id > 0 );
690 
691  rval = H5Aread( attr_id, type_id, bytes );
692  H5Aclose( attr_id );
693  if( rval < 0 )
694  {
695  H5Tclose( type_id );
696  mhdf_setFail( status, "Failed to read element type attribute. Invalid file." );
697  return;
698  }
699 
700  rval = H5Tenum_nameof( type_id, bytes, buffer, buf_len );
701  H5Tclose( type_id );
702  if( rval < 0 )
703  {
704  mhdf_setFail( status, "Invalid datatype for element type attribute. Invalid file." );
705  return;
706  }
707 
708  mhdf_setOkay( status );
709  API_END;
710  return;
711 }
712 
713 static int make_hdf_group( const char* path, hid_t file, size_t sz, mhdf_Status* status )
714 {
715 #if defined( H5Gcreate_vers ) && H5Gcreate_vers > 1
716  hid_t handle = H5Gcreate2( file, path, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT );
717  /* empty statement to avoid compiler warning */
718  if( sz )
719  {
720  }
721 #else
722  hid_t handle = H5Gcreate( file, path, sz );
723 #endif
724  if( handle < 0 )
725  {
726  mhdf_setFail( status, "Failed to create \"%s\" group.", path );
727  return 0;
728  }
729  else
730  {
731  H5Gclose( handle );
732  return 1;
733  }
734 }
735 
736 const char* mhdf_node_type_handle( void )
737 {
738  static const char rval[] = "nodes";
739  return rval;
740 }
741 
742 const char* mhdf_set_type_handle( void )
743 {
744  static const char rval[] = "sets";
745  return rval;
746 }
747 
748 int mhdf_isPolyElement( mhdf_FileHandle file_handle, const char* elem_handle, mhdf_Status* status )
749 {
750  FileHandle* file_ptr;
751  hid_t elem_id;
752  int rval;
753  API_BEGIN;
754 
755  file_ptr = (FileHandle*)( file_handle );
756  if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
757 
758  elem_id = mhdf_elem_group_from_handle( file_ptr, elem_handle, status );
759  if( elem_id < 0 ) return -1;
760 
761  mhdf_setOkay( status );
762  rval = mhdf_is_in_group( elem_id, POLY_INDEX_NAME, status );
763  H5Gclose( elem_id );
764  API_END;
765  return rval;
766 }
767 
768 void mhdf_writeHistory( mhdf_FileHandle file_handle, const char** strings, int num_strings, mhdf_Status* status )
769 {
770  FileHandle* file_ptr;
771  hid_t data_id, type_id, space_id;
772  hsize_t dim = (hsize_t)num_strings;
773  herr_t rval;
774  API_BEGIN;
775 
776  file_ptr = (FileHandle*)( file_handle );
777  if( !mhdf_check_valid_file( file_ptr, status ) ) return;
778 
779  type_id = H5Tcopy( H5T_C_S1 );
780  if( type_id < 0 || H5Tset_size( type_id, H5T_VARIABLE ) < 0 )
781  {
782  if( type_id >= 0 ) H5Tclose( type_id );
783  mhdf_setFail( status, "Could not create variable length string type." );
784  return;
785  }
786 
787  space_id = H5Screate_simple( 1, &dim, NULL );
788  if( space_id < 0 )
789  {
790  H5Tclose( type_id );
791  mhdf_setFail( status, "H5Screate_simple failed." );
792  return;
793  }
794 
795 #if defined( H5Dcreate_vers ) && H5Dcreate_vers > 1
796  data_id =
797  H5Dcreate2( file_ptr->hdf_handle, HISTORY_PATH, type_id, space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT );
798 #else
799  data_id = H5Dcreate( file_ptr->hdf_handle, HISTORY_PATH, type_id, space_id, H5P_DEFAULT );
800 #endif
801  H5Sclose( space_id );
802  if( data_id < 0 )
803  {
804  H5Tclose( type_id );
805  mhdf_setFail( status, "Failed to create \"%s\".", HISTORY_PATH );
806  return;
807  }
808 
809  rval = H5Dwrite( data_id, type_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, strings );
810  H5Dclose( data_id );
811  H5Tclose( type_id );
812  if( rval < 0 )
813  {
814  H5Gunlink( file_ptr->hdf_handle, HISTORY_PATH );
815  mhdf_setFail( status, "Failed to write history data." );
816  return;
817  }
818 
819  mhdf_setOkay( status );
820  API_END;
821 }
822 
823 char** mhdf_readHistory( mhdf_FileHandle file_handle, int* num_strings, mhdf_Status* status )
824 {
825  FileHandle* file_ptr;
826  hid_t data_id, type_id, space_id, group_id;
827  hsize_t dim;
828  herr_t rval;
829  char** array;
830  API_BEGIN;
831 
832  file_ptr = (FileHandle*)( file_handle );
833  if( !mhdf_check_valid_file( file_ptr, status ) ) return NULL;
834 
835  /* check if file contains history data */
836 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
837  group_id = H5Gopen2( file_ptr->hdf_handle, ROOT_GROUP, H5P_DEFAULT );
838 #else
839  group_id = H5Gopen( file_ptr->hdf_handle, ROOT_GROUP );
840 #endif
841  if( group_id < 0 )
842  {
843  mhdf_setFail( status, "Could not open root group. Invalid file." );
844  return NULL;
845  }
846 
847  rval = mhdf_is_in_group( group_id, HISTORY_NAME, status );
848  if( rval < 1 )
849  {
850  H5Gclose( group_id );
851  *num_strings = 0;
852  if( 0 == rval ) mhdf_setOkay( status );
853  return NULL;
854  }
855 
856 #if defined( H5Dopen_vers ) && H5Dopen_vers > 1
857  data_id = H5Dopen2( group_id, HISTORY_NAME, H5P_DEFAULT );
858 #else
859  data_id = H5Dopen( group_id, HISTORY_NAME );
860 #endif
861  H5Gclose( group_id );
862  if( data_id < 0 )
863  {
864  mhdf_setFail( status, "Failed to open \"%s\".", HISTORY_PATH );
865  return NULL;
866  }
867 
868  space_id = H5Dget_space( data_id );
869  if( space_id < 0 )
870  {
871  H5Dclose( data_id );
872  mhdf_setFail( status, "Internal error calling H5Dget_space." );
873  return NULL;
874  }
875 
876  if( 1 != H5Sget_simple_extent_ndims( space_id ) || 1 != H5Sget_simple_extent_dims( space_id, &dim, NULL ) )
877  {
878  H5Dclose( data_id );
879  mhdf_setFail( status, "Invalid dimension for \"%s\".", HISTORY_PATH );
880  return NULL;
881  }
882  H5Sclose( space_id );
883 
884  if( 0 == dim )
885  {
886  H5Dclose( data_id );
887  *num_strings = 0;
888  mhdf_setOkay( status );
889  return NULL;
890  }
891 
892  array = (char**)mhdf_malloc( dim * sizeof( char* ), status );
893  if( !array )
894  {
895  H5Dclose( data_id );
896  return NULL;
897  }
898 
899  type_id = H5Tcopy( H5T_C_S1 );
900  if( type_id < 0 || H5Tset_size( type_id, H5T_VARIABLE ) < 0 )
901  {
902  H5Dclose( data_id );
903  if( type_id >= 0 ) H5Tclose( type_id );
904  mhdf_setFail( status, "Could not create variable length string type." );
905  free( array );
906  return NULL;
907  }
908 
909  rval = H5Dread( data_id, type_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, array );
910  H5Tclose( type_id );
911  H5Dclose( data_id );
912  if( rval < 0 )
913  {
914  free( array );
915  mhdf_setFail( status, "H5Dread failed." );
916  return NULL;
917  }
918 
919  *num_strings = dim;
920  mhdf_setOkay( status );
921  API_END;
922  return array;
923 }
924 
925 void mhdf_getNextStartId( mhdf_FileHandle file, mhdf_index_t* start_id_out, mhdf_Status* status )
926 {
927  FileHandle* file_ptr = (FileHandle*)file;
928  API_BEGIN;
929 
930  mhdf_setOkay( status );
931  if( mhdf_check_valid_file( file_ptr, status ) ) *start_id_out = file_ptr->max_id + 1;
932 
933  API_END;
934 }