F5types.c

Go to the documentation of this file.

#include "F5types.h"
#include "F5defs.h"
#include "F5private.h"
#include "F5X.h"
#include "F5A.h"
 
/* #if defined(__APPLE__) && defined(__MACH__) && defined(__POWERPC__) */
#include <stdlib.h>
/* #else */
/* #include <malloc.h> */
/* #endif */
#include <assert.h>
#include <string.h>
 
#ifdef double
#error double must not be redefined!
#undef double
#endif
 
#define new(type, size) (type*)calloc(size, sizeof(type))
#define delete(ptr)     if (ptr) free(ptr)
 
hid_t   F5T_rgb_g()
{
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;
}
 
hid_t   F5T_rgba_g()
{
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;
}
 
hid_t   F5T_bgr_g()
{
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;
}
 
 
hid_t   F5T_rgb16_g()
{
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;
}
 
 
hid_t   F5T_rgba16_g()
{
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;
}
 
hid_t   F5T_rgb_real_g()
{
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;
}
 
hid_t   F5T_rgba_real_g()
{
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;
}
 
/*
hid_t   F5T_vec3_float_g()
{
static  hid_t id = -1;
        if (id<0)
        {
                id = H5Tcreate(H5T_COMPOUND, 12);
                H5Tinsert(id, "x", 0, H5T_NATIVE_FLOAT);
                H5Tinsert(id, "y", 4, H5T_NATIVE_FLOAT);
                H5Tinsert(id, "z", 8, H5T_NATIVE_FLOAT);
        }
        return id;
}
 
hid_t   F5T_metric33_float_g()
{
static  hid_t id = -1;
        if (id<0)
        {
                id = H5Tcreate(H5T_COMPOUND, 6*4);
                H5Tinsert(id, "gxx", 0, H5T_NATIVE_FLOAT);
                H5Tinsert(id, "gxy", 4, H5T_NATIVE_FLOAT);
                H5Tinsert(id, "gyy", 8, H5T_NATIVE_FLOAT);
                H5Tinsert(id, "gxz",12, H5T_NATIVE_FLOAT);
                H5Tinsert(id, "gyz",16, H5T_NATIVE_FLOAT);
                H5Tinsert(id, "gzz",20, H5T_NATIVE_FLOAT);
        }
        return id;
}
*/
 
hid_t   F5T_vec3_double_g()
{
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;
}
 
hid_t   F5T_covec3_double_g()
{
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;
}
 
hid_t   F5T_cartesianpoint3_double_g()
{
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;
}
 
hid_t   F5Ttransient_F5field_Array_enum()
{
        /*
          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;
}
 
hid_t   F5Tsave_F5field_enum(hid_t loc_id)
{
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;
}
 
const char*F5Tget_field_description(ArrayType what)
{
        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  "";
}
 
 
herr_t  F5Tset_field_enum(hid_t loc_id, hid_t enum_type_id, ArrayType what)
{
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;
}
 
ArrayType F5Tget_field_Array_enum(hid_t loc_id,
                                  int*major_version, int*minor_version, int*release_version)
{
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;
}
 
/************************************************************************************/
hid_t   F5Ttransient_ProcArray_enum()
{
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;
}
 
 
hid_t   F5Tsave_ProcArray_enum(hid_t loc_id)
{
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;
}
 
 
herr_t  F5Tset_field_ProcArray_enum(hid_t loc_id, ProceduralArrayType what, hid_t ProcTypeIdLocation)
{
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;
}
 
 
ProceduralArrayType F5Tget_field_ProcArray_enum(hid_t loc_id,
                                                hid_t enum_type,
                                                int*major_version, int*minor_version, int*release_version)
{
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;
}
 
 
/*
typedef struct
{
        /// Descriptive name.
        char    *name;
        /// HDF5 Type ID
        hid_t   type_id;
        /// Rank of the tensor
        int     rank,
        /// Dimensionality of the underlying manifold
                dimension,
        /// Actual components which require storage
                components;
        /// Index mapping array per component from linear component index to memory component, size(indexing)=dimension^rank
        int     *indexing;
        /// Sign change information during indexing per component, size(parity)=dimension^rank
        int     *parity;
        /// Upper/Lower indexing information per index, size(covariance)=rank
        int     *covariance;
        /// Reverse indexing information, size(reverse_indexing) = components
        int     *reverse_indexing;
        /// Name of a metric tensor field
        char    *metric;
        /// Textual description of non-tensorial transformation rules
        char    *transformation_rule;
 
}       F5Ttensor_t;
*/
 
 
/**
  Create a new tensor type description.
  All arrays are allocated, but set to zero.
 */
F5Ttensor_t*newF5Ttensor(const char*name, int rank, int dimension, int components)
{
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;
}
 
 
void F5Tcreate_symmetric_rank2_covariant_tensor(F5Ttensor_t*This)
{
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
        */
}
 
 
/**
 Save tensor type to file and return a copy.
 All internal arrays are copied, no reference counting.
 */
F5_API F5Ttensor_t*F5Ttensor_commit(hid_t loc_id, F5Ttensor_t*);
 
/**
 Remove a tensor description.
 */
F5_API int deleteF5Ttensor(F5Ttensor_t*This)
{
        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;
}
 
int     F5Tis_convertible(hid_t src_id, hid_t dst_id)
{
/*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;
}
 
#define IFITEM(x,type)\
        if (H5Tequal(x,type))\
        {printf("%s\n",#x);\
        return;}
 
F5_API void F5Tprint(hid_t type)
{
        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");
}