F5types.h File Reference

#include "hdf5inc.h"
#include "F5defs.h"
#include "F5WinDLLApi.h"
#include <stdint.h>

Go to the source code of this file.

Data Structures
struct	F5_rgb_t
struct	F5_rgba_t
struct	F5_bgr_t
struct	F5_rgb16_t
struct	F5_rgba16_t
struct	F5_rgb_real_t
struct	F5_rgba_real_t
struct	F5Ttensor_t

Macros
#define	F5T_RGB   F5T_rgb_g()
#define	F5T_RGBA   F5T_rgba_g()
#define	F5T_BGR   F5T_bgr_g()
#define	F5T_RGB16   F5T_rgb16_g()
#define	F5T_RGBA16   F5T_rgba16_g()
#define	F5T_RGB_REAL   F5T_rgb_real_g()
#define	F5T_RGBA_REAL   F5T_rgba_real_g()

Typedefs
typedef unsigned char	F5_byte_t
typedef unsigned char	F5_uint8_t
typedef unsigned short	F5_int16_t
typedef F5_int16_t	F5_uint16_t
typedef uint32_t	F5_uint32_t
typedef uint64_t	F5_uint64_t
typedef int32_t	F5_int32_t
typedef float	F5_float_t
typedef double	F5_double_t

Functions
F5_API hid_t	F5T_rgb_g ()
F5_API hid_t	F5T_rgba_g ()
F5_API hid_t	F5T_bgr_g ()
F5_API hid_t	F5T_rgb16_g ()
F5_API hid_t	F5T_rgba16_g ()
F5_API hid_t	F5T_rgb_real_g ()
F5_API hid_t	F5T_rgba_real_g ()
F5_API hid_t	F5T_vec3_double_g ()
F5_API F5Ttensor_t *	newF5Ttensor (const char *name, int rank, int dimension, int components)
F5_API F5Ttensor_t *	F5Ttensor_commit (hid_t loc_id, F5Ttensor_t *)
F5_API int	deleteF5Ttensor (F5Ttensor_t *)
F5_API int	F5Tis_convertible (hid_t first_type, hid_t second_type)
F5_API hid_t	F5Ttransient_F5field_Array_enum ()
F5_API hid_t	F5Tsave_F5field_enum (hid_t loc_id)
F5_API herr_t	F5Tset_field_enum (hid_t loc_id, hid_t enum_type_id, ArrayType what)
F5_API const char *	F5Tget_field_description (ArrayType what)
F5_API ArrayType	F5Tget_field_Array_enum (hid_t loc_id, int *major_version, int *minor_version, int *release_version)
F5_API herr_t	F5Tset_field_ProcArray_enum (hid_t loc_id, ProceduralArrayType what, hid_t ProcIDLocation)
F5_API ProceduralArrayType	F5Tget_field_ProcArray_enum (hid_t loc_id, hid_t enum_type_id, int *major_version, int *minor_version, int *release_version)
F5_API void	F5Tprint (hid_t type)

Macro Definition Documentation

F5T_BGR

#define F5T_BGR   F5T_bgr_g()

Definition at line 39 of file F5types.h.

F5T_RGB

#define F5T_RGB   F5T_rgb_g()

Examples

ObjtoF5.c.

Definition at line 37 of file F5types.h.

Referenced by F5Fwrite_flexible(), and F5FwriteIMAGE().

F5T_RGB16

#define F5T_RGB16   F5T_rgb16_g()

Definition at line 40 of file F5types.h.

F5T_RGB_REAL

#define F5T_RGB_REAL   F5T_rgb_real_g()

Definition at line 42 of file F5types.h.

Referenced by F5Fwrite_flexible(), F5FwriteIMAGE(), and saveF5image().

F5T_RGBA

#define F5T_RGBA   F5T_rgba_g()

Definition at line 38 of file F5types.h.

F5T_RGBA16

#define F5T_RGBA16   F5T_rgba16_g()

Definition at line 41 of file F5types.h.

F5T_RGBA_REAL

#define F5T_RGBA_REAL   F5T_rgba_real_g()

Definition at line 43 of file F5types.h.

Typedef Documentation

F5_byte_t

typedef unsigned char F5_byte_t

Definition at line 16 of file F5types.h.

F5_double_t

typedef double F5_double_t

Definition at line 25 of file F5types.h.

F5_float_t

typedef float F5_float_t

Definition at line 24 of file F5types.h.

F5_int16_t

typedef unsigned short F5_int16_t

Definition at line 19 of file F5types.h.

F5_int32_t

typedef int32_t F5_int32_t

Definition at line 23 of file F5types.h.

F5_uint16_t

typedef F5_int16_t F5_uint16_t

Definition at line 20 of file F5types.h.

F5_uint32_t

typedef uint32_t F5_uint32_t

Definition at line 21 of file F5types.h.

F5_uint64_t

typedef uint64_t F5_uint64_t

Definition at line 22 of file F5types.h.

F5_uint8_t

typedef unsigned char F5_uint8_t

Definition at line 17 of file F5types.h.

Function Documentation

deleteF5Ttensor()

F5_API int deleteF5Ttensor

(

F5Ttensor_t *

This

)

Remove a tensor description.

Definition at line 622 of file F5types.c.

{
        delete(This->name);
        if (This->type_id>0)
                H5Tclose(This->type_id);
 
        delete(This->indexing);
        delete(This->parity);
        delete(This->covariance);
        delete(This->reverse_indexing);
        delete(This->metric);
        delete(This->transformation_rule);
        return 1;
}

References F5Ttensor_t::covariance, F5_API, H5Tclose(), F5Ttensor_t::indexing, F5Ttensor_t::metric, F5Ttensor_t::name, F5Ttensor_t::parity, F5Ttensor_t::reverse_indexing, F5Ttensor_t::transformation_rule, and F5Ttensor_t::type_id.

F5T_bgr_g()

F5_API hid_t F5T_bgr_g

(

)

Definition at line 50 of file F5types.c.

{
static  hid_t id = -1;
        if (id<0)
        {
                id = H5Tcreate(H5T_COMPOUND, 3);
                H5Tinsert(id, "b", 0, H5T_NATIVE_UCHAR);
                H5Tinsert(id, "g", 1, H5T_NATIVE_UCHAR);
                H5Tinsert(id, "r", 2, H5T_NATIVE_UCHAR);
        }
        return id;
}

F5T_rgb16_g()

F5_API hid_t F5T_rgb16_g

(

)

Definition at line 64 of file F5types.c.

{
static  hid_t id = -1;
        if (id<0)
        {
                id = H5Tcreate(H5T_COMPOUND, 6);
                H5Tinsert(id, "r", 0, H5T_NATIVE_USHORT);
                H5Tinsert(id, "g", 2, H5T_NATIVE_USHORT);
                H5Tinsert(id, "b", 4, H5T_NATIVE_USHORT);
        }
        return id;
}

F5T_rgb_g()

F5_API hid_t F5T_rgb_g

(

)

Definition at line 23 of file F5types.c.

{
static  hid_t id = -1;
        if (id<0)
        {
                id = H5Tcreate(H5T_COMPOUND, 3);
                H5Tinsert(id, "r", 0, H5T_NATIVE_UCHAR);
                H5Tinsert(id, "g", 1, H5T_NATIVE_UCHAR);
                H5Tinsert(id, "b", 2, H5T_NATIVE_UCHAR);
        }
        return id;
}

F5T_rgb_real_g()

F5_API hid_t F5T_rgb_real_g

(

)

Definition at line 92 of file F5types.c.

{
static  hid_t id = -1;
        if (id<0)
        {
                id = H5Tcreate(H5T_COMPOUND, 12);
                H5Tinsert(id, "r", 0, H5T_NATIVE_FLOAT);
                H5Tinsert(id, "g", 4, H5T_NATIVE_FLOAT);
                H5Tinsert(id, "b", 8, H5T_NATIVE_FLOAT);
        }
        return id;
}

F5T_rgba16_g()

F5_API hid_t F5T_rgba16_g

(

)

Definition at line 78 of file F5types.c.

{
static  hid_t id = -1;
        if (id<0)
        {
                id = H5Tcreate(H5T_COMPOUND, 4*2);
                H5Tinsert(id, "r", 0, H5T_NATIVE_USHORT);
                H5Tinsert(id, "g", 2, H5T_NATIVE_USHORT);
                H5Tinsert(id, "b", 4, H5T_NATIVE_USHORT);
                H5Tinsert(id, "a", 6, H5T_NATIVE_USHORT);
        }
        return id;
}

F5T_rgba_g()

F5_API hid_t F5T_rgba_g

(

)

Definition at line 36 of file F5types.c.

{
static  hid_t id = -1;
        if (id<0)
        {
                id = H5Tcreate(H5T_COMPOUND, 4);
                H5Tinsert(id, "r", 0, H5T_NATIVE_UCHAR);
                H5Tinsert(id, "g", 1, H5T_NATIVE_UCHAR);
                H5Tinsert(id, "b", 2, H5T_NATIVE_UCHAR);
                H5Tinsert(id, "a", 3, H5T_NATIVE_UCHAR);
        }
        return id;
}

F5T_rgba_real_g()

F5_API hid_t F5T_rgba_real_g

(

)

Definition at line 105 of file F5types.c.

{
static  hid_t id = -1;
        if (id<0)
        {
                id = H5Tcreate(H5T_COMPOUND, 4*sizeof(float) );
                H5Tinsert(id, "r", 0, H5T_NATIVE_FLOAT);
                H5Tinsert(id, "g", 4, H5T_NATIVE_FLOAT);
                H5Tinsert(id, "b", 8, H5T_NATIVE_FLOAT);
                H5Tinsert(id, "a",12, H5T_NATIVE_FLOAT);
        }
        return id;
}

F5T_vec3_double_g()

F5_API hid_t F5T_vec3_double_g

(

)

Definition at line 150 of file F5types.c.

{
static  hid_t id = -1;
        if (id<0)
        {
                id = H5Tcreate(H5T_COMPOUND, 24);
                H5Tinsert(id, "Dx",               0, H5T_NATIVE_DOUBLE);
                H5Tinsert(id, "Dy",  sizeof(double), H5T_NATIVE_DOUBLE);
                H5Tinsert(id, "Dz",2*sizeof(double), H5T_NATIVE_DOUBLE);
        }
        return id;
}

F5Tget_field_Array_enum()

F5_API ArrayType F5Tget_field_Array_enum	(	hid_t	loc_id,
		int *	major_version,
		int *	minor_version,
		int *	release_version )

Get the field type for a field, which is supposed to be an HDF5 group or dataset.

We try to open an attribute named FIBER_ARRAY_TYPE_ENUM, its type is supposed to be a named data type bound to the file. The attributes of this type will be the version number information for the given loc_id . The value of this attribute will be an enum compatible with the ArrayType enum from which the information is retrieved. There are some fallback mechanisms in case there are troubles, such as no such attribute existing.

Definition at line 305 of file F5types.c.

{
hid_t   attr_id;
ArrayType what = UnknownArrayType;
hid_t   type_id;
herr_t  err = -1;
 
        if (major_version)   *major_version = 0;
        if (minor_version)   *minor_version = 0;
        if (release_version) *release_version = 0;
 
        attr_id = F5Atry_to_open(loc_id, FIBER_ARRAY_TYPE_ENUM);
        if (attr_id<0)
        {
                F5printf(10, "F5Tget_field_Array_enum(): No type enum attribute.");
                attr_id = F5Atry_to_open(loc_id, FIBER_UNIFORMARRAY_BASE_ATTRIBUTE);
#ifdef  F5_BACKWARD_COMPATIBILITY
                if (attr_id>0)
                {
                        H5Aclose(attr_id);
                        return UniformSampling;
                }
                /* This is guessing for the best match... */
                {
                H5I_type_t ObjectType = H5Iget_type(loc_id);
                        switch (ObjectType)
                        {
                        case H5I_DATASET:
                                /* Need to check for dataset's dataspace here.
                                   Could be constant as well.
                                */
                                return Contiguous;
 
                        default: ;
                        }
                }
#endif
                return UnknownArrayType;
        }
        type_id = H5Aget_type(attr_id);
 
        if (H5Tcommitted(type_id)<=0)
        {
                F5printf(-1, "F5Tget_field_enum(): Attribute " FIBER_ARRAY_TYPE_ENUM " is NOT a named type, cannot retrieve versioning information.");
        }
        else
        {
                F5Aget_version(type_id, major_version, minor_version, release_version);
        }
 
        /*
          NOTE: We must use the transient memory type here, such that
          we get byteorder conversion of the enum int type.
          We MUST NOT use the file type for reading!
        */
        H5E_BEGIN_TRY
        err = F_H5Aread(attr_id, F5Ttransient_F5field_Array_enum(), &what, FIBER_ARRAY_TYPE_ENUM);
        H5E_END_TRY
 
        /*
          enum types don't match, so that could be an old F5 file,
          and we'll do some wild guess here now what it could be.
         */
        if (err<0)
        {
                F5printf(-1, "F5Tget_field_enum(): Attribute " FIBER_ARRAY_TYPE_ENUM " enum types do no match, thus assume uniform field if subgroup.");
 
        H5I_type_t ObjectType = H5Iget_type(loc_id);
                switch (ObjectType)
                {
                case H5I_DATASET:
                        what = Contiguous;
                        break;
 
                case H5I_GROUP:
                        /*
                          This check could be more advanced and look for the origin/delta attributes
                          in the subgroup. If those are no there, we may assume the field to be
                          fragmented instead - possibly contiguously fragmented or also uniform fragmented
                          if the subgroup has origin/delta attributes.
                         */
                        what = UniformSampling;
                        break;
 
                default:
                        what = UnknownArrayType;
                }
        }
 
        H5Aclose(attr_id);
        H5Tclose(type_id);
 
        return what;
}

References Contiguous, F5Aget_version(), F5Atry_to_open(), F5printf, F5Ttransient_F5field_Array_enum(), F_H5Aread(), FIBER_ARRAY_TYPE_ENUM, FIBER_UNIFORMARRAY_BASE_ATTRIBUTE, H5Tclose(), UniformSampling, and UnknownArrayType.

Referenced by F5Fget_field_enum().

F5Tget_field_description()

F5_API const char * F5Tget_field_description

(

ArrayType

what

)

Return a human-readable description of the array type, for convenience on console or log file outputs.

Definition at line 249 of file F5types.c.

{
        switch(what)
        {
        case UnknownArrayType           :       return "UnknownArrayType";
        case Contiguous                 :       return "Contiguous";
        case SeparatedCompound          :       return "SeparatedCompound";
        case Constant                   :       return "Constant";
        case FragmentedContiguous       :       return "FragmentedContiguous";
        case FragmentedSeparatedCompound:       return "FragmentedSeparatedCompound";
        case DirectProduct              :       return "DirectProduct";
        case IndexPermutation           :       return "IndexPermutation";
        case UniformSampling            :       return "UniformSampling";
        case FragmentedUniformSampling  :       return "FragmentedUniformSampling";
        }
        return  "";
}

References Constant, Contiguous, DirectProduct, FragmentedContiguous, FragmentedSeparatedCompound, FragmentedUniformSampling, IndexPermutation, SeparatedCompound, UniformSampling, and UnknownArrayType.

F5Tget_field_ProcArray_enum()

F5_API ProceduralArrayType F5Tget_field_ProcArray_enum	(	hid_t	loc_id,
		hid_t	enum_type_id,
		int *	major_version,
		int *	minor_version,
		int *	release_version )

Definition at line 490 of file F5types.c.

{
hid_t   attr_id;
ProceduralArrayType what;
hid_t   type_id;
        attr_id = F5Aopen_name(loc_id, FIBER_ARRAY_TYPE_ENUM);
        type_id = H5Aget_type(attr_id);
 
        if (H5Tcommitted(type_id)<=0)
        {
                F5printf(-1, "F5Tget_field_enum(): Not a named type, cannot retrieve versioning information.");
        }
        /*
          NOTE: We must use the transient memory type here, such that
          we get byteorder conversion of the enum int type.
          We MUST NOT use the file type for reading!
         */
        F_H5Aread(attr_id, F5Ttransient_ProcArray_enum(), &what, FIBER_ARRAY_TYPE_ENUM);
        F5Aget_version(type_id, major_version, minor_version, release_version);
        H5Aclose(attr_id);
        H5Tclose(type_id);
 
        return what;
}

References F5Aget_version(), F5Aopen_name(), F5printf, F5Ttransient_ProcArray_enum(), F_H5Aread(), FIBER_ARRAY_TYPE_ENUM, and H5Tclose().

F5Tis_convertible()

F5_API int F5Tis_convertible	(	hid_t	first_type,
		hid_t	second_type )

Check if the two types are equivalent. This requires that each type of a compound type has the the same name and the same class. Also, all attributes must be equal.

Definition at line 637 of file F5types.c.

{
/*herr_t (*old_func)(void*);*/
/*void *old_client_data; */
H5T_cdata_t *pcdata;
H5T_conv_t c;
int     i;
hid_t   class_src_id,
        class_dst_id;
 
        F5printf(200, "F5Tis_convertible(%d,%d)", src_id, dst_id);
 
        class_src_id = H5Tget_class(src_id);
        class_dst_id = H5Tget_class(dst_id);
 
//printf("F5Tis_convertible(%d,%d)\n", src_id, dst_id);
//if (class_src_id == H5T_COMPOUND) puts("src is compound");
//if (class_dst_id == H5T_COMPOUND) puts("dst is compound");
 
        if (class_src_id == H5T_COMPOUND && class_dst_id == H5T_COMPOUND)
        {
        int     src_n = H5Tget_nmembers(src_id),
                dst_n = H5Tget_nmembers(dst_id);
 
//      printf("src[%d], dst[%d]\n", src_n, dst_n);
 
                if (src_n != dst_n)
                        return 0;
 
                for(i=0; i<src_n; i++)
                {
                char * src_name = H5Tget_member_name(src_id, i ),
                     * dst_name = H5Tget_member_name(dst_id, i );
 
                int     ok = strcmp(src_name, dst_name)==0;
 
//                      printf("-> {%s} {%s}\n", src_name, dst_name);
 
                        H5free_memory(src_name);
                        H5free_memory(dst_name);
 
                        if (!ok)
                                return 0;
                }
        }
 
        H5E_BEGIN_TRY
        c = H5Tfind(src_id, dst_id, &pcdata );
        H5E_END_TRY
 
        return c!=NULL;
}

References F5printf, and ok.

F5Tprint()

F5_API void F5Tprint

(

hid_t

type

)

Prints type info

Definition at line 695 of file F5types.c.

{
        printf("F5Tprint started\n");
 
                IFITEM(H5T_NATIVE_CHAR,type)
                IFITEM(H5T_NATIVE_SHORT,type)
                IFITEM(H5T_NATIVE_INT ,type)
                IFITEM(H5T_NATIVE_LONG ,type)
                IFITEM(H5T_NATIVE_LLONG ,type)
                IFITEM(H5T_NATIVE_USHORT ,type)
                IFITEM(H5T_NATIVE_UINT ,type)
                IFITEM(H5T_NATIVE_ULONG ,type)
                IFITEM(H5T_NATIVE_ULLONG ,type)
                IFITEM(H5T_NATIVE_FLOAT ,type)
                IFITEM(H5T_NATIVE_DOUBLE ,type)
                IFITEM(H5T_NATIVE_LDOUBLE ,type)
                IFITEM(H5T_NATIVE_INT8 ,type)
                IFITEM(H5T_NATIVE_INT16 ,type)
                IFITEM(H5T_NATIVE_INT32 ,type)
                IFITEM(H5T_NATIVE_INT64 ,type)
                IFITEM(H5T_NATIVE_UCHAR ,type)
//              IFITEM(F5T_COORD3_FLOAT, type)
//              IFITEM(F5T_COORD3_DOUBLE, type)
 
        printf("F5Tprint(): UNKNOWN TYPE\n");
}

References F5_API, and IFITEM.

F5Tsave_F5field_enum()

F5_API hid_t F5Tsave_F5field_enum

(

hid_t

loc_id

)

Create a named field type for F5 array descriptions by saving the transient enum type to a file.

Definition at line 222 of file F5types.c.

{
hid_t   type_id;
 
        /* Try to open existing field ID first. */
 
        H5E_BEGIN_TRY
        type_id = H5Topen2(loc_id, FIBER_ARRAY_TYPE_ENUM, H5P_DEFAULT);
        H5E_END_TRY
 
        if (type_id<0)
        {
                type_id = H5Tcopy( F5Ttransient_F5field_Array_enum() );
 
                H5Tcommit2(loc_id,  FIBER_ARRAY_TYPE_ENUM, type_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
 
                F5Asave_string(type_id, FIBER_VERSION_URL_LOCATION, FIBER_VERSION_URL);
                F5Asave_version(type_id, FIBER_MAJOR_VERSION, FIBER_MINOR_VERSION, FIBER_RELEASE_VERSION);
        }
        else
        {
                F5printf(30, "F5Tsave_F5field_enum() Warning: No version check implemented yet!");
        }
 
        return type_id;
}

References F5Asave_string(), F5Asave_version(), F5printf, F5Ttransient_F5field_Array_enum(), FIBER_ARRAY_TYPE_ENUM, FIBER_MAJOR_VERSION, FIBER_MINOR_VERSION, FIBER_RELEASE_VERSION, FIBER_VERSION_URL, and FIBER_VERSION_URL_LOCATION.

Referenced by F5LTmake_enum_type().

F5Tset_field_enum()

F5_API herr_t F5Tset_field_enum	(	hid_t	loc_id,
		hid_t	enum_type_id,
		ArrayType	what )

Set a field type in a file.

Definition at line 268 of file F5types.c.

{
hid_t   space_id = H5Screate(H5S_SCALAR);
hid_t   attr_id;
herr_t  err;
 
        if (loc_id < 0)
        {
                F5printf(30, "F5Tset_field_enum(%lli,%d): Called with invalid location ID!", loc_id, what);
                H5Sclose(space_id);
                return -1;
        }
 
        F5printf(30, "F5Tset_field_enum(%lli,%d)", loc_id, what);
 
        H5E_BEGIN_TRY
        attr_id = H5Acreate2(loc_id, FIBER_ARRAY_TYPE_ENUM, enum_type_id, space_id, H5P_DEFAULT, H5P_DEFAULT);
        H5E_END_TRY
 
        if (attr_id<0)
        {
                F5printf(30, "F5Tset_field_enum(): Overwriting Field Typeinfo (last one counts!)");
 
                F5check( H5Adelete(loc_id, FIBER_ARRAY_TYPE_ENUM) );
                attr_id = H5Acreate2(loc_id, FIBER_ARRAY_TYPE_ENUM, enum_type_id, space_id, H5P_DEFAULT, H5P_DEFAULT);
        }
 
        err = H5Awrite(attr_id, enum_type_id, &what);
 
        if (err<0)
                F5printf(30, "F5Tset_field_enum(%lli)::H5Awrite() returned %d\n", loc_id, err);
 
        H5Aclose(attr_id);
        H5Sclose(space_id);
        return 0;
}

References F5check, F5printf, and FIBER_ARRAY_TYPE_ENUM.

Referenced by F5Fcreate(), F5FSwrite_fraction(), F5Fwrite_1D(), F5Fwrite_flexible(), F5Fwrite_fraction(), F5Fwrite_fraction_external(), F5Fwrite_fractionS(), F5Fwrite_linear(), F5Fwrite_linear_fraction(), F5FwriteIMAGE(), F5Fwrites(), F5FwriteX(), F5Lwrite(), F5LwriteS(), and F5Lwrites().

F5Tset_field_ProcArray_enum()

F5_API herr_t F5Tset_field_ProcArray_enum	(	hid_t	loc_id,
		ProceduralArrayType	what,
		hid_t	ProcIDLocation )

Set the array type of a procedural array.

Parameters

ProcIDLocation

Group ID where the enumeration type is stored in the file.

Definition at line 455 of file F5types.c.

{
hid_t   space_id = H5Screate(H5S_SCALAR);
hid_t   attr_id;
herr_t  err;
hid_t   enum_type_id;
 
        F5printf(30, "F5Tset_field_ProcArray_enum(%d,%d)", loc_id, what);
 
        enum_type_id = F5Tsave_ProcArray_enum(ProcTypeIdLocation);
 
        H5E_BEGIN_TRY
        attr_id = H5Acreate2(loc_id, FIBER_ARRAY_TYPE_ENUM, enum_type_id, space_id, H5P_DEFAULT, H5P_DEFAULT);
        H5E_END_TRY
 
        if (attr_id<0)
        {
                F5printf(30, "F5Tset_field_ProcArray_enum(): Overwriting Field Typeinfo (last one counts!)");
 
                F5check( H5Adelete(loc_id, FIBER_ARRAY_TYPE_ENUM) );
                attr_id = H5Acreate2(loc_id, FIBER_ARRAY_TYPE_ENUM, enum_type_id, space_id, H5P_DEFAULT, H5P_DEFAULT);
        }
 
        err = H5Awrite(attr_id, enum_type_id, &what);
 
        if (err<0)
                F5printf(30, "F5Tset_field_ProcArray_enum(%d)::H5Awrite() returned %d\n", loc_id, err);
 
        H5Aclose(attr_id);
        H5Sclose(space_id);
        H5Tclose(enum_type_id);
        return 0;
}

References F5check, F5printf, F5Tsave_ProcArray_enum(), FIBER_ARRAY_TYPE_ENUM, and H5Tclose().

Referenced by F5LwriteX().

F5Ttensor_commit()

F5_API F5Ttensor_t * F5Ttensor_commit	(	hid_t	loc_id,
		F5Ttensor_t *	)

Save tensor type to file and return a copy. All internal arrays are copied, no reference counting.

References F5_API.

F5Ttransient_F5field_Array_enum()

F5_API hid_t F5Ttransient_F5field_Array_enum

(

)

Get a field type for F5 array descriptions.

Definition at line 189 of file F5types.c.

{
        /*
          Note: This transient type ID will never be closed.
         */
static  hid_t type_id = -1;
int     enum_value;
 
        if (type_id>0) return type_id;
 
        type_id = H5Tenum_create(H5T_NATIVE_INT);
#define InsertEnum(type_id, enum_member) enum_value=enum_member; \
                        H5Tenum_insert(type_id, #enum_member, &enum_value);
 
        InsertEnum(type_id, UnknownArrayType);
        InsertEnum(type_id, Contiguous);
        InsertEnum(type_id, SeparatedCompound);
        InsertEnum(type_id, Constant);
        InsertEnum(type_id, FragmentedContiguous);
        InsertEnum(type_id, FragmentedSeparatedCompound);
        InsertEnum(type_id, DirectProduct);
        InsertEnum(type_id, IndexPermutation);
        InsertEnum(type_id, UniformSampling);
        InsertEnum(type_id, FragmentedUniformSampling);
 
/*      enum alias?
        enum_value = Contiguous;
        H5Tenum_insert(type_id, "Contigous", &enum_value);
*/
 
        return type_id;
}

References Constant, Contiguous, DirectProduct, FragmentedContiguous, FragmentedSeparatedCompound, FragmentedUniformSampling, IndexPermutation, InsertEnum, SeparatedCompound, UniformSampling, and UnknownArrayType.

Referenced by F5Fwrite_fraction_external(), F5Tget_field_Array_enum(), and F5Tsave_F5field_enum().

newF5Ttensor()

F5_API F5Ttensor_t * newF5Ttensor	(	const char *	name,
		int	rank,
		int	dimension,
		int	components )

Create a new tensor type description. All arrays are allocated, but set to zero.

Parameters

name	A descriptive name, eg. vector, covector, metric, Christoffel, Riemann, Ricci ... Be careful to choose a meaningful name and distringuish among the type of the tensor an various instances of this type. For instance, "Ricci" is not necessarily a good name, as it is a symmetric tensor of rank two, exactly the same as the metric. So in practice these should be two tensor fields of different names bu with the same type.
rank	The rank of the tensor field, e.g. 2 for a two-form. Note that covariance properties need to be set in the covariance array.
dimension	The dimensions of the base manifold.
components	The actual number of variables that need to be kept in memory. Due to symmetry/asymmetry relationships, this might only be a subset of the full set of components.

Create a new tensor type description. All arrays are allocated, but set to zero.

Definition at line 552 of file F5types.c.

{
F5Ttensor_t*This = new(F5Ttensor_t, 1);
int     i, total_components;
 
        This->name = strdup(name);
        This->type_id = -1; /* not yet defined */
        This->rank = rank;
        This->dimension = dimension;
        This->components = components;
 
        total_components = dimension;
        for(i=1; i<rank; i++)
                total_components *= dimension;
 
 
        This->indexing = new(int, total_components);
        This->parity   = new(int, total_components);
 
        This->covariance = new(int, rank);
        This->reverse_indexing = new(int, components);
 
        return This;
}

References F5Ttensor_t::components, F5Ttensor_t::covariance, F5Ttensor_t::dimension, F5Ttensor_t::indexing, F5Ttensor_t::name, name, F5Ttensor_t::parity, F5Ttensor_t::rank, F5Ttensor_t::reverse_indexing, and F5Ttensor_t::type_id.