Functions
F5_API int	F5Fopen (F5Path f, const char fieldname)
F5_API F5Path *	F5FopenMostRecentSlice (hid_t File_id, double t, const char gridname, const char fieldname, const char coordinate_system)
F5_API void	F5Fclose (F5Path *f)
F5_API hid_t	F5Fgrab (F5Path *f)
F5_API hid_t	F5Fget_type2 (F5Path *f, hid_t elink_fapl_id)
F5_API hid_t	F5Tget_space (F5Path *f)
F5_API int	F5Fcreate (F5Path fpath, const char fieldname, int dimension, hsize_t *dims, hid_t fieldtype, hid_t property_id)
F5_API const char *	F5Fwhatsup (F5ErrorCode)
F5_API F5ErrorCode	F5Fwrite (F5Path fpath, const char fieldname, int dimension, hsize_t dims, hid_t fieldtype, hid_t memtype, const void dataPtr, hid_t property_id)
F5_API F5ErrorCode	F5FwriteHyperDimensional (F5Path fpath, const char fieldname, int rank, hsize_t dims, hid_t fieldtype, hid_t memtype, const void dataPtr, hid_t property_id)
F5_API F5ErrorCode	F5FwriteIMAGE (F5Path fpath, const char fieldname, int dimension, hsize_t dims, hid_t fieldtype, hid_t memtype, const void dataPtr, hid_t property_id)
F5_API F5ErrorCode	F5FwriteX (F5Path fpath, const char fieldname, int rank, const hsize_t dims[], hid_t fieldtype, hid_t memtype, const void *const dataPtr[], const int polynom_order[], const int component_map[], hid_t property_id)
F5_API int	F5Fwrite_linear (F5Path fpath, const char fieldname, int rank, hsize_t dims, hid_t fieldtype, const void base, const void *delta)
F5_API F5ErrorCode	F5Fwrite_fraction (F5Path fpath, const char fieldname, int rank, const hsize_t full_dims, const hsize_t fragment_dims, hid_t fieldtype, hid_t memtype, const void dataPtr, const hsize_t datastart, const hsize_t start_border, const hsize_t end_border, const char *fraction_name, hid_t property_id)
F5_API F5ErrorCode	F5Fwrite_fractionS (F5Path fpath, const char fieldname, int rank, const hsize_t full_dims, const hsize_t fragment_dims, hid_t fieldtype, hid_t memtype, const void dataPtr, const hsize_t datastart, const hsize_t start_border, const hsize_t end_border, const char *fraction_name, hid_t property_id)
F5_API int	F5FSwrite_fraction (F5Path fpath, const char fieldname, int rank, const hsize_t full_dims, const hsize_t fragment_dims, hid_t fieldtype, hid_t memtype, const void const dataPtr, const hsize_t datastart, const hsize_t start_border, const hsize_t end_border, const char fraction_name, hid_t property_id, int AllowFullCoverage)
F5_API int	F5Fwrite_linear_fraction (F5Path fpath, const char fieldname, int rank, const hsize_t full_dims, const hsize_t fragment_dims, hid_t fieldtype, const void base, const void delta, const hsize_t datastart, const char fraction_name)
F5_API int	F5Fis_linear (F5Path fpath, const char fieldname)

Detailed Description

Interfacing data set creation/write routines using the F5Path structure. Calls the low-level Field operation functions, but is designed for the end-user.

Function Documentation

◆ F5Fclose()

F5_API void F5Fclose ( F5Path * f )

Close a field entry within an F5Path object and leave all other entries intact.

Definition at line 92 of file F5F.c.

{
        if (!f) return;
 
        if (f->Field_hid>0)
        {
                if (F5Fis_group(f) )
                        H5Gclose( f->Field_hid );
                else
                        H5Dclose( f->Field_hid );
 
                f->Field_hid = 0;
        }
}

References F5Fis_group(), F5Path::Field_hid, and H5Gclose.

Referenced by F5closeVC(), F5Cwrite_triangular_surface(), F5Fcreate(), F5Flink_triangular_surface(), F5Fopen(), F5FSwrite_fraction(), F5Fwrite_1D(), F5Fwrite_flexible(), F5Fwrite_fraction(), F5Fwrite_fraction_external(), F5Fwrite_fractionS(), F5Fwrite_linear(), F5Fwrite_linear_fraction(), F5FwriteIMAGE(), F5Fwrites(), F5FwriteX(), F5Rcreate_curvilinear_cartesian3D(), F5Rcreate_rectilinear(), F5Rcreate_uniform_cartesian3D(), F5Rcreate_uniform_cartesian3Dbbox(), F5Rcreate_uniformd(), and F5Rcreate_uniformf().

◆ F5Fcreate()

F5_API int F5Fcreate	(	F5Path *	fpath,
		const char *	fieldname,
		int	dimension,
		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.

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.
fpath	An F5 Path object that has been created by a F5Rcreate() or related calls from the F5R group. Any previous field ID contained there will be closed and overwritten.
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.

See also: F5Lcreate()

Todo: Add consistency check of sustained dataspace properties across multiple fields per representation.

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

Definition at line 328 of file F5F.c.

{
hsize_t save_dims[FIBER_MAX_RANK];
 
        F5printf(40,"F5Fcreate()");
 
        if (!fpath) return 0;
 
        F5Fclose(fpath);
 
        F5printf_indent++;
        F5B_permute_dimensions(save_dims, rank, dims, fpath->myChart->perm_vector, F5Bget_chart_dims(fpath->myChart));
        F5printf_indent--;
 
        if (!F5LTset_dataspace(fpath, rank, save_dims))
        {
                F5printf(-1, "F5Fcreate(%s): cannot create, inconsistent dataspace!", fieldname);
                return 0;
        }
 
        fpath->Field_hid = F5Lcreate(fpath->Representation_hid, fieldname,
                                     rank, save_dims,
                                     F5file_type(fpath, fieldtype), property_id);
 
        if (fpath->Field_hid<0)
        {
                F5printf(0,"F5Fcreate -> F5Lcreate() FAILED!");
                return 0;
        }
        else
                F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), Contiguous);
 
        F5I_add_field(fpath, fieldname);
 
        F5printf(40,"~F5Fcreate() ok");
        return 1;
}

References Contiguous, F5B_permute_dimensions(), F5Bget_chart_dims(), F5Fclose(), F5file_type(), F5I_add_field(), F5Lcreate(), F5LTmake_enum_type(), F5LTset_dataspace(), F5printf, F5printf_indent, F5Tset_field_enum(), FIBER_MAX_RANK, F5Path::Field_hid, F5Path::myChart, ChartDomain_IDs::perm_vector, and F5Path::Representation_hid.

◆ F5Fget_type2()

F5_API hid_t F5Fget_type2	(	F5Path *	f,
		hid_t	elink_fapl_id )

Get the data type of an field, given an F5 path.

Returns: An HDF5 datatype, caller must call H5Tclose().

Definition at line 161 of file F5F.c.

{
        return F5Lget_type(f->Field_hid, F5Fis_group(f),
                           elink_fapl_id);
}

References F5Fis_group(), F5Lget_type(), and F5Path::Field_hid.

Referenced by F5Fget_type().

◆ F5Fgrab()

F5_API hid_t F5Fgrab ( F5Path * f )

Take an HDF5 field identifier out of control of the F5Path. The path identifier is no longer pointing to a field after this operations, it is just a truncated path up to the representation group. It is the responsibility of the caller to close the returned HDF5 identifier, which can either be a group or dataset. This can be determined either by inspecting f->FieldIDisGroup or by H5Gget_objinfo() . Note that using this function allows to keep a field ID open for later use, but undermines the transparency of fields as beeing stored as either datasets or a group with multiple datasets.

Definition at line 107 of file F5F.c.

{
        if (!f) return -1;
 
        if (f->Field_hid>0)
        {
        hid_t   id = f->Field_hid;
                /*
                if (F5Fis_group(f) )
                        H5Gclose( f->Field_hid );
                else
                        H5Dclose( f->Field_hid );
                */
                f->Field_hid = 0;
                return id;
        }
        return -1;
}

References F5Path::Field_hid.

◆ F5Fis_linear()

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

Check if a field within an F5 path is a linear mapping of points to values.

Todo: Implement. Similar to F5Lread_linear().

Definition at line 1512 of file F5F.c.

{
        return F5Lis_linear(fpath->Representation_hid, fieldname);
}

References F5Lis_linear(), and F5Path::Representation_hid.

◆ F5Fopen()

F5_API int F5Fopen	(	F5Path *	f,
		const char *	fieldname )

Open a field entry within an F5Path object and leave all other entries intact. An previously opened field entry is closed before the new one is opened.

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

Note: F5 does no HDF5 error management by itself. If any error messages from HDF5 when trying to open a non-existing field shall be emitted, the application code has to set the HDF5 error handler. F5 guarantees to leave these error handlers intact, even if they are locally disabled during some operations.

Definition at line 66 of file F5F.c.

{
        F5Fclose(f);
 
        H5E_BEGIN_TRY
        f->Field_hid = H5Dopen2(f->Representation_hid, fieldname, H5P_DEFAULT);
        H5E_END_TRY
 
        if (f->Field_hid<0)
        {
                H5E_BEGIN_TRY
                f->Field_hid = H5Gopen2(f->Representation_hid, fieldname, H5P_DEFAULT);
                H5E_END_TRY
                if (f->Field_hid<0)
                {
                        F5printf(10,"F5Fopen(,%s) Path entry is neither a group nor a data set (could be a named data type)\n", fieldname);
                        return 0;
                }
        }
 
        if (f->Field_hid<0)
                return 0;
 
        return 1;
}

References F5Fclose(), F5printf, F5Path::Field_hid, and F5Path::Representation_hid.

◆ F5FopenMostRecentSlice()

F5_API F5Path * F5FopenMostRecentSlice	(	hid_t	File_id,
		double *	t,
		const char *	gridname,
		const char *	fieldname,
		const char *	coordinate_system )

References F5_API.

◆ F5FSwrite_fraction()

F5_API int F5FSwrite_fraction	(	F5Path *	fpath,
		const char *	fieldname,
		int	rank,
		const hsize_t *	full_dims,
		const hsize_t *	fragment_dims,
		hid_t	fieldtype,
		hid_t	memtype,
		const void const	dataPtr,
		const hsize_t *	datastart,
		const hsize_t *	start_border,
		const hsize_t *	end_border,
		const char *	fraction_name,
		hid_t	property_id,
		int	AllowFullCoverage )

Write a dataset given as separate components which only covers a fraction of the entire representation's domain.

Parameters

dimension	The dimension of the data set.
full_dims	The extension of the full (virtual) data set in each dimension, i.e. the size of the entire field when reconstructed from all fragments covering this field.
datastart	The (multidimensional) start index of the saved data set.
fragment_dims	The number of elements of this fraction.
fraction_name	An optional string to name this fraction. It may be NULL to use an internal default.
AllowFullCoverage	If non-zero, then the data set is not written as a fragment in case its dimensions cover the entire data space. Use this reduction option with care. This automatism might lead to bad effects, especcially it eliminates the capability to add fragments later. By default, leave this parameter at 0.

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

Returns: true

Definition at line 1157 of file F5F.c.

{
hid_t   field_id;
hsize_t full_dims[FIBER_MAX_RANK], start_dims[FIBER_MAX_RANK], ldims[FIBER_MAX_RANK],
        sborder[FIBER_MAX_RANK], eborder[FIBER_MAX_RANK];
 
        F5printf(40, "F5FSwrite_fraction()");
        F5printf_indent++;
        F5Tpermute_dimensions(fpath, rank, full_dims , dims      );
        F5Tpermute_dimensions(fpath, rank, start_dims, datastart );
        F5Tpermute_dimensions(fpath, rank, ldims     , frag_dims );
        F5Tpermute_dimensions(fpath, rank, sborder   , start_border );
        F5Tpermute_dimensions(fpath, rank, eborder   , end_border   );
 
        if (rank==3)
        {
#ifdef  DO_DATASPACE_CONSISTENCY_CHECK
                if (dims)
                {
                        F5printf(60, "F5FSwrite_fraction() : "
                          "global dims=[%d,%d,%d] datastart=[%d,%d,%d] ldims=[%d,%d,%d]",
                                 (int)dims[0], (int)dims[1], (int)dims[2],
                                 (int)datastart[0], (int)datastart[1], (int)datastart[2],
                                         (int)ldims[0],  (int)ldims[1] , (int)ldims[2]
                                );
 
                        F5printf(60, "F5FSwrite_fraction()->"
                                 "full dataset=[%d,%d,%d] start=[%d,%d,%d] ldims=[%d,%d,%d]",
                                 (int)full_dims[0], (int)full_dims[1], (int)full_dims[2],
                                 (int)start_dims[0],(int)start_dims[1],(int)start_dims[2],
                                 (int)ldims[0],  (int)ldims[1] , (int)ldims[2]
                                );
                }
                else
                {
                        F5printf(60, "F5FSwrite_fraction() : "
                          "(no global dims) datastart=[%d,%d,%d] ldims=[%d,%d,%d]",
                                 (int)datastart[0], (int)datastart[1], (int)datastart[2],
                                         (int)ldims[0],  (int)ldims[1] , (int)ldims[2]
                                );
 
                        F5printf(60, "F5FSwrite_fraction()->"
                                 "(no full data dimensions) start=[%d,%d,%d] ldims=[%d,%d,%d]",
                                 (int)start_dims[0],(int)start_dims[1],(int)start_dims[2],
                                 (int)ldims[0],  (int)ldims[1] , (int)ldims[2]
                                );
                }
#endif
        }
        F5printf_indent--;
        F5Fclose( fpath );
 
#ifdef  DO_DATASPACE_CONSISTENCY_CHECK
        if (dims)
        {
                if (!F5LTset_dataspace(fpath, rank, full_dims))
                {
                        F5printf(-1, "F5FSwrite_fraction(%s): cannot create, inconsistent dataspace!", fieldname);
                        return 0;
                }
        }
#endif
 
#if 0
        if (F5B_identical_dims(rank, full_dims, end_dims) )
                F5printf(80, "F5FSwrite_fraction(%s) dimensions cover full dataset", fieldname);
        else
                F5printf(80, "F5FSwrite_fraction(%s) dimensions do not cover full dataset", fieldname);
 
        if (F5B_iszero_dims(rank, start_dims) )
                F5printf(80, "F5FSwrite_fraction(%s) fragment starts at zero", fieldname);
        else
                F5printf(80, "F5FSwrite_fraction(%s) fragment starts at some offset", fieldname);
#endif
 
        if (AllowFullCoverage && F5B_identical_dims(rank, full_dims, ldims) && F5B_iszero_dims(rank, start_dims) )
        {
                F5printf(8, "F5FSwrite_fraction(%s) writing full dataset", fieldname);
 
                fpath->Field_hid = F5Lwrites(fpath->Representation_hid, fieldname,
                                             rank, full_dims,
                                             F5file_type(fpath, fieldtype), memtype, dataPtr,
                                             F5LTmake_enum_type(fpath), property_id);
 
                if (fpath->Field_hid<=0)
                        return -1;
 
                F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), SeparatedCompound);
                F5I_add_field(fpath, fieldname);
                F5printf(9, "~F5FSwrite_fraction(%s) writing full dataset\n", fieldname);
 
                return 1;
        }
        F5printf(8, "F5FSwrite_fraction(%s) writing dataset fragment\n", fieldname);
 
        field_id = F5LSwrite_fraction(fpath->Representation_hid, fieldname, rank, full_dims, ldims,
                                      F5file_type(fpath, fieldtype), memtype, dataPtr,
                                      datastart?start_dims:NULL,
                                      start_border?sborder:NULL, end_border?eborder:NULL,
                                      fraction_name, F5LTmake_enum_type(fpath), property_id);
 
        fpath->Field_hid = field_id;
 
        if (fpath->Field_hid<=0)
                return -1;
 
/*
        F5printf(10,"~F5FSwrite_fraction(%s) temporarily set type attribute...", fieldname);
        F5Dset_type_attribute(fpath->Field_hid, F5file_type(fpath, fieldtype) );
*/
 
        F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), FragmentedSeparatedCompound);
 
        F5I_add_field(fpath, fieldname);
 
        F5printf(9, "F5FSwrite_fraction(%s) writing dataset fragment\n", fieldname);
        return 1;
}

References F5B_iszero_dims(), F5Fclose(), F5file_type(), F5I_add_field(), F5LSwrite_fraction(), F5LTmake_enum_type(), F5LTset_dataspace(), F5Lwrites(), F5printf, F5printf_indent, F5Tpermute_dimensions(), F5Tset_field_enum(), FIBER_MAX_RANK, F5Path::Field_hid, FragmentedSeparatedCompound, F5Path::Representation_hid, and SeparatedCompound.

◆ F5Fwhatsup()

F5_API const char * F5Fwhatsup ( F5ErrorCode EC )

Return a string explaining the meaning of a certain error code.

Definition at line 367 of file F5F.c.

{
        switch(EC)
        {
        case    F5_SUCCESS:                     return "OK";
        case    F5ERROR_INVALID_FPATH:          return "Invalid Path";
        case    F5ERROR_INCONSISTENT_DATASPACE: return "Inconsistent Dataspace";
        case    F5ERROR_INVALID_FRAGMENT_START: return "Fragment starts beyond dataspace";
        case    F5ERROR_INVALID_FRAGMENT_END:   return "Fragment extends beyond dataspace";
        case    F5ERROR_ALREADY_EXISTS:         return "Object already exists";
        case    F5ERROR_COMPOUND_EXPECTED:      return "Compound type expected";
        case    F5ERROR_COMPONENTMAP_EXPECTED:  return "Component map expected";
        case    F5ERROR_COMPONENTMAP_INVALID:   return "Component map invalid";
 
        case    F5ERROR_NONSPECIFIED:           return "Unspecified error";
 
        default: return "Invalid error code (compile-time bug)";
        }
}

References F5_SUCCESS, F5ERROR_ALREADY_EXISTS, F5ERROR_COMPONENTMAP_EXPECTED, F5ERROR_COMPONENTMAP_INVALID, F5ERROR_COMPOUND_EXPECTED, F5ERROR_INCONSISTENT_DATASPACE, F5ERROR_INVALID_FPATH, F5ERROR_INVALID_FRAGMENT_END, F5ERROR_INVALID_FRAGMENT_START, and F5ERROR_NONSPECIFIED.

◆ F5Fwrite()

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

Write some data as a contiguous field under the given F5Path location with the given name.

The dimensions of the data must match exactly the dataspace of the containing Skeleton. Use F5FwriteHyperDimensional() to store a dataset that is higher-dimensional than the containing Skeleton.

Parameters

fpath	The F5Path pointing to the location of the Field. The field ID filled in. Any previous field ID contained there will be closed and overwritten.
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().

Todo: Implement, and add consistency check of sustained dataspace properties across multiple fields per representation.

Returns: error code telling the success of the write:

Definition at line 467 of file F5F.c.

{
        return F5Fwrite_flexible( fpath, fieldname, rank, dims, fieldtype, memtype, dataPtr, property_id, 1 );
}

References F5Fwrite_flexible().

Referenced by F5Fwrite_uniform_cartesian3D(), F5Rcreate_curvilinear_cartesian3D(), F5Rcreate_uniform_sparse2(), F5write_uniform_cartesian3Dv(), and saveF5image().

◆ F5Fwrite_fraction()

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

Write a dataset which only covers a fraction of the entire representation's domain. Such datasets are called "fragmented".

Parameters

fpath	An F5 Path object that has been created by a F5Rcreate() or related calls from the F5R group. Any previous field ID contained there will be closed and overwritten.
rank	The rank (dimensionality) of the data set. Maximum value 8 is set by HDF5.
full_dims	The extension of the full (virtual) data set in each dimension, i.e. the size of the entire field when reconstructed from all fragments covering this field.
datastart	The (multidimensional) start index of the saved data set. Also known as the minimum integer coordinates of this fragment in the coarse grid.
fragment_dims	The number of elements of this fraction.
fraction_name	A string to name this fraction. It may be an arbitrary name, but should be consistently used among all fragmented fields. It may be NULL to use an internal default (this feauture is not implemented yet, so please DO specify a valid name here).
property_id	An HDF5 dataset property ID. If it is negative, then a default property will be created locally via H5Pcreate(H5P_DATASET_CREATE).
start_border	The number of overlapping elements at the lower border (also known as ghost zones). It may be NULL if the fragments do no overlap.
end_border	The number of overlapping elements at the upper border (also known as ghost zones). It may be NULL if the fragments do no overlap.
fieldtype	The data type of the field as it should appear in the file.
memtype	The data type of the field as it exists in memory. It may be negative if it is identical to the field type. For instance, if an array of doubles should be written into a file in single precision, specify fieldtype=H5T_NATIVE_DOUBLE and memtype=H5T_NATIVE_FLOAT .

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

Returns: An error code telling why the function failed.

Definition at line 778 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;
 
        if (!fieldname)
        {
                F5printf(0, "F5Fwrite_fraction() invalid field name!");
                return  F5ERROR_INVALID_FIELDNAME;
        }
        if (!datastart)
        {
                F5printf(0, "F5Fwrite_fraction() for field %s has no datastart given for fragment %s",
                         fieldname, fraction_name);
                return  F5ERROR_INVALID_PARAMETERS;
        }
        if (!fraction_dims)
        {
                F5printf(0, "F5Fwrite_fraction() for field %s has no fragment dimensions given for fragment %s",
                         fieldname, fraction_name);
                return  F5ERROR_INVALID_PARAMETERS;
        }
 
        F5print_dimensions(20, "F5Fwrite_fraction", rank, fraction_dims);
 
        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
 
#if 0
        hm, we better drop this idea of automatically writing a contiguous field
        if a field covers the full dimension, because then the topology is
        no longer expandable...
 
        if (F5B_identical_dims(rank, full_dims, ldims) && F5B_identical_dims(rank, start_dims, 0) )
        {
                fpath->Field_hid = F5Lwrite(fpath->Representation_hid, fieldname,
                                            rank, full_dims,
                                            F5file_type(fpath, fieldtype), memtype, dataPtr,
                                            F5LTmake_enum_type(fpath), property_id);
 
                F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), Contigous);
                F5I_add_field(fpath, fieldname, FIBER_HDF5_REGULAR_FIELD);
 
                F5printf(30, "~F5Fwrite_fraction(%s) wrote contigous field", fieldname);
                return  F5_SUCCESS;
        }
#endif
        field_id = F5Lwrite_fraction(fpath->Representation_hid, fieldname, 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);
 
        if (field_id<=0)
        {
                F5printf(0, "F5Fwrite_fraction(%s) error in writing field, illegal ID returned from low-level function.", fieldname);
                return F5ERROR_NONSPECIFIED;
        }
        assert( field_id );
 
        fpath->Field_hid = field_id;
 
        assert( fpath->Field_hid );
 
#if     1
/*
  there must be a reason why the type attribute writing was not enabled, but forgot why...
  It should be set because type identification should be faster on reading as no iteration
  over the group is required then.
  WB 2.SEP.16 */
 
/*      F5printf(10,"~F5Fwrite_fraction(%s) temporarily set type attribute...", fieldname); */
        F5Dset_type_attribute(fpath->Field_hid, F5file_type(fpath, fieldtype) );
#endif
 
        F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), FragmentedContiguous);
 
        assert( fpath->Field_hid );
        F5I_add_field(fpath, fieldname);
 
        F5printf(30, "~F5Fwrite_fraction(%s) wrote fragmented contigous field", fieldname);
        return  F5_SUCCESS;
}

References F5_SUCCESS, F5Dset_type_attribute(), F5ERROR_INVALID_FIELDNAME, F5ERROR_INVALID_FPATH, F5ERROR_INVALID_FRAGMENT_END, F5ERROR_INVALID_FRAGMENT_START, F5ERROR_INVALID_PARAMETERS, F5ERROR_NONSPECIFIED, F5Fclose(), F5file_type(), F5I_add_field(), F5LTmake_enum_type(), F5LTset_dataspace(), F5Lwrite(), F5Lwrite_fraction(), F5print_dimensions(), F5printf, F5printf_indent, F5Tpermute_dimensions(), F5Tset_field_enum(), FIBER_MAX_RANK, F5Path::Field_hid, FragmentedContiguous, and F5Path::Representation_hid.

◆ F5Fwrite_fractionS()

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

Write a dataset given as a compound as separate components, changing the in-memory data layout.

Definition at line 913 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;
 
        F5print_dimensions(20, "F5Fwrite_fractionS", rank, fraction_dims);
 
        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_fractionS(%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_fractionS(%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_fractionS(%s): cannot create, inconsistent dataspace!", fieldname);
                        return  F5_SUCCESS; /* ??? */
                }
        }
#endif
 
        field_id = F5Lwrite_fractionS(fpath->Representation_hid, fieldname, 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);
 
        if (field_id<=0)
        {
                return F5ERROR_NONSPECIFIED;
        }
 
        fpath->Field_hid = field_id;
 
        F5printf(10,"~F5Fwrite_fractionS(%s) temporarily set type attribute...", fieldname);
        F5Dset_type_attribute(fpath->Field_hid, F5file_type(fpath, fieldtype) );
 
        F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), FragmentedSeparatedCompound);
 
        F5I_add_field(fpath, fieldname);
 
        F5printf(30, "~F5Fwrite_fraction(%s) wrote fragmented contigous field", fieldname);
        return  F5_SUCCESS;
}

References F5_SUCCESS, F5Dset_type_attribute(), F5ERROR_INVALID_FPATH, F5ERROR_INVALID_FRAGMENT_END, F5ERROR_INVALID_FRAGMENT_START, F5ERROR_NONSPECIFIED, F5Fclose(), F5file_type(), F5I_add_field(), F5LTmake_enum_type(), F5LTset_dataspace(), F5Lwrite_fractionS(), F5print_dimensions(), F5printf, F5printf_indent, F5Tpermute_dimensions(), F5Tset_field_enum(), FIBER_MAX_RANK, F5Path::Field_hid, FragmentedSeparatedCompound, and F5Path::Representation_hid.

◆ F5Fwrite_linear()

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

Write a field which is a linear mapping of a base and delta value.

Parameters

fpath	An F5Path object referring to the location where the field shall be created. It must contain a valid Representation_hid. Its Field_hid will contain a reference to the newly created Field on return. If the F5Path object already contained a valid Field_hid, then this one will be closed by this call.
rank	The rank (dimensionality) of the data set.
dims	The extension of the data set.
fieldtype	The type of the field, being compatible to base and delta.

Returns: zero, if the entry could not be opened, non-zero if successful.

Todo: Make this function compatible with F5FwriteX instead. Need to revise this function such that base and delta may be different types, for instance a point and a tangential vector. Possibly provide an alternative function where the min/max is specified instead.

Definition at line 1464 of file F5F.c.

{
hid_t   field_id;
hsize_t save_dims[FIBER_MAX_RANK];
 
        F5printf(40,"F5Fwrite_linear(%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 );
 
        F5printf_indent++;
        F5Tpermute_dimensions(fpath, rank, save_dims, dims );
        F5printf_indent--;
 
        F5Fclose( fpath );
 
        F5printf(41,"F5Fwrite_linear(%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))
        {
                F5printf(-1, "F5Fwrite_linear(%s): cannot create, inconsistent dataspace!", fieldname);
                return 0;
        }
 
        field_id = F5Lwrite_linear(fpath->Representation_hid, fieldname,
                                   rank, save_dims,
                                   F5file_type(fpath, fieldtype),
                                   base, delta);
 
        if (field_id<0) return 0; /* already exists? */
 
        {
        int     rank = H5Tget_nmembers( fieldtype );
 
                F5LAsave_dimensions(field_id, FIBER_UNIFORMARRAY_ELEMENTS_ATTRIBUTE, rank, dims);
        }
 
        fpath->Field_hid = field_id;
 
        F5Tset_field_enum(field_id, F5LTmake_enum_type(fpath), UniformSampling);
 
        F5I_add_field(fpath, fieldname);
 
        F5printf(40, "~F5Fwrite_linear()");
        return 1;
}

References F5_API, F5Fclose(), F5file_type(), F5I_add_field(), F5LAsave_dimensions(), F5LTmake_enum_type(), F5LTset_dataspace(), F5Lwrite_linear(), F5printf, F5printf_indent, F5Tpermute_dimensions(), F5Tset_field_enum(), FIBER_MAX_RANK, FIBER_UNIFORMARRAY_ELEMENTS_ATTRIBUTE, F5Path::Field_hid, F5Path::Representation_hid, and UniformSampling.

Referenced by F5Rcreate_rectilinear(), F5Rcreate_uniform_cartesian3D(), F5Rcreate_uniform_cartesian3Dbbox(), F5Rcreate_uniformd(), F5Rcreate_uniformf(), and saveF5image().

◆ F5Fwrite_linear_fraction()

F5_API int F5Fwrite_linear_fraction	(	F5Path *	fpath,
		const char *	fieldname,
		int	rank,
		const hsize_t *	full_dims,
		const hsize_t *	fragment_dims,
		hid_t	fieldtype,
		const void *	base,
		const void *	delta,
		const hsize_t *	datastart,
		const char *	fraction_name )

Write a dataset given as small "linear mappings" which only covers a fraction of the entire representation's domain. Useful to specify local bounding boxes.

Parameters

dimension	The dimension of the data set.
full_dims	The extension of the full (virtual) data set in each dimension, i.e. the size of the entire field when reconstructed from all fragments covering this field.
datastart	The (multidimensional) start index of the saved data set.
fragment_dims	The number of elements of this fraction.
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: true

See also: F5Fwrite_linear_fraction_overlap()

Definition at line 1416 of file F5F.c.

{
hid_t   F_id = F5Gappend(fpath->Representation_hid, fieldname);
hid_t   B_id;
hsize_t ldims[FIBER_MAX_RANK];
hsize_t offset[FIBER_MAX_RANK];
//int   i;
const char*fragment_name = fraction_name?fraction_name:F5Fblockname(rank, datastart);
        F5Fclose( fpath );
 
        F5printf(8, "F5Fwrite_linear_fraction(%s)\n", fieldname);
 
        F5Tpermute_dimensions(fpath, rank, ldims, local_dims );
        F5Tpermute_dimensions(fpath, rank, offset, datastart );
 
        B_id = F5Lwrite_linear(F_id, fragment_name, rank, ldims,
                               F5file_type(fpath, fieldtype),
                               base, delta);
 
        if (B_id<=0)
                return 0;
 
        F5Tset_field_enum(B_id, F5LTmake_enum_type(fpath), UniformSampling);
 
        if (full_dims)
                F5Lset_space(F_id, rank, full_dims);
 
        F5LAsave_dimensions(B_id, FIBER_FRAGMENT_OFFSET_ATTRIBUTE, rank, offset);
 
        F5Xclose(B_id);
 
        fpath->Field_hid = F_id;
 
        F5Tset_field_enum(F_id, F5LTmake_enum_type(fpath), FragmentedUniformSampling);
 
        F5I_add_field(fpath, fieldname);
 
        F5printf(9, "~F5Fwrite_linear_fraction(%s)\n", fieldname);
        return 1;
}

References F5Fclose(), F5file_type(), F5Gappend(), F5I_add_field(), F5LAsave_dimensions(), F5Lset_space(), F5LTmake_enum_type(), F5Lwrite_linear(), F5printf, F5Tpermute_dimensions(), F5Tset_field_enum(), F5Xclose(), FIBER_FRAGMENT_OFFSET_ATTRIBUTE, FIBER_MAX_RANK, F5Path::Field_hid, FragmentedUniformSampling, F5Path::Representation_hid, and UniformSampling.

◆ F5FwriteHyperDimensional()

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

Write some data as a contiguous field under the given F5Path location with the given name where the data dimensions are higher than the underlying skeleton. This functionality is useful to store data where the higher dimensions express constant, but unknown, number of data elements per point in the base space.

Definition at line 476 of file F5F.c.

{
// TODO: Implement consistency check on the base space dimensions!
 
        return F5Fwrite_flexible( fpath, fieldname, rank, dims, fieldtype, memtype, dataPtr, property_id, 0 );
}

References F5Fwrite_flexible().

◆ F5FwriteIMAGE()

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

Save a dataset according to the specifications in https://support.hdfgroup.org/HDF5/doc/ADGuide/ImageSpec.html Only rank 2 dimensions are allowed here. All other arguments will lead to an error. Note that this specification is quite inconsistent, as an rgb data set is modeled as a three-dimensional array, not a two-dimensional array of type rgb. Still, we allow this format explicitely here since it is a standard.

Definition at line 487 of file F5F.c.

{
hsize_t save_dims[FIBER_MAX_RANK];
        if (rank!=2)
        {
                F5printf(40,"F5FwriteIMAGE(%s, rank=%d, dims=%dx%dx%dx%d) INVALID RANK (must be 2)! \n", 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
                        );
                return  F5ERROR_INCONSISTENT_DATASPACE;
        }
 
        F5printf(40,"F5FwriteIMAGE(%s, rank=%d, dims=%dx%dx%dx%d)\n", 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);
 
        F5printf_indent++;
        F5Tpermute_dimensions(fpath, rank, save_dims, dims );
        F5printf_indent--;
 
        F5printf(41,"F5Fwrite(%s): permuted dims: rank=%d, dims=%dx%dx%dx%d)\n", 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))
        {
                F5printf(-1, "F5Fwrite(%s): cannot create, inconsistent dataspace!", fieldname);
                return F5ERROR_INCONSISTENT_DATASPACE;
        }
 
        if (fieldtype == F5T_RGB_REAL)
        {
                save_dims[2] = 3;
                rank = 3;
                fieldtype = H5T_NATIVE_FLOAT;
                memtype   = H5T_NATIVE_FLOAT;
                fpath->Field_hid = F5Lwrite(fpath->Representation_hid, fieldname,
                                            rank, save_dims,
                                            F5file_type(fpath, fieldtype), memtype, dataPtr,
                                            F5LTmake_enum_type(fpath),
                                            dcpl_id);
 
                if (fpath->Field_hid<=0)
                {
                        F5printf(1, "F5Fwrite_IMAGE() - FAILED to append field fragment data.");
                        return -1;
                }
 
                /* FROM: http://hdf.ncsa.uiuc.edu/HDF5/doc/ADGuide/ImageSpec.html */
                F5Asave_string(fpath->Field_hid, "CLASS", "IMAGE");
                F5Asave_string(fpath->Field_hid, "INTERLACE_MODE", "INTERLACE_PIXEL");
                F5Asave_string(fpath->Field_hid, "DISPLAY_ORIGIN", "LL");
                F5Asave_string(fpath->Field_hid, "IMAGE_VERSION",  "1.2");
                F5Asave_string(fpath->Field_hid, "IMAGE_SUBCLASS", "IMAGE_TRUECOLOR");
                F5Asave_string(fpath->Field_hid, "IMAGE_COLORMODEL", "RGB");
 
                F5Dset_type_attribute(fpath->Field_hid, F5T_RGB_REAL);
        }
        else if (fieldtype == F5T_RGB)
        {
                save_dims[2] = 3;
                rank = 3;
                fieldtype = H5T_NATIVE_UCHAR;
                memtype   = H5T_NATIVE_UCHAR;
                fpath->Field_hid = F5Lwrite(fpath->Representation_hid, fieldname,
                                            rank, save_dims,
                                            F5file_type(fpath, fieldtype), memtype, dataPtr,
                                            F5LTmake_enum_type(fpath),
                                            dcpl_id);
 
                /* FROM: http://www.hdfgroup.org/HDF5/doc/ADGuide/ImageSpec.html */
#if     0
                F5Asave_string(fpath->Field_hid, "CLASS", "IMAGE");
                F5Asave_string(fpath->Field_hid, "INTERLACE_MODE", "INTERLACE_PIXEL");
                F5Asave_string(fpath->Field_hid, "DISPLAY_ORIGIN", "LL");
                F5Asave_string(fpath->Field_hid, "IMAGE_VERSION",  "1.2");
                F5Asave_string(fpath->Field_hid, "IMAGE_SUBCLASS", "IMAGE_TRUECOLOR");
                F5Asave_string(fpath->Field_hid, "IMAGE_COLORMODEL", "RGB");
#else
                F5Asave_strings(fpath->Field_hid, "CLASS", "IMAGE",1);
                F5Asave_strings(fpath->Field_hid, "INTERLACE_MODE", "INTERLACE_PIXEL",1);
                F5Asave_strings(fpath->Field_hid, "DISPLAY_ORIGIN", "LL",1);
                F5Asave_strings(fpath->Field_hid, "IMAGE_VERSION",  "1.2",1);
                F5Asave_strings(fpath->Field_hid, "IMAGE_SUBCLASS", "IMAGE_TRUECOLOR",1);
                F5Asave_strings(fpath->Field_hid, "IMAGE_COLORMODEL", "RGB",1);
#endif
 
/*      unsigned char MinMax[] = { 0, 0xFF };
                F5Asave(fpath->Field_hid, "IMAGE_MINMAXRANGE",
                        H5T_NATIVE_UCHAR, H5T_NATIVE_UCHAR, MinMax, 2);
*/
//              F5Dset_type_attribute(fpath->Field_hid, F5T_RGB);
        }
        else if (fieldtype == H5T_NATIVE_USHORT)
        {
                save_dims[2] = 1;
                rank = 2;
                fieldtype = H5T_NATIVE_USHORT;
                memtype   = H5T_NATIVE_USHORT;
                fpath->Field_hid = F5Lwrite(fpath->Representation_hid, fieldname,
                                            rank, save_dims,
                                            F5file_type(fpath, fieldtype), memtype, dataPtr,
                                            F5LTmake_enum_type(fpath),
                                            dcpl_id);
 
                /* FROM: http://www.hdfgroup.org/HDF5/doc/ADGuide/ImageSpec.html */
#if     0
                F5Asave_string(fpath->Field_hid, "CLASS", "IMAGE");
                F5Asave_string(fpath->Field_hid, "INTERLACE_MODE", "INTERLACE_PIXEL");
                F5Asave_string(fpath->Field_hid, "DISPLAY_ORIGIN", "LL");
                F5Asave_string(fpath->Field_hid, "IMAGE_VERSION",  "1.2");
                F5Asave_string(fpath->Field_hid, "IMAGE_SUBCLASS", "IMAGE_TRUECOLOR");
                F5Asave_string(fpath->Field_hid, "IMAGE_COLORMODEL", "RGB");
#else
                F5Asave_strings(fpath->Field_hid, "CLASS", "IMAGE",1);
                F5Asave_strings(fpath->Field_hid, "DISPLAY_ORIGIN", "LL",1);
                F5Asave_strings(fpath->Field_hid, "IMAGE_VERSION",  "1.2",1);
                F5Asave_strings(fpath->Field_hid, "IMAGE_SUBCLASS", "IMAGE_GRAYSCALE",1);
#endif
        unsigned short MinMax[] = { 0, 0xFFFF };
                F5Asave(fpath->Field_hid, "IMAGE_MINMAXRANGE",
                        H5T_NATIVE_USHORT, H5T_NATIVE_USHORT, MinMax, 2);
        }
        else
        {
                fpath->Field_hid = F5Lwrite(fpath->Representation_hid, fieldname,
                                            rank, save_dims,
                                            F5file_type(fpath, fieldtype), memtype, dataPtr,
                                            F5LTmake_enum_type(fpath),
                                            dcpl_id);
        }
 
        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_API, F5_SUCCESS, F5Asave(), F5Asave_string(), F5Asave_strings(), F5Dset_type_attribute(), F5ERROR_INCONSISTENT_DATASPACE, F5ERROR_INVALID_FPATH, F5Fclose(), F5file_type(), 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_flexible().

◆ F5FwriteX()

F5_API F5ErrorCode F5FwriteX	(	F5Path *	fpath,
		const char *	fieldname,
		int	rank,
		const hsize_t	dims[],
		hid_t	fieldtype,
		hid_t	memtype,
		const void *const	dataPtr[],
		const int	polynom_order[],
		const int	component_map[],
		hid_t	property_id )

Write a field which is defined procedurally as a polynomial function of each manifold coordinate index.

Parameters

rank	Dimensionality of the base manifold
dims[rank]	Extension of the base manifold
fieldtype	The type of the field as it should appear in the file
memtype	The type of the field as it resides in memory
dataPtr[COMPONENTS]	An array of polynom coefficients for each component of fieldtype
polynom_order[COMPONENTS]	The order of each component's polynom
component_map[rank]	Mapping from manifold index to component

Definition at line 1312 of file F5F.c.

{
hid_t   field_id;
hsize_t full_dims[FIBER_MAX_RANK];
 
        F5printf(40, "F5FwriteX()");
        F5Tpermute_dimensions(fpath, rank, full_dims , dims      );
 
        if (!F5LTset_dataspace(fpath, rank, full_dims))
        {
                F5printf(-1, "F5FSwriteX(%s): cannot create, inconsistent dataspace!", fieldname);
                return F5ERROR_INCONSISTENT_DATASPACE;
        }
 
        field_id = F5LwriteX(fpath->Representation_hid, fieldname,
                             rank, dims,
                             F5file_type(fpath, fieldtype), memtype,
                             dataPtr, polynom_order,
                             component_map,
                             property_id,
                             fpath->GlobalChart_hid);
 
        if (field_id<0)
        {
                F5printf(-1, "F5FSwriteX(%s): cannot create direct product field!",
                         fieldname);
 
                if (field_id == -2) return F5ERROR_COMPOUND_EXPECTED;
                if (field_id == -3) return F5ERROR_COMPONENTMAP_EXPECTED;
                if (field_id == -4) return F5ERROR_COMPONENTMAP_INVALID;
 
                return F5ERROR_ALREADY_EXISTS;
        }
 
        F5Fclose( fpath );
        fpath->Field_hid = field_id;
 
/*
        F5printf(10,"~F5FSwrite_fraction(%s) temporarily set type attribute...", fieldname);
        F5Dset_type_attribute(fpath->Field_hid, F5file_type(fpath, fieldtype) );
*/
 
        F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), DirectProduct );
 
        F5I_add_field(fpath, fieldname);
 
        F5printf(9, "F5FSwriteX(%s) writing direct product\n", fieldname);
        return F5_SUCCESS;
}

References DirectProduct, F5_SUCCESS, F5ERROR_ALREADY_EXISTS, F5ERROR_COMPONENTMAP_EXPECTED, F5ERROR_COMPONENTMAP_INVALID, F5ERROR_COMPOUND_EXPECTED, F5ERROR_INCONSISTENT_DATASPACE, F5Fclose(), F5file_type(), F5I_add_field(), F5LTmake_enum_type(), F5LTset_dataspace(), F5LwriteX(), F5printf, F5Tpermute_dimensions(), F5Tset_field_enum(), FIBER_MAX_RANK, F5Path::Field_hid, F5Path::GlobalChart_hid, and F5Path::Representation_hid.

◆ F5Tget_space()

F5_API hid_t F5Tget_space ( F5Path * f )

Get the data space of an field, given an F5 path.

Returns: An HDF5 dataspace, caller must call H5Sclose().

Definition at line 167 of file F5F.c.

{
hsize_t dims[FIBER_MAX_RANK];
int     rank;
 
        F5printf(40, "F5Tget_space()");
 
        if (!f) return -1;
        if (f->Topology_hid<0) return -1;
 
        rank = F5LAget_dimensions(f->Topology_hid,
                                  FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE,
                                  dims);
 
        /* NOTE: This code could go into versioning-specific execution, i.e.
           do only if the version is 0.0.0
        */
#ifdef  F5_BACKWARD_COMPATIBILITY
        if (rank<0 && f->Field_hid>0)
        {
                F5printf(40, "F5Tget_space(): F5LAget_dimensions() attribute "FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE
                         " not found on enveloping Topology, inspecting dataset.");
                rank = F5LAget_dimensions(f->Field_hid,  FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE, dims);
        }
        if (rank<0 && f->Field_hid>0)
        {
                F5printf(40, "F5Tget_space(): F5LAget_dimensions() attribute "FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE
                         " not found on data set, trying old `Size' attribute\n");
                rank = F5LAget_dimensions(f->Field_hid, "Size", dims);
        }
#endif
        if (rank<0 && f->Field_hid>0 && !F5Fis_group(f) )
        {
                F5printf(40, "F5Tget_space(): no data dims attribute found, returning field's data space...\n" );
                return H5Dget_space(f->Field_hid);
        }
        if (rank<0)
        {
                F5printf(40, "F5Tget_space(): rank could not be determined...\n");
                return -1;
        }
 
        F5printf(40, "F5Tget_space(): F5LAget_dimensions() reported rank %d\n", rank);
        {
        int     i;
                for(i=0; i<rank; i++)
                {
                        if (dims[i] == 0)
                        {
                                F5printf(40, "F5Tget_space(): No topology associated...\n");
                                return -1;
                        }
                }
        }
 
        return H5Screate_simple(rank, dims, dims );
}

References F5Fis_group(), F5LAget_dimensions(), F5printf, FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE, FIBER_MAX_RANK, F5Path::Field_hid, and F5Path::Topology_hid.

Referenced by F5Tget_extent().

Functions

Detailed Description

Function Documentation

◆ F5Fclose()

◆ F5Fcreate()

◆ F5Fget_type2()

◆ F5Fgrab()

◆ F5Fis_linear()

◆ F5Fopen()

◆ F5FopenMostRecentSlice()

◆ F5FSwrite_fraction()

◆ F5Fwhatsup()

◆ F5Fwrite()

◆ F5Fwrite_fraction()

◆ F5Fwrite_fractionS()

◆ F5Fwrite_linear()

◆ F5Fwrite_linear_fraction()

◆ F5FwriteHyperDimensional()

◆ F5FwriteIMAGE()

◆ F5FwriteX()

◆ F5Tget_space()