F5L.c File Reference

#include "F5L.h"
#include "F5X.h"
#include "F5defs.h"
#include "F5private.h"
#include "F5A.h"
#include <assert.h>
#include <stdlib.h>

Go to the source code of this file.

Data Structures
struct	TypeIterationParameters

Macros
#define	MAX_BLOCKNAME   1024

Functions
int	F5Tcheck_committed (hid_t fieldtype)
hid_t	F5Lcreate (hid_t R_id, const char *fieldname, int dimension, const hsize_t *dims, hid_t fieldtype, hid_t dataset_creation_property_id)
hid_t	F5Lget_type (hid_t Field_hid, int FieldIDisGroup, hid_t fapl_id)
hid_t	F5Lget_space (hid_t Field_id)
int	F5Lset_space (hid_t Field_id, int rank, const hsize_t *dims)
int	F5Lget_compound_extent_dims (hid_t CompoundGroupID, hsize_t *dims)
hid_t	F5Lget_compound_space (hid_t CompoundGroupID)
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)
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)
hid_t	F5LwriteS (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)
int	F5LreadS (hid_t Container_id, hid_t LoadID, void *dataPtr, hid_t ElementLoadID)
hid_t	F5Lwrite_fraction (hid_t R_id, const char *fieldname, int rank, 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)
hid_t	F5Lwrite_fractionS (hid_t R_id, const char *fieldname, int rank, 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)
hid_t	F5Lwrite_fraction_external (hid_t R_id, const char *fieldname, const char *target_file_name, const char *target_obj_name, const char *prefix, int rank, const hsize_t *full_dims, const hsize_t *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)
hid_t	F5LSwrite_fraction (hid_t R_id, const char *fieldname, int rank, 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)
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)
hid_t	F5Lread_linear (hid_t F_id, hsize_t *dims, hid_t fieldtype, void *base, void *delta)
int	F5Lis_linear (hid_t Rep_id, const char *fieldname)
hid_t	F5Lwrite_entity (hid_t R_id, const char *fieldname, hid_t fieldtype, const void *value)
int	F5Dset_type_attribute (hid_t F_id, hid_t fieldtype)
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)
hid_t	F5LwriteX (hid_t R_id, 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, hid_t ProcIDLocation)

Macro Definition Documentation

MAX_BLOCKNAME

#define MAX_BLOCKNAME   1024

Fragmented Datasets

Definition at line 623 of file F5L.c.

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

Function Documentation

F5Dset_type_attribute()

int F5Dset_type_attribute	(	hid_t	F_id,
		hid_t	fieldtype )

Add an attribute to the given group that designates this group as storing multiple components of some compound data types.

Definition at line 1052 of file F5L.c.

{
hid_t   TypeAttrDS_hid;
hid_t   TypeAttr_hid;
herr_t  herr;
void    *buf;
 
        TypeAttr_hid = F5Atry_to_open( F_id, FIBER_HDF5_TYPEID_ATTRIB );
        if (TypeAttr_hid>0)
        {
                F5printf(5, "F5 Warning: F5Dset_type_attribute(): type already exists!\n");
                H5Aclose(TypeAttr_hid);
                return -1;
        }
 
        TypeAttrDS_hid = H5Screate(H5S_SCALAR);
        TypeAttr_hid = H5Acreate2(F_id, FIBER_HDF5_TYPEID_ATTRIB, fieldtype, TypeAttrDS_hid,
                                  H5P_DEFAULT, H5P_DEFAULT);
        if (TypeAttr_hid<0)
        {
                F5printf(1, "F5Dset_type_attribute::H5Acreate() failed.");
                H5Sclose(TypeAttrDS_hid);
                return -3;
        }
 
        buf = calloc( H5Tget_size(fieldtype), 1);
        herr = H5Awrite(TypeAttr_hid, fieldtype, buf);
        if (herr<0)  F5printf(1, "F5Dset_type_attribute::H5Awrite() failed.");
        H5Sclose(TypeAttrDS_hid);
        H5Aclose(TypeAttr_hid);
        free(buf);
 
        if (!F5Tcheck_committed(fieldtype))
                F5printf(0, "F5 Warning: F5Dset_type_attribute(): compound type not committed!\n");
 
        return  0;
}

References F5Atry_to_open(), F5printf, F5Tcheck_committed(), FIBER_HDF5_TYPEID_ATTRIB, and free().

Referenced by F5Fwrite_fraction(), F5Fwrite_fractionS(), F5FwriteIMAGE(), F5LSwrite_fraction(), F5LwriteS(), F5Lwrites(), and F5LwriteX().

F5Lget_space()

hid_t F5Lget_space

(

hid_t

Field_id

)

Get the dataspace of an F5 field. The field id may be a group or a dataset ID. If it has an dimensions attribute, then this one is taken for dataspace information. Otherwise, the dataspace of the dataset is used. If it's not a dataset and does not have a dimension attribute, then it's an error.

Definition at line 250 of file F5L.c.

{
hid_t   space_id, attr_id;
int     rank = -1, i, Dims[FIBER_MAX_RANK];
hsize_t dims[FIBER_MAX_RANK];
 
        F5printf(40, "-- F5Lget_space(): Determine skeleton topology.");
 
        H5E_BEGIN_TRY
        attr_id  = F5Aopen_name(Field_id, FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE);
        H5E_END_TRY
 
        if (attr_id>0)
        {
        hsize_t TotalNumber = 1;
 
                space_id = H5Aget_space(attr_id);
                rank      = H5Sget_simple_extent_npoints(space_id);
 
                F_H5Aread(attr_id, H5T_NATIVE_INT, Dims, FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE);
                H5Aclose(attr_id);
                H5Sclose(space_id);
 
                for(i=0; i<rank; i++)
                {
                        dims[i] = Dims[i];
                        TotalNumber *= dims[i];
                }
                if (TotalNumber==0) /* no known regular topology here */
                {
                        F5printf(20, "  F5Lget_space(): Unknown topology, might be complex.");
                        return -1;
                }
 
                space_id = H5Screate_simple(rank, dims, dims);
                return space_id;
        }
 
        space_id = H5Dget_space(Field_id);
        return space_id;
}

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

F5Lis_linear()

int F5Lis_linear	(	hid_t	Rep_id,
		const char *	fieldname )

Definition at line 985 of file F5L.c.

{
hid_t   attr_id, F_id;
 
        H5E_BEGIN_TRY
        F_id = H5Gopen2(Rep_id, fieldname, H5P_DEFAULT);
        H5E_END_TRY
 
        if (F_id<0)
                return 0;
 
        H5E_BEGIN_TRY
        attr_id  = F5Aopen_name(F_id, FIBER_UNIFORMARRAY_BASE_ATTRIBUTE);
        H5E_END_TRY
 
        if (attr_id<0)
        {
                puts("no "FIBER_UNIFORMARRAY_BASE_ATTRIBUTE" attribute!");
                H5Gclose( F_id );
                return 0;
        }
        H5Aclose(attr_id);
 
        H5E_BEGIN_TRY
        attr_id  = F5Aopen_name(F_id, FIBER_UNIFORMARRAY_DELTA_ATTRIBUTE);
        H5E_END_TRY
 
        if (attr_id<0)
        {
                H5Gclose( F_id );
                return 0;
        }
        H5Aclose(attr_id);
        H5Gclose( F_id );
 
        return 1;
}

References F5Aopen_name(), FIBER_UNIFORMARRAY_BASE_ATTRIBUTE, FIBER_UNIFORMARRAY_DELTA_ATTRIBUTE, and H5Gclose.

Referenced by F5Fis_linear(), F5P_is_rectilinear(), and F5P_is_uniform().

F5Lwrite_fraction_external()

hid_t F5Lwrite_fraction_external	(	hid_t	R_id,
		const char *	fieldname,
		const char *	target_file_name,
		const char *	target_obj_name,
		const char *	prefix,
		int	rank,
		const hsize_t *	full_dims,
		const hsize_t *	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 )

Definition at line 738 of file F5L.c.

{
hid_t   F_id, B_id;
 
        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_external(R_id, fieldname, target_file_name, target_obj_name, prefix );
        if (F_id<0)
        {
                F5printf(20, "F5Lwrite_fraction_external() - FAILED to create external field fragment.");
                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_external() - FAILED to append field fragment data.");
                        F5Xclose(F_id);
                        return B_id;
                }
        }
        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);
        return F_id;
}

References F5Gappend_external(), 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_external().

F5Lwrite_fractionS()

hid_t F5Lwrite_fractionS	(	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 contiguious compound data set as separated compound data into the file, which involves data transformation.

Calls F5LwriteS().

Definition at line 691 of file F5L.c.

{
hid_t   F_id, B_id;
 
        F5printf(-1, "F5Lwrite_fractionS(rank=%d)", rank);
 
        F_id = F5Gappend(R_id,  fieldname);
        if (F_id<0)
        {
                F5printf(1, "F5Lwrite_fractionS() - FAILED to append field fragment group.");
                return F_id;
        }
        {
        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);
        }
        if (B_id<0)
        {
                F5printf(1, "F5Lwrite_fractionS() - FAILED to append field fragment data.");
                F5Xclose(F_id);
                return B_id;
        }
 
        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);
        return F_id;
}

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

F5LwriteX()

hid_t F5LwriteX	(	hid_t	R_id,
		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,
		hid_t	ProcIDLocation )

Definition at line 1202 of file F5L.c.

{
hid_t   creator_id;
hid_t   F_id = -1;
int     i, comp;
int     Ncomponents;
const int MaxComponentNameLength = 16; /* component names are usually very short, maybe just one letter */
 
        if (rank==3) F5printf(10, "F5LwriteX(field=%s) %dx%dx%d", fieldname, (int)dims[0], (int)dims[1], (int)dims[2] );
        if (rank==2) F5printf(10, "F5LwriteX(field=%s) %dx%d"   , fieldname, (int)dims[0], (int)dims[1] );
        else         F5printf(10, "F5LwriteX(field=%s)\n", fieldname);
 
        if ( H5Tget_class( fieldtype ) != H5T_COMPOUND)
        {
                printf("F5 Warning: F5LwriteX(%s): type is not a compound type!\n", fieldname);
                return -2;
        }
        if (!component_map)
        {
                printf("F5 Warning: F5LwriteX(%s): no component map!\n", fieldname);
                return -3;
        }
 
        Ncomponents = H5Tget_nmembers(fieldtype);
        for(i=0; i<rank; i++)
        {
                if (component_map[i]<0 || component_map[i]>=Ncomponents)
                {
                        printf("F5 Warning: F5LwriteX(%s): invalid component map!\n", fieldname);
                        return -4;
                }
        }
 
        if (!F5Tcheck_committed(fieldtype))
                printf("F5 Warning: F5LwriteX(%s): type not committed?!\n", fieldname);
 
        F_id = F5Gcreate(R_id, fieldname, Ncomponents, MaxComponentNameLength);
        if (F_id<0)
        {
                F5printf(1, "**F5LwriteX(%s) could not create direct product group!", fieldname);
                return -1;
        }
 
        creator_id = property_id<0 ? H5Pcreate(H5P_DATASET_CREATE) : property_id;
 
        F5Dset_type_attribute(F_id,  fieldtype);
        F5Asave_ints(F_id, FIBER_HDF5_COMPONENTMAP_ATTRIB, component_map, rank);
 
        for(comp=0; comp<Ncomponents; comp++)
        {
        hid_t   ds_id;
        hid_t   id, ComponentType, MemComponentType;
        char       * ComponentName;
        const void * data = dataPtr[comp];
        herr_t  herr;
        hsize_t poly_order = polynom_order[comp];
/*      hsize_t extent     = dims[comp]; */
 
                if (!data) continue;
                ComponentName = H5Tget_member_name(fieldtype, comp);
                ComponentType = H5Tget_member_type(fieldtype, comp);
                if (memtype)
                {
                int     mem_idx = H5Tget_member_index(memtype, ComponentName);
                        if (mem_idx<0)
                        {
                                F5printf(10, "**F5LwriteX(%s) could not find memory equivalent of save component %s!",
                                         fieldname, ComponentName);
                                MemComponentType = ComponentType;
                        }
                        else
                        {
                                data             = dataPtr[mem_idx];
                                poly_order       = polynom_order[mem_idx];
/*                              extent           = dims[mem_idx]; */
                                MemComponentType = H5Tget_member_type(memtype, mem_idx);
 
                                F5printf(10, "F5LwriteX(%s): member type %s : %d -> %d (polynomial order %d, data at %p)",
                                         fieldname, ComponentName, mem_idx, comp, (int)(poly_order), data);
 
                                if (!data)
                                {
                                        F5printf(10, "F5LwriteX(%s): member type %s : No polynom data - member not saved!",
                                                 fieldname, ComponentName );
 
                                        H5free_memory(ComponentName);
                                        H5Tclose(ComponentType);
                                        continue;
                                }
                        }
                }
                else
                {
                        MemComponentType = ComponentType;
                        F5printf(10, "F5LwriteX(%s): no component type remapping...", fieldname);
                }
 
                ds_id = H5Screate_simple(1, &poly_order, NULL);
                id    = H5Dcreate2(F_id, ComponentName, ComponentType, ds_id, creator_id, H5P_DEFAULT, H5P_DEFAULT);
                if (id<0)
                {
                        F5printf(1, "**F5LwriteX(%s) could not create component %s!",
                                 fieldname, ComponentName);
                }
 
                herr  = H5Dwrite(id, MemComponentType, H5S_ALL, H5S_ALL, H5P_DEFAULT, data);
                if (herr<0)
                {
                        F5printf(1, "**F5LwriteX(%s) could not save component %s!",
                                 fieldname, ComponentName);
                }
 
                F5printf(1, "**F5LwriteX() set field ProcArray enum...");
                if (poly_order>0)
                        F5Tset_field_ProcArray_enum(id, PolynomialProcArray, ProcIDLocation);
                else
                        F5Tset_field_ProcArray_enum(id, ExplicitProcArray, ProcIDLocation);
 
                H5Dclose(id);
                H5Sclose(ds_id);
 
                H5free_memory(ComponentName);
                H5Tclose(ComponentType);
        }
 
        if (property_id<0)
                H5Pclose(creator_id);
 
        F5printf(10, "~F5LwriteX(%s), id=%d\n", fieldname, F_id);
        return F_id;
}

References ExplicitProcArray, F5Asave_ints(), F5Dset_type_attribute(), F5Gcreate(), F5printf, F5Tcheck_committed(), F5Tset_field_ProcArray_enum(), FIBER_HDF5_COMPONENTMAP_ATTRIB, H5Tclose(), and PolynomialProcArray.

Referenced by F5FwriteX().

F5Tcheck_committed()

int F5Tcheck_committed

(

hid_t

fieldtype

)

Check whether the specified type is already committed in the file. This is only relevant for compound structures.

Definition at line 34 of file F5L.c.

{
        F5printf(200, "F5Tcheck_committed()" );
        switch(H5Tget_class( fieldtype ) )
        {
        case H5T_COMPOUND:
                if (H5Tcommitted(fieldtype)>0)
                        return 1;
                return 0;
 
        default:
                return 1;
        }
}

References F5printf.

Referenced by F5Dset_type_attribute(), F5Lwrite(), F5Lwrite_linear(), F5LwriteS(), F5Lwrites(), and F5LwriteX().