F5private.c

Go to the documentation of this file.

#include "F5private.h"
#include "F5X.h"
#include "F5B.h"
#include "F5A.h"
 
#include <assert.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
 
hid_t F5Acreate(hid_t loc_id, const char *name, hid_t type_id, hid_t space_id, hid_t create_plist )
{
        return H5Acreate2( loc_id, name, type_id, space_id,  create_plist, H5P_DEFAULT );
}
 
#if 0
#if 0
 
hid_t F5AScreate(hid_t location, const char*name, hid_t type, hid_t space, hid_t property_id)
{
        return H5Acreate(location, name, type, space, property_id);
}
 
herr_t  F5ASwrite(hid_t attr_hid, hid_t type, const void*data)
{
        return H5Awrite(attr_hid, type, data);
}
 
herr_t  F5ASclose(hid_t attr_hid)
{
        return H5Aclose(attr_hid);
}
 
hid_t   F5ASopen(hid_t location, const char*name)
{
        return F5Aopen_name(location, name);
}
 
hid_t   F5ASget_space(hid_t attr_hid)
{
        return H5Aget_space(attr_hid);
}
 
herr_t  F5ASread(hid_t attr_id, hid_t type, void*data)
{
        return H5Aread(attr_id, type, data );
}
 
#else
 
/*
 F5 wrap functions for simulating attributes with shared types.
 These function behave exactly like the H5A... functions, but the given type
 may be a shared datatype.
 
 The trouble here is that HDF5 allows shared datatypes only for datasets,
 not for attributes. Thus we simulate an attribute via datasets here.
 
 @note location must be a group or file ID, in contrast to H5A...,
       it must not be a dataset or named datatype ID.
*/
 
hid_t   F5AScreate(hid_t location, const char*name, hid_t type, hid_t space, hid_t property_id)
{
        return H5Dcreate(location, name, type, space, property_id);
}
 
herr_t  F5ASwrite(hid_t attr_hid, hid_t type, const void*data)
{
        return H5Dwrite(attr_hid, type, H5S_ALL , H5S_ALL, H5P_DEFAULT, data);
}
 
herr_t  F5ASclose(hid_t attr_hid)
{
        return H5Dclose( attr_hid);
}
 
hid_t   F5ASopen(hid_t location, const char*name)
{
        return H5Dopen(location, name);
}
 
hid_t   F5ASget_space(hid_t attr_hid)
{
        return H5Dget_space(attr_hid);
}
 
hid_t   F5ASget_type(hid_t attr_hid)
{
        return H5Dget_type(attr_hid);
}
 
herr_t  F5ASread(hid_t attr_id, hid_t type, void*data)
{
        return H5Dread(attr_id, type, H5S_ALL, H5S_ALL, H5P_DEFAULT, data);
}
 
#endif
#endif
 
 
 
hid_t   F5I_create_contents(hid_t File_id)
{
hid_t   TOC_id;
hid_t   G_id;
 
        if (File_id<0)
        {
                F5printf(0, "F5I_create_contents(): Invalid File!\n");
                return -1;
        }
 
        F5printf(30, "F5I_create_contents(%d): mkgroup %s", File_id, FIBER_CONTENTS) ;
        TOC_id = F5Gappend(File_id, FIBER_CONTENTS);
 
        if (TOC_id<0)
                return -1;
 
        H5E_BEGIN_TRY
        H5Adelete(TOC_id, FIBER_VERSION_ATTRIBUTE_NAME);
        H5E_END_TRY
 
        F5Asave_version(TOC_id, FIBER_MAJOR_VERSION, FIBER_MINOR_VERSION, FIBER_RELEASE_VERSION);
 
        G_id = F5Gappend(TOC_id, FIBER_CONTENT_GRIDS);
        assert(G_id>0);
        H5Gclose( G_id);
        G_id = F5Gappend(TOC_id, FIBER_CONTENT_FIELDS);
        H5Gclose( G_id);
 
        H5Gset_comment(File_id, FIBER_CONTENTS,
                       "All file objects in reverse order for easier browsing. ");
 
        H5Gset_comment(TOC_id, FIBER_CONTENT_GRIDS,
                       "All grids and their sequences.");
 
        {
        hid_t param_space_id = F5Gappend(TOC_id, FIBER_PARAMETER_SPACE);
        hid_t time_param_id  = F5Gappend(param_space_id, FIBER_HDF5_TIME_ATTRIB);
                H5Gclose(time_param_id);
                H5Gclose(param_space_id);
        }
        F5printf(30, "~F5I_create_contents()") ;
        return TOC_id;
}
 
herr_t  F5Glink_soft_to_id(hid_t loc_id, hid_t existing_id, const char*linkname)
{
char    objname[2048];
herr_t  retval = H5Iget_name(existing_id, objname, sizeof(objname) );
 
        if (retval<1)
                return retval;
 
        F5printf(30, "F5Glink(%s)", linkname);
        retval = H5Glink(loc_id,  H5G_LINK_SOFT, objname, linkname);
        F5printf(30, "~F5Glink()");
        return retval;
}
 
herr_t F5Glink(hid_t loc_id, H5G_link_t link_type, const char *current_name, const char *new_name  )
{
herr_t  retval;
        H5E_BEGIN_TRY
        retval = H5Glink(loc_id,  link_type,  current_name, new_name);
        H5E_END_TRY
 
        if (retval<0)
                F5printf(30, "F5Glink(,,%s -> %s) FAILED\n", current_name, new_name);
        else
                F5printf(30, "F5Glink(,,%s -> %s) DONE\n", current_name, new_name);
 
        return retval;
}
 
 
void    F5I_add_field(F5Path*fpath, const char*fieldname)
{
        if (!fpath) return;
 
        if (!fpath->Field_hid)
        {
                F5printf(3, "F5I_add_field(%s): INVALID Field ID %ld",fieldname, (long)fpath->Field_hid); 
                assert(fpath->Field_hid);
                return;
        } 
        F5printf(30, "F5I_add_field(%s)",fieldname);
 
        /* Creating Field Information per Bundle */
        {
hid_t   FieldTable = F5Gappend(fpath->ContentsGroup_hid, FIBER_CONTENT_FIELDS);
hid_t   FieldInfo  = F5Gappend(FieldTable, fieldname);
 
char    gridref[2048] = "/" FIBER_CONTENTS "/" FIBER_CONTENT_GRIDS "/";
char    gridname[2048];
char    *g;
 
        if (fpath->Grid_hid<0)
        {
                F5printf(-1, "F5I_add_field(): FATAL INTERNAL ERROR: No Grid id!");
                return;
        }
        if (H5Iget_name(fpath->Grid_hid, gridname, sizeof(gridname) )<1)
        {
                F5printf(-1, "F5I_add_field(): Could not get name for Grid id!");
                assert(0);
        }
 
        /* /T=1234.5676/myFunnyGrid */
        g = strrchr(gridname, '/');
        if (!g) g = gridname; else g++;
/*      puts(g);        */
        strcat(gridref, g);
 
        /*
         NOTE: This link might already exist!
               If so, it's not an error.
        */
        H5E_BEGIN_TRY
        /*  /TableOfContents/Fields/myFunnyField/myFunnyGrid -> /TableOfContents/Grids/myFunnyGrid   */
        H5Glink(FieldInfo, H5G_LINK_SOFT, gridref , g);
        H5E_END_TRY
 
        H5Gclose( FieldInfo );
        H5Gclose( FieldTable );
        }
}
 
void    F5I_add_grid(F5Path*fpath, const char*gridname, const double*time)
{
hid_t   GridsTable     ;
hid_t   GridInfo       ;
 
TimeTableEntry GridTimeInfo;
 
        if (!fpath) return;
 
        F5printf(30, "F5I_add_grid(%s,t=%g)@%d", gridname, *time, (int)(fpath->ContentsGroup_hid) );
 
        GridsTable     = F5Gappend(fpath->ContentsGroup_hid, FIBER_CONTENT_GRIDS);
 
        F5printf(30, "F5I_add_grid(%s,t=%g): grid table %d", gridname, *time, (int)(GridsTable) );
 
        GridInfo       = F5Gappend(GridsTable, gridname);
 
        if (time)
                GridTimeInfo.TimeValue = *time;
 
        GridTimeInfo.TimesliceName[0] = '/';
        F5I_timegroup(time, GridTimeInfo.TimesliceName+1, F5_TIMESLICE_NAME_LENGTH-2 );
 
#if     0
        if (time)
        {
        double  T = *time;
                printf("F5I_add_grid(T=%g) TimeTableEntry={%g, %s})\n",
                       T,
                       GridTimeInfo.TimeValue,
                       GridTimeInfo.TimesliceName);
 
                assert( GridTimeInfo.TimeValue == *time);
        }
        else
                printf("F5I_add_grid() TimeTableEntry={(undefined),%s})\n",
                       GridTimeInfo.TimesliceName );
#endif
 
 
 
/*
  Note: We could link here directly to the respective grid.
        However, then we cannot get the concrete time for which the grid is valid,
        because grid groups don't have a time attribute by themselves such that
        the same grid object can be shared among multiple timesteps.
        For the same reason, it does not have a backlink to the slice group where
        it is contained.
        Thus, when browsing via grid types, it is required to specify the grid name
        twice:
 
         /TableOfContents/Grids/MyFunnyGrid/T=1234.5676/MyFunnyGrid/
 
*/
        H5E_BEGIN_TRY
        /* ln -s /TableOfContents/Grids/MyFunnyGrid/T=1234.5676 -> /T=1234.5676   */
        H5Glink(GridInfo, H5G_LINK_SOFT, GridTimeInfo.TimesliceName, GridTimeInfo.TimesliceName+1);
        H5E_END_TRY
 
        if (time)
        {
/*
  ln -s /T=1234.5676/MyFunnyGrid/F5::TimeTable -> /TableOfContents/Grids/MyFunnyGrid/
 */
        herr_t  timetableError;
 
                H5E_BEGIN_TRY
                timetableError = H5Lcreate_hard( GridsTable, gridname, /* targetname */
                                                 fpath->Grid_hid, F5_TIMETABLE_NAME, /* linkname */
                                                 H5P_DEFAULT, H5P_DEFAULT);
                H5E_END_TRY
 
                if (timetableError>=0)
                {
                        F5Bappend_timetable(GridInfo, fpath->ContentsGroup_hid, &GridTimeInfo, 1);
                }
        }
 
        H5Gclose(GridsTable);
        H5Gclose(GridInfo);
}
 
static  int F5verbosity()
{
static int verbosity = 0;
static const char*F5_VERBOSITY = 0;
 
        /* avoid parsing the environment string at each call */
        if (F5_VERBOSITY)
                return verbosity;
 
        F5_VERBOSITY = getenv("F5_VERBOSITY");
        if (!F5_VERBOSITY)
        {
                F5_VERBOSITY = "0";
                return verbosity;
        }
        verbosity = atoi(F5_VERBOSITY);
 
        return verbosity;
}
 
herr_t F_H5Aread(hid_t attr_id, hid_t mem_type_id, void *buf, const char*name )
{
        F5printf(50, "Reading attribute `%s'", name);
        return H5Aread(attr_id, mem_type_id, buf);
}
 
#ifdef  H5Gclose
#undef  H5Gclose
#endif
 
herr_t _F5Gclose(hid_t id, const char*filename, int lineno)
{
        F5printf(110, "   H5Gclose(%lx): %s(%d)", (long)id, filename, lineno );
        return H5Gclose( id );
}
 
 
int F5printf_indent = 0;
 
#undef  F5printf
void    F5printf(int verbosity, const char *fmt,...)
{
va_list argptr;
int     i;
        if (verbosity > F5verbosity() )
                return;
 
        va_start(argptr, fmt);
        for(i = 0; i<F5printf_indent; i++)
                putc(' ',stderr);
        vfprintf(stderr, fmt, argptr);
        putc('\n',stderr);
        fflush(stderr);
        va_end(argptr);
}
 
void    F5printx(int verbosity, const char*sourcefilename, int lineNo, const char*FunctionName,
                 const char *fmt,...)
{
va_list argptr;
int     i;
int     EffectiveVerbosity = F5verbosity();
        if (EffectiveVerbosity<0) EffectiveVerbosity = -EffectiveVerbosity;
        if (verbosity > EffectiveVerbosity)
                return;
 
        if (F5verbosity()<0)
        {
                fprintf(stderr, "%s:%d [%s]\t", sourcefilename, lineNo, FunctionName);
        }
 
        va_start(argptr, fmt);
        for(i = 0; i<F5printf_indent; i++)
                putc(' ',stderr);
        vfprintf(stderr, fmt, argptr);
        putc('\n',stderr);
        fflush(stderr);
        va_end(argptr);
}
 
 
 
void    F5print_dimensions(int verbosity, const char*prefix, int rank, const hsize_t dims[])
{
        if (rank==3)
                F5printf(verbosity, "%s(%ux%ux%u)", prefix,
                (int)dims[0], (int)dims[1], (int)dims[2]);
        else if(rank==2)
                F5printf(verbosity, "%s(%ux%u)", prefix,
                         (int)dims[0], (int)dims[1]);
        else if (rank==1)
                F5printf(verbosity, "%s(%u)", prefix,
                         (int)dims[0]);
        
}
 
 
 
void F5print_OpenHandles( hid_t file_id )
{
        puts("F5print_OpenHandles"); fflush(stdout);
 
ssize_t obj_nr;
        obj_nr = H5Fget_obj_count( file_id, H5F_OBJ_ALL );
 
        if( obj_nr < 0 )
                puts("F5print_OpenHandles() Error retrieving number of open objects" );
 
        printf( "Open HDF5 object handles: %ld \n", obj_nr );
 
hid_t* objs = (hid_t*)calloc( obj_nr, sizeof( hid_t )  );
 
ssize_t check = H5Fget_obj_ids( file_id, H5F_OBJ_ALL, -1, objs );
        assert( check == obj_nr );
 
ssize_t i;
        for( i = 0; i < obj_nr; ++i)
        {
        htri_t valid;
                valid = H5Iis_valid( objs[i] ) ;
 
                if( valid == 0 )
                {
                        printf( " [%ld] is invalid!\n");
                        continue;
                }
                else if( valid < 0 )
                {
                        printf( " [%ld] Error on validness check!\n");
                        continue;
                }
 
        H5I_type_t type;
                type = H5Iget_type( objs[i] );
                if( type < 0)
                        puts( "Error retrieving type of open object." );
 
 
        int refs;
                refs = H5Iget_ref( objs[i] );
 
        char name_buf[512];
                H5Iget_name( objs[i], name_buf, 512 );
 
 
                switch( type )
                {
                CASEITEM( H5I_FILE, i, refs, name_buf )
                CASEITEM( H5I_GROUP, i, refs , name_buf )
                CASEITEM( H5I_DATATYPE, i, refs , name_buf )
                CASEITEM( H5I_DATASPACE, i, refs , name_buf )
                CASEITEM( H5I_DATASET, i, refs , name_buf )
                CASEITEM( H5I_ATTR, i, refs , name_buf )
                CASEITEM( H5I_BADID, i, refs , name_buf )
 
                default:
                        printf (" [%ld]: unknown type\n", i);
                }
        }
 
        free(objs);
}