Low-Level Field Operations

Functions
F5_API void	F5close (F5Path *f)
F5_API int	F5Fread_linear (F5Path *fpath, hsize_t *dims, hid_t fieldtype, void *base, void *delta)
F5_API hid_t	F5Lcreate (hid_t R_id, const char *fieldname, int dimension, const hsize_t *dims, hid_t fieldtype, hid_t property_id)
F5_API hid_t	F5LTcreate_topology (hid_t Grid_hid, const char *TopologyName, int IndexDepth, int SkeletonDimensionality, int DataspaceDimensionality, const hsize_t *refinement)
F5_API int	F5LTset_maximal_grid_refinement (hid_t ContentsGroup_id, const char *gridname, int IndexDepth, int Dimensionality, const hsize_t *refinement)
F5_API int	F5LTget_maximal_grid_refinement (hid_t ContentsGroup_id, const char *gridname, hsize_t *refinement)
F5_API int	F5LTget_maximal_skeleton_refinement (hid_t ContentsGroup_id, const char *gridname, hsize_t *refinement, int IndexDepth, int Dimensionality)
F5_API int	F5LTget_index_depth (hid_t Top_hid)
F5_API hid_t	F5Lwrite (hid_t R_id, const char *fieldname, int dimension, const hsize_t *dims, hid_t fieldtype, hid_t memtype, const void *dataPtr, hid_t enum_type, hid_t property_id)
F5_API hid_t	F5LwriteS (hid_t Container_id, const char *name, int dimension, const hsize_t *dims, hid_t fieldtype, hid_t memtype, const void *dataPtr, hid_t enum_type, hid_t dcpl_id)
F5_API int	F5LreadS (hid_t Container_id, hid_t memtype, void *dataPtr, hid_t ElementLoadID)
F5_API hid_t	F5Lwrite_fraction (hid_t R_id, const char *fieldname, int dimension, const hsize_t *full_dims, const hsize_t *datasize, 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 enum_type, hid_t property_id)
F5_API hid_t	F5LSwrite_fraction (hid_t R_id, const char *fieldname, int dimension, const hsize_t *full_dims, const hsize_t *datasize, 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 enum_type, hid_t property_id)
F5_API hid_t	F5Lwrite1D (hid_t R_id, const char *fieldname, hsize_t nElements, hid_t fieldtype, hid_t memtype, const void *dataPtr, hid_t enum_type, hid_t property_id)
F5_API hid_t	F5Lwrite_linear (hid_t R_id, const char *fieldname, int dimension, const hsize_t *dataspace_dims, hid_t fieldtype, const void *base, const void *delta)
F5_API hid_t	F5Lread_linear (hid_t F_id, hsize_t *dims, hid_t fieldtype, void *base, void *delta)
F5_API hid_t	F5Lwrite_entity (hid_t R_id, const char *fieldname, hid_t fieldtype, const void *value)
F5_API hid_t	F5Lwrites (hid_t F_id, const char *fieldname, int dimension, const hsize_t *dims, hid_t fieldtype, hid_t memtype, const void *const *dataPtr, hid_t enum_type, hid_t property_id)
F5_API hid_t	F5Lget_type (hid_t Field_hid, int FieldIDisGroup, hid_t elink_fapl_id)
F5_API int	F5Lget_field_dimension_and_type (hid_t Representation_hid, const char *fieldname, hsize_t dims[FIBER_MAX_RANK], hid_t *type_id)
F5_API int	F5LAsave_dimensions (hid_t Field_id, const char *aname, int rank, const hsize_t *dims)
F5_API int	F5LAget_dimensions (hid_t Field_id, const char *aname, hsize_t dims[FIBER_MAX_RANK])
F5_API int	F5Lset_space (hid_t Field_id, int rank, const hsize_t *dims)
F5_API int	F5Lget_compound_extent_dims (hid_t CompoundGroupID, hsize_t *dims)
F5_API hid_t	F5Lget_compound_space (hid_t CompoundGroupID)
F5Path *	F5LTcreateV (hid_t File_id, const double *time, const char *gridname, ChartDomain_IDs *ChartDomain, ChartDomain_IDs *coord_creator(void *udata), void *udata, const char *coordinate_system, const char *TopologyName, int IndexDepth, int SkeletonDimensionality, int Dimensionality, const hsize_t *refinement)
F5Path *	F5LTcreate (hid_t File_id, const double *time, const char *gridname, ChartDomain_IDs *ChartDomain, ChartDomain_IDs *coord_creator(), const char *coordinate_system, const char *TopologyName, int IndexDepth, int SkeletonDimensionality, int Dimensionality, const hsize_t *refinement)
F5_API F5Path *	F5LTcreate (hid_t File_id, const double *time, const char *gridname, ChartDomain_IDs *ChartDomain, new_global_chart_f coord_creator, const char *coordinate_system, const char *TopologyName, int IndexDepth, int SkeletonDimensionality, int DataspaceDimensionality, const hsize_t *refinement)

Detailed Description

Todo

Separate these functions into F5-Dataset functions, with prefix F5D, of the form:

1. Functions taking contigous compounds (data given as void*), zero components not supported:
   • F5Dcreate()
   • F5Dwrite()
   • F5Dsave() (convenience function: create + write with same field type, no I/O type conversion)
   • F5Dis()
   • F5Dopen()
   • F5Dread()
   • F5Dload() (convenience function: open + read)
2. Functions taking separated compounds (data given as void**), missing components supported:
   • F5DS...() (6 functions)
3. Special datasets:
   • F5D*_fraction()
   • F5D*_linear()
   • F5D*_entity()
4. Utility functions:
   • F5Dget_type()
   • F5Dget_space()
5. Low-level functions:
   • F5Dset_type_attribute()

Function Documentation

F5close()

F5_API void F5close

(

F5Path *

f

)

Remove a F5Path object.

Definition at line 186 of file F5B.c.

{
        if (!f) return;
 
        F5B_delete_global_chart(f->myChart);
        F5B_delete_global_chart(f->FileIDs);
        if (f->field_enum_type_hid>0)   H5Tclose(f->field_enum_type_hid);
        F5printf(100, "F5close(): Closing representation... %d", f->Representation_hid );
        if (f->Representation_hid)      H5Gclose(f->Representation_hid);
        F5printf(100, "F5close(): Closing global chart...");
        if (f->GlobalChart_hid)         H5Gclose(f->GlobalChart_hid);
        F5printf(100, "F5close(): Closing chart group...");
        if (f->Charts_hid)              H5Gclose(f->Charts_hid);
        F5printf(100, "F5close(): Closing chart...");
        if (f->Chart_hid)               H5Gclose(f->Chart_hid);
        if (f->Topology_hid)            H5Gclose(f->Topology_hid);
        F5printf(100, "F5close(): Closing grid...");
        if (f->Grid_hid)                H5Gclose(f->Grid_hid);
        F5printf(100, "F5close(): Closing slice...");
        if (f->Slice_hid)               H5Gclose(f->Slice_hid);
        F5printf(100, "F5close(): Closing ContentsGroup...");
        if (f->ContentsGroup_hid>0)     H5Gclose(f->ContentsGroup_hid);
 
        if (f->Field_hid>0)
        {
                F5printf(40, "F5close(): field is %s.", F5Fis_group(f)?"a group":"a dataset");
 
                if (F5Fis_group(f) )
                        H5Gclose( f->Field_hid );
                else
                        H5Dclose( f->Field_hid );
        }
 
        deleteF5Path(f);
}

References F5Path::Chart_hid, F5Path::Charts_hid, F5Path::ContentsGroup_hid, deleteF5Path(), F5B_delete_global_chart(), F5Fis_group(), F5printf, F5Path::field_enum_type_hid, F5Path::Field_hid, F5Path::FileIDs, F5Path::GlobalChart_hid, F5Path::Grid_hid, H5Gclose, H5Tclose(), F5Path::myChart, F5Path::Representation_hid, F5Path::Slice_hid, and F5Path::Topology_hid.

Referenced by F5closep(), F5Cwrite_regular_surface(), F5Fwrite_uniform_cartesian3D(), F5Fwrite_uniform_cartesian3Ds(), F5iterate_timeslices(), F5Rcreate_rectilinear(), F5write_particle_cartesian3Dv(), F5write_particle_cartesian3DvU(), F5write_particle_double_cartesian3Dv(), F5write_particle_positions(), F5write_uniform_cartesian3Dv(), F5write_uniform_cartesian3Dvs(), and saveF5image().

F5Fread_linear()

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

Try to read a field which is a linear mapping of a base (origin) and delta value. The fpath object gets the the field identifier set to the opened field (which is available to retrieve additional user-defined attributes and such).

@params dims The dimensions of integer coordinates.

Returns

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

Definition at line 1517 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(fpath->Field_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(), FIBER_MAX_RANK, and F5Path::Field_hid.

F5LAget_dimensions()

F5_API int F5LAget_dimensions	(	hid_t	Field_id,
		const char *	aname,
		hsize_t	dims[FIBER_MAX_RANK] )

Read an n-dimensional attribute.

Parameters

dims	The n values, maximally FIBER_MAX_RANK

Returns

The actual rank.

Definition at line 233 of file F5A.c.

{
 hid_t  attr_id;
/*int     rank = -1, i, UADims[FIBER_MAX_RANK]; */
 
        F5printf(50, "-- F5LAget_dimensions(,aname=%s,)", aname);
 
        H5E_BEGIN_TRY
        attr_id  = F5Aopen_name(Field_id, aname);
        H5E_END_TRY
 
        if (attr_id>0)
        {
        hid_t   space_id = H5Aget_space(attr_id);
        int     rank     = H5Sget_simple_extent_npoints(space_id);
                assert (space_id > 0);
 
                F_H5Aread(attr_id, H5T_NATIVE_HSIZE, dims, aname );
                H5Aclose(attr_id);
                H5Sclose(space_id);
/*
                //for(i=0; i<rank; i++)
                //      dims[i] = UADims[i];
*/
                return rank;
        }
        return -1;
}

References F5Aopen_name(), F5printf, F_H5Aread(), and FIBER_MAX_RANK.

Referenced by F5Lget_dimensions(), F5LTexpand_dataspace(), F5LTget_maximal_grid_refinement(), F5LTget_maximal_skeleton_refinement(), F5LTset_dataspace(), F5LTset_maximal_grid_refinement(), and F5Tget_space().

F5LAsave_dimensions()

F5_API int F5LAsave_dimensions	(	hid_t	Field_id,
		const char *	aname,
		int	rank,
		const hsize_t *	dims )

Save dimensional information to a certain location.

Returns

1 if successfull, 0 if some problem occurred during writing.

Definition at line 192 of file F5A.c.

{
int     UADims[FIBER_MAX_RANK];
int     i;
hsize_t Sdims = rank;
hid_t   space_hid = H5Screate_simple(1, &Sdims, &Sdims);
hid_t   attr_hid;
 
        F5printf(50, "-- F5LAsave_dimensions(,aname=%s, rank=%d,)", aname, rank);
 
 
        H5E_BEGIN_TRY
        attr_hid  = H5Acreate2(Field_id, aname, H5T_NATIVE_INT, space_hid, H5P_DEFAULT, H5P_DEFAULT);
        H5E_END_TRY
 
        if (attr_hid<0)
        {
                H5E_BEGIN_TRY
                attr_hid  = H5Aopen_name(Field_id, aname);
                H5E_END_TRY
        }
        if (attr_hid<0)
                return 0;
 
        for(i=0; i<rank; i++)
                 UADims[i] = dims[i];
 
        if (H5Awrite(attr_hid, H5T_NATIVE_INT, UADims )<0)
        {
                fprintf(stderr, "F5LAsave_dimensions: CANNOT WRITE %s attribute\n", aname);
 
                H5Aclose(attr_hid);
                H5Sclose(space_hid);
                return 0;
        }
 
        H5Aclose(attr_hid);
        H5Sclose(space_hid);
        return 1;
}

References F5printf, and FIBER_MAX_RANK.

Referenced by F5Fwrite_linear(), F5Fwrite_linear_fraction(), F5Fwrite_linear_fraction_overlap(), F5Lset_space(), F5LSwrite_fraction(), F5LTcreate_topology(), F5LTexpand_dataspace(), F5LTset_dataspace(), F5LTset_maximal_grid_refinement(), F5Lwrite_fraction(), F5Lwrite_fraction_external(), and F5Lwrite_fractionS().

F5Lcreate()

F5_API hid_t F5Lcreate	(	hid_t	R_id,
		const char *	fieldname,
		int	dimension,
		const hsize_t *	dims,
		hid_t	fieldtype,
		hid_t	property_id )

 Create an HDF5 dataset for further treatment with raw HDF5 functions, e.g.
 to write an hyperslab instead of the full dataset at once.

Returns

A HDF5 dataset ID. The caller must issue H5Dclose() on the returned identifier.

Parameters

property_id	An HDF5 dataset property ID. If it is negative, then a default property will be created locally via H5Pcreate(H5P_DATASET_CREATE) .
dataspace_id	Pointer to an HDF5 identifier, that will be used to store a shared dataspace. It may be NULL, in which case a local dataspace is created. Until shared dataspaces are implemented in HDF5, this will make no difference in the actual HDF5 file.
R_id	The group ID where the field shall be inserted, preferably a representation group ID that has been created by an F5create_representation() call.
fieldname	The name of the field. It may be chosen arbitrarily, but must not contain slashes "/". It is furthermore recommended to avoid special characters - even if they work - and to keep the name short and concise).
dimension	The dimensionality of the data set.
dims	The extension of the data set.
fieldtype	An HDF5 type identifier.

Definition at line 60 of file F5L.c.

{
hid_t   ds_id, creator_id, id;
 
        if (fieldtype<0)
        {
                F5printf(30, "F5Lcreate(%s): INVALID field type %d!?", fieldname, (int)fieldtype);
                return -1;
        }
 
        ds_id = H5Screate_simple(dimension, dims, NULL);  /* F5Lcreate()  */
        if (ds_id<0)
        {
                F5printf(30, "F5Lcreate(): cannot create dataset!?");
                return -1;
        }
 
/*      H5Sselect_order (dataspace_id, perm_vector); */
 
        creator_id = dataset_creation_property_id<0 ? H5Pcreate(H5P_DATASET_CREATE) : dataset_creation_property_id;
        id = F5Dcreate(R_id, fieldname, fieldtype, ds_id, creator_id);
        if (id<0)
        {
                F5printf(30, "F5Lcreate(): F5Dappend(loc=%d,%s,dims=%d,,type=%d...) FAILED!\n",
                        (int)R_id, fieldname, dimension, (int)fieldtype );
        }
        else
        {
                F5printf(40, "F5Lcreate(): F5Dappend(%d,%s,...) DONE!\n", (int)R_id, fieldname);
        }
 
        /*H5Dwrite(id, fieldtype, H5S_ALL, H5S_ALL, H5P_DEFAULT, dataPtr); */
 
        H5Sclose(ds_id);
 
        /*
          Review this "auto-closing" feature of property lists,this is unlikely to be good. WB SEP 2016
         */
        if (dataset_creation_property_id<0)
                H5Pclose(creator_id);
 
        return id;
}

References F5Dcreate(), and F5printf.

Referenced by F5Fcreate(), and F5Lwrite().

F5Lget_compound_extent_dims()

F5_API int F5Lget_compound_extent_dims	(	hid_t	CompoundGroupID,
		hsize_t *	dims )

Get the dataspace extension from a compound group.

Definition at line 302 of file F5L.c.

{
hid_t   type_id = F5Lget_type( CompoundGroupID, 1, 0);
int     nComponents = H5Tget_nmembers( type_id );
int     rank = -1;
int     i;
 
        for(i=0; i<nComponents; i++)
        {
        char * comp_name = H5Tget_member_name( type_id, i );
        hid_t   sep_id = H5Dopen2(CompoundGroupID, comp_name, H5P_DEFAULT);
                H5free_memory( comp_name );
 
        hid_t space_id = H5Dget_space( sep_id );
 
                rank = H5Sget_simple_extent_dims(space_id, dims, NULL);
 
                H5Dclose(sep_id);
                H5Sclose(space_id);
                break;
        }
        H5Tclose( type_id );
        return rank;
}

References F5Lget_type(), and H5Tclose().

F5Lget_compound_space()

F5_API hid_t F5Lget_compound_space

(

hid_t

CompoundGroupID

)

Get the dataspace of a compound group.

Definition at line 327 of file F5L.c.

{
hid_t   type_id = F5Lget_type( CompoundGroupID, 1, 0);
int     nComponents = H5Tget_nmembers( type_id );
hid_t   space_id = -1;
int     i;
        for(i=0; i<nComponents; i++)
        {
        char * comp_name = H5Tget_member_name( type_id, i );
        hid_t   sep_id = H5Dopen2(CompoundGroupID, comp_name, H5P_DEFAULT);
                H5free_memory( comp_name );
 
                space_id = H5Dget_space( sep_id );
 
                H5Dclose(sep_id);
                H5Sclose(space_id);
                break;
        }
        H5Tclose( type_id );
        return space_id;
}

References F5Lget_type(), and H5Tclose().

F5Lget_field_dimension_and_type()

F5_API int F5Lget_field_dimension_and_type	(	hid_t	Representation_hid,
		const char *	fieldname,
		hsize_t	dims[FIBER_MAX_RANK],
		hid_t *	type_id )

Retrieve dimensional and type information for a specific field.

Definition at line 449 of file F5uniform.c.

{
/*
  should use F5LAget_dimensions() here...
 */
 
 hid_t  Field_id, attr_id, space_id;
int     rank = -1, i, UADims[FIBER_MAX_RANK];
 
        H5E_BEGIN_TRY
        Field_id = H5Dopen2(Representation_hid, fieldname, H5P_DEFAULT);
        H5E_END_TRY
 
        if (Field_id>0)
        {
                space_id = H5Dget_space(Field_id);
                rank = H5Sget_simple_extent_dims(space_id, dims, NULL);
                H5Sclose(space_id);
 
                if (type_id)
                        *type_id = F5Lget_type(Field_id, 0, 0);
 
                H5Dclose(Field_id);
        }
        else
        {
                Field_id = H5Gopen2(Representation_hid, fieldname, H5P_DEFAULT);
 
                attr_id  = F5Aopen_name(Field_id, FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE);
                space_id = H5Aget_space(attr_id);
                rank      = H5Sget_simple_extent_npoints(space_id);
 
                H5Aread(attr_id, H5T_NATIVE_INT, UADims );
                H5Aclose(attr_id);
                H5Sclose(space_id);
 
                for(i=0; i<rank; i++)
                        dims[i] = UADims[i];
 
                if (type_id)
                        *type_id = F5Lget_type(Field_id, 1, 0);
 
                H5Gclose(Field_id);
        }
 
        return rank;
}

References F5Aopen_name(), F5Lget_type(), FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE, FIBER_MAX_RANK, and H5Gclose.

F5Lget_type()

F5_API hid_t F5Lget_type	(	hid_t	Field_hid,
		int	FieldIDisGroup,
		hid_t	elink_fapl_id )

Retrieve type information for a specific field.

Definition at line 173 of file F5L.c.

{
        F5printf(40, "F5Lget_type(%lu,%s)", (unsigned long)Field_hid, FieldIDisGroup?"Is group":"Is dataset");
 
        if (Field_hid<1)
        {
                F5printf(40, "F5Lget_type(): no valid Field id specified");
                return -1;
        }
 
        if (FieldIDisGroup)
        {
        hid_t   attr_hid, Type_id = -1;
 
                H5E_BEGIN_TRY
                attr_hid = F5Aopen_name(Field_hid, FIBER_HDF5_TYPEID_ATTRIB);
                H5E_END_TRY
                if (attr_hid>0)
                {
                        Type_id    = H5Aget_type(attr_hid);
                        H5Aclose(attr_hid);
                        F5printf(40, "F5Lget_type(): found `%s' attribute, return its type.", FIBER_HDF5_TYPEID_ATTRIB);
                        return Type_id;
                }
                H5E_BEGIN_TRY
                attr_hid  = F5Aopen_name(Field_hid, FIBER_UNIFORMARRAY_BASE_ATTRIBUTE);
                H5E_END_TRY
 
                if (attr_hid>0)
                {
                        Type_id   = H5Aget_type(attr_hid);
                        H5Aclose(attr_hid);
                        F5printf(40, "F5Lget_type(): no `%s' attribute, but uniform base attribute %s found.",
                                 FIBER_HDF5_TYPEID_ATTRIB, FIBER_UNIFORMARRAY_BASE_ATTRIBUTE);
                        return Type_id;
                }
                F5printf(1, "F5Lget_type(): no `%s' attribute, ** performance warning ** - identifying field type by iteration over field fragments!",
                         FIBER_HDF5_TYPEID_ATTRIB);
                {
                TypeIterationParameters T;
                        T.type_id = &Type_id;
                        T.fapl_id = fapl_id;
                        H5Giterate(Field_hid, ".", 0, get_type_by_iteration, &T);
                        return Type_id;
                }
        }
        else
        {
        hid_t   NCSA_image_version = F5Atry_to_open(Field_hid, "IMAGE_VERSION");
                if (NCSA_image_version>0)
                {
                hid_t   attr_hid = F5Atry_to_open(Field_hid, FIBER_HDF5_TYPEID_ATTRIB);
                        H5Aclose( NCSA_image_version );
                        if (attr_hid>0)
                        {
                        hid_t   Type_id    = H5Aget_type(attr_hid);
                                H5Aclose(attr_hid);
                                F5printf(40, "F5Lget_type(): found NCSA image with `%s' attribute, return its type.", FIBER_HDF5_TYPEID_ATTRIB);
fprintf(stderr, "F5Lget_type(): found NCSA image with `%s' attribute, return its type.\n", FIBER_HDF5_TYPEID_ATTRIB);
                                return Type_id;
                        }
                }
#if 0
                {
                hid_t type_id = H5Dget_type(Field_hid);
                        if (H5Tis_commmitted(type_id)
                        {
                        int NAttribs = H5Aget_num_attrs( type_id );
                                F5printf(20, "HDF5 Type %lu has %d attributes", (unsigned long)type_id, NAttribs);
                        }
                        return type_id;
                }
#endif
                return  H5Dget_type(Field_hid);
        }
}

References F5Aopen_name(), F5Atry_to_open(), F5printf, TypeIterationParameters::fapl_id, FIBER_HDF5_TYPEID_ATTRIB, FIBER_UNIFORMARRAY_BASE_ATTRIBUTE, and TypeIterationParameters::type_id.

Referenced by F5Fget_type2(), F5Lget_compound_extent_dims(), F5Lget_compound_space(), F5Lget_field_dimension_and_type(), F5P_is_curvilinear(), and F5P_is_rectilinear().

F5Lread_linear()

F5_API hid_t F5Lread_linear	(	hid_t	F_id,
		hsize_t *	dims,
		hid_t	fieldtype,
		void *	base,
		void *	delta )

Try to read a field as if it were a linear mapping of indices to some values.

Parameters

dims	The extensions of an HDF5 dataspace.

Returns

An HDF5 group ID. The caller must issue H5Gclose() on the returned identifier.

Todo

Add error checkings if the used attributes do not exist.

Definition at line 911 of file F5L.c.

{
        /* A linear map must be a group, not a dataset. */
int     rank, i;
hid_t   attr_id, space_id;
hssize_t file_rank;
int     UADims[FIBER_MAX_RANK];
 
        if (F_id < 0)
                return F_id;
 
        /* If so, it must have a FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE,
           which is an alias for the corresponding dataspace of this
           field.
        */
 
        rank = H5Tget_nmembers( fieldtype );
        H5E_BEGIN_TRY
        attr_id  = F5Aopen_name(F_id, FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE);
        H5E_END_TRY
        if (attr_id<0)
        {
#ifdef    F5_BACKWARD_COMPATIBILITY
                /* OLD FILE SUPPORT */
                attr_id  = F5Aopen_name(F_id, "Size");
                if (attr_id<0)
                {
                        printf("F5Lread_linear(): ERROR: "FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE" or Size attribute not found!\n");
#else
                        printf("F5Lread_linear(): ERROR: "FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE" attribute not found!\n");
#endif
                        return -1;
#ifdef    F5_BACKWARD_COMPATIBILITY
                }
#endif
        }
        space_id = H5Aget_space(attr_id);
        file_rank = H5Sget_simple_extent_npoints(space_id);
        H5Sclose(space_id);
 
        if (file_rank != rank)
        {
                printf("F5Lread_linear(): ERROR: "FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE" does not have %d elements, but %d!\n",
                       rank, (int)file_rank);
                H5Gclose(F_id);
                return -1;
        }
 
        /* Read the dimensional values, which corresponds to retrieving the
           dataspace of this field. However, there is no true dataspace stored
           in the HDF5 file, but it is formulated via a special F5-internal
           attribute. */
 
        F_H5Aread(attr_id, H5T_NATIVE_INT, UADims, FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE);
        H5Aclose(attr_id);
 
        for(i=0; i<rank; i++)
                dims[i] = UADims[i];
 
        /* Moreover, a linear field must contain a base attribute */
        attr_id  = F5Aopen_name(F_id, FIBER_UNIFORMARRAY_BASE_ATTRIBUTE);
        F_H5Aread(attr_id, fieldtype, base, FIBER_UNIFORMARRAY_BASE_ATTRIBUTE);
        H5Aclose(attr_id);
 
        /* and a delta attribute */
        attr_id  = F5Aopen_name(F_id, FIBER_UNIFORMARRAY_DELTA_ATTRIBUTE);
        F_H5Aread(attr_id, fieldtype, delta, FIBER_UNIFORMARRAY_DELTA_ATTRIBUTE);
        H5Aclose(attr_id);
 
        return F_id;
}

References F5Aopen_name(), F_H5Aread(), FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE, FIBER_MAX_RANK, FIBER_UNIFORMARRAY_BASE_ATTRIBUTE, FIBER_UNIFORMARRAY_DELTA_ATTRIBUTE, and H5Gclose.

Referenced by F5Fread_linear(), and F5Fread_linear_fragment().

F5LreadS()

F5_API int F5LreadS	(	hid_t	Container_id,
		hid_t	memtype,
		void *	dataPtr,
		hid_t	ElementLoadID )

Read a dataset stored as separated compound as a continiguous compound dataset, involving some data transformation. Internally, hyperslabs are used.

Definition at line 552 of file F5L.c.

{
int     nDimensions = -1;
int     nComponents = H5Tget_nmembers( LoadID );
hid_t   dapl_id = H5P_DEFAULT;
int     read_ok = 0;
int     i;
        for(i=0; i<nComponents; i++)
        {
        char * comp_name = H5Tget_member_name( LoadID, i );
        hid_t    comp_id = H5Dopen2(Container_id, comp_name, dapl_id);
 
        hid_t   space_id = H5Dget_space( comp_id );
        hsize_t mem_dataspace[FIBER_MAX_RANK],
                blocksize[FIBER_MAX_RANK];
        hsize_t start [FIBER_MAX_RANK];
        hsize_t stride[FIBER_MAX_RANK];
        int     subrank = H5Sget_simple_extent_dims(space_id, blocksize, NULL);
        int     k, FastestDimension;
 
                if (i==0)
                        nDimensions = subrank;
                else if (subrank != nDimensions)
                {
                        F5printf(-1, "F5LreadS() Incompatible component subspace!?!!?");
                }
                FastestDimension = nDimensions-1;
                for(k=0; k<nDimensions; k++)
                {
                        mem_dataspace[k] = blocksize[k];
                        start[k]  = 0;
                        stride[k] = 1;
                }
                mem_dataspace[FastestDimension] = nComponents*blocksize[FastestDimension];
                start [FastestDimension]        = i;
                stride[FastestDimension]        = nComponents;
 
                /*
                ** Create the HDF5 Hyperslab
                */
                {
        hid_t   mem_space_id = H5Screate_simple(subrank, mem_dataspace, NULL);
                H5Sselect_hyperslab(mem_space_id, H5S_SELECT_SET, start, stride, blocksize, NULL);
 
                {
        herr_t  read_error = H5Dread(comp_id, ElementLoadID, mem_space_id, space_id, H5P_DEFAULT, dataPtr);
                if (read_error<0)
                {
                        F5printf(0, "F5readS() Component subspace read error at %s", comp_name);
                }
                else
                        read_ok++;
                }
 
                H5free_memory( comp_name );
 
                H5Dclose(comp_id);
                H5Sclose(space_id);
                H5Sclose(mem_space_id);
                }
        }
 
        return read_ok;
}

References F5printf, and FIBER_MAX_RANK.

F5Lset_space()

F5_API int F5Lset_space	(	hid_t	Field_id,
		int	rank,
		const hsize_t *	dims )

Save dimensional information to a certain location.

Returns

1 if successfull, 0 if some problem occurred during writing.

Definition at line 292 of file F5L.c.

{
int     ok = F5LAsave_dimensions(Field_id, FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE, rank, dims);
        if (!ok)
                F5printf(20, "  F5Lset_space(): field already has dimensions set or invalid Field id or write error.");
        return ok;
}

References F5LAsave_dimensions(), F5printf, FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE, and ok.

Referenced by F5Fwrite_linear_fraction(), F5LSwrite_fraction(), F5Lwrite_fraction(), F5Lwrite_fraction_external(), F5Lwrite_fractionS(), and F5Lwrite_linear().

F5LSwrite_fraction()

F5_API hid_t F5LSwrite_fraction	(	hid_t	R_id,
		const char *	fieldname,
		int	dimension,
		const hsize_t *	full_dims,
		const hsize_t *	datasize,
		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	enum_type,
		hid_t	property_id )

Write a dataset of separate components that only cover a fraction of the entire representation's domain.

Parameters

dimension	The dimension of the data set.
datastart	The (multidimensional) start index of the saved data set.
dataend	The (multidimensional) end index of the saved data set.
fraction_name	An optional string to name this fraction. It may be NULL to use an internal default.

Note

Subsampling can not be specified here. Subsampled data need to go into another Topology group.

Returns

A HDF5 dataset ID. The caller must issue H5Dclose() on the returned identifier.

Definition at line 793 of file F5L.c.

{
hid_t   F_id;
hid_t   B_id;
 
        F5printf(10, "F5LSwrite_fraction(field=%s, fragment=%s)",
                 fieldname, fraction_name);
 
        if (rank==3)
        {
                F5printf(60, "    start=[%d,%d,%d] size=[%d,%d,%d] full=[%d,%d,%d]\n",
                         (int)full_dims[0], (int)full_dims[1], (int)full_dims[2],
                         (int)datastart[0], (int)datastart[1], (int)datastart[2],
                         (int)datasize[0],  (int)datasize[1] , (int)datasize[2]
                        );
        }
 
 
        F_id = F5Gappend(R_id,  fieldname);
        {
        char    myBlockname[ MAX_BLOCKNAME ];
        B_id = F5Lwrites(F_id, fraction_name?fraction_name:blockname(myBlockname, rank, datastart),
                         rank, datasize, fieldtype, memtype, dataPtr, enum_type, property_id);
        }
        F5Dset_type_attribute(F_id, fieldtype);
 
        if (full_dims)
                F5Lset_space(F_id, rank, full_dims);
 
        F5LAsave_dimensions(B_id, FIBER_FRAGMENT_OFFSET_ATTRIBUTE, rank, datastart);
 
        if (start_border)
                F5LAsave_dimensions(B_id, FIBER_FRAGMENT_NOOVERLAP_START_ATTRIBUTE, rank, start_border);
 
        if (end_border)
                F5LAsave_dimensions(B_id, FIBER_FRAGMENT_NOOVERLAP_END_ATTRIBUTE, rank, end_border);
 
        F5Xclose(B_id);
 
        F5printf(11, "~F5LSwrite_fraction(field=%s, fragment=%s)\n",
                 fieldname, fraction_name);
 
        return F_id;
}

References F5Dset_type_attribute(), F5Gappend(), F5LAsave_dimensions(), F5Lset_space(), F5Lwrites(), F5printf, F5Xclose(), FIBER_FRAGMENT_NOOVERLAP_END_ATTRIBUTE, FIBER_FRAGMENT_NOOVERLAP_START_ATTRIBUTE, FIBER_FRAGMENT_OFFSET_ATTRIBUTE, and MAX_BLOCKNAME.

Referenced by F5FSwrite_fraction().

F5LTcreate() [1/2]

F5Path * F5LTcreate	(	hid_t	File_id,
		const double *	time,
		const char *	gridname,
		ChartDomain_IDs *	ChartDomain,
		ChartDomain_IDs *	coord_creator(),
		const char *	coordinate_system,
		const char *	TopologyName,
		int	IndexDepth,
		int	SkeletonDimensionality,
		int	Dimensionality,
		const hsize_t *	refinement )

Create a Topology of the given name with a representation in the certain coordinate system. If the ChartDomain has not been set yet, then the types in the newly created chart domain (F5Path->myChart) will contain valid types for the Points and tangential types, as they are created by the specified coord_creator(). Note that the coord_create() specifies the type of the coordinate system, while the coordinate_system parameter specifies the actual object that is of this respective type.

Examples

ObjtoF5.c.

Definition at line 712 of file F5LT.c.

{
ChartDomain_IDs*(*TheCoordCreator)(void*) = 0;
/*ChartDomain_IDs*TheCoordCreator = 0; */
 
        F5printf(30,"F5LTcreate(%s)\n", TopologyName);
 
        if (coord_creator)
                TheCoordCreator = coord_domain_creator; /* local function that calls coord_creator() */
 
        return F5LTcreateV(File_id, time, gridname,
                           ChartDomain,
                           TheCoordCreator,     /* local function that calls coord_creator() */
                           (void*)coord_creator,                /* user data */
                           coordinate_system,
                           TopologyName,
                           IndexDepth, SkeletonDimensionality,
                           Dimensionality,
                           refinement);
}

References F5LTcreate(), F5LTcreateV(), F5printf, and TopologyName().

Referenced by F5LTcreate(), F5Rcreate_coordinate_topology(), F5Rcreate_edges_as_vertices_topology(), F5Rcreate_hexaedrons_as_vertices_topology(), F5Rcreate_relative_vertex_Irefinement3D(), F5Rcreate_relative_vertex_Qrefinement3D(), F5Rcreate_tetrahedrons_as_vertices_topology(), and F5Rcreate_triangles_as_vertices_topology().

F5LTcreate() [2/2]

F5_API F5Path * F5LTcreate	(	hid_t	File_id,
		const double *	time,
		const char *	gridname,
		ChartDomain_IDs *	ChartDomain,
		new_global_chart_f	coord_creator,
		const char *	coordinate_system,
		const char *	TopologyName,
		int	IndexDepth,
		int	SkeletonDimensionality,
		int	DataspaceDimensionality,
		const hsize_t *	refinement )

Low-level creation function for F5Path objects.

Parameters

time	Pointer to the time instance of the current parameter space slices, or NULL if the data reside in a zero-dimensional parameter space, i.e. they are static. In a future extension, this may be a point to a multidimensional structure specifying the location in multidimensional parameter space.
SkeletonDimensionality	The dimensionality of the k-cells that is described by this Skeleton of a Grid.
DataspaceDimensionality	The dimensionality of the data that is used for the data on this Skeleton. This is best to be identical to the SkeletonDimensionality, but may differ, for instance one can store data in one-dimensional arrays over a 2D grid, or have some kind of irregular point distribution.

References F5_API, and TopologyName().

F5LTcreate_topology()

F5_API hid_t F5LTcreate_topology	(	hid_t	Grid_hid,
		const char *	TopologyName,
		int	IndexDepth,
		int	SkeletonDimensionality,
		int	DataspaceDimensionality,
		const hsize_t *	refinement )

Definition at line 329 of file F5LT.c.

{
        if (Grid_hid<=0)
        {
                F5printf(0, "F5LTcreate_topology() - invalid Grid HDF5 ID, file not open?");
                return -1;
        }
 
hid_t   Topology_hid = F5Gappend(Grid_hid,  TopologyName) ;
/*hid_t attr_id;
hid_t   space_id = H5Screate(H5S_SCALAR);
herr_t  status;
*/
        if (Topology_hid<0)
                return -2;
 
        assert(Topology_hid>0);
 
        F5printf(30, "F5LTcreate_topology(%s)<depth=%d>, rank=%d (using dataspace of rank %d)",
                 TopologyName, IndexDepth, SkeletonDimensionality, DataspaceDimensionality);
/*      printf( "F5LTcreate_topology(%s)<depth=%d>, rank=%d (using dataspace of rank %d)",
                 TopologyName, IndexDepth, SkeletonDimensionality, DataspaceDimensionality);
*/
 
        if (!F5Astore_integer(Topology_hid, FIBER_HDF5_INDEXDEPTH_ATTRIB, IndexDepth) )
        {
                F5printf(50, "Tried to re-create topology %s, ignored\n", TopologyName);
                puts("CANNOT save index depth");
                return Topology_hid;
        }
 
        if (!F5Astore_integer(Topology_hid, FIBER_HDF5_SKELETON_DIMENSIONALITY_ATTRIB, SkeletonDimensionality) )
        {
                F5printf(50, "Can't save dimensionality in %s, ignored\n", TopologyName);
                puts("CANNOT save dimensionality");
                return Topology_hid;
        }
 
        /* Dimensionality information  */
        if (DataspaceDimensionality>0)
        {
                if (!F5Asave_ints( Topology_hid, FIBER_HDF5_RANK_ATTRIBUTE, &DataspaceDimensionality, 1) )
                {
                        F5printf(3, "F5LTcreate_topology(%s)<depth=%d>, rank=%dD: CANNOT SAVE RANK - aborted, more info with F5_VERBOSITY=10 to 50"
                                 , TopologyName, IndexDepth, DataspaceDimensionality);
                        H5Gclose( Topology_hid );
                        return -1;
                }
        }
 
        if( SkeletonDimensionality > 0 && refinement )
        {
                if (1 != F5LAsave_dimensions(Topology_hid,  FIBER_HDF5_REFINEMENT_INFO, SkeletonDimensionality, refinement))
                {
                        F5printf(3, "F5LTcreate_topology(%s)<depth=%d>, rank=%dD: CANNOT SAVE REFINEMENT - aborted", TopologyName, IndexDepth, DataspaceDimensionality);
                        H5Gclose( Topology_hid );
                        return -1;
                }
        }
 
        F5printf(30, "~F5LTcreate_topology(%s)<depth=%d>, %dD", TopologyName, IndexDepth, DataspaceDimensionality);
        return Topology_hid;
}

References F5Asave_ints(), F5Astore_integer(), F5Gappend(), F5LAsave_dimensions(), F5printf, FIBER_HDF5_INDEXDEPTH_ATTRIB, FIBER_HDF5_RANK_ATTRIBUTE, FIBER_HDF5_REFINEMENT_INFO, FIBER_HDF5_SKELETON_DIMENSIONALITY_ATTRIB, H5Gclose, and TopologyName().

Referenced by F5LTcreateV().

F5LTcreateV()

F5Path * F5LTcreateV	(	hid_t	File_id,
		const double *	time,
		const char *	gridname,
		ChartDomain_IDs *	ChartDomain,
		ChartDomain_IDs *	coord_creatorvoid *udata,
		void *	udata,
		const char *	coordinate_system,
		const char *	TopologyName,
		int	IndexDepth,
		int	SkeletonDimensionality,
		int	Dimensionality,
		const hsize_t *	refinement )

The central F5Path constructor for write access: Creates the basic F5 structures in the file and sets up an F5Path object for subsequent use. Basically, all the information contained in an F5Path object can be created from the given parameters, however, some complexity arises when modifying some file that already has some structure. In such a case, it must re-use any found structures in a consistent way, especcially it has to use named types instead of intrinsic ones.

Todo

Extend slice group creation to parameter spaces

Parameters

ChartDomain

If a chartdomain is given, i.e. it is used already or stems from another file opening, then we reuse this chart domain, otherwise a new one will be created. The ChartDomain describes all types of the fields in the respective representation group as they are transient in memory. It will become the F5Path's `myChart' member. Specifying the ChartDomain is optional: if it is not given, then the coord_creator() callback function will be used to create a new coordinate object.

Note that F5LTcreateV() is more general in this respect than F5LTcreate() and F5LTcreateT(): Via the callback function, it allows to create an arbitrary subset of types for the chart domain, whereas F5LTcreate() always assumes that the representation domain is a coordinate system and creates the point, vector, covector and subsequent types for the tangential space. F5LTcreateT(), in contrast, does not create any tangential types (they are set to -1 in the ChartDomain), but only the point type, thus is more suitable for topological representations (cells referring to points, points to refined points, ...). */ if (ChartDomain) { F5printf(31, " increment chart domain references"); f->myChart = ChartDomain; f->myChart->refs++; } else if (coord_creator) { assert(udata); F5printf(31, " using new coordinate creator"); f->myChart = coord_creator(udata);

if (f->myChart) { f->Chart_hid = F5Gappend(f->Charts_hid, coordinate_system); F5printf(31, " append %s\n", coordinate_system); } else F5printf(0, " no chart created, coordinate_system is %s", coordinate_system); } else { F5printf(1, "F5 On Grid [%s] creating a Topological Skeleton [%s] without coordinates and no chart domain [%s], this might be a relative representation.", gridname, TopologyName, coordinate_system); f->myChart = 0; }

if (f->myChart && f->Chart_hid) { hid_t Domain_hid; hid_t GlobalChartAnchor_hid;

char chart_anchor[1024] = "/" FIBER_HDF5_GLOBAL_CHARTS "/"; strcat(chart_anchor, f->myChart->domain_name); strcat(chart_anchor,"/"); strcat(chart_anchor, coordinate_system);

/* Creates an entry in the "global charts" group for all cartesian charts, this is the place to store the named types of cartesian charts.

NOTE: This coordinate/chart reference stuff is planned to be replaced by shared types. This revision will work without links.

Definition at line 410 of file F5LT.c.

{
F5Path* f = NULL;
        if (File_id<0)
        {
                F5printf(1, "F5LTcreateV(): Invalid File!");
                return NULL;
        }
 
        F5printf(30, "**F5LTcreateV(grid=`%s', topology=`%s')<%d>, Repr=%dD, [%s] %s %s",
                 gridname, TopologyName, IndexDepth, Dimensionality, coordinate_system,
                 ChartDomain?" Chart Domain given":"No chart Domain",
                 coord_creator?" Coordinate Creator available":" No Coordinate Creator" );
 
        if (!gridname || !gridname[0])
        {
                return NULL;
        }
 
        /*
          Should this be relaxed to allow zero dimensionality or negative?
          What would this mean for refinements?
 
          YES - because we need zero dimensionality to identify particle sets.
         */
        if (Dimensionality<0)
        {
                F5printf(0, "**F5LTcreateV(grid=`%s', topology=`%s')<%d>, %dD, [%s] - CANNOT create skeleton entry because dimensionality is lesser than zero!",
                         gridname, TopologyName, IndexDepth, Dimensionality, coordinate_system);
                return NULL;
        }
 
        F5printf_indent++;
 
        /* Create an empty F5Path structure */
        f = newF5Path(File_id);
 
        assert(coordinate_system);
 
        /* Initialize contents property */
        f->ContentsGroup_hid = F5I_create_contents(File_id);
        assert(f->ContentsGroup_hid>0);
        F5printf(40, "F5LTcreateV():  Contents group is %d\n", (int)(f->ContentsGroup_hid) );
 
        f->field_enum_type_hid = 0;
 
        /* Prepare time slice group:
           /T=1.0/
        */
        /** @todo Extend slice group creation to parameter spaces */
        f->Slice_hid   = F5Bappend_slice(File_id, time);
        assert(f->Slice_hid>0);
 
/* create the neccessary groups for appending the data to the dataset */
 
        F5printf(30, "F5LTcreate(): append gridname `%s'\n", gridname);
        /*     /T=1.0/Gridname/            */
        f->Grid_hid             = F5Gappend(f->Slice_hid,  gridname);
        /*     /T=1.0/Gridname/Charts/     */
        f->Charts_hid           = F5Gappend(f->Grid_hid,  FIBER_HDF5_CHARTS_PER_GRID);
 
        /* register grid for reverse indexing ("on which time steps does this grid exist"?)
           @todo Extend grid registration to parameter spaces.
         */
        F5I_add_grid(f, gridname, time);
 
        /*  register the given coordinate system per grid
             /T=1.0/Gridname/Charts/Cartesian/
            This is required such that we know which coordinate system exist
            on this grid at all, therefore allowing a reading facility to request
            a coordinate representation in one of those coordinate systems. It makes
            no sense to request a representation in a coordinate system that is not
            listed with a grid, because there will be no transformation information
            available at all for this coordinate system. On the other hand, the
            information which charts are possible cannot be stored with each
            representation, because it is totally valid for a topology group to
            have no representation in a transformable grid. Instead, this
            transformation information is usually stored with the charts per grid
            and may be employed for all topology groups - for procedural transformation.
            In the case of numerical transformation rules, the transformation
            matrices have to be stored explicitely with each topology.
            Examples:
            /T=1.0/Gridname/Charts/CartesianChart/
            /T=1.0/Gridname/Charts/PolarChart/
            /T=1.0/Gridname/Points/PolarChart/Positions/
            allows to request
            /T=1.0/Gridname/Points/CartesianChart/Positions/
            although there is not yet such a representation in the file.
            In this case, the intrinsic polar->cartesian coordinate transformation
            rule is used. If there is an entry
            /T=1.0/Gridname/Charts/PolarChart/CartesianChart/
            then this group may contain more specific information on how to transform
            from polar to cartesian coordinates, e.g. specifying some angle of the
            polar axis, some offset of the polar coordinate origin, some mapping of
            the angles etc.
        */
        if (ChartDomain) // only add true coordinate systems to the list of charts
                f->Chart_hid = F5Gappend(f->Charts_hid, coordinate_system) ;
        else
                f->Chart_hid = 0;
 
        /* Create a topology group under for the certain grid:
             /T=1.0/Gridname/TopologyName
        */
        f->Topology_hid         = F5LTcreate_topology(f->Grid_hid,
                                                      TopologyName,
                                                      IndexDepth, SkeletonDimensionality,
                                                      Dimensionality,
                                                      refinement);
 
        if (f->Topology_hid<0)
        {
                F5printf(0, "**F5LTcreateV(grid=`%s', topology=`%s')<%d>, %dD, [%s] Could not create Skeleton, different dataspace properties found in file, use F5_VERBOSITY=3 for more details.",
                         gridname, TopologyName, IndexDepth, Dimensionality, coordinate_system);
                H5Gclose(f->Slice_hid );
                H5Gclose(f->Grid_hid );
                H5Gclose(f->Charts_hid );
                if (f->Chart_hid) H5Gclose(f->Chart_hid );
                deleteF5Path(f);
                return NULL;
        }
 
        F5LTset_maximal_grid_refinement(f->ContentsGroup_hid, gridname, IndexDepth, SkeletonDimensionality, refinement);
 
        assert(coordinate_system);
        /* Create a representation group under for the certain grid:
             /T=1.0/Gridname/TopologyName/RepresentationName
        */
        f->Representation_hid   = F5Gappend(f->Topology_hid,  coordinate_system);
 
        /* preparing chart */
        f->GlobalChart_hid = F5Gappend(File_id, FIBER_HDF5_GLOBAL_CHARTS) ;
 
        /**
        @param ChartDomain
           If a chartdomain is given, i.e. it is used already or stems from
           another file opening, then we reuse this chart domain, otherwise
           a new one will be created. The ChartDomain describes all types
           of the fields in the respective representation group as they
           are transient in memory. It will become the F5Path's `myChart'
           member. Specifying the ChartDomain is optional: if it is not
           given, then the coord_creator() callback function will be
           used to create a new coordinate object.
 
           Note that F5LTcreateV() is more general in this respect than
           F5LTcreate() and F5LTcreateT(): Via the callback function, it
           allows to create an arbitrary subset of types for the chart domain,
           whereas F5LTcreate() always assumes that the representation domain
           is a coordinate system and creates the point, vector, covector
           and subsequent types for the tangential space. F5LTcreateT(),
           in contrast, does not create any tangential types (they are set
           to -1 in the ChartDomain), but only the point type, thus is
           more suitable for topological representations (cells referring
           to points, points to refined points, ...).
        */
        if (ChartDomain)
        {
                F5printf(31, " increment chart domain references");
                f->myChart = ChartDomain;
                f->myChart->refs++;
        }
        else if (coord_creator)
        {
                assert(udata);
                F5printf(31, " using new coordinate creator");
                f->myChart = coord_creator(udata);
 
                if (f->myChart)
                {
                        f->Chart_hid = F5Gappend(f->Charts_hid, coordinate_system);
                        F5printf(31, " append %s\n", coordinate_system);
                }
                else
                        F5printf(0, " no chart created, coordinate_system is %s", coordinate_system);
        }
        else
        {
                F5printf(1, "F5 On Grid [%s] creating a Topological Skeleton [%s] without coordinates and no chart domain [%s], this might be a relative representation.",
                         gridname, TopologyName,  coordinate_system);
                f->myChart = 0;
        }
 
        if (f->myChart && f->Chart_hid)
        {
        hid_t   Domain_hid;
        hid_t   GlobalChartAnchor_hid;
 
        char    chart_anchor[1024] = "/" FIBER_HDF5_GLOBAL_CHARTS "/";
                strcat(chart_anchor, f->myChart->domain_name);
                strcat(chart_anchor,"/");
                strcat(chart_anchor, coordinate_system);
 
        /* Creates an entry in the "global charts" group for all cartesian charts,
           this is the place to store the named types of cartesian charts.
 
 
        NOTE: This coordinate/chart reference stuff is planned to be replaced by shared
              types. This revision will work without links.
        */
                Domain_hid = F5Gtry_to_open(f->GlobalChart_hid, f->myChart->domain_name);
                if (Domain_hid>0)
                {
                        f->FileIDs = F5FB_read_global_chart(f);
 
                        if (coordinate_system && F5Gexist(Domain_hid, coordinate_system) )
                        {
                                F5printf(10,"F5LTcreate(): Coordinate system %s already exists in domain %s, read global chart ID's...",
                                         coordinate_system, f->myChart->domain_name);
 
                                /* still link from the local chart to the global chart */
                                F5Glink(f->Chart_hid, H5G_LINK_SOFT, chart_anchor, FIBER_HDF5_CHART_TO_GLOBALCHART_REF ) ;
                                H5Gclose(Domain_hid);
                                F5printf(10,"~F5LTcreate() got data from file.");
                                F5printf_indent--;
                                return f;
                        }
                }
                else
                {
                        F5printf(10,"F5LTcreate(): Coordinate domain not found, creating file entry.");
 
                        /* Create an entry in the group of all (cartesian) charts for this specific coordinate system */
                        Domain_hid = H5Gcreate2(f->GlobalChart_hid, f->myChart->domain_name,
                                                H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
 
                        /* save relevant information (named HDF5 types) for cartesian charts */
                        f->FileIDs = F5B_save_global_chart(f->myChart, Domain_hid);
 
                        F5printf(10,"F5LTcreate(): Coordinate domain not found, creating file entry. Done!");
                }
                GlobalChartAnchor_hid = H5Gcreate2(Domain_hid, coordinate_system,
                                                   H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
 
                H5Gclose(Domain_hid);
 
                /* TODO: Check if these links already exist, if they are consistent,
                   and create them ONLY if they are required to make new.
                */
 
                /* a link from the local chart to the global chart */
                F5Glink(f->Chart_hid, H5G_LINK_SOFT, chart_anchor, FIBER_HDF5_CHART_TO_GLOBALCHART_REF ) ;
 
                strcpy(chart_anchor, "/" FIBER_HDF5_GLOBAL_CHARTS "/");
                strcat(chart_anchor, f->myChart->domain_name);
 
                H5E_BEGIN_TRY
                /* a link from the global chart to the coordinate type (cartesian coordinates) */
                F5Glink(GlobalChartAnchor_hid, H5G_LINK_HARD,
                        chart_anchor,
                        FIBER_HDF5_GLOBALCHART_COORDINATES );
                H5E_END_TRY
 
                H5Gclose(GlobalChartAnchor_hid);
        }

References F5Path::Chart_hid, F5Path::Charts_hid, F5Path::ContentsGroup_hid, deleteF5Path(), ChartDomain_IDs::domain_name, F5B_save_global_chart(), F5Bappend_slice(), F5FB_read_global_chart(), F5Gappend(), F5Gexist(), F5Glink(), F5Gtry_to_open(), F5I_add_grid(), F5I_create_contents(), F5LTcreate_topology(), F5LTset_maximal_grid_refinement(), F5printf, F5printf_indent, FIBER_HDF5_CHART_TO_GLOBALCHART_REF, FIBER_HDF5_CHARTS_PER_GRID, FIBER_HDF5_GLOBAL_CHARTS, FIBER_HDF5_GLOBALCHART_COORDINATES, F5Path::field_enum_type_hid, F5Path::FileIDs, F5Path::GlobalChart_hid, F5Path::Grid_hid, H5Gclose, F5Path::myChart, newF5Path(), ChartDomain_IDs::refs, F5Path::Representation_hid, F5Path::Slice_hid, F5Path::Topology_hid, and TopologyName().

Referenced by F5LTcreate().

F5LTget_index_depth()

F5_API int F5LTget_index_depth

(

hid_t

Top_hid

)

Get the index depth of a certain Topology ID.

Definition at line 21 of file F5LT.c.

{
int     IndexDepth = 0;
 
        if (F5Aget_ints(Top_hid, FIBER_HDF5_INDEXDEPTH_ATTRIB, &IndexDepth, 1) <= 0)
        {
                F5printf(5," *Warning* F5LTget_index_depth() could not find index depth attribute!");
                return F5_INVALID_INDEX_DEPTH;
        }
 
        return IndexDepth;
}

References F5_INVALID_INDEX_DEPTH, F5Aget_ints(), F5printf, and FIBER_HDF5_INDEXDEPTH_ATTRIB.

F5LTget_maximal_grid_refinement()

F5_API int F5LTget_maximal_grid_refinement	(	hid_t	ContentsGroup_id,
		const char *	gridname,
		hsize_t *	refinement )

Get the maximal refinement level for a certain Grid.

hsize_t MaxRefinement[ FIBER_MAX_RANK ];
int             Dims;
 
    Dims = F5LTget_maximal_grid_refinement(fpath->ContentsGroup_hid, "MyGridOfInterest", MaxRefinement);

Definition at line 192 of file F5LT.c.

{
hid_t   GridsTable     ;
hid_t   GridInfo       ;
int     Dims;
 
        if (!gridname || !refinement) return 0;
        GridsTable = F5Gappend(ContentsGroup_id, FIBER_CONTENT_GRIDS);
        GridInfo   = F5Gappend(GridsTable, gridname);
 
        Dims = F5LAget_dimensions(GridInfo, FIBER_HDF5_REFINEMENT_INFO, refinement );
 
        H5Gclose(GridsTable);
        H5Gclose(GridInfo);
        return Dims;
}

References F5Gappend(), F5LAget_dimensions(), FIBER_CONTENT_GRIDS, FIBER_HDF5_REFINEMENT_INFO, and H5Gclose.

F5LTget_maximal_skeleton_refinement()

F5_API int F5LTget_maximal_skeleton_refinement	(	hid_t	ContentsGroup_id,
		const char *	gridname,
		hsize_t *	refinement,
		int	IndexDepth,
		int	Dimensionality )

Get the maximal refinement level for a certain topological property of a Grid. For example, get the maximum refinement level for faces on a Grid:

hsize_t MaxRefinement[ FIBER_MAX_RANK ];
int             Dims;
 
    Dims = F5LTget_maximal_skeleton_refinement(fpath->ContentsGroup_hid, "MyGridOfInterest", MaxRefinement, 1, 2);

Definition at line 211 of file F5LT.c.

{
hid_t   GridsTable     ;
hid_t   GridInfo       ;
int     Dims;
char    RefinementAttributeName[1024] = FIBER_HDF5_REFINEMENT_INFO;
 
        if (!gridname || !refinement) return 0;
        GridsTable = F5Gappend(ContentsGroup_id, FIBER_CONTENT_GRIDS);
        GridInfo   = F5Gappend(GridsTable, gridname);
 
        if (IndexDepth!=0) // if not vertices
        {
                snprintf(RefinementAttributeName, sizeof(RefinementAttributeName),
                         FIBER_HDF5_REFINEMENT_INFO "<%d>[%d]", IndexDepth, Dimensionality);
        }
 
        Dims = F5LAget_dimensions(GridInfo, RefinementAttributeName, refinement );
 
        H5Gclose(GridsTable);
        H5Gclose(GridInfo);
        return Dims;
}

References F5Gappend(), F5LAget_dimensions(), FIBER_CONTENT_GRIDS, FIBER_HDF5_REFINEMENT_INFO, and H5Gclose.

F5LTset_maximal_grid_refinement()

F5_API int F5LTset_maximal_grid_refinement	(	hid_t	ContentsGroup_id,
		const char *	gridname,
		int	IndexDepth,
		int	Dimensionality,
		const hsize_t *	refinement )

Update the maximal refinement level for a certain Grid.

Parameters

IndexDepth

There can be different levels of refinement depending on the topological type of the Skeleton. Usually refinement will only be relevant for vertices, thus IndexDepth=0, but it is also possible for higher dimensional skeletons such as edges, lines, triangles...

Definition at line 240 of file F5LT.c.

{
hid_t   GridsTable     ;
hid_t   GridInfo       ;
hsize_t CurrentRefinement[ FIBER_MAX_RANK ];
int     CurrentDimensionality, i;
int     AllFine = 0;
char    RefinementAttributeName[1024] = FIBER_HDF5_REFINEMENT_INFO;
 
        F5printf(30, "int F5LTset_maximal_grid_refinement(F5Path*fpath,%s, %d, %p)\n", gridname, Dimensionality, refinement);
 
        if (!gridname)
        {
                F5printf(35, "F5LTset_maximal_grid_refinement(f->ContentsGroup_hid, gridname, Dimensionality, refinement); - NO GRIDNAME");
                return AllFine;
        }
        if (!refinement)
        {
                F5printf(35, "F5LTset_maximal_grid_refinement(f->ContentsGroup_hid, gridname, Dimensionality, refinement); - NO REFINEMENT");
                return AllFine;
        }
 
        GridsTable = F5Gappend(ContentsGroup_id, FIBER_CONTENT_GRIDS);
        GridInfo   = F5Gappend(GridsTable, gridname);
 
        if (IndexDepth!=0) // if not vertices
        {
                snprintf(RefinementAttributeName, sizeof(RefinementAttributeName),
                         FIBER_HDF5_REFINEMENT_INFO "<%d>[%d]", IndexDepth, Dimensionality);
        }
 
        CurrentDimensionality = F5LAget_dimensions(GridInfo, RefinementAttributeName, CurrentRefinement );
 
        if (CurrentDimensionality<1)
        {
                F5printf(35, "F5LTset_maximal_grid_refinement(f->ContentsGroup_hid, gridname, Dimensionality, refinement); - SAVE NEW %d",
                         (int)refinement[0] );
 
                F5LAsave_dimensions(GridInfo,  RefinementAttributeName, Dimensionality, refinement);
                AllFine = 1;
        }
        else
        {
                if (CurrentDimensionality==Dimensionality)
                {
                int     UpdateRefinement = 0;
 
                        for(i=0; i<CurrentDimensionality; i++)
                        {
                                if (CurrentRefinement[i] < refinement[i] )
                                {
                                        UpdateRefinement = 1;
                                        CurrentRefinement[i] = refinement[i];
                                }
                        }
 
                        if (UpdateRefinement)
                        {
                                F5printf(35, "F5LTset_maximal_grid_refinement(f->ContentsGroup_hid, gridname, Dimensionality, refinement); - UPDATE to %d",
                                         (int)CurrentRefinement[0] );
                                F5LAsave_dimensions(GridInfo,  RefinementAttributeName, Dimensionality, CurrentRefinement);
                        }
                        else
                        {
                                F5printf(35, "F5LTset_maximal_grid_refinement(f->ContentsGroup_hid, gridname,   Dimensionality, refinement); - NO UPDATE REQUIRED for %d",
                                         (int)CurrentRefinement[0] );
                        }
                        AllFine = 1;
                }
                else
                {
                        F5printf(0, "int F5LTset_maximal_grid_refinement(F5Path*fpath,%s, %dD, []): New refinement dimensions do not match stored ones (stored: %dD) - NOT UPDATED\n",
                                 gridname, Dimensionality, CurrentDimensionality );
                }
        }
 
        H5Gclose(GridsTable);
        H5Gclose(GridInfo);
        return AllFine;
}

References F5Gappend(), F5LAget_dimensions(), F5LAsave_dimensions(), F5printf, FIBER_CONTENT_GRIDS, FIBER_HDF5_REFINEMENT_INFO, FIBER_MAX_RANK, and H5Gclose.

Referenced by F5LTcreateV().

F5Lwrite()

F5_API hid_t F5Lwrite	(	hid_t	R_id,
		const char *	fieldname,
		int	dimension,
		const hsize_t *	dims,
		hid_t	fieldtype,
		hid_t	memtype,
		const void *	dataPtr,
		hid_t	enum_type,
		hid_t	dcpl_id )

Returns

A HDF5 dataset ID. The caller must issue H5Dclose() on the returned identifier.

Parameters

property_id	An HDF5 dataset property ID. If it is negative, then a default property will be created locally via H5Pcreate(H5P_DATASET_CREATE) .
dimension	The dimensionality of the data set. You may use F5Lwrite1D() as a convenience shortcut for one-dimensional data sets.
dims	The extension of the data set.

Note

Fields are always associated to certain coordinates system. The field type must be consistent with its coordinate system, e.g. one may not store a vector field in polar coordinates in a cartesian chart. Formally, this can be done because not all API functions have the ability to check for this consistency. However, a field type which is not part of a certain coordinate system will be treated as non-existent when reading the file later.

If a field is a structure made by separate data arrays, e.g. a vector field with components x,y,z stored as three arrays of floats, then use function F5Lwrites().

Parameters

enum_type

The Atomic Field enumeration type that is associated with the current file. Get it via F5LTmake_enum_type(fpath).

Todo

Expose xfer_plist_id parameter

Returns

An HDF5 dataset ID. The caller must issue H5Dclose() on the returned identifier.

Definition at line 357 of file F5L.c.

{
hid_t   id;
        if (fieldtype<=0)
        {
                F5printf(3, "F5Lwrite(%d,%s,%d,...): INVALID field type %d!",
                        (int)R_id, fieldname, dimension, (int)fieldtype );
                return  -1;
        }
        if (!dataPtr) /* possibly create a null data space? */
        {
                F5printf(3, "F5Lwrite(%d,%s,%d,...): WARNING - NO DATA!\n",
                         (int)R_id, fieldname, dimension );
        }
 
        id = F5Lcreate(R_id, fieldname, dimension, dims, fieldtype, dcpl_id);
        if (!F5Tcheck_committed(fieldtype))
                F5printf(10, "F5 Warning: F5Lwrite(%s): type not committed!\n", fieldname);
 
        if (id<0)
        {
                F5printf(3, "F5Lwrite(%d,%s,%d,...): Could not create field!",
                        (int)R_id, fieldname, dimension);
                return  -2;
        }
 
        F5printf(30, "F5Lwrite(): Field created, set enum");
        F5Tset_field_enum(id, enum_type, Contiguous);
 
        {
        hid_t   xfer_plist_id =  H5P_DEFAULT;
        if (dataPtr)
        {
        herr_t  err = H5Dwrite(id, memtype>0?memtype:fieldtype, H5S_ALL, H5S_ALL, xfer_plist_id, dataPtr);
 
                /* Returns a non-negative value if successful; otherwise returns a negative value.  */
                if (err<0)
                {
                        F5printf(3, "F5Lwrite(%d,%s,%d,...): Could not write field!",
                                 (int)R_id, fieldname, dimension);
                        H5Dclose( id );
                        return  -3;
                }
        }
        }
 
        return id;
}

References Contiguous, F5Lcreate(), F5printf, F5Tcheck_committed(), and F5Tset_field_enum().

Referenced by F5Fwrite_flexible(), F5Fwrite_fraction(), F5FwriteIMAGE(), F5Lwrite1D(), F5Lwrite_fraction(), F5Lwrite_fraction_external(), and F5Rcreate_uniform_sparse().

F5Lwrite1D()

F5_API hid_t F5Lwrite1D	(	hid_t	R_id,
		const char *	fieldname,
		hsize_t	nElements,
		hid_t	fieldtype,
		hid_t	memtype,
		const void *	dataPtr,
		hid_t	enum_type,
		hid_t	property_id )

Convenience function for writing one-dimensional data. Calls F5Lwrite();

Definition at line 408 of file F5L.c.

{
        return F5Lwrite(R_id, fieldname, 1, &nElements,
                        fieldtype, memtype, dataPtr, enum_type, property_id);
 
}

References F5Lwrite().

Referenced by F5Fwrite_1D(), F5Rcreate_rectilinear(), F5write_particle_cartesian3Dv(), F5write_particle_cartesian3DvU(), and F5write_particle_double_cartesian3Dv().

F5Lwrite_entity()

F5_API hid_t F5Lwrite_entity	(	hid_t	R_id,
		const char *	fieldname,
		hid_t	fieldtype,
		const void *	value )

Write a field that is a constant for all elements.

Returns

A HDF5 dataset ID. The caller must issue H5Dclose() on the returned identifier.

Definition at line 1029 of file F5L.c.

{
hid_t   ds_id = H5Screate(H5S_SCALAR);
hid_t   creator_id = H5Pcreate(H5P_DATASET_CREATE);
 
hid_t   F_id = H5Dcreate2(R_id, fieldname, fieldtype, ds_id, creator_id, H5P_DEFAULT, H5P_DEFAULT);
\
        H5Dwrite(F_id, fieldtype, H5S_ALL, H5S_ALL, H5P_DEFAULT, value);
 
        H5Sclose(ds_id);
        H5Pclose(creator_id);
 
        return F_id;
}

F5Lwrite_fraction()

F5_API hid_t F5Lwrite_fraction	(	hid_t	R_id,
		const char *	fieldname,
		int	dimension,
		const hsize_t *	full_dims,
		const hsize_t *	datasize,
		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	enum_type,
		hid_t	property_id )

Write a dataset which only covers a fraction of the entire representation's domain.

Parameters

dimension	The dimension of the data set.
datastart	The (multidimensional) start index of the saved data set.
dataend	The (multidimensional) end index of the saved data set.
fraction_name	An optional string to name this fraction. It may be NULL to use an internal default.

Note

Subsampling can not be specified here. Subsampled data need to go into another Topology group.

Returns

A HDF5 dataset ID. The caller must issue H5Dclose() on the returned identifier.

Definition at line 631 of file F5L.c.

{
hid_t   F_id, B_id;
 
        if (!datastart)
        {
                F5printf(0, "F5Lwrite_fraction() for field %s has no datastart given for fragment %s",
                         fieldname, fraction_name);
                return -1;
        }
 
        F5printf(20, "F5Lwrite_fraction(rank=%d)", rank);
        if (rank==3)
                F5printf(20, "F5Lwrite_fraction(%lux%lux%lu)",
                                (long)datasize[0], (long)datasize[1], (long)datasize[2]);
 
        F_id = F5Gappend(R_id,  fieldname);
        if (F_id<0)
        {
                F5printf(1, "F5Lwrite_fraction() - FAILED to append field fragment group.");
                return F_id;
        }
 
        {
        char    myBlockname[ MAX_BLOCKNAME ];
        B_id = F5Lwrite(F_id, fraction_name?fraction_name:blockname(myBlockname, rank, datastart),
                        rank, datasize, fieldtype, memtype, dataPtr, enum_type, property_id);
        }
        if (B_id<=0)
        {
                F5printf(1, "F5Lwrite_fraction() - FAILED to append field fragment data.");
                F5Xclose(F_id);
                return B_id;
        }
 
        if (full_dims)
                F5Lset_space(F_id, rank, full_dims);
 
        if (1 != F5LAsave_dimensions(B_id, FIBER_FRAGMENT_OFFSET_ATTRIBUTE, rank, datastart))
        {
                F5printf(1, "F5Lwrite_fraction() - FAILED to write FIBER_FRAGMENT_OFFSET_ATTRIBUTE");
        }
 
        if (start_border)
                F5LAsave_dimensions(B_id, FIBER_FRAGMENT_NOOVERLAP_START_ATTRIBUTE, rank, start_border);
 
        if (end_border)
                F5LAsave_dimensions(B_id, FIBER_FRAGMENT_NOOVERLAP_END_ATTRIBUTE, rank, end_border);
 
        F5Xclose(B_id);
        return F_id;
}

References F5Gappend(), F5LAsave_dimensions(), F5Lset_space(), F5Lwrite(), F5printf, F5Xclose(), FIBER_FRAGMENT_NOOVERLAP_END_ATTRIBUTE, FIBER_FRAGMENT_NOOVERLAP_START_ATTRIBUTE, FIBER_FRAGMENT_OFFSET_ATTRIBUTE, and MAX_BLOCKNAME.

Referenced by F5Fwrite_fraction().

F5Lwrite_linear()

F5_API hid_t F5Lwrite_linear	(	hid_t	R_id,
		const char *	fieldname,
		int	dimension,
		const hsize_t *	dims,
		hid_t	fieldtype,
		const void *	base,
		const void *	delta )

Write a field that is a linear map from coordinate indices to some data value.

Todo

Remove dimension parameter, it is clear from the fieldtype's members.

Parameters

dims	The extensions of an HDF5 dataspace.

Returns

A HDF5 group ID. The caller must issue H5Gclose() on the returned identifier.

Write a field that is a linear map from coordinate indices to some data value.

Returns

A HDF5 group ID. The caller must issue H5Gclose() on the returned identifier.

Definition at line 852 of file F5L.c.

{
hid_t   F_id;
hid_t   space_hid;
hid_t   attr_hid;
 
/*
int     rank = H5Tget_nmembers( fieldtype );
        if (rank<1)
        {
                F5printf(5, "F5Lwrite_linear(%s): Unknown field type!\n", fieldname);
                return -1;
        }
*/
 
        H5E_BEGIN_TRY
        F_id = F5Gcreate(R_id, fieldname, 0, 0);
        H5E_END_TRY
 
        if (F_id<0)
        {
                F5printf(50, "F5 Warning: F5Lwrite_linear(%s): cannot create group (already exists?)\n", fieldname);
                return -1;
        }
 
        if (!F5Tcheck_committed(fieldtype))
                printf("F5 Warning: F5Lwrite_linear(%s): type not committed!\n", fieldname);
 
        /* Set the dataspace attribute */
/*      F5Lset_space(F_id, rank, dims); */
 
        F5Lset_space(F_id, dimension, dims);
 
        space_hid = H5Screate(H5S_SCALAR);
 
        attr_hid  = H5Acreate2(F_id, FIBER_UNIFORMARRAY_BASE_ATTRIBUTE, fieldtype, space_hid,
                               H5P_DEFAULT, H5P_DEFAULT);
        /* Write scalar attribute. */
        H5Awrite(attr_hid, fieldtype, base );
        /* Close attribute.  */
        H5Aclose(attr_hid);
 
 
        attr_hid  = H5Acreate2(F_id, FIBER_UNIFORMARRAY_DELTA_ATTRIBUTE, fieldtype, space_hid,
                               H5P_DEFAULT, H5P_DEFAULT);
        /* Write scalar attribute. */
        H5Awrite(attr_hid, fieldtype, delta );
        /* Close attribute.  */
        H5Aclose(attr_hid);
 
        /* Close attribute dataspace. */
        H5Sclose(space_hid);
 
        return F_id;
}

References F5Gcreate(), F5Lset_space(), F5printf, F5Tcheck_committed(), FIBER_UNIFORMARRAY_BASE_ATTRIBUTE, and FIBER_UNIFORMARRAY_DELTA_ATTRIBUTE.

Referenced by F5Fwrite_linear(), and F5Fwrite_linear_fraction().

F5LwriteS()

F5_API hid_t F5LwriteS	(	hid_t	Container_id,
		const char *	name,
		int	dimension,
		const hsize_t *	dims,
		hid_t	fieldtype,
		hid_t	memtype,
		const void *	dataPtr,
		hid_t	enum_type,
		hid_t	dcpl_id )

Write a contiguous compound data set as separated compound data into the file, which involves data transformation.

Returns

The ID of the group, i.e. Container_id -> name

Definition at line 418 of file F5L.c.

{
int     nComponents;
hid_t   id;
        if (fieldtype<=0)
        {
                F5printf(30, "F5LwriteS(%d,%s,%d,...): INVALID field type %d!",
                        (int)R_id, fieldname, dimension, (int)fieldtype );
                return -1;
        }
 
        if ( H5Tget_class( fieldtype ) != H5T_COMPOUND )
        {
                F5printf(30, "F5LwriteS(%d,%s,%d,...): Not a compound type %d!",
                        (int)R_id, fieldname, dimension, (int)fieldtype );
                return -1;
        }
        if (!F5Tcheck_committed(fieldtype))
                printf("F5 Warning: F5LwriteS(%s): type not committed!\n", fieldname);
 
 
        if (!dataPtr)
        {
                F5printf(30, "F5LwriteS(%d,%s,%d,...): WARNING - NO DATA!\n",
                         (int)R_id, fieldname, dimension );
        }
 
        nComponents = H5Tget_nmembers(fieldtype);
 
        id = F5Gappend(R_id, fieldname);
 
//OR    id = F5Gcreate(R_id, fieldname, Ncomponents, 16);
 
        if (id<0)
        {
                F5printf(30, "F5LwriteS(%d,%s,%d,...): Could not create compound group!",
                        (int)R_id, fieldname, dimension);
                return -1;
        }
 
        F5printf(30, "F5Lwrite(): Field created, set enum");
        F5Tset_field_enum(id, enum_type, SeparatedCompound);
        F5Dset_type_attribute(id,  fieldtype);
 
        if (!dataPtr)
                return id;
 
        {
        hid_t   ds_id = H5Screate_simple(dimension, dims, NULL);
        int     comp;
        herr_t  herr;
 
                for(comp=0; comp<nComponents; comp++)
                {
                char*   ComponentName = H5Tget_member_name(fieldtype, comp);
                hid_t   ComponentType = H5Tget_member_type(fieldtype, comp);
                hid_t   MemComponentType;
                        if (memtype)
                        {
                                /* Retrieves the index of a compound or enumeration datatype member. */
                        int     mem_idx = H5Tget_member_index(memtype, ComponentName);
                                if (mem_idx<0)
                                {
                                        F5printf(10, "**F5LwriteS(%s) could not find memory equivalent "
                                                 " of save component %s!",
                                                 fieldname, ComponentName);
                                        MemComponentType = ComponentType;
                                        H5Iinc_ref( MemComponentType );
                                }
                                else
                                {
                                        F5printf(10, "F5LwriteS(%s): member type %s : %d -> %d",
                                                 fieldname, ComponentName, mem_idx, comp);
                                        MemComponentType = H5Tget_member_type(memtype, mem_idx);
                                }
                        }
                        else
                        {
                                MemComponentType = ComponentType;
                                H5Iinc_ref( MemComponentType );
                        }
 
                hid_t   D_id = H5Dcreate2(id, ComponentName, ComponentType, ds_id,
                                          H5P_DEFAULT, /* link creation */
                                          dcpl_id,     /* dataset creation */
                                          H5P_DEFAULT); /* dataset access */
 
 
                /* setup hyperslab for data writing
                 */
                        {
                        hid_t   xfer_plist_id = H5P_DEFAULT;
                        hid_t   mem_space_id;
                        hsize_t mem_dataspace[FIBER_MAX_RANK];
                        hsize_t start [FIBER_MAX_RANK];
                        hsize_t stride[FIBER_MAX_RANK];
 
                        const int FastestDimension = dimension-1;
                        int     k;
                                for(k=0; k<dimension; k++)
                                {
                                        mem_dataspace[k] = dims[k];
                                        start[k]  = 0;
                                        stride[k] = 1;
                                }
                                mem_dataspace[FastestDimension] = nComponents*dims[FastestDimension];
                                start [FastestDimension]        = comp;
                                stride[FastestDimension]        = nComponents; //nDimensions;
 
                                mem_space_id = H5Screate_simple(dimension, mem_dataspace, NULL);
                                H5Sselect_hyperslab(mem_space_id, H5S_SELECT_SET, start, stride, dims, NULL);
 
                                herr = H5Dwrite(D_id, MemComponentType, mem_space_id, H5S_ALL, xfer_plist_id, dataPtr);
 
                                if (herr<0)
                                        F5printf(1, "**F5LwriteS(%s) could not save component %s!",
                                                 fieldname, ComponentName);
                        }
 
                        H5Dclose(D_id);
                        H5free_memory(ComponentName);
                        H5Tclose( ComponentType );
                        H5Tclose( MemComponentType );
                }
 
                H5Sclose( ds_id );
        }
 
        return id;
}

References F5Dset_type_attribute(), F5Gappend(), F5printf, F5Tcheck_committed(), F5Tset_field_enum(), FIBER_MAX_RANK, H5Tclose(), and SeparatedCompound.

Referenced by F5Lwrite_fractionS().

F5Lwrites()

F5_API hid_t F5Lwrites	(	hid_t	R_id,
		const char *	fieldname,
		int	dimension,
		const hsize_t *	dims,
		hid_t	fieldtype,
		hid_t	memtype,
		const void *const *	dataPtr,
		hid_t	enum_type,
		hid_t	property_id )

Parameters

enum_type

The Atomic Field enumeration type that is associated with the current file. Get it via F5LTmake_enum_type(fpath).

Returns

A HDF5 group ID. The caller must issue H5Gclose() on the returned identifier.

Todo

should be named F5DSwrite() instead

Returns

A HDF5 group ID. The caller must issue H5Gclose() on the returned identifier.

Note

If some component array is undefined (NULL), then its place will be left empty in the file.

Definition at line 1096 of file F5L.c.

{
hid_t   ds_id = H5Screate_simple(dimension, dims, NULL);
hid_t   creator_id = property_id<0 ? H5Pcreate(H5P_DATASET_CREATE) : property_id;
hid_t   F_id = -1;
 
        if (dimension==3)
                F5printf(10, "F5Lwrites(field=%s) %dx%dx%d",
                         fieldname, (int)dims[0], (int)dims[1], (int)dims[2] );
        else
                F5printf(10, "F5Lwrites(field=%s)\n", fieldname);
 
 
        if (!F5Tcheck_committed(fieldtype))
                printf("F5 Warning: F5Lwrites(%s): type not committed!\n", fieldname);
 
        switch( H5Tget_class( fieldtype ) )
        {
        case H5T_COMPOUND:
                {
                int     comp;
                int     Ncomponents = H5Tget_nmembers(fieldtype);
 
                        F_id = F5Gcreate(R_id, fieldname, Ncomponents, 16);
                        if (F_id<0)
                                F5printf(1, "**F5Lwrites(%s) could not create separated compound group!",
                                         fieldname);
 
                        F5Dset_type_attribute(F_id,  fieldtype);
                        F5Tset_field_enum(F_id, enum_type, SeparatedCompound);
 
                        for(comp=0; comp<Ncomponents; comp++)
                        {
                        hid_t   id, ComponentType, MemComponentType;
                        char       * ComponentName;
                        const void * data = dataPtr[comp];
                        herr_t  herr;
 
                                if (!data) continue;
                                ComponentName = H5Tget_member_name(fieldtype, comp);
                                ComponentType = H5Tget_member_type(fieldtype, comp);
                                if (memtype)
                                {
                                        /* Retrieves the index of a compound or enumeration datatype member. */
                                int     mem_idx = H5Tget_member_index(memtype, ComponentName);
                                        if (mem_idx<0)
                                        {
                                                F5printf(10, "**F5Lwrites(%s) could not find memory equivalent "
                                                         " of save component %s!",
                                                         fieldname, ComponentName);
                                                MemComponentType = ComponentType;
                                                H5Iinc_ref( MemComponentType );
                                        }
                                        else
                                        {
                                                F5printf(10, "F5Lwrites(%s): member type %s : %d -> %d",
                                                         fieldname, ComponentName, mem_idx, comp);
 
                                                data = dataPtr[mem_idx];
                                                MemComponentType = H5Tget_member_type(memtype, mem_idx);
                                        }
                                }
                                else
                                {
                                        MemComponentType = ComponentType;
                                        H5Iinc_ref( MemComponentType );
                                }
 
                                id = H5Dcreate2(F_id, ComponentName, ComponentType, ds_id, creator_id, H5P_DEFAULT, H5P_DEFAULT);
                                herr = H5Dwrite(id, MemComponentType, H5S_ALL, H5S_ALL, H5P_DEFAULT, data);
                                if (herr<0)
                                        F5printf(1, "**F5Lwrites(%s) could not save component %s!",
                                                 fieldname, ComponentName);
 
                                H5Dclose(id);
                                H5free_memory(ComponentName);
                                H5Tclose(ComponentType);
                                H5Tclose( MemComponentType );
                        }
                        break;
                }
 
        case H5T_FLOAT:
                {
                        F_id = H5Dcreate2(R_id, fieldname, fieldtype, ds_id, creator_id, H5P_DEFAULT, H5P_DEFAULT);
                        H5Dwrite(F_id, memtype, H5S_ALL, H5S_ALL, H5P_DEFAULT, *dataPtr);
                        F5Tset_field_enum(F_id, enum_type, Contiguous);
                        break;
                }
 
        default:
                F5printf(-1, "F5Lwrites(field=%s) CANNOT WRITE SPECIFIED FIELD TYPE as seperated compound, because it is not a compound\n", fieldname, F_id);
                break;
        }
        H5Sclose(ds_id);
 
        if (property_id<0)
                H5Pclose(creator_id);
 
        F5printf(10, "~F5Lwrites(field=%s), id=%d\n", fieldname, F_id);
        return F_id;
}

References Contiguous, F5Dset_type_attribute(), F5Gcreate(), F5printf, F5Tcheck_committed(), F5Tset_field_enum(), H5Tclose(), and SeparatedCompound.

Referenced by F5FSwrite_fraction(), F5Fwrites(), and F5LSwrite_fraction().