F5F.c

Go to the documentation of this file.

#include "F5F.h"
#include "F5X.h"
#include "F5A.h"
#include "F5private.h"
#include "F5Bchart.h"
#include "F5L.h"
/* #if defined(__APPLE__) && defined(__MACH__) && defined(__POWERPC__) */
#include <stdlib.h>
/* #else */
/* #include <malloc.h> */
/* #endif */
#include <string.h>
#include <assert.h>
 
#define DO_DATASPACE_CONSISTENCY_CHECK
 
ArrayType F5Fget_field_enum(const F5Path*fpath, const char*fieldname,
                            int*major_version, int*minor_version, int*release_version)
{
ArrayType retval;
int     is_group = -1;
hid_t   loc_id;
 
        F5printf(50, "F5Fget_field_enum(%s)", fieldname);
 
        if (!fpath)
        {
                F5printf(50, "F5Fget_field_enum(%s): No valid F5Path given.", fieldname);
                *major_version = *minor_version = *release_version = 0;
                return UnknownArrayType;
        }
 
        if (fieldname)
        {
                H5E_BEGIN_TRY
                is_group = 0;
                loc_id = H5Dopen2(fpath->Representation_hid, fieldname, H5P_DEFAULT);
                H5E_END_TRY
                if (loc_id<0)
                {
                        loc_id = H5Gopen2(fpath->Representation_hid, fieldname, H5P_DEFAULT);
                        if (loc_id<0)
                        {
                                F5printf(50, "F5Fget_field_enum(%s): Cannot determine field type!", fieldname);
                        }
                        is_group = 1;
                }
        }
        else
                loc_id = fpath->Field_hid;
 
        retval = F5Tget_field_Array_enum(loc_id,
                                         major_version, minor_version, release_version);
 
        switch(is_group)
        {
        case 1: H5Gclose(loc_id); break;
        case 0: H5Dclose(loc_id); break;
        }
 
        F5printf(50, "~F5Fget_field_enum(%s)", fieldname);
        return retval;
}
 
 
int     F5Fopen(F5Path*f, const char*fieldname)
{
        F5Fclose(f);
 
        H5E_BEGIN_TRY
        f->Field_hid = H5Dopen2(f->Representation_hid, fieldname, H5P_DEFAULT);
        H5E_END_TRY
 
        if (f->Field_hid<0)
        {
                H5E_BEGIN_TRY
                f->Field_hid = H5Gopen2(f->Representation_hid, fieldname, H5P_DEFAULT);
                H5E_END_TRY
                if (f->Field_hid<0)
                {
                        F5printf(10,"F5Fopen(,%s) Path entry is neither a group nor a data set (could be a named data type)\n", fieldname);
                        return 0;
                }
        }
 
        if (f->Field_hid<0)
                return 0;
 
        return 1;
}
 
void    F5Fclose(F5Path*f)
{
        if (!f) return;
 
        if (f->Field_hid>0)
        {
                if (F5Fis_group(f) )
                        H5Gclose( f->Field_hid );
                else
                        H5Dclose( f->Field_hid );
 
                f->Field_hid = 0;
        }
}
 
hid_t   F5Fgrab(F5Path*f)
{
        if (!f) return -1;
 
        if (f->Field_hid>0)
        {
        hid_t   id = f->Field_hid;
                /*
                if (F5Fis_group(f) )
                        H5Gclose( f->Field_hid );
                else
                        H5Dclose( f->Field_hid );
                */
                f->Field_hid = 0;
                return id;
        }
        return -1;
}
 
int     F5Fis_group(const F5Path*fpath)
{
        if (!fpath) return 0;
        if (H5Iget_type( fpath->Field_hid ) == H5I_GROUP)
                return 1;
 
        return 0;
}
 
int     F5Ffragment_is_group(const F5Path*fpath, const char*fragment_name )
{
        if (!fpath) return 0;
 
H5G_stat_t info;
 
        herr_t status = H5Gget_objinfo(fpath->Field_hid, fragment_name, 0, &info);
 
        if (status < 0)
                return 0;
 
        if (info.type == H5G_GROUP)
        {
                F5printf(5, "F5Ffragment_is_group == true");
                return 1;
        }
 
        return 0;
}
 
 
hid_t F5Fget_type(F5Path*f)
{
        return F5Fget_type2(f,0);
}
 
hid_t F5Fget_type2(F5Path*f, hid_t elink_fapl_id)
{
        return F5Lget_type(f->Field_hid, F5Fis_group(f),
                           elink_fapl_id);
}
 
hid_t   F5Tget_space(F5Path*f)
{
hsize_t dims[FIBER_MAX_RANK];
int     rank;
 
        F5printf(40, "F5Tget_space()");
 
        if (!f) return -1;
        if (f->Topology_hid<0) return -1;
 
        rank = F5LAget_dimensions(f->Topology_hid,
                                  FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE,
                                  dims);
 
        /* NOTE: This code could go into versioning-specific execution, i.e.
           do only if the version is 0.0.0
        */
#ifdef  F5_BACKWARD_COMPATIBILITY
        if (rank<0 && f->Field_hid>0)
        {
                F5printf(40, "F5Tget_space(): F5LAget_dimensions() attribute "FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE
                         " not found on enveloping Topology, inspecting dataset.");
                rank = F5LAget_dimensions(f->Field_hid,  FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE, dims);
        }
        if (rank<0 && f->Field_hid>0)
        {
                F5printf(40, "F5Tget_space(): F5LAget_dimensions() attribute "FIBER_FIELD_DATASPACE_DIMENSIONS_ATTRIBUTE
                         " not found on data set, trying old `Size' attribute\n");
                rank = F5LAget_dimensions(f->Field_hid, "Size", dims);
        }
#endif
        if (rank<0 && f->Field_hid>0 && !F5Fis_group(f) )
        {
                F5printf(40, "F5Tget_space(): no data dims attribute found, returning field's data space...\n" );
                return H5Dget_space(f->Field_hid);
        }
        if (rank<0)
        {
                F5printf(40, "F5Tget_space(): rank could not be determined...\n");
                return -1;
        }
 
        F5printf(40, "F5Tget_space(): F5LAget_dimensions() reported rank %d\n", rank);
        {
        int     i;
                for(i=0; i<rank; i++)
                {
                        if (dims[i] == 0)
                        {
                                F5printf(40, "F5Tget_space(): No topology associated...\n");
                                return -1;
                        }
                }
        }
 
        return H5Screate_simple(rank, dims, dims );
}
 
 
int F5Tget_extent(F5Path*f, hsize_t*dims, int maxDims)
{
hsize_t mdims[FIBER_MAX_RANK], Dims[FIBER_MAX_RANK];
int     mrank;
hid_t   space_id = F5Tget_space(f);
 
 
        if (space_id<0)
                return 0;
 
        mrank = H5Sget_simple_extent_dims(space_id, mdims, NULL);
 
        H5Sclose(space_id);
 
        F5Tpermute_dimensions(f, mrank, Dims, mdims);
 
        if (mrank>maxDims)
                mrank = maxDims;
 
 
        {int    i;
                for(i=0; i<mrank; i++)
                        dims[i] = Dims[i];
        }
 
        return mrank;
}
 
 
int     F5Tget_index_depth(F5Path*f, int*result)
{
        F5printf(40, "F5Fget_index_depth()");
 
        if (!f)
                return 0;
 
        if (f->Topology_hid<0)
                return 0;
 
        if (F5Aget_ints(f->Topology_hid,
                        FIBER_HDF5_INDEXDEPTH_ATTRIB,
                        result, 1) != 1)
        {
                F5printf(40, "F5Fget_index_depth(): could not read index depth attribute");
                return 0;
        }
 
        return 1;
}
 
/* this should be renamed into F5Fpermute_dimensions */
F5_API hsize_t*F5Tpermute_dimensions(F5Path*fpath,
                                     int rank,
                                     hsize_t*target_dims,
                                     const hsize_t*source_dims)
{
int     ChartDims;
        F5printf(50, "F5Tpermute_dimensions()");
 
        /* added by mr, not sure if this is good */
        if( !target_dims || !source_dims)
        {
                F5printf(40, "F5Tpermute_dimensions() Invalid target or source");
                return NULL;
        }
 
        {
        int     i = 0;
                for(i=0; i<rank; i++)
                        if (source_dims[i]) break;
 
                if (i==rank)
                {
                        for(i=0; i<rank; i++)
                                target_dims[i] = source_dims[i];
 
                        F5printf(40, "F5Tpermute_dimensions() All source data are zero, skipping permutation...");
                        return target_dims;
                }
        }
 
        if (!fpath || !fpath->myChart)
        {
                F5printf(50, "F5Tpermute_dimensions() No Chart given, assuming default (FORTRAN) index permutation!");
                return F5B_permute_dimensions(target_dims, rank, source_dims, NULL,  0);
        }
        F5printf(50, "F5Tpermute_dimensions() params ok, rank=%d.", rank);
        for(int i=0; i<rank; i++)
                F5printf(50, "F5Tpermute_dimensions() source[%d]=%d.", i, source_dims[i] );
 
/* cannot occur because perm_vector is static member
        if (!fpath->myChart->perm_vector )
        {
                F5printf(10, "F5Tpermute_dimensions() has no permutation vector!");
                return NULL;
                }
*/
        ChartDims = F5Bget_chart_dims(fpath->myChart);
 
        return F5B_permute_dimensions(target_dims, rank, source_dims, fpath->myChart->perm_vector,  ChartDims );
}
 
int     F5Fcreate(F5Path*fpath, const char*fieldname, int rank, hsize_t*dims,
                  hid_t fieldtype, hid_t property_id)
{
hsize_t save_dims[FIBER_MAX_RANK];
 
        F5printf(40,"F5Fcreate()");
 
        if (!fpath) return 0;
 
        F5Fclose(fpath);
 
        F5printf_indent++;
        F5B_permute_dimensions(save_dims, rank, dims, fpath->myChart->perm_vector, F5Bget_chart_dims(fpath->myChart));
        F5printf_indent--;
 
        if (!F5LTset_dataspace(fpath, rank, save_dims))
        {
                F5printf(-1, "F5Fcreate(%s): cannot create, inconsistent dataspace!", fieldname);
                return 0;
        }
 
        fpath->Field_hid = F5Lcreate(fpath->Representation_hid, fieldname,
                                     rank, save_dims,
                                     F5file_type(fpath, fieldtype), property_id);
 
        if (fpath->Field_hid<0)
        {
                F5printf(0,"F5Fcreate -> F5Lcreate() FAILED!");
                return 0;
        }
        else
                F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), Contiguous);
 
        F5I_add_field(fpath, fieldname);
 
        F5printf(40,"~F5Fcreate() ok");
        return 1;
}
 
const char*F5Fwhatsup(F5ErrorCode EC)
{
        switch(EC)
        {
        case    F5_SUCCESS:                     return "OK";
        case    F5ERROR_INVALID_FPATH:          return "Invalid Path";
        case    F5ERROR_INCONSISTENT_DATASPACE: return "Inconsistent Dataspace";
        case    F5ERROR_INVALID_FRAGMENT_START: return "Fragment starts beyond dataspace";
        case    F5ERROR_INVALID_FRAGMENT_END:   return "Fragment extends beyond dataspace";
        case    F5ERROR_ALREADY_EXISTS:         return "Object already exists";
        case    F5ERROR_COMPOUND_EXPECTED:      return "Compound type expected";
        case    F5ERROR_COMPONENTMAP_EXPECTED:  return "Component map expected";
        case    F5ERROR_COMPONENTMAP_INVALID:   return "Component map invalid";
 
        case    F5ERROR_NONSPECIFIED:           return "Unspecified error";
 
        default: return "Invalid error code (compile-time bug)";
        }
}
 
 
 
F5ErrorCode F5Fwrite_flexible(F5Path*fpath, const char*fieldname,
                              int rank, hsize_t*dims,
                              hid_t fieldtype, hid_t memtype, const void * dataPtr,
                              hid_t property_id, int do_check )
{
hsize_t save_dims[FIBER_MAX_RANK];
 
        F5printf(40,"F5Fwrite(%s, rank=%d, dims=%dx%dx%dx%d)", fieldname, rank, rank>0?(int)dims[0]:1,
                 rank>1?(int)dims[1]:1,rank>2?(int)dims[2]:1, rank>3?(int)dims[3]:1
                 );
 
        if (!fpath)
                return F5ERROR_INVALID_FPATH;
 
        F5Fclose(fpath);
 
        /*
          Detect the special case of 2D RGB data, in which case we try to
          write the data compatible to the official HDF5 specification for
          images.
         */
        if ( (H5Tequal(fieldtype, F5T_RGB_REAL)>0 || H5Tequal(fieldtype, F5T_RGB)>0) && rank == 2)
        {
                return F5FwriteIMAGE(fpath, fieldname,
                                     rank, dims,
                                     fieldtype, memtype, dataPtr,
                                     property_id);
        }
 
        F5printf_indent++;
        F5Tpermute_dimensions(fpath, rank, save_dims, dims );
        F5printf_indent--;
 
        F5printf(41,"F5Fwrite(%s): permuted dims: rank=%d, dims=%dx%dx%dx%d)", fieldname, rank,
                 rank>0?(int)save_dims[0]:1, rank>1?(int)save_dims[1]:1, rank>2?(int)save_dims[2]:1, rank>3?(int)save_dims[3]:1 );
 
        if (!F5LTset_dataspace(fpath, rank, save_dims))
        {
                if( do_check )
                {
                        if (rank==3)
                                F5printf(-1, "F5Fwrite(%s): cannot write 3D field, inconsistent 3D dataspace, trying to write %dx%dx%d as HDF5 dataspace %dx%dx%d  (run again with F5_VERBOSITY=30 to see more details)!",
                                         fieldname, (int)dims[0], (int)dims[1], (int)dims[2],
                                         (int)save_dims[0], (int)save_dims[1], (int)save_dims[2]
                                        );
                        else
                                F5printf(-1, "F5Fwrite(%s): cannot write field, inconsistent dataspace (run again with F5_VERBOSITY=30 to see more details)!", fieldname);
 
                        return F5ERROR_INCONSISTENT_DATASPACE;
                }
                else
                        F5printf(-1, "F5Fwrite(%s): warning during field write, inconsistent dataspace!", fieldname);
        }
 
        fpath->Field_hid = 0;
 
        fpath->Field_hid = F5Lwrite(fpath->Representation_hid, fieldname,
                                    rank, save_dims,
                                    F5file_type(fpath, fieldtype), memtype, dataPtr,
                                    F5LTmake_enum_type(fpath),
                                    property_id);
 
        if (fpath->Field_hid<=0)
        {
                F5printf(3,"F5Fwrite(): F5Lwrite() FAILED!");
                fpath->Field_hid = 0;
        }
        else
        {
                F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), Contiguous);
                F5I_add_field(fpath, fieldname);
        }
 
        F5printf(40,"F5Fwrite() ok");
        return  F5_SUCCESS;
}
 
 
F5ErrorCode F5Fwrite(F5Path*fpath, const char*fieldname,
                     int rank, hsize_t*dims,
                     hid_t fieldtype, hid_t memtype, const void * dataPtr,
                     hid_t property_id)
{
        return F5Fwrite_flexible( fpath, fieldname, rank, dims, fieldtype, memtype, dataPtr, property_id, 1 );
}
 
 
F5ErrorCode F5FwriteHyperDimensional(F5Path*fpath, const char*fieldname,
                                     int rank, hsize_t*dims,
                                     hid_t fieldtype, hid_t memtype, const void * dataPtr,
                                     hid_t property_id)
{
// TODO: Implement consistency check on the base space dimensions!
 
        return F5Fwrite_flexible( fpath, fieldname, rank, dims, fieldtype, memtype, dataPtr, property_id, 0 );
}
 
 
F5_API F5ErrorCode F5FwriteIMAGE(F5Path*fpath, const char*fieldname,
                                 int rank, hsize_t*dims,
                                 hid_t fieldtype, hid_t memtype, const void * dataPtr,
                                 hid_t dcpl_id)
{
hsize_t save_dims[FIBER_MAX_RANK];
        if (rank!=2)
        {
                F5printf(40,"F5FwriteIMAGE(%s, rank=%d, dims=%dx%dx%dx%d) INVALID RANK (must be 2)! \n", fieldname, rank, rank>0?(int)dims[0]:1,
                         rank>1?(int)dims[1]:1,rank>2?(int)dims[2]:1, rank>3?(int)dims[3]:1
                        );
                return  F5ERROR_INCONSISTENT_DATASPACE;
        }
 
        F5printf(40,"F5FwriteIMAGE(%s, rank=%d, dims=%dx%dx%dx%d)\n", fieldname, rank, rank>0?(int)dims[0]:1,
                 rank>1?(int)dims[1]:1,rank>2?(int)dims[2]:1, rank>3?(int)dims[3]:1
                 );
        if (!fpath)
                return F5ERROR_INVALID_FPATH;
 
        F5Fclose(fpath);
 
        F5printf_indent++;
        F5Tpermute_dimensions(fpath, rank, save_dims, dims );
        F5printf_indent--;
 
        F5printf(41,"F5Fwrite(%s): permuted dims: rank=%d, dims=%dx%dx%dx%d)\n", fieldname, rank,
                 rank>0?(int)save_dims[0]:1, rank>1?(int)save_dims[1]:1, rank>2?(int)save_dims[2]:1, rank>3?(int)save_dims[3]:1 );
 
        if (!F5LTset_dataspace(fpath, rank, save_dims))
        {
                F5printf(-1, "F5Fwrite(%s): cannot create, inconsistent dataspace!", fieldname);
                return F5ERROR_INCONSISTENT_DATASPACE;
        }
 
        if (fieldtype == F5T_RGB_REAL)
        {
                save_dims[2] = 3;
                rank = 3;
                fieldtype = H5T_NATIVE_FLOAT;
                memtype   = H5T_NATIVE_FLOAT;
                fpath->Field_hid = F5Lwrite(fpath->Representation_hid, fieldname,
                                            rank, save_dims,
                                            F5file_type(fpath, fieldtype), memtype, dataPtr,
                                            F5LTmake_enum_type(fpath),
                                            dcpl_id);
 
                if (fpath->Field_hid<=0)
                {
                        F5printf(1, "F5Fwrite_IMAGE() - FAILED to append field fragment data.");
                        return -1;
                }
 
                /* FROM: http://hdf.ncsa.uiuc.edu/HDF5/doc/ADGuide/ImageSpec.html */
                F5Asave_string(fpath->Field_hid, "CLASS", "IMAGE");
                F5Asave_string(fpath->Field_hid, "INTERLACE_MODE", "INTERLACE_PIXEL");
                F5Asave_string(fpath->Field_hid, "DISPLAY_ORIGIN", "LL");
                F5Asave_string(fpath->Field_hid, "IMAGE_VERSION",  "1.2");
                F5Asave_string(fpath->Field_hid, "IMAGE_SUBCLASS", "IMAGE_TRUECOLOR");
                F5Asave_string(fpath->Field_hid, "IMAGE_COLORMODEL", "RGB");
 
                F5Dset_type_attribute(fpath->Field_hid, F5T_RGB_REAL);
        }
        else if (fieldtype == F5T_RGB)
        {
                save_dims[2] = 3;
                rank = 3;
                fieldtype = H5T_NATIVE_UCHAR;
                memtype   = H5T_NATIVE_UCHAR;
                fpath->Field_hid = F5Lwrite(fpath->Representation_hid, fieldname,
                                            rank, save_dims,
                                            F5file_type(fpath, fieldtype), memtype, dataPtr,
                                            F5LTmake_enum_type(fpath),
                                            dcpl_id);
 
                /* FROM: http://www.hdfgroup.org/HDF5/doc/ADGuide/ImageSpec.html */
#if     0
                F5Asave_string(fpath->Field_hid, "CLASS", "IMAGE");
                F5Asave_string(fpath->Field_hid, "INTERLACE_MODE", "INTERLACE_PIXEL");
                F5Asave_string(fpath->Field_hid, "DISPLAY_ORIGIN", "LL");
                F5Asave_string(fpath->Field_hid, "IMAGE_VERSION",  "1.2");
                F5Asave_string(fpath->Field_hid, "IMAGE_SUBCLASS", "IMAGE_TRUECOLOR");
                F5Asave_string(fpath->Field_hid, "IMAGE_COLORMODEL", "RGB");
#else
                F5Asave_strings(fpath->Field_hid, "CLASS", "IMAGE",1);
                F5Asave_strings(fpath->Field_hid, "INTERLACE_MODE", "INTERLACE_PIXEL",1);
                F5Asave_strings(fpath->Field_hid, "DISPLAY_ORIGIN", "LL",1);
                F5Asave_strings(fpath->Field_hid, "IMAGE_VERSION",  "1.2",1);
                F5Asave_strings(fpath->Field_hid, "IMAGE_SUBCLASS", "IMAGE_TRUECOLOR",1);
                F5Asave_strings(fpath->Field_hid, "IMAGE_COLORMODEL", "RGB",1);
#endif
 
/*      unsigned char MinMax[] = { 0, 0xFF };
                F5Asave(fpath->Field_hid, "IMAGE_MINMAXRANGE",
                        H5T_NATIVE_UCHAR, H5T_NATIVE_UCHAR, MinMax, 2);
*/
//              F5Dset_type_attribute(fpath->Field_hid, F5T_RGB);
        }
        else if (fieldtype == H5T_NATIVE_USHORT)
        {
                save_dims[2] = 1;
                rank = 2;
                fieldtype = H5T_NATIVE_USHORT;
                memtype   = H5T_NATIVE_USHORT;
                fpath->Field_hid = F5Lwrite(fpath->Representation_hid, fieldname,
                                            rank, save_dims,
                                            F5file_type(fpath, fieldtype), memtype, dataPtr,
                                            F5LTmake_enum_type(fpath),
                                            dcpl_id);
 
                /* FROM: http://www.hdfgroup.org/HDF5/doc/ADGuide/ImageSpec.html */
#if     0
                F5Asave_string(fpath->Field_hid, "CLASS", "IMAGE");
                F5Asave_string(fpath->Field_hid, "INTERLACE_MODE", "INTERLACE_PIXEL");
                F5Asave_string(fpath->Field_hid, "DISPLAY_ORIGIN", "LL");
                F5Asave_string(fpath->Field_hid, "IMAGE_VERSION",  "1.2");
                F5Asave_string(fpath->Field_hid, "IMAGE_SUBCLASS", "IMAGE_TRUECOLOR");
                F5Asave_string(fpath->Field_hid, "IMAGE_COLORMODEL", "RGB");
#else
                F5Asave_strings(fpath->Field_hid, "CLASS", "IMAGE",1);
                F5Asave_strings(fpath->Field_hid, "DISPLAY_ORIGIN", "LL",1);
                F5Asave_strings(fpath->Field_hid, "IMAGE_VERSION",  "1.2",1);
                F5Asave_strings(fpath->Field_hid, "IMAGE_SUBCLASS", "IMAGE_GRAYSCALE",1);
#endif
        unsigned short MinMax[] = { 0, 0xFFFF };
                F5Asave(fpath->Field_hid, "IMAGE_MINMAXRANGE",
                        H5T_NATIVE_USHORT, H5T_NATIVE_USHORT, MinMax, 2);
        }
        else
        {
                fpath->Field_hid = F5Lwrite(fpath->Representation_hid, fieldname,
                                            rank, save_dims,
                                            F5file_type(fpath, fieldtype), memtype, dataPtr,
                                            F5LTmake_enum_type(fpath),
                                            dcpl_id);
        }
 
        F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), Contiguous);
        F5I_add_field(fpath, fieldname);
 
        F5printf(40,"F5Fwrite() ok");
        return F5_SUCCESS;
}
 
F5_API F5ErrorCode F5Fwrite_1D(F5Path*fpath, const char*fieldname,
                              hsize_t nElements, hid_t fieldtype, hid_t memtype,
                              const void * dataPtr, hid_t property_id)
{
hid_t   file_type;
        F5printf(40,"F5Fwrite1D(%s)", fieldname);
        if (!fpath)
        {
                F5printf(41,"F5Fwrite1D(%s): no fpath given!", fieldname);
                return F5ERROR_INVALID_FPATH;
        }
        if (nElements<1)
        {
                F5printf(30,"F5Fwrite1D(%s): No elements given, field not created!",fieldname);
                return F5ERROR_INCONSISTENT_DATASPACE;
        }
        if (fpath->Representation_hid<0)
        {
                F5printf(30,"F5Fwrite1D(%s): INVALID Representation ID given!",fieldname);
                return F5ERROR_INCONSISTENT_DATASPACE;
        }
        if (fieldtype<0)
        {
                F5printf(30,"F5Fwrite1D(%s): INVALID field type ID given!",fieldname);
                return F5ERROR_INCONSISTENT_DATASPACE;
        }
 
        file_type = F5file_type(fpath, fieldtype);
        if (file_type<0)
        {
                F5printf(30,"F5Fwrite1D(%s): CANNOT created file type from field type %d given!",
                        fieldname, (int)fieldtype );
                return F5ERROR_INCONSISTENT_DATASPACE;
        }
 
        F5Fclose(fpath);
 
/* TODO: Check the consistency of the number of elements here */
 
        fpath->Field_hid = F5Lwrite1D(fpath->Representation_hid, fieldname,
                                      nElements,
                                      file_type, memtype, dataPtr,
                                      F5LTmake_enum_type(fpath),
                                      property_id);
 
        if (fpath->Field_hid < 0)
        {
                F5printf(30,"F5Fwrite1D(): F5Lwrite1D FAILED!");
                return F5ERROR_NONSPECIFIED;
        }
 
        F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), Contiguous);
        F5I_add_field(fpath, fieldname);
        F5printf(40,"F5Fwrite1D() ok");
 
        return F5_SUCCESS;
}
 
 
F5_API int F5Fwrites(F5Path*fpath, const char*fieldname,
                     int rank, hsize_t*dims,
                     hid_t fieldtype, hid_t memtype, const void ** dataPtr,
                     hid_t property_id)
{
hsize_t save_dims[FIBER_MAX_RANK];
hid_t   file_type;
 
        F5printf(40,"F5Fwrites()");
        if (!fpath) return 0;
 
        F5Fclose(fpath);
 
        F5printf_indent++;
        F5Tpermute_dimensions(fpath, rank, save_dims, dims);
        F5printf_indent--;
 
        if (!F5LTset_dataspace(fpath, rank, save_dims))
        {
                F5printf(-1, "F5Fwrites(%s): cannot create, inconsistent dataspace!", fieldname);
                return F5ERROR_INCONSISTENT_DATASPACE;
        }
 
        file_type = F5file_type(fpath, fieldtype);
 
        fpath->Field_hid = F5Lwrites(fpath->Representation_hid, fieldname,
                                     rank, save_dims,
                                     file_type, memtype, dataPtr,
                                     F5LTmake_enum_type(fpath),
                                     property_id);
 
        if (fpath->Field_hid <0)
                F5printf(1, "**F5Fwrites(%s) could not write separated compound type!", fieldname);
 
        switch( H5Tget_class(file_type  ) )
        {
        case H5T_COMPOUND:
                F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), SeparatedCompound);
                break;
 
        case H5T_INTEGER:
        case H5T_FLOAT:
                F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), Contiguous );
                break;
 
        default:
                F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), SeparatedCompound);
                break;
        }
 
        F5I_add_field(fpath, fieldname);
 
        F5printf(40,"F5Fwrites() ok");
        return F5_SUCCESS;
}
 
static int F5B_identical_dims(int rank, const hsize_t*A, const hsize_t*B)
{
int     i;
        if (A && B)
        {
                for(i=0; i<rank; i++)
                {
                        if (A[i] != B[i])
                                return 0;
                }
                return 1;
        }
 
        if (!A) A = B;
        if (!A) return 1;
 
        for(i=0; i<rank; i++)
                if (A[i]) return 0;
 
        return 1;
}
 
int     F5Fexpand_dataspace(F5Path*fpath, int rank, hsize_t*Dims)
{
hsize_t full_dims[FIBER_MAX_RANK];
int     retval;
        F5Tpermute_dimensions(fpath, rank, full_dims , Dims);
        retval = F5LTexpand_dataspace(fpath, rank, full_dims);
        F5Tpermute_dimensions(fpath, rank, Dims, full_dims);
        return retval;
}
 
F5ErrorCode F5Fwrite_fraction(F5Path*fpath, const char*fieldname,
                              int rank, const hsize_t*Dims, const hsize_t*fraction_dims,
                              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 property_id)
{
hid_t   field_id;
int     i;
hsize_t full_dims[FIBER_MAX_RANK], start_dims[FIBER_MAX_RANK], ldims[FIBER_MAX_RANK],
        sborder[FIBER_MAX_RANK], eborder[FIBER_MAX_RANK];
 
        if (!fpath)
                return F5ERROR_INVALID_FPATH;
 
        if (!fieldname)
        {
                F5printf(0, "F5Fwrite_fraction() invalid field name!");
                return  F5ERROR_INVALID_FIELDNAME;
        }
        if (!datastart)
        {
                F5printf(0, "F5Fwrite_fraction() for field %s has no datastart given for fragment %s",
                         fieldname, fraction_name);
                return  F5ERROR_INVALID_PARAMETERS;
        }
        if (!fraction_dims)
        {
                F5printf(0, "F5Fwrite_fraction() for field %s has no fragment dimensions given for fragment %s",
                         fieldname, fraction_name);
                return  F5ERROR_INVALID_PARAMETERS;
        }
 
        F5print_dimensions(20, "F5Fwrite_fraction", rank, fraction_dims);
 
        F5printf_indent++;
        F5Tpermute_dimensions(fpath, rank, full_dims , Dims );
        F5Tpermute_dimensions(fpath, rank, start_dims, datastart );
        F5Tpermute_dimensions(fpath, rank, ldims     , fraction_dims);
        F5Tpermute_dimensions(fpath, rank, sborder   , start_border );
        F5Tpermute_dimensions(fpath, rank, eborder   , end_border   );
        F5printf_indent--;
 
        if (Dims) for(i=0; i<rank; i++)
        {
                if (datastart[i] >= Dims[i])
                {
                        F5printf(-1, "F5Fwrite_fraction(%s): fragment starts beyond dataspace in dimension %d: %d (max %d allowed)!",
                                 fieldname, i, (int)datastart[i], (int)Dims[i] );
                        return F5ERROR_INVALID_FRAGMENT_START;
                }
                if (datastart[i]+fraction_dims[i] > Dims[i])
                {
                        F5printf(-1, "F5Fwrite_fraction(%s): fragment extends beyond dataspace in dimension %d: %d (max %d allowed)!",
                                 fieldname, i, (int)(datastart[i]+fraction_dims[i]), (int)Dims[i] );
                        return  F5ERROR_INVALID_FRAGMENT_END;
                }
        }
        //
        // closing the field in the FPath here
        // because it will be overwritten with a new field ID soon
        //
        F5Fclose( fpath );
 
#ifdef  DO_DATASPACE_CONSISTENCY_CHECK
        if (Dims)
        {
                if (!F5LTset_dataspace(fpath, rank, full_dims))
                {
                        F5printf(-1, "F5Fwrite_fraction(%s): cannot create, inconsistent dataspace!", fieldname);
                        return  F5_SUCCESS; /* ??? */
                }
        }
#endif
 
#if 0
        hm, we better drop this idea of automatically writing a contiguous field
        if a field covers the full dimension, because then the topology is
        no longer expandable...
 
        if (F5B_identical_dims(rank, full_dims, ldims) && F5B_identical_dims(rank, start_dims, 0) )
        {
                fpath->Field_hid = F5Lwrite(fpath->Representation_hid, fieldname,
                                            rank, full_dims,
                                            F5file_type(fpath, fieldtype), memtype, dataPtr,
                                            F5LTmake_enum_type(fpath), property_id);
 
                F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), Contigous);
                F5I_add_field(fpath, fieldname, FIBER_HDF5_REGULAR_FIELD);
 
                F5printf(30, "~F5Fwrite_fraction(%s) wrote contigous field", fieldname);
                return  F5_SUCCESS;
        }
#endif
        field_id = F5Lwrite_fraction(fpath->Representation_hid, fieldname, rank, Dims ? full_dims : NULL, ldims,
                                     F5file_type(fpath, fieldtype), memtype, dataPtr,
                                     start_dims,
                                     start_border?sborder:NULL, end_border?eborder:NULL,
                                     fraction_name, F5LTmake_enum_type(fpath), property_id);
 
        if (field_id<=0)
        {
                F5printf(0, "F5Fwrite_fraction(%s) error in writing field, illegal ID returned from low-level function.", fieldname);
                return F5ERROR_NONSPECIFIED;
        }
        assert( field_id );
 
        fpath->Field_hid = field_id;
 
        assert( fpath->Field_hid );
 
#if     1
/*
  there must be a reason why the type attribute writing was not enabled, but forgot why...
  It should be set because type identification should be faster on reading as no iteration
  over the group is required then.
  WB 2.SEP.16 */
 
/*      F5printf(10,"~F5Fwrite_fraction(%s) temporarily set type attribute...", fieldname); */
        F5Dset_type_attribute(fpath->Field_hid, F5file_type(fpath, fieldtype) );
#endif
 
        F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), FragmentedContiguous);
 
        assert( fpath->Field_hid );
        F5I_add_field(fpath, fieldname);
 
        F5printf(30, "~F5Fwrite_fraction(%s) wrote fragmented contigous field", fieldname);
        return  F5_SUCCESS;
}
 
 
 
 
 
F5ErrorCode F5Fwrite_fractionS(F5Path*fpath, const char*fieldname,
                               int rank, const hsize_t*Dims, const hsize_t*fraction_dims,
                               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 property_id)
{
hid_t   field_id;
int     i;
hsize_t full_dims[FIBER_MAX_RANK], start_dims[FIBER_MAX_RANK], ldims[FIBER_MAX_RANK],
        sborder[FIBER_MAX_RANK], eborder[FIBER_MAX_RANK];
 
        if (!fpath)
                return F5ERROR_INVALID_FPATH;
 
        F5print_dimensions(20, "F5Fwrite_fractionS", rank, fraction_dims);
 
        F5printf_indent++;
        F5Tpermute_dimensions(fpath, rank, full_dims , Dims );
        F5Tpermute_dimensions(fpath, rank, start_dims, datastart );
        F5Tpermute_dimensions(fpath, rank, ldims     , fraction_dims);
        F5Tpermute_dimensions(fpath, rank, sborder   , start_border );
        F5Tpermute_dimensions(fpath, rank, eborder   , end_border   );
        F5printf_indent--;
 
        if (Dims) for(i=0; i<rank; i++)
        {
                if (datastart[i] >= Dims[i])
                {
                        F5printf(-1, "F5Fwrite_fractionS(%s): fragment starts beyond dataspace in dimension %d: %d (max %d allowed)!",
                                 fieldname, i, (int)datastart[i], (int)Dims[i] );
                        return F5ERROR_INVALID_FRAGMENT_START;
                }
                if (datastart[i]+fraction_dims[i] > Dims[i])
                {
                        F5printf(-1, "F5Fwrite_fractionS(%s): fragment extends beyond dataspace in dimension %d: %d (max %d allowed)!",
                                 fieldname, i, (int)(datastart[i]+fraction_dims[i]), (int)Dims[i] );
                        return  F5ERROR_INVALID_FRAGMENT_END;
                }
        }
        //
        // closing the field in the FPath here
        // because it will be overwritten with a new field ID soon
        //
        F5Fclose( fpath );
 
#ifdef  DO_DATASPACE_CONSISTENCY_CHECK
        if (Dims)
        {
                if (!F5LTset_dataspace(fpath, rank, full_dims))
                {
                        F5printf(-1, "F5Fwrite_fractionS(%s): cannot create, inconsistent dataspace!", fieldname);
                        return  F5_SUCCESS; /* ??? */
                }
        }
#endif
 
        field_id = F5Lwrite_fractionS(fpath->Representation_hid, fieldname, rank, Dims ? full_dims : NULL, ldims,
                                      F5file_type(fpath, fieldtype), memtype, dataPtr,
                                      start_dims,
                                      start_border?sborder:NULL, end_border?eborder:NULL,
                                      fraction_name, F5LTmake_enum_type(fpath), property_id);
 
        if (field_id<=0)
        {
                return F5ERROR_NONSPECIFIED;
        }
 
        fpath->Field_hid = field_id;
 
        F5printf(10,"~F5Fwrite_fractionS(%s) temporarily set type attribute...", fieldname);
        F5Dset_type_attribute(fpath->Field_hid, F5file_type(fpath, fieldtype) );
 
        F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), FragmentedSeparatedCompound);
 
        F5I_add_field(fpath, fieldname);
 
        F5printf(30, "~F5Fwrite_fraction(%s) wrote fragmented contigous field", fieldname);
        return  F5_SUCCESS;
}
 
 
 
 
 
 
 
 
F5ErrorCode F5Fwrite_fraction_external(F5Path*fpath, const char*fieldname,
 
                                       const char *target_file_name,
                                       const char *target_obj_name,
                                       const char *prefix,
 
                              int rank, const hsize_t*Dims, const hsize_t*fraction_dims,
                              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 property_id)
{
hid_t   field_id;
int     i;
hsize_t full_dims[FIBER_MAX_RANK], start_dims[FIBER_MAX_RANK], ldims[FIBER_MAX_RANK],
        sborder[FIBER_MAX_RANK], eborder[FIBER_MAX_RANK];
 
        if (!fpath)
                return F5ERROR_INVALID_FPATH;
 
        F5printf(30, "F5Fwrite_fraction_external(%s, rank=%d)", fieldname, rank);
        if (rank==3)
                F5printf(20, "F5Fwrite_fraction_external(%lux%lux%lu)",
                (int)fraction_dims[0], (int)fraction_dims[1], (int)fraction_dims[2]);
        else if(rank==2)
                F5printf(20, "F5Fwrite_fraction_external(%lux%lu)",
                         (int)fraction_dims[0], (int)fraction_dims[1]);
        else if (rank==1)
                F5printf(20, "F5Fwrite_fraction_external(%lu)",
                         (int)fraction_dims[0]);
 
        F5printf_indent++;
 
        F5Tpermute_dimensions(fpath, rank, full_dims , Dims );
        F5Tpermute_dimensions(fpath, rank, start_dims, datastart );
        F5Tpermute_dimensions(fpath, rank, ldims     , fraction_dims);
        F5Tpermute_dimensions(fpath, rank, sborder   , start_border );
        F5Tpermute_dimensions(fpath, rank, eborder   , end_border   );
        F5printf_indent--;
 
        if (Dims) for(i=0; i<rank; i++)
        {
                if (datastart[i] >= Dims[i])
                {
                        F5printf(-1, "F5Fwrite_fraction(%s): fragment starts beyond dataspace in dimension %d: %d (max %d allowed)!",
                                 fieldname, i, (int)datastart[i], (int)Dims[i] );
                        return F5ERROR_INVALID_FRAGMENT_START;
                }
                if (datastart[i]+fraction_dims[i] > Dims[i])
                {
                        F5printf(-1, "F5Fwrite_fraction(%s): fragment extends beyond dataspace in dimension %d: %d (max %d allowed)!",
                                 fieldname, i, (int)(datastart[i]+fraction_dims[i]), (int)Dims[i] );
                        return  F5ERROR_INVALID_FRAGMENT_END;
                }
        }
        //
        // closing the field in the FPath here
        // because it will be overwritten with a new field ID soon
        //
        F5Fclose( fpath );
 
#ifdef  DO_DATASPACE_CONSISTENCY_CHECK
        if (Dims)
        {
                if (!F5LTset_dataspace(fpath, rank, full_dims))
                {
                        F5printf(-1, "F5Fwrite_fraction(%s): cannot create, inconsistent dataspace!", fieldname);
                        return  F5_SUCCESS; /* ??? */
                }
        }
#endif
        field_id = F5Lwrite_fraction_external(fpath->Representation_hid, fieldname,
 
                                              target_file_name,
                                              target_obj_name,
                                              prefix,
 
                                     rank, Dims ? full_dims : NULL, ldims,
                                     F5file_type(fpath, fieldtype), memtype, dataPtr,
                                     start_dims,
                                     start_border?sborder:NULL, end_border?eborder:NULL,
                                     fraction_name, F5LTmake_enum_type(fpath), property_id);
 
        fpath->Field_hid = field_id;
 
/*      F5printf(10,"~F5Fwrite_fraction(%s) temporarily set type attribute...", fieldname);
        F5Dset_type_attribute(fpath->Field_hid, F5file_type(fpath, fieldtype) );
*/
#if     0
/*
  As with HDF5 1.8.14 - 1.8.17, 1.10.0 , saving attributes with a named type that
  has been committed to another file than the external file does not work.
 */
        F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), FragmentedContiguous);
#else
        F5Tset_field_enum(fpath->Field_hid, F5Ttransient_F5field_Array_enum(), FragmentedContiguous);
#endif
 
        F5I_add_field(fpath, fieldname);
 
        F5printf(30, "~F5Fwrite_fraction(%s) wrote fragmented contigous field", fieldname);
        return  F5_SUCCESS;
}
 
 
int     F5Fis_fragmented(F5Path*fpath, const char*fieldname)
{
int major_version, minor_version, release_version;
ArrayType at = F5Fget_field_enum(fpath, fieldname,
                                 &major_version, &minor_version, &release_version);
 
        if (major_version != FIBER_MAJOR_VERSION ||
            minor_version != FIBER_MINOR_VERSION ||
            release_version != FIBER_RELEASE_VERSION)
                return 0;
 
        switch(at)
        {
        case FragmentedContiguous:
        case FragmentedSeparatedCompound:
        case FragmentedUniformSampling:
                return 1;
 
        default: return 0;
        }
}
 
int     F5Fis_separatedcompound(F5Path*fpath, const char*fieldname)
{
int major_version, minor_version, release_version;
ArrayType at = F5Fget_field_enum(fpath, fieldname,
                                 &major_version, &minor_version, &release_version);
 
        if (major_version != FIBER_MAJOR_VERSION ||
            minor_version != FIBER_MINOR_VERSION ||
            release_version != FIBER_RELEASE_VERSION)
                return 0;
 
        switch(at)
        {
        case FragmentedSeparatedCompound:
                return 1;
 
        default: return 0;
        }
}
 
int     F5B_iszero_dims(int rank, hsize_t*dims)
{
int     i;
        for(i=0; i<rank; i++)
                if (dims[i]>0) return 0;
 
        return 1;
}
 
int F5FSwrite_fraction(F5Path*fpath, const char*fieldname,
                       int rank, const hsize_t*dims, const hsize_t*frag_dims,
                       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 property_id,
                       int AllowFullCoverage)
{
hid_t   field_id;
hsize_t full_dims[FIBER_MAX_RANK], start_dims[FIBER_MAX_RANK], ldims[FIBER_MAX_RANK],
        sborder[FIBER_MAX_RANK], eborder[FIBER_MAX_RANK];
 
        F5printf(40, "F5FSwrite_fraction()");
        F5printf_indent++;
        F5Tpermute_dimensions(fpath, rank, full_dims , dims      );
        F5Tpermute_dimensions(fpath, rank, start_dims, datastart );
        F5Tpermute_dimensions(fpath, rank, ldims     , frag_dims );
        F5Tpermute_dimensions(fpath, rank, sborder   , start_border );
        F5Tpermute_dimensions(fpath, rank, eborder   , end_border   );
 
        if (rank==3)
        {
#ifdef  DO_DATASPACE_CONSISTENCY_CHECK
                if (dims)
                {
                        F5printf(60, "F5FSwrite_fraction() : "
                          "global dims=[%d,%d,%d] datastart=[%d,%d,%d] ldims=[%d,%d,%d]",
                                 (int)dims[0], (int)dims[1], (int)dims[2],
                                 (int)datastart[0], (int)datastart[1], (int)datastart[2],
                                         (int)ldims[0],  (int)ldims[1] , (int)ldims[2]
                                );
 
                        F5printf(60, "F5FSwrite_fraction()->"
                                 "full dataset=[%d,%d,%d] start=[%d,%d,%d] ldims=[%d,%d,%d]",
                                 (int)full_dims[0], (int)full_dims[1], (int)full_dims[2],
                                 (int)start_dims[0],(int)start_dims[1],(int)start_dims[2],
                                 (int)ldims[0],  (int)ldims[1] , (int)ldims[2]
                                );
                }
                else
                {
                        F5printf(60, "F5FSwrite_fraction() : "
                          "(no global dims) datastart=[%d,%d,%d] ldims=[%d,%d,%d]",
                                 (int)datastart[0], (int)datastart[1], (int)datastart[2],
                                         (int)ldims[0],  (int)ldims[1] , (int)ldims[2]
                                );
 
                        F5printf(60, "F5FSwrite_fraction()->"
                                 "(no full data dimensions) start=[%d,%d,%d] ldims=[%d,%d,%d]",
                                 (int)start_dims[0],(int)start_dims[1],(int)start_dims[2],
                                 (int)ldims[0],  (int)ldims[1] , (int)ldims[2]
                                );
                }
#endif
        }
        F5printf_indent--;
        F5Fclose( fpath );
 
#ifdef  DO_DATASPACE_CONSISTENCY_CHECK
        if (dims)
        {
                if (!F5LTset_dataspace(fpath, rank, full_dims))
                {
                        F5printf(-1, "F5FSwrite_fraction(%s): cannot create, inconsistent dataspace!", fieldname);
                        return 0;
                }
        }
#endif
 
#if 0
        if (F5B_identical_dims(rank, full_dims, end_dims) )
                F5printf(80, "F5FSwrite_fraction(%s) dimensions cover full dataset", fieldname);
        else
                F5printf(80, "F5FSwrite_fraction(%s) dimensions do not cover full dataset", fieldname);
 
        if (F5B_iszero_dims(rank, start_dims) )
                F5printf(80, "F5FSwrite_fraction(%s) fragment starts at zero", fieldname);
        else
                F5printf(80, "F5FSwrite_fraction(%s) fragment starts at some offset", fieldname);
#endif
 
        if (AllowFullCoverage && F5B_identical_dims(rank, full_dims, ldims) && F5B_iszero_dims(rank, start_dims) )
        {
                F5printf(8, "F5FSwrite_fraction(%s) writing full dataset", fieldname);
 
                fpath->Field_hid = F5Lwrites(fpath->Representation_hid, fieldname,
                                             rank, full_dims,
                                             F5file_type(fpath, fieldtype), memtype, dataPtr,
                                             F5LTmake_enum_type(fpath), property_id);
 
                if (fpath->Field_hid<=0)
                        return -1;
 
                F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), SeparatedCompound);
                F5I_add_field(fpath, fieldname);
                F5printf(9, "~F5FSwrite_fraction(%s) writing full dataset\n", fieldname);
 
                return 1;
        }
        F5printf(8, "F5FSwrite_fraction(%s) writing dataset fragment\n", fieldname);
 
        field_id = F5LSwrite_fraction(fpath->Representation_hid, fieldname, rank, full_dims, ldims,
                                      F5file_type(fpath, fieldtype), memtype, dataPtr,
                                      datastart?start_dims:NULL,
                                      start_border?sborder:NULL, end_border?eborder:NULL,
                                      fraction_name, F5LTmake_enum_type(fpath), property_id);
 
        fpath->Field_hid = field_id;
 
        if (fpath->Field_hid<=0)
                return -1;
 
/*
        F5printf(10,"~F5FSwrite_fraction(%s) temporarily set type attribute...", fieldname);
        F5Dset_type_attribute(fpath->Field_hid, F5file_type(fpath, fieldtype) );
*/
 
        F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), FragmentedSeparatedCompound);
 
        F5I_add_field(fpath, fieldname);
 
        F5printf(9, "F5FSwrite_fraction(%s) writing dataset fragment\n", fieldname);
        return 1;
}
 
static double poly_eval(const double coefficients[], int order, int x)
{
double  f = coefficients[0];
        if (order==1)
                f += x*coefficients[1];
        else
                return 0;  /* not coded yet... */
 
        return f;
}
 
void F5FevalX(double*result, int Mrank, const int index[],
              int components, const double*const polynomials[], const int polynom_order[],
              const int component_map[])
{
int i;
        for(i=0; i<Mrank; i++)
        {
        int     c = component_map[ i ];
                result[ c ] = poly_eval( polynomials[c], polynom_order[c], index[ i ] );
        }
/*
        for(i=0; i<components; i++)
        {
                result[i] = poly_eval( polynomials[i], polynom_order[i], index[ component_map[ i ] ] );
        }
*/
}
 
 
F5ErrorCode F5FwriteX(F5Path*fpath, 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   field_id;
hsize_t full_dims[FIBER_MAX_RANK];
 
        F5printf(40, "F5FwriteX()");
        F5Tpermute_dimensions(fpath, rank, full_dims , dims      );
 
        if (!F5LTset_dataspace(fpath, rank, full_dims))
        {
                F5printf(-1, "F5FSwriteX(%s): cannot create, inconsistent dataspace!", fieldname);
                return F5ERROR_INCONSISTENT_DATASPACE;
        }
 
        field_id = F5LwriteX(fpath->Representation_hid, fieldname,
                             rank, dims,
                             F5file_type(fpath, fieldtype), memtype,
                             dataPtr, polynom_order,
                             component_map,
                             property_id,
                             fpath->GlobalChart_hid);
 
        if (field_id<0)
        {
                F5printf(-1, "F5FSwriteX(%s): cannot create direct product field!",
                         fieldname);
 
                if (field_id == -2) return F5ERROR_COMPOUND_EXPECTED;
                if (field_id == -3) return F5ERROR_COMPONENTMAP_EXPECTED;
                if (field_id == -4) return F5ERROR_COMPONENTMAP_INVALID;
 
                return F5ERROR_ALREADY_EXISTS;
        }
 
        F5Fclose( fpath );
        fpath->Field_hid = field_id;
 
/*
        F5printf(10,"~F5FSwrite_fraction(%s) temporarily set type attribute...", fieldname);
        F5Dset_type_attribute(fpath->Field_hid, F5file_type(fpath, fieldtype) );
*/
 
        F5Tset_field_enum(fpath->Field_hid, F5LTmake_enum_type(fpath), DirectProduct );
 
        F5I_add_field(fpath, fieldname);
 
        F5printf(9, "F5FSwriteX(%s) writing direct product\n", fieldname);
        return F5_SUCCESS;
}
 
 
static  const char*F5Fblockname(int dimensions, const hsize_t*start)
{
        puts("Default blockname is unimplemented!");
        return "block";
}
 
static  int is_all_zero(int rank, const hsize_t*data)
{
int     i = 0;
        for(i=0; i<rank; i++)
                if (data[i]) return 0;
 
        return 1;
}
 
int     F5Fwrite_linear_fraction_overlap(F5Path*myPath,
                                         int rank,
                                         const hsize_t*start_border,
                                         const hsize_t*end_border,
                                         const char*fraction_name)
{
        if (!myPath           ) return 0;
        if (!myPath->Field_hid) return 0;
        if (!fraction_name)     return 0;
 
hid_t   B_id = H5Gopen2( myPath->Field_hid,  fraction_name, H5P_DEFAULT);
        if (start_border)
        {
        hsize_t sborder[FIBER_MAX_RANK];
                if (!is_all_zero(rank, start_border))
                {
                        F5Tpermute_dimensions(myPath, rank, sborder   , start_border );
                        F5LAsave_dimensions(B_id, FIBER_FRAGMENT_NOOVERLAP_START_ATTRIBUTE, rank, sborder);
                }
        }
        if (end_border)
        {
        hsize_t eborder[FIBER_MAX_RANK];
                if (!is_all_zero(rank, end_border))
                {
                        F5Tpermute_dimensions(myPath, rank, eborder   , end_border   );
                        F5LAsave_dimensions(B_id, FIBER_FRAGMENT_NOOVERLAP_END_ATTRIBUTE, rank, eborder);
                }
        }
        F5Xclose(B_id);
        return 1;
}
 
int     F5Fwrite_linear_fraction(F5Path*fpath, const char*fieldname,
                                 int rank, const hsize_t*full_dims,
                                 const hsize_t*local_dims,
                                 hid_t fieldtype, const void*base, const void*delta,
                                 const hsize_t*datastart,
                                 const char*fraction_name)
{
hid_t   F_id = F5Gappend(fpath->Representation_hid, fieldname);
hid_t   B_id;
hsize_t ldims[FIBER_MAX_RANK];
hsize_t offset[FIBER_MAX_RANK];
//int   i;
const char*fragment_name = fraction_name?fraction_name:F5Fblockname(rank, datastart);
        F5Fclose( fpath );
 
        F5printf(8, "F5Fwrite_linear_fraction(%s)\n", fieldname);
 
        F5Tpermute_dimensions(fpath, rank, ldims, local_dims );
        F5Tpermute_dimensions(fpath, rank, offset, datastart );
 
        B_id = F5Lwrite_linear(F_id, fragment_name, rank, ldims,
                               F5file_type(fpath, fieldtype),
                               base, delta);
 
        if (B_id<=0)
                return 0;
 
        F5Tset_field_enum(B_id, F5LTmake_enum_type(fpath), UniformSampling);
 
        if (full_dims)
                F5Lset_space(F_id, rank, full_dims);
 
        F5LAsave_dimensions(B_id, FIBER_FRAGMENT_OFFSET_ATTRIBUTE, rank, offset);
 
        F5Xclose(B_id);
 
        fpath->Field_hid = F_id;
 
        F5Tset_field_enum(F_id, F5LTmake_enum_type(fpath), FragmentedUniformSampling);
 
        F5I_add_field(fpath, fieldname);
 
        F5printf(9, "~F5Fwrite_linear_fraction(%s)\n", fieldname);
        return 1;
}
 
 
 
F5_API int  F5Fwrite_linear(F5Path*fpath, const char*fieldname,
                            int rank, hsize_t*dims,
                            hid_t fieldtype, const void * base, const void*delta)
{
hid_t   field_id;
hsize_t save_dims[FIBER_MAX_RANK];
 
        F5printf(40,"F5Fwrite_linear(%s): rank=%d, dims=%dx%dx%dx%d)", fieldname, rank,
                 rank>0?(int)dims[0]:1, rank>1?(int)dims[1]:1, rank>2?(int)dims[2]:1, rank>3?(int)dims[3]:1 );
 
        F5printf_indent++;
        F5Tpermute_dimensions(fpath, rank, save_dims, dims );
        F5printf_indent--;
 
        F5Fclose( fpath );
 
        F5printf(41,"F5Fwrite_linear(%s): permuted dims: rank=%d, dims=%dx%dx%dx%d)", fieldname, rank,
                 rank>0?(int)save_dims[0]:1, rank>1?(int)save_dims[1]:1, rank>2?(int)save_dims[2]:1, rank>3?(int)save_dims[3]:1 );
 
        if (!F5LTset_dataspace(fpath, rank, save_dims))
        {
                F5printf(-1, "F5Fwrite_linear(%s): cannot create, inconsistent dataspace!", fieldname);
                return 0;
        }
 
        field_id = F5Lwrite_linear(fpath->Representation_hid, fieldname,
                                   rank, save_dims,
                                   F5file_type(fpath, fieldtype),
                                   base, delta);
 
        if (field_id<0) return 0; /* already exists? */
 
        {
        int     rank = H5Tget_nmembers( fieldtype );
 
                F5LAsave_dimensions(field_id, FIBER_UNIFORMARRAY_ELEMENTS_ATTRIBUTE, rank, dims);
        }
 
        fpath->Field_hid = field_id;
 
        F5Tset_field_enum(field_id, F5LTmake_enum_type(fpath), UniformSampling);
 
        F5I_add_field(fpath, fieldname);
 
        F5printf(40, "~F5Fwrite_linear()");
        return 1;
}
 
int F5Fis_linear(F5Path*fpath, const char*fieldname)
{
        return F5Lis_linear(fpath->Representation_hid, fieldname);
}
 
int F5Fread_linear(F5Path*fpath,
                  hsize_t*dims,
                  hid_t fieldtype, void * base, void*delta)
{
hid_t   field_id;
int     rank;
hsize_t file_dims[FIBER_MAX_RANK];
 
        F5printf(40, "F5Fread_linear()");
/*      F5Fclose( fpath );  */
 
/*      field_id = F5Lread_linear(fpath->Representation_hid, fieldname, */
 
        field_id = F5Lread_linear(fpath->Field_hid,
                                  file_dims,
                                  fieldtype,
                                  base, delta);
 
        if (field_id < 0 )
                return 0;
 
        if (dims)
        {
                rank = H5Tget_nmembers( fieldtype );
                F5printf_indent++;
                F5Tpermute_dimensions(fpath, rank, dims, file_dims );
                F5printf_indent--;
        }
 
        F5printf(40, "~F5Fread_linear()");
        return 1;
}
 
int F5Fread_linear_fragment(F5Path*fpath,
                        hid_t fragment_hid,
                        hsize_t*dims,
                        hid_t fieldtype, void * base, void*delta)
{
hid_t   field_id;
int     rank;
hsize_t file_dims[FIBER_MAX_RANK];
 
        F5printf(40, "F5Fread_linear()");
                /*      F5Fclose( fpath );  */
 
                                        /*      field_id = F5Lread_linear(fpath->Representation_hid, fieldname, */
 
        field_id = F5Lread_linear(fragment_hid,
                                  file_dims,
                                  fieldtype,
                                  base, delta);
 
        if (field_id < 0 )
                return 0;
 
        if (dims)
        {
                rank = H5Tget_nmembers( fieldtype );
                F5printf_indent++;
                F5Tpermute_dimensions(fpath, rank, dims, file_dims );
                F5printf_indent--;
        }
 
        F5printf(40, "~F5Fread_linear()");
        return 1;
}
 
 
 
 
/************************************************
 
 Attribute functions operating on fields.
 
*************************************************/
 
int     F5Fget_attribute_byname( F5Path*f, const char*attribute_name,
                                 void*data, hsize_t N, hid_t mem_type_id,
                                 const char*fragment_name)
{
herr_t  err;
hid_t   attr_id, type_id;
        if (!f)
        {
                F5printf(5, "Open attribute %s without path object cannot succeed!", attribute_name);
                return  0;
        }
 
        if (fragment_name)
        {
        hid_t   frag_id = F5Gtry_to_open(f->Field_hid, fragment_name);
                if (frag_id<0)
                {
                        frag_id = F5Dtry_to_open(f->Field_hid, fragment_name);
                        if (frag_id<0)
                        {
                                F5printf(5, "F5Fget_attribute_byname(%s,%s). No such fragment.", attribute_name, fragment_name);
                                return 0;
                        }
                }
 
                attr_id = F5Atry_to_open( frag_id, attribute_name);
                F5Xclose( frag_id );
        }
        else
                attr_id = F5Atry_to_open( f->Field_hid, attribute_name);
 
        if (attr_id<0)
        {
                /* attribute not found */
                F5printf(5, "Open attribute %s in fragment %s not found.", attribute_name, fragment_name);
                return 0;
        }
 
        {
        hid_t   space_id = H5Aget_space(attr_id);
        hsize_t NumberofExistingAttributeElements = H5Sget_simple_extent_npoints(space_id);
                H5Sclose(space_id);
                if (NumberofExistingAttributeElements != N)
                {
                        F5printf(1,"F5Fget_attribute_byname() MISMATCH - trying to read %d elements for attribute %s which has %d elements in file.",
                                 (int)N, attribute_name, (int)NumberofExistingAttributeElements);
                        return 0;
                }
        }
 
        if (mem_type_id)
                type_id = mem_type_id;
        else
                type_id  = H5Aget_type(attr_id);
 
        {
        H5E_BEGIN_TRY
        err =   F_H5Aread(attr_id, type_id, data, attribute_name);
        H5E_END_TRY
        }
 
        H5Aclose(attr_id);
 
        if (!mem_type_id)
                H5Tclose(type_id);
 
        if (err<0)
                return 0;
        else
                return 1;
}
 
 
int     F5Fget_range( F5Path*f, const char* fragment_name, void*minmax )
{
hid_t   type_id = F5Fget_type(f);
 
int     check = F5Fget_attribute_byname( f, FIBER_FIELD_COMPONENT_RANGE, minmax, 2, type_id , fragment_name);
 
        if( H5Iis_valid( type_id ) )
                if( H5Iget_type( type_id ) >= 0 )
                        H5Tclose(type_id);
        return check;
}
 
 
 
int     F5Fset_attribute_byname( F5Path*f, const char*attribute_name,
                                 const void*data, hsize_t N,
                                 hid_t mem_type_id,
                                 const char*fragment_name)
{
hid_t   attr_id, space_id;
        if (!f)
        {
                F5printf(5,"F5Fset_attribute() got NULL F5Path, cannot set attribute %s .",attribute_name);
                return 0;
        }
        if (f->Field_hid<1)
        {
                F5printf(5,"F5Fset_attribute() F5Path has no field ID, cannot set attribute %s .",attribute_name);
                return 0;
        }
 
        space_id = H5Screate_simple(1, &N, &N );
 
        if (fragment_name)
        {
        hid_t   frag_id;
                H5E_BEGIN_TRY
                frag_id = H5Gopen2(f->Field_hid, fragment_name, H5P_DEFAULT);
                H5E_END_TRY
                if (frag_id<0)
                {
                        frag_id = F5Dtry_to_open(f->Field_hid, fragment_name);
                }
 
                attr_id = F5Atry_to_open( frag_id, attribute_name);
                if (attr_id<0)
                        attr_id = F5Acreate( frag_id, attribute_name, mem_type_id, space_id, H5P_DEFAULT);
 
                F5Xclose( frag_id );
        }
        else
        {
                attr_id = F5Atry_to_open( f->Field_hid, attribute_name);
                if (attr_id<0)
                        attr_id = F5Acreate( f->Field_hid, attribute_name, mem_type_id, space_id, H5P_DEFAULT);
        }
 
        H5Sclose( space_id );
 
        if (attr_id<0)
        {
                F5printf(5,"F5Fset_attribute() Could neither open or create attribute %s .",attribute_name);
                return 0;
        }
 
        H5Awrite(attr_id, mem_type_id, data );
        H5Aclose(attr_id);
        return 1;
}
 
 
F5_API int F5Fset_range(F5Path*f, const char*fragment_name, const void*minmax)
{
hid_t   type_id = F5Fget_type(f);
int     check;
        if (type_id<=0)
                return 0;
 
        check = F5Fset_attribute_byname(f,
                                        FIBER_FIELD_COMPONENT_RANGE, minmax, 2,
                                        type_id, fragment_name);
 
        H5Tclose(type_id);
 
        return check;
}