F5Fmeta.h File Reference

#include "F5L.h"
#include "F5Bchart.h"
#include "F5Path.h"

Go to the source code of this file.

Functions
F5_API int	F5Fopen_group_or_dataset (F5Path *f, const char *name, hid_t *gid, hid_t *did)
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)
	F5_DEPRECATED ("Function does not provide benefits over raw HDF5 call", F5_API int F5Fread_attr_data(void *data, hsize_t N, hid_t type_id, hid_t attr_id, const char *attribute_name))
	F5_DEPRECATED ("Function does not provide benefits over raw HDF5 call", F5_API int F5Fwrite_attr_data(const void *data, hsize_t N, hid_t type_id, hid_t attr_id, const char *attribute_name))
F5_API int	F5Fget_attribute (F5Path *f, const char *attribute_name, void *data, hsize_t N, hid_t mem_type_id)
F5_API int	F5Fset_attribute (F5Path *f, const char *attribute_name, const void *data, hsize_t N, hid_t mem_type_id, int force)
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)
F5_API int	F5Fset_fragment_attribute (F5Path *f, const char *fragment_name, const char *attribute_name, const void *data, hsize_t N, hid_t mem_type_id, int force)
F5_API int	F5Fset_string_attribute (F5Path *f, const char *fragment_name, const char *attribute_name, const char *text, int force)
F5_API int	F5Fget_string_attribute (F5Path *f, const char *fragment_name, const char *attribute_name, char **text)
F5_API int	F5Fhas_attribute (F5Path *f, const char *attr_name)
F5_API hssize_t	F5Fget_attribute_nr_elements (F5Path *f, const char *fragment_name, const char *attribute_name)
F5_API int	F5Fhas_fragment_attribute (F5Path *f, const char *fragment_name, const char *attribute_name)
F5_API int	F5Fis_attribute_of_type (F5Path *f, const char *attribute_name, hid_t HDF5_type)
F5_API int	F5Fis_fragment_attribute_of_type (F5Path *f, const char *attribute_name, const char *fragment_name, hid_t HDF5_type)
F5_API int	F5Fis_range_of_type (F5Path *f, const char *fragment_name, hid_t HDF5_type)
F5_API int	F5Fget_fragment_range_ghost (F5Path *f, const char *fragment_name, void *minmax, void *minmax_ghost, hid_t mem_type_id)
F5_API int	F5Fget_fragment_range_ghost2 (F5Path *f, const char *fragment_name, void *minmax_ghost)
F5_API int	F5Fset_fragment_range_ghost2 (F5Path *f, const char *fragment_name, const void *minmax, const void *minmax_ghost, unsigned force)
F5_API int	F5Fset_fragment_range_ghost (F5Path *f, const char *fragment_name, const void *minmax, const void *minmax_ghost)
F5_API int	F5Fget_fragment_ghost_size (F5Path *f, const char *fragment_name, unsigned long *size_real, unsigned long *size_ghost)
F5_API int	F5Fset_fragment_ghost_size (F5Path *f, const char *fragment_name, unsigned long size_real, unsigned long size_ghost, int force)
F5_API int	F5Fget_average (F5Path *f, const char *fragment_name, void *avg)
F5_API int	F5Fset_average2 (F5Path *f, const char *fragment_name, const void *avg, int force)
F5_API int	F5Fset_average (F5Path *f, const char *fragment_name, const void *avg)
F5_API int	F5Fget_deviation (F5Path *f, const char *fragment_name, void *dev)
F5_API int	F5Fset_deviation2 (F5Path *f, const char *fragment_name, const void *dev, int force)
F5_API int	F5Fset_deviation (F5Path *f, const char *fragment_name, const void *dev)
F5_API int	F5Fget_histogram (F5Path *f, const char *fragment_name, unsigned long *histogram, hsize_t size)
F5_API int	F5Fset_histogram2 (F5Path *f, const char *fragment_name, const unsigned long *his, hsize_t size, int force)
F5_API int	F5Fset_histogram (F5Path *f, const char *fragment_name, const unsigned long *his, hsize_t size)
F5_API int	F5Fset_original_type2 (F5Path *f, const char *fragment_name, int force)
F5_API int	F5Fset_dictionary2 (F5Path *f, const char *fragment_name, const char *dictionary, const F5_uint16_t *words, int word_count, int force)
F5_API int	F5Fset_dictionary (F5Path *f, const char *fragment_name, const char *dictionary, const F5_uint16_t *words, int word_count, int force)
F5_API int	F5Fget_dictionary (F5Path *f, const char *fragment_name, char **dictionary, F5_uint16_t *words, int word_count)
F5_API int	F5Fset_metric_unit_description (F5Path *f, const char *unit)

Function Documentation

F5_DEPRECATED() [1/2]

F5_DEPRECATED	(	"Function does not provide benefits over raw HDF5 call"	,
		F5_API int	F5Fread_attr_datavoid *data, hsize_t N, hid_t type_id, hid_t attr_id, const char *attribute_name )

References F5_API.

F5_DEPRECATED() [2/2]

F5_DEPRECATED	(	"Function does not provide benefits over raw HDF5 call"	,
		F5_API int	F5Fwrite_attr_dataconst void *data, hsize_t N, hid_t type_id, hid_t attr_id, const char *attribute_name )

References F5_API.

F5Fget_attribute()

F5_API int F5Fget_attribute	(	F5Path *	f,
		const char *	attribute_name,
		void *	data,
		hsize_t	N,
		hid_t	mem_type_id )

Helper function. Retrieve an attribute of 2 values (e.g. 2 float, 2 doubles, 2 ints, 2 F5_vec3_float_t ... ) from a fragment.

Returns

: 1 in case of error, 0 otherwise.

Definition at line 191 of file F5Fmeta.c.

{
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;
}

References F5_API, F5Fopen_group_or_dataset_attribute(), F5Fread_attr_data(), F5Path::Field_hid, and H5Tclose().

Referenced by F5Fget_average(), F5Fget_deviation(), F5Fget_dictionary(), and F5Fget_histogram().

F5Fget_attribute_nr_elements()

F5_API hssize_t F5Fget_attribute_nr_elements	(	F5Path *	f,
		const char *	fragment_name,
		const char *	attribute_name )

Definition at line 667 of file F5Fmeta.c.

{
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;
}

References F5_API, F5Aopen_name(), F5Fopen_group_or_dataset(), F5printf, F5Path::Field_hid, and H5Gclose.

F5Fget_average()

F5_API int F5Fget_average	(	F5Path *	f,
		const char *	fragment_name,
		void *	avg )

Field attribute (optional): The average value of a dataset.

Definition at line 781 of file F5Fmeta.c.

{
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;
}

References F5_API, F5Fget_attribute(), F5Fget_fragment_attribute(), F5Fget_type(), FIBER_FIELD_COMPONENT_AVERAGE, and H5Tclose().

F5Fget_deviation()

F5_API int F5Fget_deviation	(	F5Path *	f,
		const char *	fragment_name,
		void *	dev )

Field attribute (optional): The standard deviation of data values from a field's average value.

Definition at line 813 of file F5Fmeta.c.

{
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;
}

References F5_API, F5Fget_attribute(), F5Fget_fragment_attribute(), F5Fget_type(), FIBER_FIELD_COMPONENT_DEVIATION, and H5Tclose().

F5Fget_dictionary()

F5_API int F5Fget_dictionary	(	F5Path *	f,
		const char *	fragment_name,
		char **	dictionary,
		F5_uint16_t *	words,
		int	word_count )

Dictionary string has to be passed by reference. Dynamic memory is reserved for the dictionary and must be released afterwards. e.g. : char* dict; F5Fget_dictionary(f, NULL, &dict, .. ); free(dictionary)

Definition at line 945 of file F5Fmeta.c.

{
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;
}

References F5_API, F5Fget_attribute(), F5Fget_fragment_attribute(), F5Fget_string_attribute(), FIBER_FIELD_DICTIONARY, and FIBER_FIELD_DICTIONARY_WORDS.

F5Fget_fragment_attribute()

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 )

Definition at line 267 of file F5Fmeta.c.

{
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;
}

References F5_API, F5Fopen_group_or_dataset(), F5Fopen_group_or_dataset_attribute(), F5Fread_attr_data(), F5printf, H5Gclose, and H5Tclose().

Referenced by F5Fget_average(), F5Fget_deviation(), F5Fget_dictionary(), F5Fget_fragment_ghost_size(), F5Fget_fragment_range_ghost(), F5Fget_fragment_range_ghost2(), and F5Fget_histogram().

F5Fget_fragment_ghost_size()

F5_API int F5Fget_fragment_ghost_size	(	F5Path *	f,
		const char *	fragment_name,
		unsigned long *	size_real,
		unsigned long *	size_ghost )

If available a data-array icludes values of a ghost zone and the array is partitioned in two contiguous parts. The first part contains the values inside the fragment and has size size_real, the second part contains the value inside the ghost zone with size size_ghost.

Definition at line 554 of file F5Fmeta.c.

{
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;
}

References F5_API, F5Fget_fragment_attribute(), and FIBER_FRAGMENT_ARRAY_SIZE_GHOST_ATTRIBUTE.

F5Fget_fragment_range_ghost()

F5_API int F5Fget_fragment_range_ghost	(	F5Path *	f,
		const char *	fragment_name,
		void *	minmax,
		void *	minmax_ghost,
		hid_t	mem_type_id )

Field attribute (optional): Bounding box including the ghost zone.

Definition at line 533 of file F5Fmeta.c.

{
        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;
 
}

References F5_API, F5Fget_fragment_attribute(), FIBER_FIELD_COMPONENT_RANGE, and FIBER_FIELD_COMPONENT_RANGE_GHOST.

F5Fget_fragment_range_ghost2()

F5_API int F5Fget_fragment_range_ghost2	(	F5Path *	f,
		const char *	fragment_name,
		void *	minmax_ghost )

Definition at line 545 of file F5Fmeta.c.

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

References F5_API, F5Fget_fragment_attribute(), F5Fget_type(), and FIBER_FIELD_COMPONENT_RANGE_GHOST.

F5Fget_histogram()

F5_API int F5Fget_histogram	(	F5Path *	f,
		const char *	fragment_name,
		unsigned long *	histogram,
		hsize_t	size )

Field attribute (optional): The histogram of a scalar field.

Definition at line 846 of file F5Fmeta.c.

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

References F5_API, F5Fget_attribute(), F5Fget_fragment_attribute(), and FIBER_FIELD_COMPONENT_HISTOGRAM.

F5Fget_string_attribute()

F5_API int F5Fget_string_attribute	(	F5Path *	f,
		const char *	fragment_name,
		const char *	attribute_name,
		char **	text )

Definition at line 425 of file F5Fmeta.c.

{
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;
}

References F5_API, F5Fis_group(), F5Fopen_group_or_dataset_attribute(), F5printf, F5Path::Field_hid, and H5Tclose().

Referenced by F5Fget_dictionary().

F5Fhas_attribute()

F5_API int F5Fhas_attribute	(	F5Path *	f,
		const char *	attr_name )

Test whether a field attribute exists or not

Returns

1 if exists, 0 otherwise

Definition at line 646 of file F5Fmeta.c.

{
        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;
}

References F5_API, F5printf, and F5Path::Field_hid.

F5Fhas_fragment_attribute()

F5_API int F5Fhas_fragment_attribute	(	F5Path *	f,
		const char *	fragment_name,
		const char *	attribute_name )

Test whether a field fragment attribute exists or not

Returns

1 if exists, 0 otherwise

Definition at line 732 of file F5Fmeta.c.

{
        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;
}

References F5_API, F5printf, F5Path::Field_hid, and H5Gclose.

F5Fis_attribute_of_type()

F5_API int F5Fis_attribute_of_type	(	F5Path *	f,
		const char *	attribute_name,
		hid_t	HDF5_type )

Definition at line 577 of file F5Fmeta.c.

{
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;
}

References F5_API, F5Aget_type(), F5printf, F5Path::Field_hid, and H5Tclose().

Referenced by F5Fis_range_of_type().

F5Fis_fragment_attribute_of_type()

F5_API int F5Fis_fragment_attribute_of_type	(	F5Path *	f,
		const char *	attribute_name,
		const char *	fragment_name,
		hid_t	HDF5_type )

Definition at line 611 of file F5Fmeta.c.

{
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;
}

References F5_API, F5Aget_type(), F5Fopen_group_or_dataset(), F5printf, H5Gclose, and H5Tclose().

Referenced by F5Fis_range_of_type().

F5Fis_range_of_type()

F5_API int F5Fis_range_of_type	(	F5Path *	f,
		const char *	fragment_name,
		hid_t	HDF5_type )

Test if range attribute is of certain type

Returns

1 if matching, 0 otherwise

Definition at line 602 of file F5Fmeta.c.

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

References F5_API, F5Fis_attribute_of_type(), F5Fis_fragment_attribute_of_type(), and FIBER_FIELD_COMPONENT_RANGE.

F5Fopen_group_or_dataset()

F5_API int F5Fopen_group_or_dataset	(	F5Path *	f,
		const char *	name,
		hid_t *	gid,
		hid_t *	did )

Definition at line 26 of file F5Fmeta.c.

{
        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;
}

References F5_API, F5printf, F5Path::Field_hid, and name.

Referenced by F5Fget_attribute_nr_elements(), F5Fget_fragment_attribute(), F5Fis_fragment_attribute_of_type(), and F5Fset_fragment_attribute().

F5Fopen_or_create_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 )

Definition at line 117 of file F5Fmeta.c.

{
        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;
}

References F5_API, F5Fopen_group_or_dataset_attribute(), F5printf, and H5Tclose().

Referenced by F5Fset_attribute(), F5Fset_fragment_attribute(), and F5Fset_string_attribute().

F5Fset_attribute()

F5_API int F5Fset_attribute	(	F5Path *	f,
		const char *	attribute_name,
		const void *	data,
		hsize_t	N,
		hid_t	mem_type_id,
		int	force )

Definition at line 216 of file F5Fmeta.c.

{
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;
}

References F5_API, F5Fis_group(), F5Fopen_or_create_group_or_dataset_attribute(), F5Fwrite_attr_data(), F5printf, F5Path::Field_hid, and H5Tclose().

Referenced by F5Fset_average2(), F5Fset_deviation2(), F5Fset_dictionary2(), F5Fset_histogram2(), F5Fset_original_type2(), and F5Rcreate_uniform_sparse2().

F5Fset_average()

F5_API int F5Fset_average	(	F5Path *	f,
		const char *	fragment_name,
		const void *	avg )

Definition at line 808 of file F5Fmeta.c.

{
        return F5Fset_average2( f, fragment_name, avg, 0 );
}

References F5_API, and F5Fset_average2().

Referenced by F5Rcreate_uniform_cartesian3D(), and F5Rcreate_uniform_cartesian3Dbbox().

F5Fset_average2()

F5_API int F5Fset_average2	(	F5Path *	f,
		const char *	fragment_name,
		const void *	avg,
		int	force )

Definition at line 794 of file F5Fmeta.c.

{
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;
}

References F5_API, F5Fget_type(), F5Fset_attribute(), F5Fset_fragment_attribute(), FIBER_FIELD_COMPONENT_AVERAGE, and H5Tclose().

Referenced by F5Fset_average().

F5Fset_deviation()

F5_API int F5Fset_deviation	(	F5Path *	f,
		const char *	fragment_name,
		const void *	dev )

Definition at line 841 of file F5Fmeta.c.

{
        return F5Fset_deviation2(f, fragment_name, dev, 0);
}

References F5_API, and F5Fset_deviation2().

F5Fset_deviation2()

F5_API int F5Fset_deviation2	(	F5Path *	f,
		const char *	fragment_name,
		const void *	dev,
		int	force )

Definition at line 826 of file F5Fmeta.c.

{
 
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;
}

References F5_API, F5Fget_type(), F5Fset_attribute(), F5Fset_fragment_attribute(), FIBER_FIELD_COMPONENT_DEVIATION, and H5Tclose().

Referenced by F5Fset_deviation().

F5Fset_dictionary()

F5_API int F5Fset_dictionary	(	F5Path *	f,
		const char *	fragment_name,
		const char *	dictionary,
		const F5_uint16_t *	words,
		int	word_count,
		int	force )

Definition at line 940 of file F5Fmeta.c.

{
        return F5Fset_dictionary2( f, fragment_name, dictionary, words, word_count, 0 );
}

References F5_API, and F5Fset_dictionary2().

F5Fset_dictionary2()

F5_API int F5Fset_dictionary2	(	F5Path *	f,
		const char *	fragment_name,
		const char *	dictionary,
		const F5_uint16_t *	words,
		int	word_count,
		int	force )

Field attribute (optional): A dictionary of words and a stored as string attribute, along with a seperator i.e. used for a field containing integer indeces into the dictionary (label-field) The get function does not allocate the string buffers

Definition at line 915 of file F5Fmeta.c.

{
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;
}

References F5_API, F5Fset_attribute(), F5Fset_fragment_attribute(), F5Fset_string_attribute(), FIBER_FIELD_DICTIONARY, and FIBER_FIELD_DICTIONARY_WORDS.

Referenced by F5Fset_dictionary().

F5Fset_fragment_attribute()

F5_API int F5Fset_fragment_attribute	(	F5Path *	f,
		const char *	fragment_name,
		const char *	attribute_name,
		const void *	data,
		hsize_t	N,
		hid_t	mem_type_id,
		int	force )

Definition at line 300 of file F5Fmeta.c.

{
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;
}

References F5_API, F5Fopen_group_or_dataset(), F5Fopen_or_create_group_or_dataset_attribute(), F5Fwrite_attr_data(), F5printf, F5Path::Field_hid, H5Gclose, and H5Tclose().

Referenced by F5Fset_average2(), F5Fset_deviation2(), F5Fset_dictionary2(), F5Fset_fragment_ghost_size(), F5Fset_fragment_range_ghost2(), F5Fset_histogram2(), and F5Fset_original_type2().

F5Fset_fragment_ghost_size()

F5_API int F5Fset_fragment_ghost_size	(	F5Path *	f,
		const char *	fragment_name,
		unsigned long	size_real,
		unsigned long	size_ghost,
		int	force )

Definition at line 568 of file F5Fmeta.c.

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

References F5_API, F5Fset_fragment_attribute(), and FIBER_FRAGMENT_ARRAY_SIZE_GHOST_ATTRIBUTE.

F5Fset_fragment_range_ghost()

F5_API int F5Fset_fragment_range_ghost	(	F5Path *	f,
		const char *	fragment_name,
		const void *	minmax,
		const void *	minmax_ghost )

Definition at line 528 of file F5Fmeta.c.

{
        return F5Fset_fragment_range_ghost2(f, fragment_name, minmax, minmax_ghost, 0 );
}

References F5_API, and F5Fset_fragment_range_ghost2().

F5Fset_fragment_range_ghost2()

F5_API int F5Fset_fragment_range_ghost2	(	F5Path *	f,
		const char *	fragment_name,
		const void *	minmax,
		const void *	minmax_ghost,
		unsigned	force )

Definition at line 514 of file F5Fmeta.c.

{
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;
}

References F5_API, F5Fget_type(), F5Fset_fragment_attribute(), FIBER_FIELD_COMPONENT_RANGE, FIBER_FIELD_COMPONENT_RANGE_GHOST, and H5Tclose().

Referenced by F5Fset_fragment_range_ghost().

F5Fset_histogram()

F5_API int F5Fset_histogram	(	F5Path *	f,
		const char *	fragment_name,
		const unsigned long *	his,
		hsize_t	size )

Definition at line 862 of file F5Fmeta.c.

{
        return F5Fset_histogram2(f, fragment_name, his, size, 0);
}

References F5_API, and F5Fset_histogram2().

F5Fset_histogram2()

F5_API int F5Fset_histogram2	(	F5Path *	f,
		const char *	fragment_name,
		const unsigned long *	his,
		hsize_t	size,
		int	force )

Definition at line 854 of file F5Fmeta.c.

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

References F5_API, F5Fset_attribute(), F5Fset_fragment_attribute(), and FIBER_FIELD_COMPONENT_HISTOGRAM.

Referenced by F5Fset_histogram().

F5Fset_metric_unit_description()

F5_API int F5Fset_metric_unit_description	(	F5Path *	f,
		const char *	unit )

Adds a string attribute to describe units to a data field. The F5Path must contain a valid Field_hid identifier, which2 may be either a group or a dataset. This function will set an attribute named F5_METRIC_UNIT_DESCRIPTION to the given object, which can be an arbitrary string.

Note

This unit description is only supposed to provide means for human interpretation, not for defining units in a programmatic way. Thus, the given string can be arbitrary,

Returns

-1 in case of error

Todo

Make this function using a char* and length such that it can be called directly from an c++ string and does not require the string to be 0-terminated. This needs to be supported in the function implementation as well.

Definition at line 967 of file F5Fmeta.c.

{
        return F5Fset_string_attribute(f, NULL, F5_METRIC_UNIT_DESCRIPTION, unit, 1 );
}

References F5_API, F5_METRIC_UNIT_DESCRIPTION, and F5Fset_string_attribute().

Referenced by F5write_particle_cartesian3DvU().

F5Fset_original_type2()

F5_API int F5Fset_original_type2	(	F5Path *	f,
		const char *	fragment_name,
		int	force )

Definition at line 867 of file F5Fmeta.c.

{
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;
}

References F5_API, F5Fget_type(), F5Fset_attribute(), F5Fset_fragment_attribute(), F5T_BIVEC3_DOUBLE, F5T_BIVEC3_FLOAT, F5T_COORD3_DOUBLE, F5T_COORD3_FLOAT, F5T_METRIC33_DOUBLE, F5T_VEC3_DOUBLE, F5T_VEC3_FLOAT, FIBER_FIELD_ORIGIANL_TYPE, and H5Tclose().

F5Fset_string_attribute()

F5_API int F5Fset_string_attribute	(	F5Path *	f,
		const char *	fragment_name,
		const char *	attribute_name,
		const char *	text,
		int	force )

Definition at line 350 of file F5Fmeta.c.

{
        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;
}

References F5_API, F5Fis_group(), F5Fopen_or_create_group_or_dataset_attribute(), F5printf, F5Path::Field_hid, and H5Tclose().

Referenced by F5Fset_dictionary2(), and F5Fset_metric_unit_description().