F5F.c File Reference

#include "F5F.h"
#include "F5X.h"
#include "F5A.h"
#include "F5private.h"
#include "F5Bchart.h"
#include "F5L.h"
#include <stdlib.h>
#include <string.h>
#include <assert.h>

Go to the source code of this file.

Macros
#define	DO_DATASPACE_CONSISTENCY_CHECK

Functions
ArrayType	F5Fget_field_enum (const F5Path *fpath, const char *fieldname, int *major_version, int *minor_version, int *release_version)
int	F5Fopen (F5Path *f, const char *fieldname)
void	F5Fclose (F5Path *f)
hid_t	F5Fgrab (F5Path *f)
int	F5Fis_group (const F5Path *fpath)
int	F5Ffragment_is_group (const F5Path *fpath, const char *fragment_name)
hid_t	F5Fget_type (F5Path *f)
hid_t	F5Fget_type2 (F5Path *f, hid_t elink_fapl_id)
hid_t	F5Tget_space (F5Path *f)
int	F5Tget_extent (F5Path *f, hsize_t *dims, int maxDims)
int	F5Tget_index_depth (F5Path *f, int *result)
F5_API hsize_t *	F5Tpermute_dimensions (F5Path *fpath, int rank, hsize_t *target_dims, const hsize_t *source_dims)
int	F5Fcreate (F5Path *fpath, const char *fieldname, int rank, hsize_t *dims, hid_t fieldtype, hid_t property_id)
const char *	F5Fwhatsup (F5ErrorCode EC)
F5ErrorCode	F5Fwrite_flexible (F5Path *fpath, const char *fieldname, int rank, hsize_t *dims, hid_t fieldtype, hid_t memtype, const void *dataPtr, hid_t property_id, int do_check)
F5ErrorCode	F5Fwrite (F5Path *fpath, const char *fieldname, int rank, hsize_t *dims, hid_t fieldtype, hid_t memtype, const void *dataPtr, hid_t property_id)
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	F5FwriteIMAGE (F5Path *fpath, const char *fieldname, int rank, hsize_t *dims, hid_t fieldtype, hid_t memtype, const void *dataPtr, hid_t dcpl_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 rank, hsize_t *dims, hid_t fieldtype, hid_t memtype, const void **dataPtr, hid_t property_id)
int	F5Fexpand_dataspace (F5Path *fpath, int rank, hsize_t *Dims)
F5ErrorCode	F5Fwrite_fraction (F5Path *fpath, const char *fieldname, int rank, const hsize_t *Dims, const hsize_t *fraction_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)
F5ErrorCode	F5Fwrite_fractionS (F5Path *fpath, const char *fieldname, int rank, const hsize_t *Dims, const hsize_t *fraction_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)
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 *Dims, const hsize_t *fraction_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)
int	F5Fis_fragmented (F5Path *fpath, const char *fieldname)
int	F5Fis_separatedcompound (F5Path *fpath, const char *fieldname)
int	F5B_iszero_dims (int rank, hsize_t *dims)
int	F5FSwrite_fraction (F5Path *fpath, const char *fieldname, int rank, const hsize_t *dims, const hsize_t *frag_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)
void	F5FevalX (double *result, int Mrank, const int index[], int components, const double *const polynomials[], const int polynom_order[], const int component_map[])
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)
int	F5Fwrite_linear_fraction_overlap (F5Path *myPath, int rank, const hsize_t *start_border, const hsize_t *end_border, const char *fraction_name)
int	F5Fwrite_linear_fraction (F5Path *fpath, const char *fieldname, int rank, const hsize_t *full_dims, const hsize_t *local_dims, hid_t fieldtype, const void *base, const void *delta, const hsize_t *datastart, const char *fraction_name)
F5_API int	F5Fwrite_linear (F5Path *fpath, const char *fieldname, int rank, hsize_t *dims, hid_t fieldtype, const void *base, const void *delta)
int	F5Fis_linear (F5Path *fpath, const char *fieldname)
int	F5Fread_linear (F5Path *fpath, hsize_t *dims, hid_t fieldtype, void *base, void *delta)
int	F5Fread_linear_fragment (F5Path *fpath, hid_t fragment_hid, hsize_t *dims, hid_t fieldtype, void *base, void *delta)
int	F5Fget_attribute_byname (F5Path *f, const char *attribute_name, void *data, hsize_t N, hid_t mem_type_id, const char *fragment_name)
int	F5Fget_range (F5Path *f, const char *fragment_name, void *minmax)
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	F5Fset_range (F5Path *f, const char *fragment_name, const void *minmax)

Macro Definition Documentation

DO_DATASPACE_CONSISTENCY_CHECK

#define DO_DATASPACE_CONSISTENCY_CHECK

Definition at line 15 of file F5F.c.

Function Documentation

F5B_iszero_dims()

int F5B_iszero_dims	(	int	rank,
		hsize_t *	dims )

Definition at line 1148 of file F5F.c.

{
int     i;
        for(i=0; i<rank; i++)
                if (dims[i]>0) return 0;
 
        return 1;
}

Referenced by F5FSwrite_fraction().

F5FevalX()

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

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

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

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

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

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

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().

F5Fis_fragmented()

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

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

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

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.

F5Fset_attribute_byname()

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.

Examples

FragmentedField.c.

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 )

Examples

ADCIRCtoF5.cpp, and ObjtoF5.c.

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_flexible()

F5ErrorCode F5Fwrite_flexible	(	F5Path *	fpath,
		const char *	fieldname,
		int	rank,
		hsize_t *	dims,
		hid_t	fieldtype,
		hid_t	memtype,
		const void *	dataPtr,
		hid_t	property_id,
		int	do_check )

Definition at line 389 of file F5F.c.

{
hsize_t save_dims[FIBER_MAX_RANK];
 
        F5printf(40,"F5Fwrite(%s, rank=%d, dims=%dx%dx%dx%d)", fieldname, 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
                 );
 
        if (!fpath)
                return F5ERROR_INVALID_FPATH;
 
        F5Fclose(fpath);
 
        /*
          Detect the special case of 2D RGB data, in which case we try to
          write the data compatible to the official HDF5 specification for
          images.
         */
        if ( (H5Tequal(fieldtype, F5T_RGB_REAL)>0 || H5Tequal(fieldtype, F5T_RGB)>0) && rank == 2)
        {
                return F5FwriteIMAGE(fpath, fieldname,
                                     rank, dims,
                                     fieldtype, memtype, dataPtr,
                                     property_id);
        }
 
        F5printf_indent++;
        F5Tpermute_dimensions(fpath, rank, save_dims, dims );
        F5printf_indent--;
 
        F5printf(41,"F5Fwrite(%s): permuted dims: rank=%d, dims=%dx%dx%dx%d)", fieldname, rank,
                 rank>0?(int)save_dims[0]:1, rank>1?(int)save_dims[1]:1, rank>2?(int)save_dims[2]:1, rank>3?(int)save_dims[3]:1 );
 
        if (!F5LTset_dataspace(fpath, rank, save_dims))
        {
                if( do_check )
                {
                        if (rank==3)
                                F5printf(-1, "F5Fwrite(%s): cannot write 3D field, inconsistent 3D dataspace, trying to write %dx%dx%d as HDF5 dataspace %dx%dx%d  (run again with F5_VERBOSITY=30 to see more details)!",
                                         fieldname, (int)dims[0], (int)dims[1], (int)dims[2],
                                         (int)save_dims[0], (int)save_dims[1], (int)save_dims[2]
                                        );
                        else
                                F5printf(-1, "F5Fwrite(%s): cannot write field, inconsistent dataspace (run again with F5_VERBOSITY=30 to see more details)!", fieldname);
 
                        return F5ERROR_INCONSISTENT_DATASPACE;
                }
                else
                        F5printf(-1, "F5Fwrite(%s): warning during field write, inconsistent dataspace!", fieldname);
        }
 
        fpath->Field_hid = 0;
 
        fpath->Field_hid = F5Lwrite(fpath->Representation_hid, fieldname,
                                    rank, save_dims,
                                    F5file_type(fpath, fieldtype), memtype, dataPtr,
                                    F5LTmake_enum_type(fpath),
                                    property_id);
 
        if (fpath->Field_hid<=0)
        {
                F5printf(3,"F5Fwrite(): F5Lwrite() FAILED!");
                fpath->Field_hid = 0;
        }
        else
        {
                F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), Contiguous);
                F5I_add_field(fpath, fieldname);
        }
 
        F5printf(40,"F5Fwrite() ok");
        return  F5_SUCCESS;
}

References Contiguous, F5_SUCCESS, F5ERROR_INCONSISTENT_DATASPACE, F5ERROR_INVALID_FPATH, F5Fclose(), F5file_type(), F5FwriteIMAGE(), F5I_add_field(), F5LTmake_enum_type(), F5LTset_dataspace(), F5Lwrite(), F5printf, F5printf_indent, F5T_RGB, F5T_RGB_REAL, F5Tpermute_dimensions(), F5Tset_field_enum(), FIBER_MAX_RANK, F5Path::Field_hid, and F5Path::Representation_hid.

Referenced by F5Fwrite(), and F5FwriteHyperDimensional().

F5Fwrite_fraction_external()

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 *	Dims,
		const hsize_t *	fraction_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()

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().

F5Tget_extent()

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

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.

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().