F5types.c File Reference

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

Go to the source code of this file.

Macros
#define	new(type, size)
#define	delete(ptr)
#define	InsertEnum(type_id, enum_member)
#define	IFITEM(x, type)

Functions
hid_t	F5T_rgb_g ()
hid_t	F5T_rgba_g ()
hid_t	F5T_bgr_g ()
hid_t	F5T_rgb16_g ()
hid_t	F5T_rgba16_g ()
hid_t	F5T_rgb_real_g ()
hid_t	F5T_rgba_real_g ()
hid_t	F5T_vec3_double_g ()
hid_t	F5T_covec3_double_g ()
hid_t	F5T_cartesianpoint3_double_g ()
hid_t	F5Ttransient_F5field_Array_enum ()
hid_t	F5Tsave_F5field_enum (hid_t loc_id)
const char *	F5Tget_field_description (ArrayType what)
herr_t	F5Tset_field_enum (hid_t loc_id, hid_t enum_type_id, ArrayType what)
ArrayType	F5Tget_field_Array_enum (hid_t loc_id, int *major_version, int *minor_version, int *release_version)
hid_t	F5Ttransient_ProcArray_enum ()
hid_t	F5Tsave_ProcArray_enum (hid_t loc_id)
herr_t	F5Tset_field_ProcArray_enum (hid_t loc_id, ProceduralArrayType what, hid_t ProcTypeIdLocation)
ProceduralArrayType	F5Tget_field_ProcArray_enum (hid_t loc_id, hid_t enum_type, int *major_version, int *minor_version, int *release_version)
F5Ttensor_t *	newF5Ttensor (const char *name, int rank, int dimension, int components)
void	F5Tcreate_symmetric_rank2_covariant_tensor (F5Ttensor_t *This)
F5_API F5Ttensor_t *	F5Ttensor_commit (hid_t loc_id, F5Ttensor_t *)
F5_API int	deleteF5Ttensor (F5Ttensor_t *This)
int	F5Tis_convertible (hid_t src_id, hid_t dst_id)
F5_API void	F5Tprint (hid_t type)

Macro Definition Documentation

delete

#define delete

(

ptr

)

Value:

if (ptr) free(ptr)

Definition at line 21 of file F5types.c.

IFITEM

#define IFITEM	(		x,
			type )

Value:

if (H5Tequal(x,type))\
{printf("%s\n",#x);\
return;}

Definition at line 690 of file F5types.c.

#define IFITEM(x,type)\
        if (H5Tequal(x,type))\
        {printf("%s\n",#x);\
        return;}

Referenced by F5Tprint().

InsertEnum

#define InsertEnum	(		type_id,
			enum_member )

Value:

enum_value=enum_member; \
H5Tenum_insert(type_id, #enum_member, &enum_value);

Referenced by F5Ttransient_F5field_Array_enum(), and F5Ttransient_ProcArray_enum().

new

#define new	(		type,
			size )

Value:

(type*)calloc(size, sizeof(type))

Definition at line 20 of file F5types.c.

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

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

hid_t F5T_cartesianpoint3_double_g

(

)

Definition at line 176 of file F5types.c.

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

F5T_covec3_double_g()

hid_t F5T_covec3_double_g

(

)

Definition at line 163 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;
}

F5T_rgb16_g()

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

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

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

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

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

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

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;
}

F5Tcreate_symmetric_rank2_covariant_tensor()

void F5Tcreate_symmetric_rank2_covariant_tensor

(

F5Ttensor_t *

This

)

Definition at line 578 of file F5types.c.

{
int i, j, ni, nj, I;
 
        assert(This->rank==2);
 
        I = 0; /* the linear index */
 
        /* Create symmetric 2x2 tensor */
        for(ni=0, i=0; i<This->dimension; i++ )
        {
                for(nj=0, j=0; j<i; j++ )
                {
                        This->indexing[ni+j] = This->indexing[nj+i] = I++;
                        nj += This->dimension;
                }
                This->indexing[ni+i] = I++;
                ni += This->dimension;
        }
 
        for(i=0; i<This->dimension*This->dimension; i++)
        {
                This->parity[i] = +1;
        }
 
        /* Create covariant indices: g_mn */
        This->covariance[0] = -1;
        This->covariance[1] = -1;
 
        /* TODO:
        This->reverse_indexing
        */
}

References F5Ttensor_t::covariance, F5Ttensor_t::dimension, F5Ttensor_t::indexing, F5Ttensor_t::parity, and F5Ttensor_t::rank.

F5Tget_field_Array_enum()

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

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

ProceduralArrayType F5Tget_field_ProcArray_enum	(	hid_t	loc_id,
		hid_t	enum_type,
		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()

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

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

F5Tsave_ProcArray_enum()

hid_t F5Tsave_ProcArray_enum

(

hid_t

loc_id

)

Definition at line 422 of file F5types.c.

{
hid_t   type_id;
char    vbuf[1024];
        sprintf(vbuf, "%s-%d.%d.%d", FIBER_ARRAY_TYPE_ENUM,
                FIBER_MAJOR_VERSION, FIBER_MINOR_VERSION, FIBER_RELEASE_VERSION);
 
        /* Try to open existing field ID first. */
 
        F5printf(50, "F5Tsave_ProcArray_enum(): Try to open existing procfield enum id %s\n", vbuf );
        H5E_BEGIN_TRY
        type_id = H5Topen2(loc_id, vbuf, H5P_DEFAULT);
        H5E_END_TRY
 
        if (type_id<0)
        {
                type_id = H5Tcopy( F5Ttransient_ProcArray_enum() );
 
                F5printf(50, "F5Tsave_ProcArray_enum(): Saving type as %s\n", vbuf );
                H5Tcommit2(loc_id,  vbuf, 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_ProcArray_enum() Warning: No version check implemented yet!");
        }
 
        return type_id;
}

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

Referenced by F5Tset_field_ProcArray_enum().

F5Tset_field_enum()

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

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

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

F5Ttransient_ProcArray_enum()

hid_t F5Ttransient_ProcArray_enum

(

)

Definition at line 402 of file F5types.c.

{
static  hid_t type_id = -1;
int     enum_value;
 
        if (type_id>0) return type_id;
 
        type_id = H5Tenum_create(H5T_NATIVE_INT);
 
        InsertEnum(type_id, UnknownProcArray);
        InsertEnum(type_id, ExplicitProcArray);
        InsertEnum(type_id, PolynomialProcArray);
        /*
        InsertEnum(type_id, FourierProcArray);
        InsertEnum(type_id, ChebychevProcArray);
        */
        return type_id;
}

References ExplicitProcArray, InsertEnum, PolynomialProcArray, and UnknownProcArray.

Referenced by F5Tget_field_ProcArray_enum(), and F5Tsave_ProcArray_enum().

newF5Ttensor()

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.

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.