F5types.h

Go to the documentation of this file.

#ifndef __F5_types_H
#define __F5_types_H
 
#include "hdf5inc.h"
#include "F5defs.h"
 
#include "F5WinDLLApi.h"
 
#include <stdint.h> /* required for int32_t */
 
#ifdef  __cplusplus
extern "C"
{
#endif
 
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;
 
typedef struct  { F5_byte_t   r,g,b;   } F5_rgb_t;
typedef struct  { F5_byte_t   r,g,b,a; } F5_rgba_t;
typedef struct  { F5_byte_t   b,g,r;   } F5_bgr_t;
typedef struct  { F5_int16_t  r,g,b;   } F5_rgb16_t;
typedef struct  { F5_int16_t  r,g,b,a; } F5_rgba16_t;
 
/** floating-point colors */
typedef struct  { F5_float_t  r,g,b;   } F5_rgb_real_t;
typedef struct  { F5_float_t  r,g,b,a; } F5_rgba_real_t;
 
#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()
 
 
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();
 
/**
 Given a tensor of rank three with indices i,j,k,
 then its corresponding linear index is given by
 Li = i+rank*j+rank*rank*k
 Not all of the tensor components might reside actually
 in memory, but due to symmetries only some of them do.
 The indexing array is used to map the linear index to
 the actual memory index:
 
 Rijk = data[ indexing[ Li ] ]
 
  The parity array specifies the sign change when accessing
  components in addition to the indexing. It may be zero for
  components which are never non-zero. Usually it will just be
  +1 or -1 . The final tensor value is given by
 
  Rijk = data[ indexing[ Li ] ] * parity[ Li ]
 
  The size of the indexing and parity arrays is given by the components member.
 
  The covariance array gives the upper or lower indexing scheme.
  For a rank 3 tensor, it has three entries that may be positive or negative.
 
  The reverse_indexing array provides the inverse mapping of the indexing array.
 
  The metric member specifies relative to which metric tensor field this
  indicable field is actually a tensor field.
 */
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.
        If all entries are zero, then this information has not yet been defined.
        If the pointer is zero, then no symmetries are defined, i.e. all components
        are relevant.
        */
        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.
  @param 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.
  @param 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.
  @param dimension  The dimensions of the base manifold.
  @param 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.
 */
F5_API F5Ttensor_t*newF5Ttensor(const char*name, int rank, int dimension, int components);
 
/**
 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*);
 
/**
   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.
 */
F5_API int F5Tis_convertible(hid_t first_type, hid_t second_type);
 
/**
   Get a field type for F5 array descriptions.
 */
F5_API hid_t    F5Ttransient_F5field_Array_enum();
 
/**
   Create a named field type for F5 array descriptions by
   saving the transient enum type to a file.
 */
F5_API hid_t    F5Tsave_F5field_enum(hid_t loc_id);
 
/**
   Set a field type in a file.
 */
F5_API herr_t   F5Tset_field_enum(hid_t loc_id, hid_t enum_type_id, ArrayType what);
 
/**
   Return a human-readable description of the array type,
   for convenience on console or log file outputs.
 */
F5_API const char*F5Tget_field_description(ArrayType what);
 
/**
   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 \b type will be the version number
   information for the given loc_id .
   The \b 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.
 */
F5_API ArrayType F5Tget_field_Array_enum(hid_t loc_id,
                                        int*major_version, int*minor_version, int*release_version);
 
/**
   Set the array type of a procedural array.
   @param ProcIDLocation Group ID where the enumeration type is stored in the file.
 */
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);
 
/**
 * Prints type info
 */
 
F5_API void F5Tprint(hid_t type);
 
#ifdef  __cplusplus
}    /* extern "C" */
#endif
 
 
#endif  /* __F5_types_H */