F5Fmeta.c

Go to the documentation of this file.

#include "F5Fmeta.h"
#include "F5X.h"
#include "F5A.h"
#include "F5private.h"
#include "F5Bchart.h"
#include "F5L.h"
#include "F5coordinates.h"
/* #if defined(__APPLE__) && defined(__MACH__) && defined(__POWERPC__) */
#include <stdlib.h>
/* #else */
/* #include <malloc.h> */
/* #endif */
#include <string.h>
#include <assert.h>
 
 
#pragma message "This function is conflicting with the F5F API and will fail in common situations. See source comments for details."
/*
  This function is problematic. What does it mean to have a group or dataset within
  a field? This is a highly internal semantics that should not be exposed to the user.
  In particular, a field can be a dataset itself, this is the default case, so this
  function will certainly fail in the default case.
 
  (mr) this was only a clean up of quite some existing copy&paste code. I will rework stuff to have it work as it should.
 */
F5_API int F5Fopen_group_or_dataset( F5Path*f, const char* name, hid_t*gid, hid_t*did )
{
        if (!f) return 0;
 
H5E_BEGIN_TRY
        *gid = H5Gopen2(f->Field_hid, name, H5P_DEFAULT);
        if (*gid<0)
        {
                F5printf(55,"F5Fopen_group_or_dataset() no group, trying for a dataset!");
                *did = H5Dopen2(f->Field_hid, name, H5P_DEFAULT);
                if(*did<0)
                {
                        F5printf(55,"F5Fopen_group_or_dataset() no dataset found");
                        return 0;
                }
                else
                        F5printf(55,"F5Fopen_group_or_dataset() Yay dataset found!");
        }
        else
                F5printf(55,"F5Fopen_group_or_dataset() Yay! found group!");
H5E_END_TRY
 
        return 1;
}
 
#pragma message "This function is contradicting and complicating the F5F API and thus deprecated. See source comments for details."
/*
F5F* functions are supposed to operate on F5Path objects only. A field is identified in a F5Path object via its Field identifier.
It can be either a group or a dataset, being completely transparent to the user.
Consequently, any operations on the Field identifier such as opening an attribute are generic and can be done on the Field identifier itself.
When opening an attribute, there is no need to distinguish between group and dataset identifiers.
Separating between them is just an artificial complication that the F5F API intended to hide from the user.
 */
F5_API int F5Fopen_group_or_dataset_attribute( F5Path*f, const char* attribute_name, hid_t gid, hid_t did, hsize_t N, hid_t*attr_id, hid_t*space_id )
{
        if( !f ) return 0;
 
H5E_BEGIN_TRY
        *attr_id = F5Aopen_name(gid>0?gid:did, attribute_name);
H5E_END_TRY
 
        if (*attr_id<0)
        {
                F5printf(1,"F5Fget_fragment_attribute() could not find range attribute!");
//              if (gid>0) H5Gclose(gid);
//              if (did>0) H5Dclose(did);
                return 0;
        }
        *space_id = H5Aget_space(*attr_id);
        assert( *space_id >0);
        if (H5Sget_simple_extent_npoints(*space_id) != N)
        {
//              if (gid>0) H5Gclose(gid);
//              if (did>0) H5Dclose(did);
                H5Aclose(*attr_id);
                H5Sclose(*space_id);
                F5printf(1,"F5Fget_fragment_attribute() found range attribute with not N elements!");
                return 0;
        }
 
        return 1;
}
 
/*
F5_API hsize_t F5Fget_attribut_elements( F5Path*f, const char* attribute_name, hid_t gid, hid_t did, hid_t*attr_id, hid_t*space_id )
{
  int N;
        if( !f ) return 0;
 
H5E_BEGIN_TRY
        *attr_id = F5Aopen_name(gid>0?gid:did, attribute_name);
H5E_END_TRY
 
        if (*attr_id<0)
        {
                F5printf(1,"F5Fget_fragment_attribute() could not find range attribute!");
                return -1;
        }
        *space_id = H5Aget_space(*attr_id);
        assert( *space_id >0);
 
        N = H5Sget_simple_extent_npoints(*space_id);
 
        H5Aclose(*attr_id);
        H5Sclose(*space_id);
 
        return N;
}
*/
 
#pragma message "This function is conflicting with the F5F API, see comments for F5Fopen_group_or_dataset_attribute()"
F5_API int F5Fopen_or_create_group_or_dataset_attribute( F5Path*f, const char* attribute_name, hid_t gid, hid_t did, hsize_t N,  hid_t type_id, int force, hid_t*space_id, hid_t*attr_id )
{
        if( !f ) return 0;
 
        H5E_BEGIN_TRY
        *attr_id = H5Acreate2( gid>0? gid : did,
                              attribute_name, type_id, *space_id,
                              H5P_DEFAULT, H5P_DEFAULT );
        H5E_END_TRY
 
        if (*attr_id < 0 && force == 0)
        {
                F5printf(55,"F5Fopen_or_create_group_or_dataset_attribute() Could not set %s attribute, might already exist.", attribute_name);
                H5Sclose(*space_id);
                H5Tclose(type_id);
//              if (gid>0) H5Gclose(gid);
//              if (did>0) H5Dclose(did);
                return 0;
        }
        else if( *attr_id<0 ) // try for existing attribute
        {
                F5printf(1,"F5Fopen_or_create_group_or_dataset_attribute() Could not create attribute.");
                return F5Fopen_group_or_dataset_attribute( f, attribute_name, gid, did, N, attr_id, space_id );
        }
 
        return 1;
}
 
/*
  This function does nothing but to allocate and copy data uneccesarily.
  The caller can just call the HDF5 API directly to achieve the same.
  This function does not provide any benefits over direct call, only slows down
  execution by additional memory allocation and copying data.
  Furthermore it does not operate on F5Path objects and thus does not deserve the F5F prefix.
 */
F5_API int F5Fread_attr_data( void*data, hsize_t N, hid_t type_id, hid_t attr_id, const char*attribute_name )
{
size_t  type_size;
char    *buf;
 
        type_size = H5Tget_size(type_id);
        buf = (char*)malloc( N * type_size );
        F_H5Aread( attr_id, type_id, buf, attribute_name );
 
        memcpy( data, buf, N * type_size );
 
        free(buf);
 
        return 1;
}
 
/*
  Same comment as for  F5Fwrite_attr_data()
*/
F5_API int F5Fwrite_attr_data( const void*data, hsize_t N, hid_t type_id, hid_t attr_id, const char*attribute_name )
{
size_t  type_size;
char    *buf;
 
        type_size = H5Tget_size(type_id) ;
        buf =(char*)malloc( N * type_size );
 
        memcpy(buf, data, N * type_size);
//      memcpy(buf          , data, type_size);
//      memcpy(buf+type_size, value2, type_size);
 
        H5Awrite(attr_id, type_id, buf );
        free(buf);
 
        return 1;
}
 
 
 
F5_API int F5Fget_attribute( F5Path*f, const char*attribute_name,
                             void*data, hsize_t N, hid_t mem_type_id )
{
hid_t   attr_id, space_id, type_id;
 
        if (!f) return 0;
 
        if( !F5Fopen_group_or_dataset_attribute( f, attribute_name, f->Field_hid, 0, N, &attr_id, &space_id ) )
                return 0;
 
        if (mem_type_id)
                type_id = mem_type_id;
        else
                type_id  = H5Aget_type(attr_id);
 
        F5Fread_attr_data( data, N, type_id, attr_id, attribute_name );
 
        H5Aclose(attr_id);
        H5Sclose(space_id);
        if (!mem_type_id)
                H5Tclose(type_id);
 
        return 1;
}
 
F5_API int F5Fset_attribute( F5Path*f, const char*attribute_name,
                             const void*data, hsize_t N, hid_t mem_type_id, int force )
{
const hsize_t dims = N;
hid_t   attr_id, type_id, space_id;
 
        if (!f)
        {
                F5printf(5,"F5Fset_attribute() got NULL F5Path, no range written!");
                return 0;
        }
        if (f->Field_hid<1)
        {
                F5printf(5,"F5Fset_attribute() F5Path has no field ID, no range written!");
                return 0;
        }
 
        space_id= H5Screate_simple(1, &dims, &dims );
 
        if (mem_type_id)
                type_id = mem_type_id;
        else
                type_id  = H5Aget_type(attr_id); // this code CANNOT work because attr_id has not been initialized!!!
 
/*
  This is an extremely complicated workaround due to the wrong design of function F5Fopen_or_create_group_or_dataset_attribute().
  All what is required here is to use the Field_id in the F5Path object and to write an attribute using this Field_id, regardless
  what type it is.
 */
        if( F5Fis_group( f ) )
        {
                if( !F5Fopen_or_create_group_or_dataset_attribute( f, attribute_name, f->Field_hid, 0, N, type_id, force, &space_id, &attr_id ) )
                        return 0;
        }
        else
        {
                if( !F5Fopen_or_create_group_or_dataset_attribute( f, attribute_name, 0, f->Field_hid, N, type_id, force, &space_id, &attr_id ) )
                        return 0;
        }
 
        F5Fwrite_attr_data( data, N, type_id, attr_id, attribute_name );
 
        H5Aclose(attr_id);
        H5Sclose(space_id);
 
        if (!mem_type_id)
                H5Tclose(type_id);
 
        return 1;
}
 
F5_API int F5Fget_fragment_attribute( F5Path*f, const char*fragment_name, const char*attribute_name,
                                       void*data, hsize_t N, hid_t mem_type_id )
{
hid_t   attr_id,
        space_id,
        type_id,
        gid = -1, did = -1;
 
        F5Fopen_group_or_dataset( f, fragment_name, &gid, &did );
 
        if( !F5Fopen_group_or_dataset_attribute(f, attribute_name, gid, did, N, &attr_id, &space_id) )
                return 0;
 
        if (mem_type_id)
                type_id = mem_type_id;
        else
                type_id  = H5Aget_type(attr_id);
 
        F5Fread_attr_data( data, N, type_id, attr_id, attribute_name );
 
        if (gid>0) H5Gclose(gid);
        if (did>0) H5Dclose(did);
        H5Aclose(attr_id);
        H5Sclose(space_id);
 
        if (!mem_type_id)
                H5Tclose(type_id);
 
        F5printf(55,"F5Fget_fragment_attribute() returning normally!");
 
        return 1;
}
 
F5_API int F5Fset_fragment_attribute( F5Path*f, const char*fragment_name, const char*attribute_name,
                                      const void*data, const hsize_t N, hid_t mem_type_id, int force )
{
const hsize_t dims = N;
hid_t   attr_id,
        type_id,
        space_id,
        gid = -1, did = -1;
 
        if (!f)
        {
                F5printf(5,"F5Fset_fragment_attribute() got NULL F5Path, no range written!");
                return 0;
        }
        if (f->Field_hid<1)
        {
                F5printf(5,"F5Fset_fragment_attribute() F5Path has no field ID, no range written!");
                return 0;
        }
 
        space_id= H5Screate_simple(1, &dims, &dims );
        type_id = mem_type_id;
 
        if( !F5Fopen_group_or_dataset( f, fragment_name, &gid, &did ) )
        {
                F5printf(50,"F5Fset_fragment_attribute() Could not set %s attribute, fragment %s does not exist.",
                         attribute_name, fragment_name);
                H5Sclose(space_id);
                H5Tclose(type_id);
                return 0;
        }
 
        if( !F5Fopen_or_create_group_or_dataset_attribute( f, attribute_name, gid, did, N, type_id, force, &space_id, &attr_id ) )
                return 0;
 
        F5Fwrite_attr_data( data, N, type_id, attr_id, attribute_name );
 
        H5Aclose(attr_id);
        H5Sclose(space_id);
        if (gid>0) H5Gclose(gid);
        if (did>0) H5Dclose(did);
 
        F5printf(55,"F5Fset_fragment_attribute2() returning normally!");
 
        return 1;
 
 
  return 1;
}
 
F5_API int F5Fset_string_attribute(F5Path*f, const char*fragment_name, const char* attribute_name, const char*text, int force )
{
        if (f->Field_hid > 0)
        {
                if( fragment_name != NULL )
                {
                hid_t   type_id  = H5Tcopy(H5T_C_S1);
                hid_t   space_id = H5Screate(H5S_SCALAR);
                hid_t   attr_id;
                size_t  size     = strlen(text);
                        H5Tset_size(type_id, size);
                        H5Tset_strpad(type_id, H5T_STR_NULLTERM);
 
                        H5E_BEGIN_TRY
                                attr_id = H5Acreate2( f->Field_hid, attribute_name, type_id, space_id,  H5P_DEFAULT, H5P_DEFAULT);
                        H5E_END_TRY
                                if (attr_id > 0)
                                {
                                        F5printf(50, "F5Fset_string_attribute(): Unit Attribute %s written to %d.",
                                                 text, (int)f->Field_hid);
                                        H5Awrite(attr_id, type_id, text);
                                        H5Aclose(attr_id);
                                }
                                else
                                {
                                        F5printf(50, "F5Fset_string_attribute(): WARNING Unit Attribute not written to %s/%d.",
                                                 text, (int)f->Field_hid);
                                }
 
                        H5Sclose(space_id);
                        H5Tclose(type_id);
                        return 1;
                }
                else
                {
                hid_t   type_id  = H5Tcopy(H5T_C_S1);
                hid_t   space_id = H5Screate(H5S_SCALAR);
                hid_t   attr_id;
                size_t  size     = strlen(text);
                        H5Tset_size(type_id, size);
                        H5Tset_strpad(type_id, H5T_STR_NULLTERM);
 
                        if( F5Fis_group( f ) )
                        {
                                if( !F5Fopen_or_create_group_or_dataset_attribute( f, attribute_name, f->Field_hid, 0, 1, type_id, force, &space_id, &attr_id ) )
                                        return 0;
                        }
                        else
                        {
                                if( !F5Fopen_or_create_group_or_dataset_attribute( f, attribute_name, 0, f->Field_hid, 1, type_id, force, &space_id, &attr_id ) )
                                        return 0;
                        }
 
                        if (attr_id > 0)
                        {
                                F5printf(50, "F5Fset_string_attribute(): String attribute %s written to %d.", text, (int)f->Field_hid);
                                H5Awrite(attr_id, type_id, text);
                                H5Aclose(attr_id);
                        }
                        else
                        {
                                F5printf(50, "F5Fset_string_attribute(): WARNING Unit Attribute not written to %s/%d.", text, (int)f->Field_hid);
                                return 0;
                        }
 
                        return 1;
                }
 
        }
        else
                F5printf(50, "F5Fset_string_attribute(): Invalid field ID.");
 
        return 0;
}
 
F5_API int F5Fget_string_attribute(F5Path*f, const char*fragment_name, const char* attribute_name, char**text )
{
hid_t attr_id, space_id;
 
        if (f->Field_hid > 0)
        {
                if( fragment_name != NULL )
                {
                        H5E_BEGIN_TRY
                                attr_id = H5Aopen( f->Field_hid, attribute_name, H5P_DEFAULT);
                        H5E_END_TRY
                                if (attr_id > 0)
                                {
                                        F5printf(50, "F5Fset_string_attribute(): txt attribute %s fount at %d.",
                                                 attribute_name, (int)f->Field_hid);
                                hid_t type_id;
                                        type_id = H5Aget_type( attr_id );
 
                                size_t str_len = H5Tget_size( type_id );
 
                                        *text = (char*) calloc( str_len, sizeof(char) );
 
                                        H5Aread(attr_id, H5T_STRING, *text );
 
                                        H5Tclose( type_id );
                                        H5Aclose(attr_id);
                                }
                                else
                                {
                                        F5printf(50, "F5Fset_string_attribute(): WARNING Unit Attribute not written to %s/%d.",
                                                 text, (int)f->Field_hid);
                                }
 
                        return 1;
                }
                else
                {
                        if( F5Fis_group( f ) )
                        {
                                puts("isgroup");
                                if( !F5Fopen_group_or_dataset_attribute( f, attribute_name, f->Field_hid, 0, 1, &attr_id, &space_id ) )
                                        return 0;
                        }
                        else
                        {
                                puts("isnogroup");
                                if( !F5Fopen_group_or_dataset_attribute( f, attribute_name, 0, f->Field_hid, 1,  &attr_id, &space_id ) )
                                        return 0;
                        }
 
                        puts("read attr");
 
                        if (attr_id > 0)
                        {
 
                                F5printf(50, "F5Fset_string_attribute(): txt attribute %s fount at %d.",
                                                 attribute_name, (int)f->Field_hid);
                                hid_t type_id;
                                        type_id = H5Aget_type( attr_id );
 
                                size_t str_len = H5Tget_size( type_id );
 
//                                      printf("str_len: %d\n", str_len);
 
                                        *text = (char*) calloc( str_len, sizeof(char) );
 
                                        H5Aread(attr_id, type_id, *text );
 
                                        H5Tclose( type_id );
 
                                        H5Aclose(attr_id);
                        }
                        else
                        {
                                F5printf(50, "F5Fset_string_attribute(): WARNING Unit Attribute not written to %s/%d.", text, (int)f->Field_hid);
                        }
 
 
                        return 1;
                }
 
        }
        else
                F5printf(50, "F5Fset_string_attribute(): Invalid field ID.");
 
        return 0;
}
 
 
F5_API int F5Fset_fragment_range_ghost2(F5Path*f, const char*fragment_name, const void*minmax, const void*minmax_ghost, unsigned force )
{
hid_t type_id;
int check;
        type_id = F5Fget_type(f);
        check = F5Fset_fragment_attribute(f, fragment_name, FIBER_FIELD_COMPONENT_RANGE, minmax, 2, type_id, force);
 
        if( check )
                check = F5Fset_fragment_attribute(f, fragment_name, FIBER_FIELD_COMPONENT_RANGE_GHOST, minmax_ghost, 2, type_id, force);
 
        H5Tclose(type_id);
        return check;
}
 
F5_API int F5Fset_fragment_range_ghost(F5Path*f, const char*fragment_name, const void*minmax, const void*minmax_ghost )
{
        return F5Fset_fragment_range_ghost2(f, fragment_name, minmax, minmax_ghost, 0 );
}
 
F5_API int F5Fget_fragment_range_ghost(F5Path*f, const char*fragment_name, void*minmax, void*minmax_ghost, hid_t mem_type_id )
{
        if( F5Fget_fragment_attribute( f, fragment_name, FIBER_FIELD_COMPONENT_RANGE, minmax, 2 ,mem_type_id) )
        {
                return F5Fget_fragment_attribute( f, fragment_name,  FIBER_FIELD_COMPONENT_RANGE_GHOST,
                                                   minmax_ghost, 2, mem_type_id);
        }
        else
                return 0;
 
}
 
F5_API int F5Fget_fragment_range_ghost2(F5Path*f, const char*fragment_name, void*minmax_ghost )
{
hid_t type_id;
        type_id = F5Fget_type(f);
 
        return F5Fget_fragment_attribute( f, fragment_name,  FIBER_FIELD_COMPONENT_RANGE_GHOST,
                                                   minmax_ghost, 2, type_id);
}
 
F5_API int F5Fget_fragment_ghost_size( F5Path*f,  const char*fragment_name, unsigned long* size_real,
                                       unsigned long* size_ghost)
{
unsigned long sizes[2];
int check;
         check = F5Fget_fragment_attribute( f, fragment_name,  FIBER_FRAGMENT_ARRAY_SIZE_GHOST_ATTRIBUTE,
                                            sizes, 2, H5T_NATIVE_ULONG );
 
         *size_real  = sizes[0];
         *size_ghost = sizes[1];
 
         return check;
}
 
F5_API int F5Fset_fragment_ghost_size(F5Path*f,  const char*fragment_name, unsigned long size_real, unsigned long size_ghost, int force)
{
unsigned long sizes[2];
        sizes[0] = size_real;
        sizes[1] = size_ghost;
        return F5Fset_fragment_attribute( f, fragment_name, FIBER_FRAGMENT_ARRAY_SIZE_GHOST_ATTRIBUTE,
                                          sizes, 2, H5T_NATIVE_ULONG, force );
}
 
F5_API int F5Fis_attribute_of_type(F5Path*f, const char*attribute_name, hid_t HDF5_type)
{
hid_t attrib = 0;
 
        if (!f)
        {
                F5printf(50, "F5Fis_attribute_of_type, invalid F5Path");
                return 0;
        }
 
hid_t gettype = F5Aget_type(f->Field_hid, attribute_name, &attrib);
 
        if (H5Tequal(HDF5_type,gettype))
        {
                H5Tclose(gettype);
                H5Aclose(attrib);
                return 1;
        }
 
        H5Tclose(gettype);
        H5Aclose(attrib);
 
        return 0;
}
 
F5_API int F5Fis_range_of_type(F5Path*f, const char*fragment_name, hid_t HDF5_type)
{
        if( !fragment_name )
                return F5Fis_attribute_of_type(f, FIBER_FIELD_COMPONENT_RANGE, HDF5_type );
        else
                return F5Fis_fragment_attribute_of_type(f, fragment_name, FIBER_FIELD_COMPONENT_RANGE, HDF5_type );
 
}
 
F5_API int F5Fis_fragment_attribute_of_type(F5Path*f, const char*fragment_name, const char*attribute_name, hid_t HDF5_type)
{
hid_t attrib = 0, gid = -1, did = -1;
 
        if (!f)
        {
                F5printf(15, "F5Fis_range_of_type, invalid F5Path");
                return 0;
        }
 
        if( !F5Fopen_group_or_dataset( f, fragment_name, &gid, &did ) )
                return 0;
 
        hid_t gettype = F5Aget_type((gid>0)?gid:did, attribute_name, &attrib);
 
        if (H5Tequal(HDF5_type,gettype))
        {
                H5Tclose(gettype);
                H5Aclose(attrib);
 
                if (did > 0) H5Dclose(did);
                if (gid > 0) H5Gclose(gid);
 
                return 1;
        }
 
        H5Tclose(gettype);
        H5Aclose(attrib);
 
        if (did > 0) H5Dclose(did);
        if (gid > 0) H5Gclose(gid);
 
        return 0;
}
 
F5_API int F5Fhas_attribute(F5Path*f, const char*attr_name)
{
        if (!f)
        {
                F5printf(50, "F5Fhas_attribute, invalid F5Path");
                return 0;
        }
 
htri_t exist = H5Aexists(f->Field_hid, attr_name);
 
        if (exist > 0)
                return 1;
        else if (exist < 0)
        {
                puts("F5Fhas_attribute, ERROR H5Aexists failed");
                return 0;
        }
        else
                return exist;
}
 
F5_API hssize_t F5Fget_attribute_nr_elements( F5Path*f, const char*fragment_name, const char*attribute_name )
{
hid_t attr_id;
hid_t space_id;
hssize_t nr_elements = 0;
hid_t did = 0 , gid = 0;
int check;
 
        if (!f)
        {
                F5printf(50, "F5Fget_attribute_nr_elements, invalid F5Path");
                return 0;
        }
 
        if( fragment_name != NULL )
        {
                check = F5Fopen_group_or_dataset( f, fragment_name, &gid, &did );
 
                if( check == 0 ) return 0;
 
        hid_t open_id = gid>0?gid:did;
 
                if( open_id > 0 )
                {
                        attr_id = F5Aopen_name( open_id, attribute_name);
                        if( attr_id < 0 )
                        {
                                F5printf(1,"F5Fget_attribute_nr_elements could not find attribute %s!", attribute_name);
                                return 0;
                        }
                        space_id = H5Aget_space( attr_id );
                        assert(space_id);
                        nr_elements =  H5Sget_simple_extent_npoints( space_id );
 
                        H5Sclose( space_id );
                        H5Aclose( attr_id);
                }
 
                if( gid > 0 )
                        H5Gclose( gid );
 
                if( did > 0 )
                        H5Dclose( gid );
        }
        else
        {
                attr_id = F5Aopen_name( f->Field_hid, attribute_name);
                if( attr_id < 0 )
                {
                        F5printf(1,"F5Fget_attribute_nr_elements could not find attribute %s!", attribute_name);
                        return 0;
                }
 
                space_id = H5Aget_space( attr_id );
                assert(space_id);
                nr_elements =  H5Sget_simple_extent_npoints( space_id );
 
                H5Sclose( space_id );
                H5Aclose( attr_id);
 
        }
 
        return nr_elements;
}
 
F5_API int F5Fhas_fragment_attribute(F5Path*f, const char*fragment_name, const char*attr_name)
{
        if (!f)
        {
                F5printf(50, "F5Fhas_attribute, invalid F5Path");
                return 0;
        }
 
hid_t Gid = -1, Did = -1;
 
        H5E_BEGIN_TRY
 
        Gid = H5Gopen2(f->Field_hid, fragment_name, H5P_DEFAULT);
 
        if (Gid<0)
        {
                F5printf(55,"F5Fhas_fragment_attribute() no group, trying for a dataset!");
                Did = H5Dopen2(f->Field_hid, fragment_name, H5P_DEFAULT);
                if(Did<0)
                {
                        F5printf(55,"F5Fhas_fragment_attribute() no dataset found");
                        H5Dclose(Did);
                        H5Gclose(Gid);
                        return 0;
                }
                else
                        F5printf(55,"F5Fhas_fragment_attribute() Yay dataset found!");
        }
        else
                F5printf(55,"F5Fhas_fragment_attribute() Yay! found group!");
 
        H5E_END_TRY
 
htri_t exist = H5Aexists((Gid>0)?Gid:Did, attr_name);
 
        if (Did > 0) H5Dclose(Did);
        if (Gid > 0) H5Gclose(Gid);
 
        if (exist > 0)
                return 1;
        else if (exist < 0)
        {
                puts("F5Fhas_attribute, ERROR H5Aexists failed");
                return 0;
        }
        else
                return exist;
}
 
F5_API int F5Fget_average(F5Path*f, const char*fragment_name,  void*avg)
{
hid_t type_id;
int check;
        type_id = F5Fget_type(f);
        if( !fragment_name )
                check = F5Fget_attribute( f, FIBER_FIELD_COMPONENT_AVERAGE, avg, 1, type_id );
        else
                check = F5Fget_fragment_attribute( f, fragment_name, FIBER_FIELD_COMPONENT_AVERAGE, avg, 1, type_id );
        H5Tclose(type_id);
        return check;
}
 
F5_API int F5Fset_average2(F5Path*f, const char*fragment_name, const void*avg, int force)
{
hid_t type_id;
int check;
        type_id = F5Fget_type(f);
        if(!fragment_name)
                check = F5Fset_attribute(f,  FIBER_FIELD_COMPONENT_AVERAGE, avg, 1, type_id, force);
        else
                check = F5Fset_fragment_attribute(f,  fragment_name, FIBER_FIELD_COMPONENT_AVERAGE, avg, 1, type_id, force);
 
        H5Tclose(type_id);
        return check;
}
 
F5_API int F5Fset_average(F5Path*f, const char*fragment_name, const void*avg)
{
        return F5Fset_average2( f, fragment_name, avg, 0 );
}
 
F5_API int F5Fget_deviation(F5Path*f,  const char*fragment_name, void*dev)
{
hid_t type_id;
int check;
        type_id = F5Fget_type(f);
        if(!fragment_name)
                check = F5Fget_attribute( f, FIBER_FIELD_COMPONENT_DEVIATION, dev, 1, type_id );
        else
                check = F5Fget_fragment_attribute( f, fragment_name, FIBER_FIELD_COMPONENT_DEVIATION, dev, 1, type_id );
        H5Tclose(type_id);
        return check;
}
 
F5_API int F5Fset_deviation2(F5Path*f, const char*fragment_name, const void*dev, int force)
{
 
hid_t type_id;
int check;
        type_id = F5Fget_type(f);
        if( !fragment_name )
                check = F5Fset_attribute(f,  FIBER_FIELD_COMPONENT_DEVIATION, dev, 1, type_id, force);
        else
                check = F5Fset_fragment_attribute(f,  fragment_name, FIBER_FIELD_COMPONENT_DEVIATION, dev, 1, type_id, force);
 
        H5Tclose(type_id);
        return check;
}
 
F5_API int F5Fset_deviation(F5Path*f, const char*fragment_name, const void*dev)
{
        return F5Fset_deviation2(f, fragment_name, dev, 0);
}
 
F5_API int F5Fget_histogram( F5Path*f, const char*fragment_name, unsigned long*histogram, hsize_t size )
{
        if( !fragment_name)
                return F5Fget_attribute( f, FIBER_FIELD_COMPONENT_HISTOGRAM, histogram, size, H5T_NATIVE_ULONG );
        else
                return F5Fget_fragment_attribute( f, fragment_name, FIBER_FIELD_COMPONENT_HISTOGRAM, histogram, size, H5T_NATIVE_ULONG );
}
 
F5_API int F5Fset_histogram2( F5Path*f, const char*fragment_name, const unsigned long*his, hsize_t size, int force )
{
        if(!fragment_name)
                return F5Fset_attribute(f,  FIBER_FIELD_COMPONENT_HISTOGRAM, his, size, H5T_NATIVE_ULONG, force);
        else
                return F5Fset_fragment_attribute(f, fragment_name, FIBER_FIELD_COMPONENT_HISTOGRAM, his, size, H5T_NATIVE_ULONG, force);
}
 
F5_API int F5Fset_histogram( F5Path*f,const char*fragment_name,  const unsigned long*his, hsize_t size )
{
        return F5Fset_histogram2(f, fragment_name, his, size, 0);
}
 
F5_API int F5Fset_original_type2(F5Path*f, const char*fragment_name, int force)
{
char buf[256];
        strcpy( buf, "Undefined" );
hid_t type_id;
int check;
        type_id = F5Fget_type(f);
 
        if( H5Tequal( H5T_NATIVE_USHORT, type_id ) )       // scalars
                strcpy( buf, "H5T_NATIVE_USHORT" );
        else if( H5Tequal( H5T_NATIVE_INT, type_id ) )
                strcpy( buf, "H5T_NATIVE_INT" );
        else if( H5Tequal( H5T_NATIVE_UCHAR, type_id ) )
                strcpy( buf, "H5T_NATIVE_UCHAR" );
        else if( H5Tequal( H5T_NATIVE_FLOAT, type_id ) )
                strcpy( buf, "H5T_NATIVE_FLOAT" );
        else if( H5Tequal( H5T_NATIVE_DOUBLE, type_id ) )
                strcpy( buf, "H5T_NATIVE_DOUBLE" );
        else if( H5Tequal( F5T_COORD3_FLOAT, type_id ) )   // coords/vecs
                strcpy( buf, "F5T_COORD3_FLOAT" );
        else if( H5Tequal( F5T_COORD3_DOUBLE, type_id ) )
                strcpy( buf, "F5T_COORD3_DOUBLE" );
        else if( H5Tequal( F5T_VEC3_FLOAT, type_id ) )
                strcpy( buf, "F5T_VEC3_FLOAT" );
        else if( H5Tequal( F5T_VEC3_DOUBLE, type_id ) )
                strcpy( buf, "F5T_VEC3_DOUBLE" );
        else if( H5Tequal( F5T_BIVEC3_FLOAT, type_id ) )   //bivecs
                strcpy( buf, "F5T_BIVEC3_FLOAT" );
        else if( H5Tequal( F5T_BIVEC3_DOUBLE, type_id ) )
                strcpy( buf, "F5T_BIVEC3_DOUBLE" );
        else if( H5Tequal( F5T_METRIC33_FLOAT, type_id ) ) // 2nd order tensors
                strcpy( buf, "F5T_METRIC33_FLOAT" );
        else if( H5Tequal( F5T_METRIC33_DOUBLE, type_id ) )
                strcpy( buf, "F5T_METRIC33_DOUBLE" );
 
 
 
 
 
        if( !fragment_name )
                check = F5Fset_attribute(f,  FIBER_FIELD_ORIGIANL_TYPE, buf, strlen(buf), H5Tcopy(H5T_C_S1), force);
        else
                check = F5Fset_fragment_attribute(f,  fragment_name, FIBER_FIELD_ORIGIANL_TYPE, buf, strlen(buf),  H5Tcopy(H5T_C_S1), force);
 
        H5Tclose(type_id);
        return check;
}
 
F5_API int F5Fset_dictionary2(F5Path*f, const char*fragment_name, const char*dictionary, const F5_uint16_t* words, int word_count, int force)
{
int check;
 
        if( !fragment_name )
                check = F5Fset_string_attribute(f, NULL, FIBER_FIELD_DICTIONARY, dictionary, 1 );
        else
                check = F5Fset_string_attribute(f, fragment_name, FIBER_FIELD_DICTIONARY, dictionary, 1 );
 
        if(!check)
        {
                puts("F5Fset_dictionary2() error setting FIBER_FIELD_DICTIONARY attribute!");
                return check;
        }
 
        if( !fragment_name )
                check = F5Fset_attribute(f, FIBER_FIELD_DICTIONARY_WORDS, words, word_count,
                                         H5T_NATIVE_USHORT, force);
        else
                check = F5Fset_fragment_attribute(f, fragment_name, FIBER_FIELD_DICTIONARY_WORDS, words, word_count,
                                                  H5T_NATIVE_USHORT, force);
 
        return check;
}
 
F5_API int F5Fset_dictionary(F5Path*f, const char*fragment_name, const char*dictionary, const F5_uint16_t* words, int word_count, int force)
{
        return F5Fset_dictionary2( f, fragment_name, dictionary, words, word_count, 0 );
}
 
F5_API int F5Fget_dictionary(  F5Path*f, const char*fragment_name, char**dictionary, F5_uint16_t*words, int word_count )
{
int check;
 
        check = F5Fget_string_attribute( f, fragment_name, FIBER_FIELD_DICTIONARY, dictionary );
 
        if(!check)
        {
                puts("F5Fget_dictionary() error getting FIBER_FIELD_DICTIONARY attribute!");
                return check;
        }
 
        if( !fragment_name )
                check = F5Fget_attribute( f, FIBER_FIELD_DICTIONARY_WORDS, words, word_count, H5T_NATIVE_USHORT );
        else
                check = F5Fget_fragment_attribute( f, fragment_name, FIBER_FIELD_DICTIONARY_WORDS, words, word_count, H5T_NATIVE_USHORT );
 
        return check;
}
 
 
 
F5_API int F5Fset_metric_unit_description(F5Path*f, const char*unit)
{
        return F5Fset_string_attribute(f, NULL, F5_METRIC_UNIT_DESCRIPTION, unit, 1 );
}