F5Bslice.c

Go to the documentation of this file.

#include "hdf5inc.h"
#include <string.h>
 
#include "F5B.h"
#include "F5A.h"
#include "F5defs.h"
#include "F5X.h"
#include "F5private.h"
 
const char*F5_default_time_attrib_names[] =
{ "time", "Time", "TIME", 0 };
 
struct slice_info
{
        const char**time_attribs;
        hid_t what;
        double*t, nearest_t;
};
 
static  herr_t slice_iter (hid_t loc_id, const char *name, void *opdata)
{
struct slice_info*si = (struct slice_info*)opdata;
hid_t gid = H5Gopen2(loc_id, name, H5P_DEFAULT );
const char**s;
 
        for(s=si->time_attribs; *s; s++)
        {
        hid_t   attr_id;
        double  t = 0;
 
                attr_id = F5Atry_to_open(gid, *s);
                if (attr_id<0)
                        continue;
 
                if (F_H5Aread(attr_id, H5T_NATIVE_DOUBLE, &t, *s)<0)
                {
                        H5Aclose(attr_id);
                        continue;
                }
                H5Aclose(attr_id);
/*              printf("SLICE: Have T=%lg, Query: T=%lg\n", t, *si->t);*/
                if (t>(*si->t) )
                {
                        return 1;
                }
                si->nearest_t = t;
                break;
        }
        if (si->what>0)
                H5Gclose(si->what);
        si->what = gid;
        return 0;
}
 
hid_t   F5BgetMostRecentSlice(double*t, hid_t loc_id, const char**time_attribs)
{
struct slice_info si = { 0, -1, 0 };
        si.time_attribs = time_attribs;
        si.t = t;
 
        H5Giterate(loc_id, ".", 0, slice_iter, &si);
 
        if (si.what>0)
                *t = si.nearest_t;
 
        return si.what;
}
 
 
hid_t   F5BgetMostRecentFileSlice(double t, const char*filename)
{
hid_t   fid = H5Fopen(filename, H5F_ACC_RDONLY, H5P_DEFAULT);
 
        if (fid<0)
                return -1;
 
{hid_t  slice_id = F5BgetMostRecentSlice(&t, fid, F5_default_time_attrib_names);
 
        H5Fclose(fid);
 
        if (slice_id>0)
        {
                printf("F5Bslice: got data slice for T=%lg\n", t);
        }
 
        return slice_id;
}
}
 
char*F5I_timegroup(const double*time, char*destbuf, size_t len)
{
int     precision = 10;
char    *result = destbuf;
        if (!time)
        {
                return strncpy(destbuf, FIBER_STATIC_DATA, len);
        }
 
#ifdef  _MSC_VER
        _snprintf
#else
        snprintf
#endif
                (destbuf,len,"t=%0*.*f", 2*precision, precision, *time);
 
/*
  (destbuf,len,"t=%0*.*lf", 2*precision, precision, *time);
*/
 
 
/*      printf("TIME %lg -->\n", time); */
        return result;
}
 
int     F5setTimeUnit(hid_t file_id, const F5_TimeParameter*TP)
{
/* TODO:
        Create a type which is convertible to "double",
        Open group FIBER_HDF5_GLOBAL_CHARTS
        Commit the type to this group
        Add attributes to this group which describe the type's
        unit
        Close it
 
        And do all that with checking whether such an type
        already exists before.
 
        Only the offset, TimeSemantics and comment members from
        the F5_TimeParameter structure are used.
 */
        return 0;
}
 
hid_t   F5Bappend_timeslice(hid_t file_id, const F5_TimeParameter*time)
{
        /* ...TODO: Coding....... */
        return F5Bappend_slice(file_id, &time->value);
}
 
hid_t   F5Bappend_slice(hid_t file_id, const double*time)
{
char    timename[128];
hid_t   Slice_hid = F5Gappend(file_id, F5I_timegroup(time, timename, sizeof(timename) ));
 
        if (time)
                F5printf(30," -- F5Bappend_slice(%lg)", *time);
        else
                F5printf(30," -- F5Bappend_slice( <static> )");
 
        if (time)
        {
                /* TODO: add time slice attribute ONLY if it is not yet
                   //       there. Think about: what if it is there, but is
                   //   not consistent?
                */
        hid_t space_hid = H5Screate(H5S_SCALAR);
        hid_t attr_hid  = F5Aappend(Slice_hid, FIBER_HDF5_TIME_ATTRIB , H5T_NATIVE_DOUBLE, space_hid, H5P_DEFAULT);
                H5Awrite(attr_hid, H5T_NATIVE_DOUBLE,  time);
                H5Sclose(space_hid);
                H5Aclose(attr_hid);
        }
        return Slice_hid;
}
 
/*********** TIMETABLE FUNCTIONS *************/
 
hid_t   F5Bcreate_timetable_type()
{
hid_t   dtype_id = H5Tcreate( H5T_COMPOUND, sizeof(TimeTableEntry) );
        {
        hid_t   string_dtype_id = H5Tcreate( H5T_STRING, F5_TIMESLICE_NAME_LENGTH );
                H5Tinsert( dtype_id, FIBER_HDF5_TIME_ATTRIB, 0, H5T_NATIVE_DOUBLE);
                H5Tinsert( dtype_id, "F5::SliceGroup", sizeof(double), string_dtype_id );
                H5Tclose( string_dtype_id );
        }
        return dtype_id;
}
 
static  int     F5check_timetable_Type(hid_t type_id)
{
        if (type_id<0)
                return 0;
 
        if (H5Tget_class(type_id) == H5T_COMPOUND)
        {
                if (H5Tget_nmembers( type_id) == 2)
                        return 1;
        }
        return 0;
}
 
hid_t   F5Bget_file_timetable_type(hid_t loc_id)
{
hid_t   timetable_type_id;
 
        H5E_BEGIN_TRY
        timetable_type_id = H5Topen2( loc_id, F5_TIMETABLE_NAME, H5P_DEFAULT );
        H5E_END_TRY
        if (F5check_timetable_Type(timetable_type_id) )
        {
                return timetable_type_id;
        }
 
        timetable_type_id = F5Bcreate_timetable_type();
 
        H5Tcommit2( loc_id, F5_TIMETABLE_NAME, timetable_type_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
 
        return timetable_type_id;
}
 
static  hid_t   F5Bcreate_timetable_dataset(hid_t loc_id, hid_t dtype_location_id, hsize_t init_dims)
{
hsize_t maximum_dims = H5S_UNLIMITED;
hid_t   space_id = H5Screate_simple( 1, &init_dims, &maximum_dims );
 
hid_t   dset_creation_property_id = H5Pcreate( H5P_DATASET_CREATE );
 
hid_t   dataset_id;
 
hsize_t chunk_length = 1024;
 
hid_t   dtype_id = F5Bget_file_timetable_type( dtype_location_id );
 
        if (dtype_id<0)
        {
                return -1;
        }
 
        H5Pset_chunk(dset_creation_property_id, 1, &chunk_length);
        H5E_BEGIN_TRY
        dataset_id = H5Dcreate2( loc_id, F5_TIMETABLE_NAME,
                                 dtype_id,
                                 space_id,
                                 H5P_DEFAULT,
                                 dset_creation_property_id,
                                 H5P_DEFAULT);
        H5E_END_TRY
 
        H5Pclose( dset_creation_property_id );
        H5Sclose( space_id );
        H5Tclose( dtype_id );
 
        return dataset_id;
}
 
/*
int     F5Binit_timetable(hid_t loc_id, hid_t dtype_id)
{
hid_t   timetable_dataset_id
        =
        F5Bcreate_timetable_dataset(loc_id, dtype_id, 0);
 
        if (timetable_dataset_id<0)
                return 0;
 
        H5Dclose(timetable_dataset_id);
        return 1;
}
*/
 
hsize_t F5Bappend_timetable(hid_t loc_id, hid_t dtype_location_id,
                            const TimeTableEntry*TTE,
                            hsize_t     append_dims)
{
hid_t   mem_space_id;
hid_t   dataset_id;
hsize_t size = 0;
hsize_t current_dim = 0;
 
        if (!TTE) return 0;
 
        mem_space_id = H5Screate_simple( 1, &append_dims, NULL);
 
        H5E_BEGIN_TRY
        dataset_id  = H5Dopen2( loc_id, F5_TIMETABLE_NAME, H5P_DEFAULT);
        H5E_END_TRY
 
/*      printf("F5Bappend_timetable(,,TimeTableEntry={%g,%s},%d)\n",
               TTE->TimeValue, TTE->TimesliceName,
               (int)append_dims );
        fflush(stdout);
*/
        if (dataset_id<=0)
        {
                dataset_id =
                        F5Bcreate_timetable_dataset(loc_id, dtype_location_id, append_dims);
 
                if (dataset_id<=0)
                        return 0;
 
        {
        hid_t   timetable_type_id = F5Bcreate_timetable_type();
                H5Dwrite( dataset_id, timetable_type_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, TTE);
                H5Tclose( timetable_type_id );
        }
                H5Dclose( dataset_id );
                return append_dims;
        }
 
        {
        hid_t   current_file_space_id = H5Dget_space(dataset_id );
                H5Sget_simple_extent_dims( current_file_space_id, &current_dim, NULL);
                H5Sclose( current_file_space_id );
        }
 
        size = append_dims + current_dim;
        H5Dset_extent( dataset_id, &size);
 
        {
        hid_t   file_space_id = H5Dget_space(dataset_id );
                H5Sselect_hyperslab(file_space_id, H5S_SELECT_SET, &current_dim, NULL, &append_dims, NULL);
 
/*              printf("F5Bappend_timetable(): New extent %d, insert at %d, count = %d\n",
                       (int)size, (int)current_dim, (int)append_dims);
*/
        hid_t   timetable_type_id = F5Bcreate_timetable_type();
                H5Dwrite( dataset_id, timetable_type_id, mem_space_id, file_space_id, H5P_DEFAULT, TTE);
                H5Tclose( timetable_type_id );
                H5Sclose( file_space_id );
        }
 
        H5Dclose( dataset_id );
 
        return size;
}
 
 
hsize_t F5Bget_timetable_size(hid_t loc_id)
{
hid_t   dataset_id;
hsize_t current_dim = 0;
 
        H5E_BEGIN_TRY
        dataset_id  = H5Dopen2( loc_id, F5_TIMETABLE_NAME, H5P_DEFAULT);
        H5E_END_TRY
 
        if (dataset_id<=0)
                return 0;
 
        {
        hid_t   timetable_type_id = H5Dget_type( dataset_id );
        int     type_is_ok = F5check_timetable_Type(timetable_type_id);
                H5Tclose( timetable_type_id );
                if (!type_is_ok)
                {
                        H5Dclose( dataset_id );
                        F5printf(-1, "WARNING: Invalid Time Table time detected!");
                        return 0;
                }
        }
 
 
        {
        hid_t   current_file_space_id = H5Dget_space(dataset_id );
                H5Sget_simple_extent_dims( current_file_space_id, &current_dim, NULL);
                H5Sclose( current_file_space_id );
        }
 
 
        H5Dclose( dataset_id );
 
        return current_dim;
}
 
 
hsize_t F5Bread_timetable(hid_t loc_id,
                          TimeTableEntry*TTE,
                          hsize_t table_size)
{
hid_t   dataset_id;
 
        H5E_BEGIN_TRY
        dataset_id  = H5Dopen2( loc_id, F5_TIMETABLE_NAME, H5P_DEFAULT);
        H5E_END_TRY
 
        if (dataset_id<=0)
                return 0;
 
 
        {
        hid_t   space_id = H5Dget_space(dataset_id );
        hsize_t current_dim = 0;
                H5Sget_simple_extent_dims( space_id, &current_dim, NULL);
                H5Sclose( space_id );
 
                if (table_size<current_dim)
                {
                        H5Dclose( dataset_id );
                        return 0;
                }
 
                {
                hid_t dtype_id  = F5Bcreate_timetable_type();
 
                        H5Dread( dataset_id, dtype_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, TTE);
                        H5Tclose( dtype_id );
                }
 
                H5Dclose( dataset_id );
                return current_dim;
        }
}