F5F.h File Reference

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

Go to the source code of this file.

Typedefs
typedef enum F5ErrorCode_type	F5ErrorCode

Enumerations

enum

F5ErrorCode_type {   F5_SUCCESS = 0 , F5ERROR_INVALID_FPATH = -1 , F5ERROR_INCONSISTENT_DATASPACE = -2 , F5ERROR_INVALID_FRAGMENT_START = -3 ,   F5ERROR_INVALID_FRAGMENT_END = -4 , F5ERROR_INVALID_FIELDNAME = -5 , F5ERROR_INVALID_FRAGMENTNAME = -6 , F5ERROR_INVALID_DATA_ADDRESS = -7 ,   F5ERROR_INVALID_PARAMETERS = -9 , F5ERROR_ALREADY_EXISTS = -10 , F5ERROR_COMPOUND_EXPECTED = -30 , F5ERROR_COMPONENTMAP_EXPECTED = -31 ,   F5ERROR_COMPONENTMAP_INVALID = -32 , F5ERROR_NONSPECIFIED = -100 }

Functions
F5_API int	F5Fis_group (const F5Path *)
F5_API int	F5Ffragment_is_group (const F5Path *fpath, const char *fragment_name)
F5_API int	F5LTset_dataspace (F5Path *f, int rank, hsize_t *dims)
F5_API int	F5LTexpand_dataspace (F5Path *f, int rank, hsize_t *dims)
F5_API int	F5Fexpand_dataspace (F5Path *fpath, int rank, hsize_t *Dims)
F5_API hid_t	F5file_type (F5Path *fpath, hid_t fieldtype)
F5_API void	F5close (F5Path *f)
F5_API void	F5closep (F5Path **f)
F5_API int	F5Fopen (F5Path *f, const char *fieldname)
F5_API F5Path *	F5FopenMostRecentSlice (hid_t File_id, double *t, const char *gridname, const char *fieldname, const char *coordinate_system)
F5_API void	F5Fclose (F5Path *f)
F5_API hid_t	F5Fgrab (F5Path *f)
F5_API hid_t	F5Fget_type2 (F5Path *f, hid_t elink_fapl_id)
F5_API hid_t	F5Fget_type (F5Path *f)
F5_API hid_t	F5Tget_space (F5Path *f)
F5_API hsize_t *	F5Tpermute_dimensions (F5Path *fpath, int rank, hsize_t *target_dims, const hsize_t *source_dims)
F5_API int	F5Tget_extent (F5Path *f, hsize_t *dims, int maxDims)
F5_API int	F5Tget_index_depth (F5Path *f, int *result)
F5_API int	F5LTget_skeleton_dimensionality (hid_t Top_hid)
F5_API int	F5Tget_refinement_level (F5Path *f, hsize_t *dims, int maxDims)
F5_API int	F5Fcreate (F5Path *fpath, const char *fieldname, int dimension, hsize_t *dims, hid_t fieldtype, hid_t property_id)
F5_API const char *	F5Fwhatsup (F5ErrorCode)
F5_API F5ErrorCode	F5Fwrite (F5Path *fpath, const char *fieldname, int dimension, hsize_t *dims, hid_t fieldtype, hid_t memtype, const void *dataPtr, hid_t property_id)
F5_API F5ErrorCode	F5FwriteHyperDimensional (F5Path *fpath, const char *fieldname, int rank, hsize_t *dims, hid_t fieldtype, hid_t memtype, const void *dataPtr, hid_t property_id)
F5_API F5ErrorCode	F5_DEPRECATED ("This is an internal function. Use F5FwriteHyperDimensional() instead.", F5Fwrite_flexible(F5Path *fpath, const char *fieldname, int dimension, hsize_t *dims, hid_t fieldtype, hid_t memtype, const void *dataPtr, hid_t property_id, int do_check))
F5_API F5ErrorCode	F5FwriteIMAGE (F5Path *fpath, const char *fieldname, int dimension, hsize_t *dims, hid_t fieldtype, hid_t memtype, const void *dataPtr, hid_t property_id)
F5_API F5ErrorCode	F5Fwrite_1D (F5Path *fpath, const char *fieldname, hsize_t nElements, hid_t fieldtype, hid_t memtype, const void *dataPtr, hid_t property_id)
F5_API int	F5Fwrites (F5Path *fpath, const char *fieldname, int dimension, hsize_t *dims, hid_t fieldtype, hid_t memtype, const void **dataPtr, hid_t property_id)
F5_API F5ErrorCode	F5FwriteX (F5Path *fpath, const char *fieldname, int rank, const hsize_t dims[], hid_t fieldtype, hid_t memtype, const void *const dataPtr[], const int polynom_order[], const int component_map[], hid_t property_id)
F5_API void	F5FevalX (double *result, int Mrank, const int index[], int components, const double *const polynomials[], const int polynom_order[], const int component_map[])
F5_API int	F5Fwrite_linear (F5Path *fpath, const char *fieldname, int rank, hsize_t *dims, hid_t fieldtype, const void *base, const void *delta)
F5_API F5ErrorCode	F5Fwrite_fraction (F5Path *fpath, const char *fieldname, int rank, const hsize_t *full_dims, const hsize_t *fragment_dims, hid_t fieldtype, hid_t memtype, const void *dataPtr, const hsize_t *datastart, const hsize_t *start_border, const hsize_t *end_border, const char *fraction_name, hid_t property_id)
F5_API F5ErrorCode	F5Fwrite_fraction_external (F5Path *fpath, const char *fieldname, const char *target_file_name, const char *target_obj_name, const char *prefix, int rank, const hsize_t *full_dims, const hsize_t *fragment_dims, hid_t fieldtype, hid_t memtype, const void *dataPtr, const hsize_t *datastart, const hsize_t *start_border, const hsize_t *end_border, const char *fraction_name, hid_t property_id)
F5_API F5ErrorCode	F5Fwrite_fractionS (F5Path *fpath, const char *fieldname, int rank, const hsize_t *full_dims, const hsize_t *fragment_dims, hid_t fieldtype, hid_t memtype, const void *dataPtr, const hsize_t *datastart, const hsize_t *start_border, const hsize_t *end_border, const char *fraction_name, hid_t property_id)
F5_API int	F5FSwrite_fraction (F5Path *fpath, const char *fieldname, int rank, const hsize_t *full_dims, const hsize_t *fragment_dims, hid_t fieldtype, hid_t memtype, const void *const *dataPtr, const hsize_t *datastart, const hsize_t *start_border, const hsize_t *end_border, const char *fraction_name, hid_t property_id, int AllowFullCoverage)
F5_API int	F5Fwrite_linear_fraction (F5Path *fpath, const char *fieldname, int rank, const hsize_t *full_dims, const hsize_t *fragment_dims, hid_t fieldtype, const void *base, const void *delta, const hsize_t *datastart, const char *fraction_name)
F5_API int	F5Fwrite_linear_fraction_overlap (F5Path *myPath, int rank, const hsize_t *start_border, const hsize_t *end_border, const char *fraction_name)
F5_API ArrayType	F5Fget_field_enum (const F5Path *fpath, const char *fieldname, int *major_version, int *minor_version, int *release_version)
F5_API int	F5Fis_linear (F5Path *fpath, const char *fieldname)
F5_API int	F5Fis_fragmented (F5Path *fpath, const char *fieldname)
F5_API int	F5Fis_separatedcompound (F5Path *fpath, const char *fieldname)
F5_API int	F5Fread_linear (F5Path *fpath, hsize_t *dims, hid_t fieldtype, void *base, void *delta)
F5_API int	F5Fread_linearo (F5Path *fpath, const char *fieldname, hsize_t *dims, hid_t fieldtype, void *base, void *delta)
F5_API int	F5Fread_linear_fragment (F5Path *fpath, hid_t fragment_hid, hsize_t *dims, hid_t fieldtype, void *base, void *delta)
F5_API int	F5Fget_attribute_byname (F5Path *f, const char *attribute_name, void *data, hsize_t N, hid_t mem_type_id, const char *fragment_name)
F5_API int	F5Fset_attribute_byname (F5Path *f, const char *attribute_name, const void *data, hsize_t N, hid_t mem_type_id, const char *fragment_name)
F5_API int	F5Fget_range (F5Path *f, const char *fragment_name, void *minmax)
F5_API int	F5Fset_range (F5Path *f, const char *fragment_name, const void *minmax)

Typedef Documentation

F5ErrorCode

typedef enum F5ErrorCode_type F5ErrorCode

Examples

ObjtoF5.c.

Definition at line 267 of file F5F.h.

Enumeration Type Documentation

F5ErrorCode_type

enum F5ErrorCode_type

Enumerator
F5_SUCCESS	no troubles
F5ERROR_INVALID_FPATH	fpath pointer is invalid
F5ERROR_INCONSISTENT_DATASPACE	inconsistent dataspace (does not match with representation group)
F5ERROR_INVALID_FRAGMENT_START	F5Fwrite_fraction(): fragment starts beyond dataspace
F5ERROR_INVALID_FRAGMENT_END	F5Fwrite_fraction(): fragment ends beyond dataspace
F5ERROR_INVALID_FIELDNAME	Invalid field name
F5ERROR_INVALID_FRAGMENTNAME	Invalid fragment name
F5ERROR_INVALID_DATA_ADDRESS	Invalid data pointer, nullptr
F5ERROR_INVALID_PARAMETERS	Some invalid function parameter
F5ERROR_ALREADY_EXISTS
F5ERROR_COMPOUND_EXPECTED
F5ERROR_COMPONENTMAP_EXPECTED
F5ERROR_COMPONENTMAP_INVALID
F5ERROR_NONSPECIFIED

Definition at line 223 of file F5F.h.

{
        /** no troubles */
        F5_SUCCESS       = 0,
 
        /** fpath pointer is invalid */
        F5ERROR_INVALID_FPATH = -1,
 
        /**  inconsistent dataspace (does not match with representation group)  */
 
        F5ERROR_INCONSISTENT_DATASPACE = -2,
 
        /**   F5Fwrite_fraction(): fragment starts beyond dataspace */
        F5ERROR_INVALID_FRAGMENT_START = -3,
 
        /**   F5Fwrite_fraction(): fragment ends beyond dataspace */
        F5ERROR_INVALID_FRAGMENT_END   = -4,
 
        /**   Invalid field name */
        F5ERROR_INVALID_FIELDNAME   = -5,
 
        /**   Invalid fragment name */
        F5ERROR_INVALID_FRAGMENTNAME   = -6,
 
        /**   Invalid data pointer, nullptr */
        F5ERROR_INVALID_DATA_ADDRESS   = -7,
 
        /**   Some invalid function parameter */
        F5ERROR_INVALID_PARAMETERS    = -9,
 
        F5ERROR_ALREADY_EXISTS = -10,
 
        /** @relates F5FwriteX  */
        F5ERROR_COMPOUND_EXPECTED     = -30,
 
        /** @relates F5FwriteX  */
        F5ERROR_COMPONENTMAP_EXPECTED = -31,
 
        /** @relates F5FwriteX  */
        F5ERROR_COMPONENTMAP_INVALID  = -32,
 
        F5ERROR_NONSPECIFIED = -100
};

Function Documentation

F5_DEPRECATED()

F5_API F5ErrorCode F5_DEPRECATED	(	"This is an internal function. Use F5FwriteHyperDimensional() instead."	,
		F5Fwrite_flexible(F5Path *fpath, const char *fieldname, int dimension, hsize_t *dims, hid_t fieldtype, hid_t memtype, const void *dataPtr, hid_t property_id, int do_check)	)

References F5_API.

F5closep()

F5_API void F5closep

(

F5Path **

f

)

Definition at line 222 of file F5B.c.

{
        if (!f)  return;
        if (!*f) return;
        F5close(*f);
        *f = NULL;
}

References F5close().

F5FevalX()

F5_API void F5FevalX	(	double *	result,
		int	Mrank,
		const int	index[],
		int	components,
		const double *const	polynomials[],
		const int	polynom_order[],
		const int	component_map[] )

Definition at line 1293 of file F5F.c.

{
int i;
        for(i=0; i<Mrank; i++)
        {
        int     c = component_map[ i ];
                result[ c ] = poly_eval( polynomials[c], polynom_order[c], index[ i ] );
        }
/*
        for(i=0; i<components; i++)
        {
                result[i] = poly_eval( polynomials[i], polynom_order[i], index[ component_map[ i ] ] );
        }
*/
}

F5Fexpand_dataspace()

F5_API int F5Fexpand_dataspace	(	F5Path *	fpath,
		int	rank,
		hsize_t *	Dims )

Definition at line 768 of file F5F.c.

{
hsize_t full_dims[FIBER_MAX_RANK];
int     retval;
        F5Tpermute_dimensions(fpath, rank, full_dims , Dims);
        retval = F5LTexpand_dataspace(fpath, rank, full_dims);
        F5Tpermute_dimensions(fpath, rank, Dims, full_dims);
        return retval;
}

References F5LTexpand_dataspace(), F5Tpermute_dimensions(), and FIBER_MAX_RANK.

F5Ffragment_is_group()

F5_API int F5Ffragment_is_group	(	const F5Path *	fpath,
		const char *	fragment_name )

flag to tell wether the fragment in the current field is a group

Note: The requirement to call this function is likely a design error in the calling code.

Definition at line 135 of file F5F.c.

{
        if (!fpath) return 0;
 
H5G_stat_t info;
 
        herr_t status = H5Gget_objinfo(fpath->Field_hid, fragment_name, 0, &info);
 
        if (status < 0)
                return 0;
 
        if (info.type == H5G_GROUP)
        {
                F5printf(5, "F5Ffragment_is_group == true");
                return 1;
        }
 
        return 0;
}

References F5printf, and F5Path::Field_hid.

F5Fget_attribute_byname()

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

Get a field's attribute, possibly specifying data conversion.

Parameters

mem_type_id	The type of the attribute as it resides in memory, may be zero to use the type of the attribute in-file.
fragment_name	Optional name of a fragment, null string indicates unfragmented read.

Definition at line 1593 of file F5F.c.

{
herr_t  err;
hid_t   attr_id, type_id;
        if (!f)
        {
                F5printf(5, "Open attribute %s without path object cannot succeed!", attribute_name);
                return  0;
        }
 
        if (fragment_name)
        {
        hid_t   frag_id = F5Gtry_to_open(f->Field_hid, fragment_name);
                if (frag_id<0)
                {
                        frag_id = F5Dtry_to_open(f->Field_hid, fragment_name);
                        if (frag_id<0)
                        {
                                F5printf(5, "F5Fget_attribute_byname(%s,%s). No such fragment.", attribute_name, fragment_name);
                                return 0;
                        }
                }
 
                attr_id = F5Atry_to_open( frag_id, attribute_name);
                F5Xclose( frag_id );
        }
        else
                attr_id = F5Atry_to_open( f->Field_hid, attribute_name);
 
        if (attr_id<0)
        {
                /* attribute not found */
                F5printf(5, "Open attribute %s in fragment %s not found.", attribute_name, fragment_name);
                return 0;
        }
 
        {
        hid_t   space_id = H5Aget_space(attr_id);
        hsize_t NumberofExistingAttributeElements = H5Sget_simple_extent_npoints(space_id);
                H5Sclose(space_id);
                if (NumberofExistingAttributeElements != N)
                {
                        F5printf(1,"F5Fget_attribute_byname() MISMATCH - trying to read %d elements for attribute %s which has %d elements in file.",
                                 (int)N, attribute_name, (int)NumberofExistingAttributeElements);
                        return 0;
                }
        }
 
        if (mem_type_id)
                type_id = mem_type_id;
        else
                type_id  = H5Aget_type(attr_id);
 
        {
        H5E_BEGIN_TRY
        err =   F_H5Aread(attr_id, type_id, data, attribute_name);
        H5E_END_TRY
        }
 
        H5Aclose(attr_id);
 
        if (!mem_type_id)
                H5Tclose(type_id);
 
        if (err<0)
                return 0;
        else
                return 1;
}

References F5Atry_to_open(), F5Dtry_to_open(), F5Gtry_to_open(), F5printf, F5Xclose(), F_H5Aread(), F5Path::Field_hid, and H5Tclose().

Referenced by F5Fget_range().

F5Fget_field_enum()

F5_API ArrayType F5Fget_field_enum	(	const F5Path *	fpath,
		const char *	fieldname,
		int *	major_version,
		int *	minor_version,
		int *	release_version )

Get the field enumeration type for a given field. If the fieldname is zero, then the fpath object must contain a valid Field_id. The F5Path object is unchanged.

Definition at line 17 of file F5F.c.

{
ArrayType retval;
int     is_group = -1;
hid_t   loc_id;
 
        F5printf(50, "F5Fget_field_enum(%s)", fieldname);
 
        if (!fpath)
        {
                F5printf(50, "F5Fget_field_enum(%s): No valid F5Path given.", fieldname);
                *major_version = *minor_version = *release_version = 0;
                return UnknownArrayType;
        }
 
        if (fieldname)
        {
                H5E_BEGIN_TRY
                is_group = 0;
                loc_id = H5Dopen2(fpath->Representation_hid, fieldname, H5P_DEFAULT);
                H5E_END_TRY
                if (loc_id<0)
                {
                        loc_id = H5Gopen2(fpath->Representation_hid, fieldname, H5P_DEFAULT);
                        if (loc_id<0)
                        {
                                F5printf(50, "F5Fget_field_enum(%s): Cannot determine field type!", fieldname);
                        }
                        is_group = 1;
                }
        }
        else
                loc_id = fpath->Field_hid;
 
        retval = F5Tget_field_Array_enum(loc_id,
                                         major_version, minor_version, release_version);
 
        switch(is_group)
        {
        case 1: H5Gclose(loc_id); break;
        case 0: H5Dclose(loc_id); break;
        }
 
        F5printf(50, "~F5Fget_field_enum(%s)", fieldname);
        return retval;
}

References F5printf, F5Tget_field_Array_enum(), F5Path::Field_hid, H5Gclose, F5Path::Representation_hid, and UnknownArrayType.

Referenced by F5Fis_fragmented(), F5Fis_separatedcompound(), and F5iterate_field_fragments().

F5Fget_range()

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

Field attribute (recommended): The min/max of components of a dataset. This two-element attribute is of the same type as a dataset, but contains the respective minimal/maximal value of the data's components. Example: for a set of point locations distributed in space, this gives the bounding box.

Parameters

memtype_id

HDF5 Type ID describing the min/max variables. May be zero to use exactly the type of the field. Otherwise, type conversion must be available to HDF5.

Note

WARNING: You should never use the file type for reading, because then you might get values in the wrong bitorder! Usually you want to provide a type that is identically to the file type, but constructed from NATIVE types!

Todo

Write a function that converts types from file type to native type...

Definition at line 1666 of file F5F.c.

{
hid_t   type_id = F5Fget_type(f);
 
int     check = F5Fget_attribute_byname( f, FIBER_FIELD_COMPONENT_RANGE, minmax, 2, type_id , fragment_name);
 
        if( H5Iis_valid( type_id ) )
                if( H5Iget_type( type_id ) >= 0 )
                        H5Tclose(type_id);
        return check;
}

References F5Fget_attribute_byname(), F5Fget_type(), FIBER_FIELD_COMPONENT_RANGE, and H5Tclose().

F5Fget_type()

F5_API hid_t F5Fget_type

(

F5Path *

f

)

Definition at line 156 of file F5F.c.

{
        return F5Fget_type2(f,0);
}

References F5Fget_type2().

Referenced by F5Fget_average(), F5Fget_deviation(), F5Fget_fragment_range_ghost2(), F5Fget_range(), F5Fset_average2(), F5Fset_deviation2(), F5Fset_fragment_range_ghost2(), F5Fset_original_type2(), and F5Fset_range().

F5file_type()

F5_API hid_t F5file_type	(	F5Path *	fpath,
		hid_t	fieldtype )

In F5, types are saved to the file to store certain information about datasets. The insufficiency in HDF5 is that a certain type can be saved to one file only, but not to many files, like a dataset. When a type is saved to a file, it becomes a "named type" - in contrast to "transient" types, which are not bound to a file. Only named types may carry attributes, transient types may not contain attributes.

Type attributes are used to describe properties of a type, in particular its tensorial properties, which is beyond the raw native type definition of e.g. float and dimension. We cannot store this information with a transient type, but must do it by our own ;-( .

Generic support would be desireable, but is not implemented right now. For now, only a limited set of pre-defined low-tensorial data types is hard-coded. By knowing this hard-coded type, also the tensorial type information is written into the file when saving the data type. Admittedly, this is not pretty, and a future revision will provide a more dynamically mechanism here.

The functionality is as follows:

Given a transient HDF5 type, return a named type that is suitable for the current file. The file ID's will be filled with the named data types.

@Note The file which is contained in fpath will be changed by this operation, because a new type might be created and saved into the file, so the fpath parameter cannot be const.

@Note This function currently only knows aboout point, vector and predefined tensor types in the ChartId. It is NOT fully generic. If it cannot convert some field type into a file type, it returns the transient type, i.e. we don't get a named type in this case.

Definition at line 941 of file F5Bchart.c.

{
        if (!fpath || !fpath->myChart)
        {
                F5printf(20, "F5file_type: No chart given, returning memory type.");
                return fieldtype;
        }
 
        F5printf(40, "F5file_type(%p, %d): chart=%p", fpath, (int) fieldtype, fpath->myChart );
 
        switch( H5Tget_class( fieldtype) )
        {
        default:
                F5printf(20, "F5file_type query for unknown type (could be a native one).");
                return fieldtype;
 
        case H5T_INTEGER:
        case H5T_FLOAT:
        case H5T_STRING:
                F5printf(20, "F5file_type query for integer/float/string type (could be a native one).");
                return fieldtype;
 
        case H5T_BITFIELD:
        case H5T_OPAQUE:
        case H5T_REFERENCE:
        case H5T_ENUM:
        case H5T_VLEN:
        case H5T_ARRAY:
                F5printf(20, "F5file_type query for unsupported type (could be a native one).");
                return fieldtype;
 
        case H5T_COMPOUND:
                ;
        }
 
/*
  The following code is executed once we know the fieldtype is a compound type.
 */
 
        {
        hid_t   FirstCompoundType = H5Tget_member_type( fieldtype, 0);
        int     CompoundPrecision = H5Tget_size( FirstCompoundType );
 
        F5_ChartPrecisionTypes*IN   = F5Bget_precision_by_size(fpath->myChart, CompoundPrecision),
                              *OUT  = F5Bget_precision_by_size(fpath->FileIDs, CompoundPrecision);
 
                H5Tclose( FirstCompoundType );
 
                F5printf(20, "F5file_type query for compound type, precision %d.\n", CompoundPrecision);
 
                assert(IN);
                assert(OUT);
                assert( fpath->myChart );
                assert( fpath->FileIDs );
 
                if (F5Tequal(fieldtype, IN->Point_hid_t) )
                {
                        F5printf(20, "F5file_type query for point type.\n");
                        if (OUT->Point_hid_t<1)
                        {
                                F5printf(0, "F5file_type(): Possible internal error, point type not found in file!");
 
                                OUT->Point_hid_t = F5Tmake_precise_tensor(fpath, FIBER_HDF5_CHART_POINT_TYPE, CompoundPrecision,
                                                                          IN->Point_hid_t, 0,0, 0);
                                {
                                int cd = fpath->myChart->cell_dimensionality;
                                        printf("CELL Dimensionality: %d\n", cd);
                                        F5Asave_ints(OUT->Point_hid_t,  FIBER_HDF5_CELLDIMENSIONALITY, &cd, 1);
                                }
 
#ifdef  SAVE_MEMORDER_WITH_TYPE
                                F5T_save_perm_vector(OUT->Point_hid_t,
                                                     H5Tget_nmembers( OUT->Point_hid_t ),
                                                     fpath->FileIDs->perm_vector);
#endif
                        }
                        return OUT->Point_hid_t;
                }
                else if (F5Tequal(fieldtype, IN->Vector_hid_t) )
                {
                        F5printf(20, "F5file_type query for vector type %d", (int) IN->Vector_hid_t );
                        if (OUT->Vector_hid_t<1)
                        {
                        int     covariance[] = {1}; /* Tangential vectors have one upper index */
                                OUT->Vector_hid_t =
                                        F5Tmake_precise_tensor(fpath, FIBER_HDF5_CHART_VECTOR_TYPE, CompoundPrecision,
                                                               IN->Vector_hid_t, 1, covariance, 1);
                        }
                        return OUT->Vector_hid_t;
                }
                else if (F5Tequal(fieldtype, IN->Covector_hid_t) )
                {
                        F5printf(20, "F5file_type query for covector type.\n");
                        if (OUT->Covector_hid_t<1)
                        {
                        int     covariance[] = {-1}; /* Co-vectors have one lower index */
                                OUT->Covector_hid_t =
                                        F5Tmake_precise_tensor(fpath, FIBER_HDF5_CHART_COVECTOR_TYPE, CompoundPrecision,
                                                               IN->Covector_hid_t, 1, covariance, 1);
                        }
                        return OUT->Covector_hid_t;
                }
                else if (F5Tequal(fieldtype, IN->Bivector_hid_t) )
                {
                        F5printf(20, "F5file_type query for bivector type.\n");
                        if (OUT->Bivector_hid_t<1)
                        {
                        int     covariance[] = {1,1}; /* bivectors have two upper indices */
                                OUT->Bivector_hid_t =
                                        F5Tmake_precise_tensor(fpath, FIBER_HDF5_CHART_BIVECTOR_TYPE, CompoundPrecision,
                                                               IN->Bivector_hid_t, 2, covariance, 2);
                        }
                        return OUT->Bivector_hid_t;
                }
                else if (F5Tequal(fieldtype, IN->Bicovector_hid_t) )
                {
                        F5printf(20, "F5file_type query for bicovector type.\n");
                        if (OUT->Bivector_hid_t<1)
                        {
                        int     covariance[] = {-1,-1}; /* bicovectors have two lower indices */
                                OUT->Bicovector_hid_t =
                                        F5Tmake_precise_tensor(fpath, FIBER_HDF5_CHART_BICOVECTOR_TYPE, CompoundPrecision,
                                                               IN->Bicovector_hid_t, 2, covariance, 2);
                        }
                        return OUT->Bicovector_hid_t;
                }
 
                else if (F5Tequal(fieldtype, IN->Metric_hid_t) )
                {
                        F5printf(20, "F5file_type query for metric type.\n");
                        if (OUT->Metric_hid_t<1)
                        {
                                /* g_\mu\nu */
                        int     covariance[] = {-1, -1}; /* Metric tensors have two lower indices */
                                OUT->Metric_hid_t =
                                        F5Tmake_precise_tensor(fpath, FIBER_HDF5_CHART_METRIC_TYPE, CompoundPrecision,
                                                               IN->Metric_hid_t, 2, covariance, 0);
                        }
                        return OUT->Metric_hid_t;
                }
                else if (F5Tequal(fieldtype, IN->Cometric_hid_t) )
                {
                        F5printf(20, "F5file_type query for cometric type.\n");
                        if (OUT->Cometric_hid_t<1)
                        {
                                /* g^\mu\nu */
                        int     covariance[] = {1, 1}; /* Cometric tensors have two upper indices */
                                OUT->Cometric_hid_t =
                                        F5Tmake_precise_tensor(fpath, FIBER_HDF5_CHART_COMETRIC_TYPE, CompoundPrecision,
                                                               IN->Cometric_hid_t, 2, covariance, 0);
                        }
                        return OUT->Cometric_hid_t;
                }
 
 
                F5printf(2, __FILE__ ": Warning: F5file_type() query could not identify file type.\n");
                {
                int     TypeMembers = H5Tget_nmembers( fieldtype );
                const   char*MultiplicityCategory;
                hid_t   MultiplicityCategory_id;
                        switch(TypeMembers)
                        {
                        case 1: MultiplicityCategory = "Chart-free compound types with one member"; break;
                        case 2: MultiplicityCategory = "Chart-free compound types with two members"; break;
                        case 3: MultiplicityCategory = "Chart-free compound types with three members"; break;
                        case 4: MultiplicityCategory = "Chart-free compound types with four members"; break;
                        default:MultiplicityCategory = "Chart-free compound types with many members"; break;
                        }
                        MultiplicityCategory_id = F5Gappend(fpath->GlobalChart_hid, MultiplicityCategory);
 
                        {
#define FIBER_HDF5_ANONYMOUS_TYPENAME "F5::TypeName%04u"
                        char    type_name[1024];
                        unsigned nthType = 0;
                                for(;nthType<10000;nthType++)
                                {
                                hid_t   type_id;
                                        sprintf(type_name, FIBER_HDF5_ANONYMOUS_TYPENAME, nthType);
                                        type_id = F5Tappend(MultiplicityCategory_id, type_name, fieldtype);
 
                                        if (type_id>0)
                                        {
                                                /*
                                                  Inject This type to the chart file identifiers
                                                  for the output file, for mere cleanup upon file
                                                  closing. Otherwise This type ID will NOT be associated
                                                  with the respective chart.
                                                 */
                                                F5B_inject_precision_type(OUT, type_id);
                                                H5Gclose(MultiplicityCategory_id);
                                                return type_id;
                                        }
                                }
                                puts("F5file_type: Creating anonymous type name failed!");
                                H5Gclose(MultiplicityCategory_id);
                                return fieldtype;
                        }
                }
        }
}

References _F5_ChartPrecisionTypes::Bicovector_hid_t, _F5_ChartPrecisionTypes::Bivector_hid_t, ChartDomain_IDs::cell_dimensionality, _F5_ChartPrecisionTypes::Cometric_hid_t, _F5_ChartPrecisionTypes::Covector_hid_t, F5Asave_ints(), F5B_inject_precision_type(), F5Bget_precision_by_size(), F5Gappend(), F5printf, F5T_save_perm_vector(), F5Tappend(), F5Tmake_precise_tensor(), FIBER_HDF5_ANONYMOUS_TYPENAME, FIBER_HDF5_CELLDIMENSIONALITY, FIBER_HDF5_CHART_BICOVECTOR_TYPE, FIBER_HDF5_CHART_BIVECTOR_TYPE, FIBER_HDF5_CHART_COMETRIC_TYPE, FIBER_HDF5_CHART_COVECTOR_TYPE, FIBER_HDF5_CHART_METRIC_TYPE, FIBER_HDF5_CHART_POINT_TYPE, FIBER_HDF5_CHART_VECTOR_TYPE, F5Path::FileIDs, F5Path::GlobalChart_hid, H5Gclose, H5Tclose(), _F5_ChartPrecisionTypes::Metric_hid_t, F5Path::myChart, ChartDomain_IDs::perm_vector, _F5_ChartPrecisionTypes::Point_hid_t, and _F5_ChartPrecisionTypes::Vector_hid_t.

Referenced by F5Fcreate(), F5FSwrite_fraction(), F5Fwrite_1D(), F5Fwrite_flexible(), F5Fwrite_fraction(), F5Fwrite_fraction_external(), F5Fwrite_fractionS(), F5Fwrite_linear(), F5Fwrite_linear_fraction(), F5FwriteIMAGE(), F5Fwrites(), F5FwriteX(), F5Rcreate_uniform_sparse(), F5write_particle_cartesian3Dv(), F5write_particle_cartesian3DvU(), and F5write_particle_double_cartesian3Dv().

F5Fis_fragmented()

F5_API int F5Fis_fragmented	(	F5Path *	fpath,
		const char *	fieldname )

Definition at line 1106 of file F5F.c.

{
int major_version, minor_version, release_version;
ArrayType at = F5Fget_field_enum(fpath, fieldname,
                                 &major_version, &minor_version, &release_version);
 
        if (major_version != FIBER_MAJOR_VERSION ||
            minor_version != FIBER_MINOR_VERSION ||
            release_version != FIBER_RELEASE_VERSION)
                return 0;
 
        switch(at)
        {
        case FragmentedContiguous:
        case FragmentedSeparatedCompound:
        case FragmentedUniformSampling:
                return 1;
 
        default: return 0;
        }
}

References F5Fget_field_enum(), FIBER_MAJOR_VERSION, FIBER_MINOR_VERSION, FIBER_RELEASE_VERSION, FragmentedContiguous, FragmentedSeparatedCompound, and FragmentedUniformSampling.

F5Fis_group()

F5_API int F5Fis_group

(

const F5Path *

fpath

)

flag to tell wether the field id is a group

Definition at line 126 of file F5F.c.

{
        if (!fpath) return 0;
        if (H5Iget_type( fpath->Field_hid ) == H5I_GROUP)
                return 1;
 
        return 0;
}

References F5Path::Field_hid.

Referenced by F5close(), F5Fclose(), F5Fget_string_attribute(), F5Fget_type2(), F5Fset_attribute(), F5Fset_string_attribute(), F5iterate_field_fragments(), and F5Tget_space().

F5Fis_separatedcompound()

F5_API int F5Fis_separatedcompound	(	F5Path *	fpath,
		const char *	fieldname )

Definition at line 1128 of file F5F.c.

{
int major_version, minor_version, release_version;
ArrayType at = F5Fget_field_enum(fpath, fieldname,
                                 &major_version, &minor_version, &release_version);
 
        if (major_version != FIBER_MAJOR_VERSION ||
            minor_version != FIBER_MINOR_VERSION ||
            release_version != FIBER_RELEASE_VERSION)
                return 0;
 
        switch(at)
        {
        case FragmentedSeparatedCompound:
                return 1;
 
        default: return 0;
        }
}

References F5Fget_field_enum(), FIBER_MAJOR_VERSION, FIBER_MINOR_VERSION, FIBER_RELEASE_VERSION, and FragmentedSeparatedCompound.

F5Fread_linear_fragment()

F5_API int F5Fread_linear_fragment	(	F5Path *	fpath,
		hid_t	fragment_hid,
		hsize_t *	dims,
		hid_t	fieldtype,
		void *	base,
		void *	delta )

same as F5Fread_linear, but reads a fragment of a field @TODO revise this function as it requires a fragment_hid, which is out of synch with the remaining F5 API: Fragments must never passed as id's but only as name, which may also be a null pointer to indicate unfragmented fields.

Definition at line 1550 of file F5F.c.

{
hid_t   field_id;
int     rank;
hsize_t file_dims[FIBER_MAX_RANK];
 
        F5printf(40, "F5Fread_linear()");
                /*      F5Fclose( fpath );  */
 
                                        /*      field_id = F5Lread_linear(fpath->Representation_hid, fieldname, */
 
        field_id = F5Lread_linear(fragment_hid,
                                  file_dims,
                                  fieldtype,
                                  base, delta);
 
        if (field_id < 0 )
                return 0;
 
        if (dims)
        {
                rank = H5Tget_nmembers( fieldtype );
                F5printf_indent++;
                F5Tpermute_dimensions(fpath, rank, dims, file_dims );
                F5printf_indent--;
        }
 
        F5printf(40, "~F5Fread_linear()");
        return 1;
}

References F5Lread_linear(), F5printf, F5printf_indent, F5Tpermute_dimensions(), and FIBER_MAX_RANK.

F5Fread_linearo()

F5_API int F5Fread_linearo	(	F5Path *	fpath,
		const char *	fieldname,
		hsize_t *	dims,
		hid_t	fieldtype,
		void *	base,
		void *	delta )

References F5_API.

F5Fset_attribute_byname()

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

Set a field's attribute.

Parameters

fragment_name

Optional name of a fragment, null string indicates unfragmented read.

Definition at line 1680 of file F5F.c.

{
hid_t   attr_id, space_id;
        if (!f)
        {
                F5printf(5,"F5Fset_attribute() got NULL F5Path, cannot set attribute %s .",attribute_name);
                return 0;
        }
        if (f->Field_hid<1)
        {
                F5printf(5,"F5Fset_attribute() F5Path has no field ID, cannot set attribute %s .",attribute_name);
                return 0;
        }
 
        space_id = H5Screate_simple(1, &N, &N );
 
        if (fragment_name)
        {
        hid_t   frag_id;
                H5E_BEGIN_TRY
                frag_id = H5Gopen2(f->Field_hid, fragment_name, H5P_DEFAULT);
                H5E_END_TRY
                if (frag_id<0)
                {
                        frag_id = F5Dtry_to_open(f->Field_hid, fragment_name);
                }
 
                attr_id = F5Atry_to_open( frag_id, attribute_name);
                if (attr_id<0)
                        attr_id = F5Acreate( frag_id, attribute_name, mem_type_id, space_id, H5P_DEFAULT);
 
                F5Xclose( frag_id );
        }
        else
        {
                attr_id = F5Atry_to_open( f->Field_hid, attribute_name);
                if (attr_id<0)
                        attr_id = F5Acreate( f->Field_hid, attribute_name, mem_type_id, space_id, H5P_DEFAULT);
        }
 
        H5Sclose( space_id );
 
        if (attr_id<0)
        {
                F5printf(5,"F5Fset_attribute() Could neither open or create attribute %s .",attribute_name);
                return 0;
        }
 
        H5Awrite(attr_id, mem_type_id, data );
        H5Aclose(attr_id);
        return 1;
}

References F5Acreate(), F5Atry_to_open(), F5Dtry_to_open(), F5printf, F5Xclose(), and F5Path::Field_hid.

Referenced by F5Fset_range().

F5Fset_range()

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

Set the range of values within a dataset. The given min/max values must be of the same type as in the field.

Definition at line 1737 of file F5F.c.

{
hid_t   type_id = F5Fget_type(f);
int     check;
        if (type_id<=0)
                return 0;
 
        check = F5Fset_attribute_byname(f,
                                        FIBER_FIELD_COMPONENT_RANGE, minmax, 2,
                                        type_id, fragment_name);
 
        H5Tclose(type_id);
 
        return check;
}

References F5_API, F5Fget_type(), F5Fset_attribute_byname(), FIBER_FIELD_COMPONENT_RANGE, and H5Tclose().

Referenced by F5Rcreate_uniform_cartesian3D(), and F5Rcreate_uniform_cartesian3Dbbox().

F5Fwrite_1D()

F5_API F5ErrorCode F5Fwrite_1D	(	F5Path *	fpath,
		const char *	fieldname,
		hsize_t	nElements,
		hid_t	fieldtype,
		hid_t	memtype,
		const void *	dataPtr,
		hid_t	property_id )

Definition at line 631 of file F5F.c.

{
hid_t   file_type;
        F5printf(40,"F5Fwrite1D(%s)", fieldname);
        if (!fpath)
        {
                F5printf(41,"F5Fwrite1D(%s): no fpath given!", fieldname);
                return F5ERROR_INVALID_FPATH;
        }
        if (nElements<1)
        {
                F5printf(30,"F5Fwrite1D(%s): No elements given, field not created!",fieldname);
                return F5ERROR_INCONSISTENT_DATASPACE;
        }
        if (fpath->Representation_hid<0)
        {
                F5printf(30,"F5Fwrite1D(%s): INVALID Representation ID given!",fieldname);
                return F5ERROR_INCONSISTENT_DATASPACE;
        }
        if (fieldtype<0)
        {
                F5printf(30,"F5Fwrite1D(%s): INVALID field type ID given!",fieldname);
                return F5ERROR_INCONSISTENT_DATASPACE;
        }
 
        file_type = F5file_type(fpath, fieldtype);
        if (file_type<0)
        {
                F5printf(30,"F5Fwrite1D(%s): CANNOT created file type from field type %d given!",
                        fieldname, (int)fieldtype );
                return F5ERROR_INCONSISTENT_DATASPACE;
        }
 
        F5Fclose(fpath);
 
/* TODO: Check the consistency of the number of elements here */
 
        fpath->Field_hid = F5Lwrite1D(fpath->Representation_hid, fieldname,
                                      nElements,
                                      file_type, memtype, dataPtr,
                                      F5LTmake_enum_type(fpath),
                                      property_id);
 
        if (fpath->Field_hid < 0)
        {
                F5printf(30,"F5Fwrite1D(): F5Lwrite1D FAILED!");
                return F5ERROR_NONSPECIFIED;
        }
 
        F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), Contiguous);
        F5I_add_field(fpath, fieldname);
        F5printf(40,"F5Fwrite1D() ok");
 
        return F5_SUCCESS;
}

References Contiguous, F5_API, F5_SUCCESS, F5ERROR_INCONSISTENT_DATASPACE, F5ERROR_INVALID_FPATH, F5ERROR_NONSPECIFIED, F5Fclose(), F5file_type(), F5I_add_field(), F5LTmake_enum_type(), F5Lwrite1D(), F5printf, F5Tset_field_enum(), F5Path::Field_hid, and F5Path::Representation_hid.

Referenced by F5Cwrite_triangular_surface_vc(), F5Flink_triangular_surface(), F5write_particle_cartesian3Dv(), F5write_particle_cartesian3DvU(), F5write_particle_double_cartesian3Dv(), and F5write_particle_positions().

F5Fwrite_fraction_external()

F5_API F5ErrorCode F5Fwrite_fraction_external	(	F5Path *	fpath,
		const char *	fieldname,
		const char *	target_file_name,
		const char *	target_obj_name,
		const char *	prefix,
		int	rank,
		const hsize_t *	full_dims,
		const hsize_t *	fragment_dims,
		hid_t	fieldtype,
		hid_t	memtype,
		const void *	dataPtr,
		const hsize_t *	datastart,
		const hsize_t *	start_border,
		const hsize_t *	end_border,
		const char *	fraction_name,
		hid_t	property_id )

Definition at line 1001 of file F5F.c.

{
hid_t   field_id;
int     i;
hsize_t full_dims[FIBER_MAX_RANK], start_dims[FIBER_MAX_RANK], ldims[FIBER_MAX_RANK],
        sborder[FIBER_MAX_RANK], eborder[FIBER_MAX_RANK];
 
        if (!fpath)
                return F5ERROR_INVALID_FPATH;
 
        F5printf(30, "F5Fwrite_fraction_external(%s, rank=%d)", fieldname, rank);
        if (rank==3)
                F5printf(20, "F5Fwrite_fraction_external(%lux%lux%lu)",
                (int)fraction_dims[0], (int)fraction_dims[1], (int)fraction_dims[2]);
        else if(rank==2)
                F5printf(20, "F5Fwrite_fraction_external(%lux%lu)",
                         (int)fraction_dims[0], (int)fraction_dims[1]);
        else if (rank==1)
                F5printf(20, "F5Fwrite_fraction_external(%lu)",
                         (int)fraction_dims[0]);
 
        F5printf_indent++;
 
        F5Tpermute_dimensions(fpath, rank, full_dims , Dims );
        F5Tpermute_dimensions(fpath, rank, start_dims, datastart );
        F5Tpermute_dimensions(fpath, rank, ldims     , fraction_dims);
        F5Tpermute_dimensions(fpath, rank, sborder   , start_border );
        F5Tpermute_dimensions(fpath, rank, eborder   , end_border   );
        F5printf_indent--;
 
        if (Dims) for(i=0; i<rank; i++)
        {
                if (datastart[i] >= Dims[i])
                {
                        F5printf(-1, "F5Fwrite_fraction(%s): fragment starts beyond dataspace in dimension %d: %d (max %d allowed)!",
                                 fieldname, i, (int)datastart[i], (int)Dims[i] );
                        return F5ERROR_INVALID_FRAGMENT_START;
                }
                if (datastart[i]+fraction_dims[i] > Dims[i])
                {
                        F5printf(-1, "F5Fwrite_fraction(%s): fragment extends beyond dataspace in dimension %d: %d (max %d allowed)!",
                                 fieldname, i, (int)(datastart[i]+fraction_dims[i]), (int)Dims[i] );
                        return  F5ERROR_INVALID_FRAGMENT_END;
                }
        }
        //
        // closing the field in the FPath here
        // because it will be overwritten with a new field ID soon
        //
        F5Fclose( fpath );
 
#ifdef  DO_DATASPACE_CONSISTENCY_CHECK
        if (Dims)
        {
                if (!F5LTset_dataspace(fpath, rank, full_dims))
                {
                        F5printf(-1, "F5Fwrite_fraction(%s): cannot create, inconsistent dataspace!", fieldname);
                        return  F5_SUCCESS; /* ??? */
                }
        }
#endif
        field_id = F5Lwrite_fraction_external(fpath->Representation_hid, fieldname,
 
                                              target_file_name,
                                              target_obj_name,
                                              prefix,
 
                                     rank, Dims ? full_dims : NULL, ldims,
                                     F5file_type(fpath, fieldtype), memtype, dataPtr,
                                     start_dims,
                                     start_border?sborder:NULL, end_border?eborder:NULL,
                                     fraction_name, F5LTmake_enum_type(fpath), property_id);
 
        fpath->Field_hid = field_id;
 
/*      F5printf(10,"~F5Fwrite_fraction(%s) temporarily set type attribute...", fieldname);
        F5Dset_type_attribute(fpath->Field_hid, F5file_type(fpath, fieldtype) );
*/
#if     0
/*
  As with HDF5 1.8.14 - 1.8.17, 1.10.0 , saving attributes with a named type that
  has been committed to another file than the external file does not work.
 */
        F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), FragmentedContiguous);
#else
        F5Tset_field_enum(fpath->Field_hid, F5Ttransient_F5field_Array_enum(), FragmentedContiguous);
#endif
 
        F5I_add_field(fpath, fieldname);
 
        F5printf(30, "~F5Fwrite_fraction(%s) wrote fragmented contigous field", fieldname);
        return  F5_SUCCESS;
}

References F5_SUCCESS, F5ERROR_INVALID_FPATH, F5ERROR_INVALID_FRAGMENT_END, F5ERROR_INVALID_FRAGMENT_START, F5Fclose(), F5file_type(), F5I_add_field(), F5LTmake_enum_type(), F5LTset_dataspace(), F5Lwrite_fraction_external(), F5printf, F5printf_indent, F5Tpermute_dimensions(), F5Tset_field_enum(), F5Ttransient_F5field_Array_enum(), FIBER_MAX_RANK, F5Path::Field_hid, FragmentedContiguous, and F5Path::Representation_hid.

F5Fwrite_linear_fraction_overlap()

F5_API int F5Fwrite_linear_fraction_overlap	(	F5Path *	myPath,
		int	rank,
		const hsize_t *	start_border,
		const hsize_t *	end_border,
		const char *	fraction_name )

Write overlap attributes associated with linear fractions.

Definition at line 1383 of file F5F.c.

{
        if (!myPath           ) return 0;
        if (!myPath->Field_hid) return 0;
        if (!fraction_name)     return 0;
 
hid_t   B_id = H5Gopen2( myPath->Field_hid,  fraction_name, H5P_DEFAULT);
        if (start_border)
        {
        hsize_t sborder[FIBER_MAX_RANK];
                if (!is_all_zero(rank, start_border))
                {
                        F5Tpermute_dimensions(myPath, rank, sborder   , start_border );
                        F5LAsave_dimensions(B_id, FIBER_FRAGMENT_NOOVERLAP_START_ATTRIBUTE, rank, sborder);
                }
        }
        if (end_border)
        {
        hsize_t eborder[FIBER_MAX_RANK];
                if (!is_all_zero(rank, end_border))
                {
                        F5Tpermute_dimensions(myPath, rank, eborder   , end_border   );
                        F5LAsave_dimensions(B_id, FIBER_FRAGMENT_NOOVERLAP_END_ATTRIBUTE, rank, eborder);
                }
        }
        F5Xclose(B_id);
        return 1;
}

References F5LAsave_dimensions(), F5Tpermute_dimensions(), F5Xclose(), FIBER_FRAGMENT_NOOVERLAP_END_ATTRIBUTE, FIBER_FRAGMENT_NOOVERLAP_START_ATTRIBUTE, FIBER_MAX_RANK, and F5Path::Field_hid.

F5Fwrites()

F5_API int F5Fwrites	(	F5Path *	fpath,
		const char *	fieldname,
		int	dimension,
		hsize_t *	dims,
		hid_t	fieldtype,
		hid_t	memtype,
		const void **	dataPtr,
		hid_t	property_id )

Write an array of compound data type as separated components.

Parameters

dataPtr	An array of pointers to the respective arrays for each component
memtype	An HDF5 compound data type that specifies how the data reside in memory.

Returns

0 if the entry could not be opened, non-zero otherwise.

Definition at line 690 of file F5F.c.

{
hsize_t save_dims[FIBER_MAX_RANK];
hid_t   file_type;
 
        F5printf(40,"F5Fwrites()");
        if (!fpath) return 0;
 
        F5Fclose(fpath);
 
        F5printf_indent++;
        F5Tpermute_dimensions(fpath, rank, save_dims, dims);
        F5printf_indent--;
 
        if (!F5LTset_dataspace(fpath, rank, save_dims))
        {
                F5printf(-1, "F5Fwrites(%s): cannot create, inconsistent dataspace!", fieldname);
                return F5ERROR_INCONSISTENT_DATASPACE;
        }
 
        file_type = F5file_type(fpath, fieldtype);
 
        fpath->Field_hid = F5Lwrites(fpath->Representation_hid, fieldname,
                                     rank, save_dims,
                                     file_type, memtype, dataPtr,
                                     F5LTmake_enum_type(fpath),
                                     property_id);
 
        if (fpath->Field_hid <0)
                F5printf(1, "**F5Fwrites(%s) could not write separated compound type!", fieldname);
 
        switch( H5Tget_class(file_type  ) )
        {
        case H5T_COMPOUND:
                F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), SeparatedCompound);
                break;
 
        case H5T_INTEGER:
        case H5T_FLOAT:
                F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), Contiguous );
                break;
 
        default:
                F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), SeparatedCompound);
                break;
        }
 
        F5I_add_field(fpath, fieldname);
 
        F5printf(40,"F5Fwrites() ok");
        return F5_SUCCESS;
}

References Contiguous, F5_API, F5_SUCCESS, F5ERROR_INCONSISTENT_DATASPACE, F5Fclose(), F5file_type(), F5I_add_field(), F5LTmake_enum_type(), F5LTset_dataspace(), F5Lwrites(), F5printf, F5printf_indent, F5Tpermute_dimensions(), F5Tset_field_enum(), FIBER_MAX_RANK, F5Path::Field_hid, F5Path::Representation_hid, and SeparatedCompound.

Referenced by F5Fwrite_uniform_cartesian3Ds(), and F5write_uniform_cartesian3Dvs().

F5LTexpand_dataspace()

F5_API int F5LTexpand_dataspace	(	F5Path *	f,
		int	rank,
		hsize_t *	dims )

Definition at line 120 of file F5LT.c.

{
hsize_t current_dims[FIBER_MAX_RANK];
int     current_rank, Mrank;
int     i;
 
        F5printf(30, "F5LTexpand_dataspace(,%d,)", rank);
        if (!f)
                return 1;
 
        F5Aget_ints( f->Topology_hid, FIBER_HDF5_RANK_ATTRIBUTE, &Mrank, 1);
        if (Mrank<0)
        {
                F5printf(30, "F5LTexpand_dataspace(,%d,): INVALID FILE: RANK attribute is not integer - cannot set dataspace!", rank);
                return 0;
        }
        if (Mrank>=0)
        {
                if (Mrank != rank)
                {
                        F5printf(30, "F5LTexpand_dataspace(,%d,): Dimensions incompatible with RANK attribute %d - inconsistent dataspace!", rank, Mrank);
                        puts("Set DATAPACE: Inconsistent rank!");
                        return 0;
                }
        }
 
        current_rank = F5LAget_dimensions(f->Topology_hid,
                                          FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE,
                                          current_dims);
 
        if (current_rank>0)
        {
                if (rank != current_rank)
                {
                        puts("Set DATAPACE: Inconsistent rank!");
                        return 0;
                }
 
                for(i=0; i<rank; i++)
                {
                        if (current_dims[i] < dims[i])
                                current_dims[i] = dims[i];
                }
        }
        else
                for(i=0; i<rank; i++)
                        current_dims[i] = dims[i];
 
        F5LAsave_dimensions(f->Topology_hid, FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE, rank, current_dims);
        F5printf(30, "F5LTexpand_dataspace(,rank=%d,): expand dimensions of topology.", rank);
 
        for(i=0; i<rank; i++)
                dims[i] = current_dims[i];
 
        return 1;
}

References F5Aget_ints(), F5LAget_dimensions(), F5LAsave_dimensions(), F5printf, FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE, FIBER_HDF5_RANK_ATTRIBUTE, FIBER_MAX_RANK, and F5Path::Topology_hid.

Referenced by F5Fexpand_dataspace().

F5LTget_skeleton_dimensionality()

F5_API int F5LTget_skeleton_dimensionality

(

hid_t

Top_hid

)

Definition at line 34 of file F5LT.c.

{
int     result = FIBER_HDF5_INVALID_SKELETON_DIMENSIONALITY;
        if (F5Aget_ints(Top_hid, FIBER_HDF5_SKELETON_DIMENSIONALITY_ATTRIB, &result, 1) <= 0)
                F5printf(5," *Warning* F5LTget_F5LTget_skeleton_dimensionality() could not find skeleton dimensionality,setting unknown -1");
 
        return result;
}

References F5Aget_ints(), F5printf, FIBER_HDF5_INVALID_SKELETON_DIMENSIONALITY, and FIBER_HDF5_SKELETON_DIMENSIONALITY_ATTRIB.

Referenced by F5iterate_topologies().

F5LTset_dataspace()

F5_API int F5LTset_dataspace	(	F5Path *	f,
		int	rank,
		hsize_t *	dims )

Definition at line 43 of file F5LT.c.

{
hsize_t current_dims[FIBER_MAX_RANK];
int     current_rank, Mrank = -1;
 
        if (!f)
        {
                return 0;
        }
 
        F5printf(30, "F5LTset_dataspace(,rank=%d,)", rank);
 
        F5Aget_ints( f->Topology_hid, FIBER_HDF5_RANK_ATTRIBUTE, &Mrank, 1);
        if (Mrank<0)
        {
                F5printf(30, "F5LTset_dataspace(,%d,): INVALID FILE: RANK attribute is not integer - cannot set dataspace!", rank);
                return 0;
        }
 
        if (Mrank>=1)
        {
                if (Mrank != rank)
                {
                        if (rank==4)
                                F5printf(0, "F5LTset_dataspace(,%d,): Dimensions %dx%dx%dx%d incompatible with RANK attribute %d - inconsistent dataspace!",
                                         rank, (int)dims[0],(int)dims[1],(int)dims[2],(int)dims[3],
                                         Mrank);
                        else
                                F5printf(0, "F5LTset_dataspace(,%d,): Dimensions incompatible with RANK attribute %d - inconsistent dataspace!", rank, Mrank);
 
                        return 0;
                }
        }
 
        current_rank = F5LAget_dimensions(f->Topology_hid,
                                          FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE,
                                          current_dims);
 
        if (current_rank>0)
        {
        int     i;
                if (rank != current_rank)
                {
                        puts("F5LTset_dataspace(): Set DATAPACE: Inconsistent rank with DATASPACE_DIMENSIONS!");
                        return 0;
                }
 
                for(i=0; i<rank; i++)
                {
                        if (current_dims[i] != dims[i])
                        {
                                F5printf(5, "F5LTset_dataspace(,rank=%d,): new dimensions[%d] is %d, but already set to %d in the file as  %dx%dx%dx%d - aborting.",
                                         rank,              i, (int)(current_dims[i]), (int)(dims[i]),
                                         rank>0?(int)dims[0]:1, rank>1?(int)dims[1]:1, rank>2?(int)dims[2]:1, rank>3?(int)dims[3]:1);
                                return 0;
                        }
                }
                F5printf(5, "F5LTset_dataspace(,rank=%d,): dimensions are ok.", rank);
                return 1;
        }
        {int i;
        for(i=0; i<rank; i++)
        {
                if (dims[i] < 1)
                {
                        F5printf(10, "F5LTset_dataspace(,rank=%d,): do NOT set new topology dimensions, because dims[%d]=%d\n", rank, i, (int)dims[i] );
                        return 0;
                }
        }
        }
 
        F5LAsave_dimensions(f->Topology_hid, FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE, rank, dims);
        F5printf(30, "F5LTset_dataspace(,rank=%d,): set new dimensions to skeleton as %dx%dx%dx%d.", rank,
                 rank>0?(int)dims[0]:1, rank>1?(int)dims[1]:1, rank>2?(int)dims[2]:1, rank>3?(int)dims[3]:1);
        return 1;
}

References F5Aget_ints(), F5LAget_dimensions(), F5LAsave_dimensions(), F5printf, FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE, FIBER_HDF5_RANK_ATTRIBUTE, FIBER_MAX_RANK, and F5Path::Topology_hid.

Referenced by F5Fcreate(), F5FSwrite_fraction(), F5Fwrite_flexible(), F5Fwrite_fraction(), F5Fwrite_fraction_external(), F5Fwrite_fractionS(), F5Fwrite_linear(), F5FwriteIMAGE(), F5Fwrites(), and F5FwriteX().

F5Tget_extent()

F5_API int F5Tget_extent	(	F5Path *	f,
		hsize_t *	dims,
		int	maxDims )

Get the extent (number of elements in each dimension) for a given F5 field. This function is like getting the data space via F5Tget_space() and then performing a F5Tpermute_dimensions() on the result.

Parameters

dims	Storage place for the extension in each dimension.
maxDims	The maximal number of storage available for the dims array

Returns

The dimension of the current topology.

It is recommended to allocate the storage as

hsize_t dims[FIBER_MAX_RANK];

where FIBER_MAX_RANK is a predefined integer constant from the F5 library which corresponds to the respective HDF5 value.

Todo

Add weblink here to HDF5 docu.

Definition at line 226 of file F5F.c.

{
hsize_t mdims[FIBER_MAX_RANK], Dims[FIBER_MAX_RANK];
int     mrank;
hid_t   space_id = F5Tget_space(f);
 
 
        if (space_id<0)
                return 0;
 
        mrank = H5Sget_simple_extent_dims(space_id, mdims, NULL);
 
        H5Sclose(space_id);
 
        F5Tpermute_dimensions(f, mrank, Dims, mdims);
 
        if (mrank>maxDims)
                mrank = maxDims;
 
 
        {int    i;
                for(i=0; i<mrank; i++)
                        dims[i] = Dims[i];
        }
 
        return mrank;
}

References F5Tget_space(), F5Tpermute_dimensions(), and FIBER_MAX_RANK.

F5Tget_index_depth()

F5_API int F5Tget_index_depth	(	F5Path *	f,
		int *	result )

Parameters

result

pointer to integer which will contain the result value on return.

Returns

non-zero when attribute cold be read, zero if not.

Definition at line 255 of file F5F.c.

{
        F5printf(40, "F5Fget_index_depth()");
 
        if (!f)
                return 0;
 
        if (f->Topology_hid<0)
                return 0;
 
        if (F5Aget_ints(f->Topology_hid,
                        FIBER_HDF5_INDEXDEPTH_ATTRIB,
                        result, 1) != 1)
        {
                F5printf(40, "F5Fget_index_depth(): could not read index depth attribute");
                return 0;
        }
 
        return 1;
}

References F5Aget_ints(), F5printf, FIBER_HDF5_INDEXDEPTH_ATTRIB, and F5Path::Topology_hid.

F5Tget_refinement_level()

F5_API int F5Tget_refinement_level	(	F5Path *	f,
		hsize_t *	dims,
		int	maxDims )

References F5_API.

F5Tpermute_dimensions()

F5_API hsize_t * F5Tpermute_dimensions	(	F5Path *	fpath,
		int	rank,
		hsize_t *	target_dims,
		const hsize_t *	source_dims )

Permute a given dimensions array according to the memory ordering of the current coordinate system.

Parameters

source_dims	The source dimensions.
target_dims	The target dimensions array, may be identical to the source dimensions array.

Returns

A pointer to the target dimensions array, if successfull, otherwise NULL.

Parameters

fpath

An F5Path object that must contain a valid coordinate system description, e.g. via some F5Rcreate() operation.

Definition at line 277 of file F5F.c.

{
int     ChartDims;
        F5printf(50, "F5Tpermute_dimensions()");
 
        /* added by mr, not sure if this is good */
        if( !target_dims || !source_dims)
        {
                F5printf(40, "F5Tpermute_dimensions() Invalid target or source");
                return NULL;
        }
 
        {
        int     i = 0;
                for(i=0; i<rank; i++)
                        if (source_dims[i]) break;
 
                if (i==rank)
                {
                        for(i=0; i<rank; i++)
                                target_dims[i] = source_dims[i];
 
                        F5printf(40, "F5Tpermute_dimensions() All source data are zero, skipping permutation...");
                        return target_dims;
                }
        }
 
        if (!fpath || !fpath->myChart)
        {
                F5printf(50, "F5Tpermute_dimensions() No Chart given, assuming default (FORTRAN) index permutation!");
                return F5B_permute_dimensions(target_dims, rank, source_dims, NULL,  0);
        }
        F5printf(50, "F5Tpermute_dimensions() params ok, rank=%d.", rank);
        for(int i=0; i<rank; i++)
                F5printf(50, "F5Tpermute_dimensions() source[%d]=%d.", i, source_dims[i] );
 
/* cannot occur because perm_vector is static member
        if (!fpath->myChart->perm_vector )
        {
                F5printf(10, "F5Tpermute_dimensions() has no permutation vector!");
                return NULL;
                }
*/
        ChartDims = F5Bget_chart_dims(fpath->myChart);
 
        return F5B_permute_dimensions(target_dims, rank, source_dims, fpath->myChart->perm_vector,  ChartDims );
}

References F5_API, F5B_permute_dimensions(), F5Bget_chart_dims(), F5printf, F5Path::myChart, and ChartDomain_IDs::perm_vector.

Referenced by F5Fexpand_dataspace(), F5Fread_linear(), F5Fread_linear_fragment(), F5FSwrite_fraction(), F5Fwrite_flexible(), F5Fwrite_fraction(), F5Fwrite_fraction_external(), F5Fwrite_fractionS(), F5Fwrite_linear(), F5Fwrite_linear_fraction(), F5Fwrite_linear_fraction_overlap(), F5FwriteIMAGE(), F5Fwrites(), F5FwriteX(), and F5Tget_extent().