F5iterate.c

Go to the documentation of this file.

#include "F5iterate.h"
#include "F5B.h"
#include "F5F.h"
#include "F5defs.h"
#include "F5private.h"
#include "F5X.h"
#include "F5A.h"
#include <assert.h>
#include <string.h>
 
#if __APPLE__
#include <sys/malloc.h>
#else
#include <malloc.h>
#endif
 
 
int     F5Iignore(const char*s)
{
        if (!s)        return 1;
        if (*s == '.') return 1;
        if (*s == '_') return 1;
        return 0;
}
 
struct  H5G_iterate_timeslices_struct
{
        F5_iterate_timeslices_t*callback;
        void *operator_data;
        F5Path *path;
};
 
static herr_t H5G_iterate_timeslices(hid_t group_id, const char *member_name, void *operator_data)
{
struct H5G_iterate_timeslices_struct*That = (struct H5G_iterate_timeslices_struct*)(operator_data);
const char**s;
/*herr_t (*old_func)(void*);
  void *old_client_data;
*/
        if (F5Iignore(member_name))
                return 0;
 
        if (That->path->field_enum_type_hid<0)
                printf("H5G_iterate_timeslices() could not open enum type!\n");
 
        /* If slice is already open in this path object, close it now.
           This actually should not be the case, and is most likely a bug
           in the caller code.
        */
        if (That->path->Slice_hid>0)
        {
                F5printf(0, "H5G_iterate_timeslices(): OUCH! Timeslice was already defined!?\n");
                H5Gclose(That->path->Slice_hid);
        }
 
        That->path->Slice_hid = F5Gtry_to_open(group_id, member_name);
        if (That->path->Slice_hid < 1 )
        {
                F5printf(40, "H5G_iterate_timeslices(): Member '%s' is not a group!\n", member_name);
                return 0;
        }
 
        for(s=F5_default_time_attrib_names; *s; s++)
        {
        hid_t   attr_id;
        double  time = 0;
        int     retval;
 
                H5E_BEGIN_TRY
                attr_id = F5Aopen_name(That->path->Slice_hid, *s);
                H5E_END_TRY
 
                if (attr_id<0)
                        continue;
 
                if (F_H5Aread(attr_id, H5T_NATIVE_DOUBLE, &time, *s)<0)
                {
                        H5Aclose(attr_id);
                        continue;
                }
                H5Aclose(attr_id);
/*              printf("SLICE: Have T=%lg, Query: T=%lg\n", t, *si->t);  */
 
                retval = That->callback( That->path, time, That->operator_data);
                if (That->path->Slice_hid)
                        H5Gclose(That->path->Slice_hid);
                That->path->Slice_hid = 0;
                return retval;
        }
 
        F5printf(100, "H5Gclose(That->path->Slice_hid=%d)\n", That->path->Slice_hid );
        H5Gclose(That->path->Slice_hid);
        F5printf(100, "H5Gclose(That->path->Slice_hid) done\n");
        That->path->Slice_hid = 0;
        return 0;
}
 
/*
static herr_t H5L_iterate_timeslices(  hid_t g_id, const char *name, const H5L_info_t *info, void *op_data)
{
        return H5G_iterate_timeslices(g_id, name, op_data);
}
*/
 
int     F5iterate_timeslices(hid_t file_id, hsize_t *idx, F5_iterate_timeslices_t*callback, void *operator_data )
{
struct H5G_iterate_timeslices_struct That;
F5Path *myPath = F5Binitialize_path(file_id);
int     retval;
 
        if (!myPath)
        {
                F5printf(1, "*F5iterate_timeslices(): Could not initialize F5 Path!");
                return -1;
        }
 
        That.callback      = callback;
        That.operator_data = operator_data;
        That.path          = myPath;
 
        F5printf(100, "F5iterate_timeslices()");
 
#if     1
        {
                if (idx)
                {
                int     Idx = *idx;
                        retval = H5Giterate(file_id, "/", &Idx, H5G_iterate_timeslices, &That);
                        *idx = Idx;
                }
                else
                        retval = H5Giterate(file_id, "/", 0, H5G_iterate_timeslices, &That);
        }
#else
        {
//      herr_t  herr = H5Literate(file_id, H5_INDEX_CRT_ORDER, H5_ITER_NATIVE,
        herr_t  herr = H5Literate(file_id, H5_INDEX_NAME, H5_ITER_NATIVE,
                                   idx,  H5L_iterate_timeslices, &That);
 
                if (herr<0)
                {
                        F5printf(0, "F5iterate_timeslices(): iteration error");
                        retval = -1;
                }
                else
                        retval = 0;
        }
#endif
        F5printf(100, "F5iterate_timeslices: H5iterate done.\n" );
 
        F5close(myPath);
        F5printf(100, "F5iterate_timeslices: F5close() done.\n" );
        return retval;
}
 
 
 
/***********************************************************************************************************/
 
struct  IterateGrids
{
        F5_iterate_grids_t*callback;
        void *operator_data;
        F5_gridproperty_t**gridtypes;
        F5Path*path;
        const char*coordinate_system;
};
 
static herr_t H5G_iterate_grids(hid_t group_id, const char *member_name, void *operator_data)
{
struct IterateGrids*That = (struct IterateGrids*)operator_data;
int     retval;
hid_t   id;
 
        if (F5Iignore(member_name))
                return 0;
 
        id = That->path->Grid_hid = H5Gopen2(group_id, member_name, H5P_DEFAULT);
        if (id<0)
                printf("ERROR: H5G_iterate_grids::H5Gopen(%s) failed!\n", member_name);
 
        if (That->gridtypes)
        {
        F5_gridproperty_t**GridProperty = That->gridtypes;
                while(*GridProperty)
                {
                        if ((*GridProperty)(That->path, That->coordinate_system) )
                                return That->callback(That->path, member_name, That->operator_data);
 
                        GridProperty++;
                }
                H5Gclose(That->path->Grid_hid);
                That->path->Grid_hid = 0;
                return 0;
        }
        retval = That->callback(That->path, member_name, That->operator_data);
 
        H5Gclose(That->path->Grid_hid);
        if (id != That->path->Grid_hid && That->path->Grid_hid != -1)
                H5Gclose(id);
        That->path->Grid_hid = 0;
 
        return retval;
}
 
int     F5iterate_grids(F5Path*slice, int *idx, F5_iterate_grids_t*callback, void *operator_data,
                        F5_gridproperty_t**gridtypes, const char*coordinate_system )
{
struct IterateGrids That;
        That.callback = callback;
        That.operator_data = operator_data;
        That.gridtypes = gridtypes;
        That.coordinate_system = coordinate_system?coordinate_system:FIBER_HDF5_DEFAULT_CHART;
        That.path = slice;
 
        F5printf(100, "F5iterate_grids()");
        return H5Giterate(slice->Slice_hid, ".", idx, H5G_iterate_grids, &That);
}
 
/***********************************************************************************************************/
 
struct  VertexFieldParams
{
        F5_iterate_fields_t*callback;
        void *operator_data;
        F5_fieldtype_t*what;
        F5Path*path;
        const char*coordinate_system;
};
 
/*
  Try to open object as data set or as group.
  The field type function is evaluated on the corresponding data type.
  If the field is a data set, then it evaluates its data type.
  Otherwise, the field group must contain a TypeID attribute that specifies
  the type.
*/
static herr_t H5G_iterate_vertex_fields(hid_t group_id, const char *member_name, void *operator_data)
{
struct  VertexFieldParams * That = (struct VertexFieldParams*)operator_data;
int     retval;
hid_t   Type_id;
 
        F5printf(40, "H5G_iterate_vertex_fields(,member_name=%s, operator_data=%p)",
                 member_name, operator_data);
 
        if (F5Iignore(member_name))
                return 0;
 
        if (strcmp(member_name, FIBER_HDF5_REPRESENTER)==0)
                return 0;
 
        if (!F5Fopen(That->path, member_name) )
                return 0;
 
        if (That->what)
        {
        int     ok;
                F5printf(40, "H5G_iterate_vertex_fields(): Checking field type");
                Type_id = F5Fget_type(That->path);
                ok = That->what(Type_id);
                H5Tclose( Type_id);
                if (!ok)
                {
                        F5Fclose(That->path);
                        return 0;
                }
        }
 
        F5printf(40, "H5G_iterate_vertex_fields() calling user callback function on `%s'.", member_name);
        retval = That->callback(That->path, member_name, That->operator_data, That->coordinate_system);
        F5Fclose(That->path);
        F5printf(40, "H5G_iterate_vertex_fields() called user callback function on `%s'.", member_name);
 
        return retval;
}
 
int     F5has_standard_vertex_fields(F5Path*grid)
{
hid_t Gid;
        if (!grid) return 0;
 
        H5E_BEGIN_TRY
        Gid = H5Gopen2(grid->Grid_hid, FIBER_HDF5_POINTS, H5P_DEFAULT);
        H5E_END_TRY
 
        if (Gid>0)
        {
                H5Gclose(Gid);
                return 1;
        }
        return 0;
}
 
 
int     F5iterate_topology_fields(F5Path*grid, int *idx, F5_iterate_fields_t*callback, void *operator_data,
                                  const char*coordinate_system, F5_fieldtype_t*what)
{
int     retval;
hid_t   Cgrids = 0;
hid_t   local_chart_hid = 0;
struct  VertexFieldParams That;
 
        if (!grid->Topology_hid)
        {
                F5printf(10, "F5iterate_topology_fields(): No Topology ID!");
                return 0;
        }
 
        F5printf(100, "F5iterate_topology_fields()");
 
        That.callback = callback;
        That.operator_data = operator_data;
        That.path = grid;
        if (!coordinate_system) coordinate_system = FIBER_HDF5_DEFAULT_CHART;
        That.what = what;
 
        F5printf(40, "F5iterate_topology_fields(coordinate_system=%s)", coordinate_system);
 
        grid->Representation_hid = F5Gtry_to_open(grid->Topology_hid, coordinate_system);
        if (grid->Representation_hid<0)
        {
                if (strcmp(coordinate_system, FIBER_HDF5_DEFAULT_CHART)==0)
                {
                        coordinate_system = FIBER_HDF5_DEPRECATED_OLD_DEFAULT_CHART;
                        grid->Representation_hid = F5Gtry_to_open(grid->Topology_hid, coordinate_system);
                }
                if (grid->Representation_hid<0)
                {
                        if (strcmp(coordinate_system, FIBER_HDF5_DEPRECATED_OLD_DEFAULT_CHART)==0)
                        {
                                coordinate_system = "CartesianChart3D";
                                grid->Representation_hid = F5Gtry_to_open(grid->Topology_hid, coordinate_system);
                        }
                        if (grid->Representation_hid<0)
                        {
                                F5printf(10, "F5iterate_topology_fields(): Open Coordinate system `%s' failed!",
                                         coordinate_system );
 
                                /*
                                // Reset representation ID to zero, indicating that it is not open in the F5Path
                                // Alternatively, we could check for negative values also in F5close() and use
                                // negative values for allowing to detect errors more specifically. Currently,
                                // we don't distinguish among not-yet-opened and not-opened-due-to-error cases.
                                // Then, application code can just check for zero, makes things easier.
                                // More future-safe could would check for positiveness.
                                */
                                grid->Representation_hid = 0;
                                return 0;
                        }
                }
        }
 
        /* check if charts per grid are already available? */
        if (grid->Charts_hid)
                Cgrids = grid->Charts_hid;
        else
        {
                grid->Charts_hid         = H5Gopen2(grid->Grid_hid    , FIBER_HDF5_CHARTS_PER_GRID, H5P_DEFAULT);
                if (grid->Charts_hid <0)
                {
                        puts("ERROR: F5iterate_topology_fields(): Opening charts per grid (\""FIBER_HDF5_CHARTS_PER_GRID"\" FAILED");
                }
        }
 
        local_chart_hid = grid->Chart_hid;
        grid->Chart_hid = F5Gtry_to_open(grid->Charts_hid  , coordinate_system);
        if (grid->Chart_hid < 0 && strcmp(coordinate_system, FIBER_HDF5_DEFAULT_CHART)==0)
        {
                grid->Chart_hid = F5Gtry_to_open(grid->Charts_hid, FIBER_HDF5_DEPRECATED_OLD_DEFAULT_CHART);
        }
        if (grid->Chart_hid < 0)
        {
                F5printf(10, "F5iterate_topology_fields(): Could not open chart description for `%s', no chart info available, but still iterating...!",
                                 coordinate_system );
        }
 
        F5printf(30, "    F5iterate_topology_fields() --> iterate vertex fields");
        That.coordinate_system = coordinate_system;
        retval = H5Giterate(grid->Representation_hid, ".", idx, H5G_iterate_vertex_fields, &That);
        H5Gclose( grid->Representation_hid );
        /* if we had no charts per grid opened, close them here again. */
        if (!Cgrids)
        {
                if (grid->Charts_hid>0)
                        H5Gclose(grid->Charts_hid);
                grid->Charts_hid = 0;
        }
        if (grid->Chart_hid> 0)
                H5Gclose( grid->Chart_hid );
 
        grid->Representation_hid = 0;
        grid->Chart_hid = local_chart_hid;
 
 
        if (retval<0)
        {
                F5printf(10, "    F5iterate_topology_fields() --> Iteration error\n");
        }
 
 
        return retval;
}
 
int     F5iterate_vertex_fields(F5Path*grid, int *idx, F5_iterate_fields_t*callback, void *operator_data,
                            const char*coordinate_system, F5_fieldtype_t*what)
{
int     retval;
        if (!grid) return -1;
 
        assert(grid->Topology_hid == 0);
 
        H5E_BEGIN_TRY
        grid->Topology_hid = H5Gopen2(grid->Grid_hid, FIBER_HDF5_POINTS, H5P_DEFAULT);
        H5E_END_TRY
 
        if (grid->Topology_hid<0)
        {
                grid->Topology_hid = 0;
                return 0;
        }
        retval = F5iterate_topology_fields(grid, idx, callback, operator_data, coordinate_system, what);
        H5Gclose( grid->Topology_hid );
        grid->Topology_hid = 0;
 
        return retval;
}
 
 
/***********************************************************************************************************/
 
typedef herr_t F5_iterate_representations_t(F5Path*Representation,
                                            void*operator_data,
                                            const char*Representer_name,
                                            F5Path*RepresentationTarget);
 
struct  DomainParams
{
        F5_iterate_representations_t*callback;
        void                   *operator_data;
        F5Path                 *skeleton;
};
 
 
static herr_t H5G_iterate_representations(hid_t group_id, const char *member_name, void *operator_data)
{
struct  DomainParams * That = (struct DomainParams*)operator_data;
herr_t  retval = 0;
 
        That->skeleton->Representation_hid = F5Gtry_to_open(group_id, member_name);
        if (That->skeleton->Representation_hid)
        {
/*TODO:
  check and read FIBER_HDF5_REPRESENTER for cases when the Representer is in another Grid
*/
                That->callback(That->skeleton, That->operator_data, member_name, 0);
 
                H5Gclose( That->skeleton->Representation_hid );
                That->skeleton->Representation_hid = 0;
        }
        return retval;
}
 
 
int     F5iterate_representations(F5Path*skeleton, int *idx, F5_iterate_representations_t*callback, void *operator_data)
{
/*hid_t local_chart_hid = 0;*/
struct  DomainParams That;
 
        if (!skeleton->Topology_hid)
        {
                F5printf(10, "F5iterate_representations(): No Topology ID!");
                return 0;
        }
        if (skeleton->Representation_hid)
        {
                F5printf(10, "F5iterate_representations(): No Representation ID!");
                return 0;
        }
 
 
        F5printf(30, "F5iterate_representations()");
 
        That.callback = callback;
        That.operator_data = operator_data;
        That.skeleton = skeleton;
 
        return  H5Giterate(skeleton->Topology_hid, ".", idx, H5G_iterate_representations, &That);
 
#if     0
        if (!coordinate_system) coordinate_system = FIBER_HDF5_DEFAULT_CHART;
        That.what = what;
 
        F5printf(40, "F5iterate_topology_fields(coordinate_system=%s)\n", coordinate_system);
 
        grid->Representation_hid = F5Gtry_to_open(grid->Topology_hid, coordinate_system);
        if (grid->Representation_hid<0)
        {
                if (strcmp(coordinate_system, FIBER_HDF5_DEFAULT_CHART)==0)
                {
                        coordinate_system = FIBER_HDF5_DEPRECATED_OLD_DEFAULT_CHART;
                        grid->Representation_hid = F5Gtry_to_open(grid->Topology_hid, coordinate_system);
                }
                if (grid->Representation_hid<0)
                {
                        if (strcmp(coordinate_system, FIBER_HDF5_DEPRECATED_OLD_DEFAULT_CHART)==0)
                        {
                                coordinate_system = "CartesianChart3D";
                                grid->Representation_hid = F5Gtry_to_open(grid->Topology_hid, coordinate_system);
                        }
                        if (grid->Representation_hid<0)
                        {
                                F5printf(10, "F5iterate_topology_fields(): Open Coordinate system `%s' failed!",
                                         coordinate_system );
 
                                /*
                                // Reset representation ID to zero, indicating that it is not open in the F5Path
                                // Alternatively, we could check for negative values also in F5close() and use
                                // negative values for allowing to detect errors more specifically. Currently,
                                // we don't distinguish among not-yet-opened and not-opened-due-to-error cases.
                                // Then, application code can just check for zero, makes things easier.
                                // More future-safe could would check for positiveness.
                                */
                                grid->Representation_hid = 0;
                                return 0;
                        }
                }
        }
 
        /* check if charts per grid are already available? */
        if (grid->Charts_hid)
                Cgrids = grid->Charts_hid;
        else
        {
                grid->Charts_hid         = H5Gopen2(grid->Grid_hid    , FIBER_HDF5_CHARTS_PER_GRID, H5P_DEFAULT);
                if (grid->Charts_hid <0)
                {
                        puts("ERROR: F5iterate_topology_fields(): Opening charts per grid (\""FIBER_HDF5_CHARTS_PER_GRID"\" FAILED");
                }
        }
 
        local_chart_hid = grid->Chart_hid;
        grid->Chart_hid = F5Gtry_to_open(grid->Charts_hid  , coordinate_system);
        if (grid->Chart_hid < 0 && strcmp(coordinate_system, FIBER_HDF5_DEFAULT_CHART)==0)
        {
                grid->Chart_hid = F5Gtry_to_open(grid->Charts_hid, FIBER_HDF5_DEPRECATED_OLD_DEFAULT_CHART);
        }
        if (grid->Chart_hid < 0)
        {
                F5printf(10, "F5iterate_topology_fields(): Could not open chart description for `%s'!",
                                 coordinate_system );
        }
 
        F5printf(100, "   F5iterate_topology_fields() --> iterate vertex fields");
        That.coordinate_system = coordinate_system;
        retval = H5Giterate(grid->Representation_hid, ".", idx, H5G_iterate_vertex_fields, &That);
        H5Gclose( grid->Representation_hid );
        /* if we had no charts per grid opened, close them here again. */
        if (!Cgrids)
        {
                H5Gclose(grid->Charts_hid);
                grid->Charts_hid = 0;
        }
        if (grid->Chart_hid> 0)
                H5Gclose( grid->Chart_hid );
 
        grid->Representation_hid = 0;
        grid->Chart_hid = local_chart_hid;
 
/*
        if (retval<0)
        {
                fprintf(stderr, "F5iterate_topology_fields(): Iteration error\n");
        }
*/
        return retval;
#endif
}
 
 
 
int     F5iterate_fields(F5Path*representation, int *idx,
                         const char*representer_name,
                         F5_iterate_fields_t*callback, void *operator_data)
{
struct  VertexFieldParams That;
        That.callback = callback;
        That.operator_data = operator_data;
        That.path = representation;
        That.what = 0;
        That.coordinate_system = representer_name;
 
        return H5Giterate(representation->Representation_hid, ".", idx, H5G_iterate_vertex_fields, &That);
}
 
 
/***********************************************************************************************************/
 
/*
typedef herr_t F5_iterate_topologies_t(F5Path*field, const char*topologyname,
                                       int index_depth,
                                       void *operator_data);
*/
 
struct  TopologyParams
{
        F5_iterate_topologies_t*callback;
        void *operator_data;
        F5Path*path;
        int     do_index_depth;
        int     points_done,
                cells_done;
};
 
static herr_t H5G_iterate_topologies(hid_t group_id, const char *member_name, void *operator_data)
{
struct  TopologyParams * That = (struct TopologyParams*)operator_data;
 
int             retval = 0,
           index_depth = 0,
skeleton_dimensionality = -1;
 
        if (F5Iignore(member_name))
                return 0;
 
        F5printf(20, "         H5G_iterate_topologies(%d,%s,)", (int)(group_id), member_name);
 
        /* Alternative: just handle groups which have an index depth attribute... */
 
        /* The charts per grid group is ignored. */
        if (strcmp(member_name, FIBER_HDF5_CHARTS_PER_GRID)==0)
                return 0;
 
        /* The time table per grid group is ignored. */
        if (strcmp(member_name, F5_TIMETABLE_NAME)==0)
                return 0;
 
        /* Ignore the field information tag. */
        if (strcmp(member_name, FIBER_FIELDS_TAG)==0)
                return 0;
 
        if (That->points_done && strcmp(member_name, FIBER_HDF5_POINTS)==0)
                return 0;
 
        if (That->cells_done && strcmp(member_name, FIBER_HDF5_CELLS)==0)
                return 0;
 
        /* printf("Topology: %s\n", member_name); */
        assert(That->path->Topology_hid == 0);
        That->path->Topology_hid = H5Gopen2(group_id, member_name, H5P_DEFAULT);
        if (That->path->Topology_hid < 0 )
                puts("ERROR: Opening Topology ID FAILED!");
 
        index_depth = F5LTget_index_depth(That->path->Topology_hid);
        if (index_depth == That->do_index_depth)
        {
                skeleton_dimensionality = F5LTget_skeleton_dimensionality(That->path->Topology_hid);
 
                F5printf(5,"    F5iterate_topologies(%s: Depth=%d, Dims=%d)", member_name, index_depth, skeleton_dimensionality);
 
                if (skeleton_dimensionality == FIBER_HDF5_INVALID_SKELETON_DIMENSIONALITY)
                {
                        printf("F5: ** Skeleton group without dimension attribute found - offending group: \"%s\"\n", member_name);
                        fflush(stdout);
                }
                else
                {
                        retval = That->callback(That->path, member_name, index_depth, skeleton_dimensionality, That->operator_data);
 
                        if (retval<0)
                                F5printf(15,"   ERROR on F5iterate_topologies(%s: Depth=%d, Dims=%d)", member_name, index_depth, skeleton_dimensionality);
                        else
                                F5printf(35,"   SUCCESS on F5iterate_topologies(%s: Depth=%d, Dims=%d)", member_name, index_depth, skeleton_dimensionality);
 
                }
        }
        else if (index_depth == F5_INVALID_INDEX_DEPTH)
        {
                printf("F5: ** Skeleton group without index depth attribute found - offending illegal group: \"%s\"\n", member_name);
                fflush(stdout);
        }
 
        H5Gclose(That->path->Topology_hid);
        That->path->Topology_hid = 0;
 
        return retval;
}
 
int     F5iterate_topologies(F5Path*grid, int *idx, F5_iterate_topologies_t*callback, void *operator_data)
{
hid_t   PointsID;
int     retval;
struct  TopologyParams That;
 
        That.callback = callback;
        That.operator_data = operator_data;
        That.path = grid;
        That.points_done = 0;
        That.cells_done = 0;
 
        assert( grid->Representation_hid == 0 );
        assert( grid->Topology_hid == 0);
        assert( grid->Charts_hid == 0 );
        assert( grid->Chart_hid == 0 );
 
        if (grid->Charts_hid)   H5Gclose(grid->Charts_hid);
 
        grid->Charts_hid = H5Gopen2(grid->Grid_hid    , FIBER_HDF5_CHARTS_PER_GRID, H5P_DEFAULT);
        if (grid->Charts_hid < 0)
        {
                F5printf(10, "F5iterate_topologies(): Opening Charts per Grid FAILED!");
                puts("ERROR: Opening Charts Per Grid FAILED!");
        }
 
        H5E_BEGIN_TRY
        PointsID = H5Gopen2(grid->Grid_hid, FIBER_HDF5_POINTS, H5P_DEFAULT);
        H5E_END_TRY
        // Backward compatibility
        if (PointsID>0)
        {
        int     skeleton_dimensionality = F5LTget_skeleton_dimensionality( PointsID );
                if (FIBER_HDF5_INVALID_SKELETON_DIMENSIONALITY == skeleton_dimensionality)
                {
                        F5printf(10, "F5iterate_topologies(): BACKWARD COMPATIBILITY MODE: Considering POINTS without skeleton dimensionality.");
 
                        That.path->Topology_hid = PointsID;
                        retval = That.callback(That.path, FIBER_HDF5_POINTS, 0, -1, That.operator_data);
                        That.path->Topology_hid = 0;
                        H5Gclose(PointsID);
                        That.points_done = 1;
 
                        H5E_BEGIN_TRY
                        PointsID = H5Gopen2(grid->Grid_hid, FIBER_HDF5_CELLS, H5P_DEFAULT);
                        H5E_END_TRY
                        if (PointsID>0)
                        {
                                F5printf(10, "F5iterate_topology_fields(): BACKWARD COMPATIBILITY MODE: Considering CELLS without skeleton dimensionality.");
 
                                That.path->Topology_hid = PointsID;
                                retval = That.callback(That.path, FIBER_HDF5_CELLS, 1, 2, That.operator_data);
                                That.path->Topology_hid = 0;
                                H5Gclose(PointsID);
                                That.cells_done = 1;
                        }
                }
                else
                {
                        H5Gclose(PointsID);
                }
        }
 
        F5printf(20, "     F5iterate_topologies(): Iterate over all possible index depths on grid %d ", (int)grid->Grid_hid );
 
        /* iterate over possible index depths */
        for(That.do_index_depth = F5_MIN_INDEX_DEPTH; That.do_index_depth < F5_MAX_INDEX_DEPTH;
            That.do_index_depth++)
        {
                F5printf(20, "       F5iterate_topologies(): Checking skeletons of depth %d on grid %d ",
                         That.do_index_depth, (int)grid->Grid_hid );
                retval = H5Giterate(grid->Grid_hid, ".", idx, H5G_iterate_topologies, &That);
        }
 
        if (grid->Charts_hid!=0)
                H5Gclose( grid->Charts_hid );
 
        grid->Charts_hid = 0;
 
/*
        if (retval<0)
        {
                fprintf(stderr, "F5iterate_topologies(): Iteration error\n");
        }
*/
 
        return retval;
}
 
/***********************************************************************************************************/
 
 
struct  GridAtlasParams
{
        F5_iterate_grid_atlas_t*callback;
        F5Path*path;
        void *operator_data;
};
 
static herr_t H5G_iterate_grid_atlas(hid_t group_id, const char *member_name, void *operator_data)
{
struct  GridAtlasParams * That = (struct GridAtlasParams*)operator_data;
herr_t  retval;
hid_t   GlobalChart_id = -1,
        ChartDomain_id = -1;
        //ChartPoint_id;
        /* printf("--> %s\n", member_name); */
 
        H5E_BEGIN_TRY
        /* Grid/Charts/StandardCartesianChart3D */
        That->path->Chart_hid = H5Gopen2(group_id, member_name, H5P_DEFAULT);
        H5E_END_TRY
        if (That->path->Chart_hid<=0)
        {
                F5printf(10, "F5iterate_grid_atlas(): No valid Chart group in Grid, cannot callback.\n");
                That->path->Chart_hid=0;
                return 0;
        }
 
        H5E_BEGIN_TRY
        /* Grid/Charts/StandardCartesianChart3D/GlobalChart -> /Charts/Cartesian3D/StandardCartesianChart3D */
        GlobalChart_id = H5Gopen2(That->path->Chart_hid, FIBER_HDF5_CHART_TO_GLOBALCHART_REF, H5P_DEFAULT );
        H5E_END_TRY
        if (GlobalChart_id<=0)
        {
                /* Try an alternative for simpler, older files from F5 version 0.1.3
                 */
        hid_t   GlobalCharts_id;
                H5E_BEGIN_TRY
                GlobalCharts_id = H5Gopen2(That->path->File_hid, FIBER_HDF5_GLOBAL_CHARTS, H5P_DEFAULT );
                ChartDomain_id  = H5Gopen2(GlobalCharts_id, FIBER_HDF5_CARTESIAN_CHART_DOMAIN, H5P_DEFAULT );
                GlobalChart_id  = H5Gopen2(ChartDomain_id, member_name, H5P_DEFAULT );
                H5E_END_TRY
                if (GlobalCharts_id>0)
                        H5Gclose(GlobalCharts_id);
 
                if (GlobalChart_id<=0)
                {
                        F5printf(0, "F5iterate_grid_atlas(): No valid Global Chart reference for chart Grid/%s (missing GlobalChart link), ignoring this chart.", member_name);
                        H5Gclose(That->path->Chart_hid);
                        That->path->Chart_hid = 0;
                        return 0;
                }
                F5printf(0, "F5iterate_grid_atlas(): No valid Global Chart reference for chart %s, using alternative lookup.\n", member_name);
        }
 
        if (ChartDomain_id<=0) /* standard lookup follows */
        {
                H5E_BEGIN_TRY
        /* /Charts/Cartesian3D/StandardCartesianChart3D/Coordinates Group, same as /Charts/Cartesian3D  */
                ChartDomain_id = H5Gopen2(GlobalChart_id,  FIBER_HDF5_GLOBALCHART_COORDINATES, H5P_DEFAULT );
                H5E_END_TRY
                if (ChartDomain_id<=0)
                {
                hid_t   GlobalCharts_id;
 
                        F5printf(0, "F5iterate_grid_atlas(): No valid Chart domain for %s, "
                                 "file should have group /Charts/"FIBER_HDF5_CARTESIAN_CHART_DOMAIN"/%s/Coordinates "
                                 "we try /Charts/"FIBER_HDF5_CARTESIAN_CHART_DOMAIN" instead."
                                 , member_name, member_name);
 
                        H5E_BEGIN_TRY
                        GlobalCharts_id = H5Gopen2(That->path->File_hid, FIBER_HDF5_GLOBAL_CHARTS, H5P_DEFAULT );
                        ChartDomain_id  = H5Gopen2(GlobalCharts_id, FIBER_HDF5_CARTESIAN_CHART_DOMAIN, H5P_DEFAULT );
                        H5E_END_TRY
                        if (GlobalCharts_id<=0)
                        {
                                F5printf(0, "F5iterate_grid_atlas(): No /"FIBER_HDF5_GLOBAL_CHARTS" group found, unable to identify coordinates for chart %s.", member_name);
                                H5Gclose(That->path->Chart_hid);
                                That->path->Chart_hid = 0;
                                return 0;
                        }
                        H5Gclose(GlobalCharts_id);
                        if (ChartDomain_id<=0)
                        {
                        F5printf(0, "F5iterate_grid_atlas(): "
                                 "No chart domain /Charts/"FIBER_HDF5_CARTESIAN_CHART_DOMAIN" found, cannot callback for %s\n",
                                 member_name);
 
                                H5Gclose(GlobalChart_id);
                                H5Gclose(That->path->Chart_hid);
                                That->path->Chart_hid = 0;
                                return 0;
                        }
 
                        F5B_delete_global_chart(That->path->myChart);
                        F5B_delete_global_chart(That->path->FileIDs);
 
                        That->path->FileIDs = F5B_read_chart_domain( ChartDomain_id, FIBER_HDF5_CARTESIAN_CHART_DOMAIN);
                        if (!That->path->FileIDs)
                        {
                                F5printf(0, "CANNOT read global chart domain "FIBER_HDF5_GLOBALCHART_COORDINATES );
                                return 0;
                        }
                        F5printf(200, "FALLBACK: iterate grid atlas: copy chart domain");
                        That->path->myChart = F5Bcopy_chart_domain( That->path->FileIDs );
 
                        F5printf(200, "FALLBACK: iterate grid atlas: callback calling");
                        retval = That->callback(That->path, member_name,
                                                GlobalChart_id, ChartDomain_id,
                                                That->operator_data);
 
                        F5printf(200, "FALLBACK: iterate grid atlas: delete global charts");
 
                        F5B_delete_global_chart(That->path->myChart); That->path->myChart = 0;
                        F5B_delete_global_chart(That->path->FileIDs); That->path->FileIDs = 0;
 
                        F5printf(100, "FALLBACK: Grid Atlas iteration done, closing chart ID");
                        H5Gclose(That->path->Chart_hid);
                        F5printf(100, "FALLBACK: Grid Atlas iteration done, closed chart ID");
                        That->path->Chart_hid = 0;
                        H5Gclose(GlobalChart_id);
                        H5Gclose(ChartDomain_id);
 
                        return retval;
                }
        }
 
/*
//      H5E_BEGIN_TRY
//      ChartPoint_id = H5Topen(ChartDomain_id, FIBER_HDF5_CHART_POINT_TYPE);
//      H5E_END_TRY
//      if (ChartPoint_id>0)
//      puts("all ok");
*/
        F5B_delete_global_chart(That->path->myChart);
        F5B_delete_global_chart(That->path->FileIDs);
 
        That->path->FileIDs = F5B_read_global_chart(GlobalChart_id, FIBER_HDF5_GLOBALCHART_COORDINATES );
        if (!That->path->FileIDs)
        {
                F5printf(0, "CANNOT read global chart coordinates "FIBER_HDF5_GLOBALCHART_COORDINATES );
                return 0;
        }
 
        F5printf(200, "iterate grid atlas: copy chart domain");
        That->path->myChart = F5Bcopy_chart_domain( That->path->FileIDs );
 
        F5printf(200, "iterate grid atlas: callback calling");
        retval = That->callback(That->path, member_name,
                                GlobalChart_id, ChartDomain_id,
                                That->operator_data);
 
        F5printf(200, "iterate grid atlas: delete global charts");
 
        F5B_delete_global_chart(That->path->myChart); That->path->myChart = 0;
        F5B_delete_global_chart(That->path->FileIDs); That->path->FileIDs = 0;
 
 
        F5printf(100, "Grid Atlas iteration done, closing chart ID");
        H5Gclose(That->path->Chart_hid);
        F5printf(100, "Grid Atlas iteration done, closed chart ID");
        That->path->Chart_hid = 0;
        H5Gclose(GlobalChart_id);
        H5Gclose(ChartDomain_id);
/*      H5Tclose(ChartPoint_id); */
 
        return retval;
}
 
int     F5iterate_grid_atlas(F5Path*grid, int *idx, F5_iterate_grid_atlas_t*callback, void *operator_data)
{
int     retval;
struct GridAtlasParams GAP;
        if (!grid) return 0;
        if (! (grid->Grid_hid>0) )
        {
                F5printf(10, "F5iterate_grid_atlas(): No valid Grid ID in path, cannot iterate.\n");
                return 0;
        }
 
        if (grid->Chart_hid>0)
        {
                F5printf(10, "F5iterate_grid_atlas(): Grid path already contains a chart, cannot iterate.\n");
                return 0;
        }
 
        GAP.operator_data = operator_data;
        GAP.callback      = callback;
        GAP.path          = grid;
 
        F5printf(10, "F5iterate_grid_atlas()");
 
        retval = H5Giterate(grid->Grid_hid, FIBER_HDF5_CHARTS_PER_GRID, idx, H5G_iterate_grid_atlas, &GAP);
 
        return retval;
}
 
/***********************************************************************************************************/
/***********************************************************************************************************/
/***********************************************************************************************************/
 
struct  FieldFragmentParams
{
        F5_iterate_fields_fragments_t*callback;
        void *operator_data;
        F5Path*path;
};
 
#if 0
static herr_t H5G_iterate_field_fragments(hid_t group_id, const char *member_name, void *operator_data)
{
struct  FieldFragmentParams*That = (struct FieldFragmentParams*)operator_data;
        return That->callback(That->path, member_name, That->operator_data);
}
#endif
 
static herr_t H5L_iterate_field_fragments( hid_t g_id, const char *name, const H5L_info_t *info, void *op_data)
{
struct  FieldFragmentParams*That = (struct FieldFragmentParams*)op_data;
 
        if (F5Iignore(name))
                return 0;
 
        return That->callback(That->path, name, That->operator_data);
}
 
int     F5iterate_field_fragments(F5Path*field, int *idx, F5_iterate_fields_fragments_t*callback, void *operator_data)
{
        /*printf("test here.. \n"); */
        if (!field)
        {
                /*printf( "F5iterate_field_fragments(): No Field given!\n"); */
                F5printf(1, "F5iterate_field_fragments(): No Field given!\n");
                return 0;
        }
        if (!field->Field_hid)
        {
                /*printf("F5iterate_field_fragments(): Field not open, forget to open it?\n"); */
                F5printf(1, "F5iterate_field_fragments(): Field not open, forget to open it?\n");
                return 0;
        }
        if (!F5Fis_group(field) )
        {
                /*printf("F5iterate_field_fragments(): Field is not a group!?\n"); */
                F5printf(1, "F5iterate_field_fragments(): Field is not a group!?\n");
                return 0;
        }
        if (!callback)
        {
                /*printf("F5iterate_field_fragments(): No Callback function given!\n"); */
                F5printf(1, "F5iterate_field_fragments(): No Callback function given!\n");
                return 0;
        }
 
        {
        struct FieldFragmentParams That;
        int     IterateByName = 0;
        int     major_version, minor_version, release_version;
//      ArrayType at =
                F5Fget_field_enum(field, NULL,
                                  &major_version, &minor_version, &release_version);
 
                // fragments were introduced with 0.1.3
                if (major_version == 0 &&
                    minor_version == 1 &&
                    release_version < 3)
                {
                        printf( "F5iterate_field_fragments(): Incompatible version %d.%d.%d!\n",
                                major_version, minor_version, release_version);
 
                        F5printf(1, "F5iterate_field_fragments(): Incompatible version %d.%d.%d!\n",
                                 major_version, minor_version, release_version);
                        return 0;
                }
 
                That.callback = callback;
                That.path = field;
                That.operator_data = operator_data;
 
                F5printf(100, "F5iterate_field_fragments()");
#if     0
                return H5Giterate(field->Field_hid, ".", idx, H5G_iterate_field_fragments, &That);
#else
 
                if (major_version == 0 &&
                    minor_version == 1 &&
                    release_version < 6)
                        IterateByName = 1;
 
                {
                hid_t gcpl_id  = H5Gget_create_plist( field->Field_hid );
                unsigned crt_order_flags; // The flags for link creation order
                        H5Pget_link_creation_order(gcpl_id, &crt_order_flags);
                        H5Pclose(gcpl_id);
 
                        if (crt_order_flags & H5P_CRT_ORDER_TRACKED &&
                            crt_order_flags & H5P_CRT_ORDER_INDEXED)
                                IterateByName = 0;
                }
 
                if (IterateByName)
                {
                        F5printf(30, "F5iterate_field_fragments() using naming order");
                        return H5Literate(field->Field_hid, H5_INDEX_NAME, H5_ITER_NATIVE, 0, H5L_iterate_field_fragments, &That);
                }
                else
                {
                        F5printf(30, "F5iterate_field_fragments() using Creation order");
                        return H5Literate(field->Field_hid, H5_INDEX_CRT_ORDER, H5_ITER_NATIVE, 0, H5L_iterate_field_fragments, &That);
                }
#endif
        }
}
 
 
 
struct  H5G_iterate_grids_per_bundle_struct
{
        // (hid_t file_id, hid_t gridinfo_id, const char*gridname, void *user_data);
        F5_iterate_grids_per_bundle_t*callback;
        void    *operator_data;
        hid_t   file_id;
};
 
static herr_t H5G_iterate_grids_per_bundle(hid_t group_id, const char *member_name, void *operator_data)
{
struct H5G_iterate_grids_per_bundle_struct*That = (struct H5G_iterate_grids_per_bundle_struct*)(operator_data);
//      F5printf(100, "H5G_iterate_grids_per_bundle() before open");
hid_t   gridinfo_id = F5Gtry_to_open(group_id, member_name);
herr_t  ok;
//      F5printf(100, "H5G_iterate_grids_per_bundle() after open, before callback");
        ok = That->callback( That->file_id, gridinfo_id, member_name, That->operator_data);
//      F5printf(100, "H5G_iterate_grids_per_bundle() after callback");
        H5Gclose( gridinfo_id );
 
//      F5printf(100, "H5G_iterate_grids_per_bundle() end");
 
        return ok;
}
 
#ifdef    F5_BACKWARD_COMPATIBILITY
static herr_t H5G_iterate_grids_per_bundle_from_timeslices(hid_t group_id, const char *member_name, void *operator_data)
{
struct H5G_iterate_grids_per_bundle_struct*That = (struct H5G_iterate_grids_per_bundle_struct*)(operator_data);
 
        F5printf(1, "Ancient File Recovery: Found grid=[%s]", member_name);
 
hid_t   gridinfo_id = F5Gtry_to_open(group_id, member_name);
herr_t  ok;
 
        ok = That->callback( That->file_id, gridinfo_id, member_name, That->operator_data);
 
        H5Gclose( gridinfo_id );
 
        return ok;
}
 
static herr_t H5G_iterate_grids_per_bundle_via_timeslices(hid_t group_id, const char *member_name, void *operator_data)
{
        F5printf(10, "Ancient File Recovery: At T=[%s]", member_name);
        H5Giterate(group_id, member_name, 0, H5G_iterate_grids_per_bundle_from_timeslices, operator_data);
        return 0;
}
#endif
 
int     F5iterate_grids_per_bundle(hid_t file_id, int *idx, F5_iterate_grids_per_bundle_t*callback, void *user_data )
{
hid_t   TableOfContents, Grids;
int     nGrids = 0;
struct H5G_iterate_grids_per_bundle_struct That;
 
        That.callback      = callback;
        That.operator_data = user_data;
        That.file_id       = file_id;
 
        TableOfContents = F5Gtry_to_open(file_id, FIBER_CONTENTS );
        if (TableOfContents < 1)
        {
                F5printf(1, "No table of contents? This must be an ancient file...");
#ifdef    F5_BACKWARD_COMPATIBILITY
                return H5Giterate(file_id, "/", idx, H5G_iterate_grids_per_bundle_via_timeslices, &That);
#else
                return -1;
#endif
        }
 
        Grids = F5Gtry_to_open( TableOfContents, FIBER_CONTENT_GRIDS );
        H5Gclose( TableOfContents );
 
        if (Grids < 0)
                return 0;
 
        F5printf(100, "F5iterate_grid_per_bundle()");
        nGrids = H5Giterate(Grids, ".", idx, H5G_iterate_grids_per_bundle, &That);
        H5Gclose( Grids );
        F5printf(100, "after H5Giterate");
 
        return nGrids;
}
 
typedef struct
{
        F5_iterate_gridevolution_per_bundle_t*callback;
        F5_iterate_grids_per_bundle_t*gridinfo;
        void    *user_data;
        hid_t   file_id;
        const char*gridname;
}
        F5iterate_gridevolution_struct;
 
static herr_t my_gridslices(hid_t gridinfo_id, const char*slicename, void *user_data)
{
F5iterate_gridevolution_struct*That = (F5iterate_gridevolution_struct*)user_data;
hid_t   Slice_hid;
const char**s;
 
        Slice_hid = F5Gtry_to_open(gridinfo_id, slicename);
 
        if (Slice_hid<0)
        {
                printf("  --> NO TIME GROUP: %s\n", slicename);fflush(stdout);
                return 0;
        }
 
/*      printf("  --> TIME GROUP: Yay, %s\n", slicename);  */
 
        for(s=F5_default_time_attrib_names; *s; s++)
        {
        hid_t   attr_id;
        double  time = 0.0;
 
                H5E_BEGIN_TRY
                attr_id = F5Aopen_name(Slice_hid, *s);
                H5E_END_TRY
 
                if (attr_id<0)
                        continue;
 
                F5printf(50,"H5G_iterate_gridslices(): reading time attribute [%s]\n", *s);
                if (F_H5Aread(attr_id, H5T_NATIVE_DOUBLE, &time, *s)<0)
                {
                        H5Aclose(attr_id);
                        H5Gclose(Slice_hid);
                        continue;
                }
                H5Aclose(attr_id);
        /*      printf("     SLICE: Have Grid %s at T=%lg (from %s)\n", That->gridname, time, slicename ); */
                assert( That->callback );
//              That->callback( That->file_id, That->gridname, time, Slice_hid, That->user_data);
                That->callback( That->file_id, That->gridname, time, slicename, That->user_data);
                break;
        }
        H5Gclose(Slice_hid);
        return 0;
}
 
 
#ifdef    F5_BACKWARD_COMPATIBILITY
 
struct  my_grids_per_bundle_emulate_via_timeslice_struct
{
        F5iterate_gridevolution_struct*That;
        const char*gridname;
};
 
 
static herr_t my_grids_per_bundle_emulate_via_timeslice(hid_t file_id, const char*slicename, void *user_data)
{
struct my_grids_per_bundle_emulate_via_timeslice_struct*That = (struct my_grids_per_bundle_emulate_via_timeslice_struct*)user_data;
hid_t   Slice_hid;
        F5printf(10,"Ancient File Recovery: Scanning for grid [%s] in [%s]", That->gridname, slicename);
        Slice_hid = F5Gtry_to_open(file_id, slicename);
        if (Slice_hid>0)
        {
        hid_t   Grid_hid = F5Gtry_to_open(Slice_hid, That->gridname);
                if (Grid_hid>0)
                {
                const char**s;
                        for(s=F5_default_time_attrib_names; *s; s++)
                        {
                        hid_t   attr_id;
                        double  time = 0.0;
 
                                H5E_BEGIN_TRY
                                attr_id = F5Aopen_name(Slice_hid, *s);
                                H5E_END_TRY
 
                                if (attr_id<0)
                                        continue;
 
                                if (F_H5Aread(attr_id, H5T_NATIVE_DOUBLE, &time, *s)<0)
                                {
                                        H5Aclose(attr_id);
                                        H5Gclose(Slice_hid);
                                        continue;
                                }
                                H5Aclose(attr_id);
 
                                F5printf(10,"Ancient File Recovery: GOT grid [%s] in [%s] for T=%g (attribute %s)",
                                         That->gridname, slicename, time, *s);
 
                                assert( That->That->callback );
                                That->That->callback( That->That->file_id, That->gridname, time, slicename, That->That->user_data);
                                break;
                        }
                        H5Gclose( Grid_hid);
                }
                else
                {
                        F5printf(1,"Ancient File Recovery - no such grid [%s/%s]???", slicename, That->gridname);
                }
                H5Gclose(Slice_hid);
        }
        else
        {
                F5printf(1,"Ancient File Recovery - no such slice [%s]???", slicename);
        }
 
        return 0;
}
#endif
 
static herr_t my_grids_per_bundle(hid_t file_id, hid_t gridinfo_id, const char*gridname, void *user_data)
{
F5iterate_gridevolution_struct*That = (F5iterate_gridevolution_struct*)user_data;
        That->gridname = gridname;
/*      printf("GRIDS: Yay, %s\n", gridname); */
 
        if (That->gridinfo)
                That->gridinfo( file_id, gridinfo_id, gridname, That->user_data);
 
        {
        hsize_t NTimeEntries = F5Bget_timetable_size( gridinfo_id );
                F5printf(20, "GRID [%s] has %d time table entries\n", gridname, (int)NTimeEntries);
                if (NTimeEntries)
                {
                TimeTableEntry*TTE = (TimeTableEntry*)malloc(sizeof(TimeTableEntry)*NTimeEntries);
                hsize_t readEntries = F5Bread_timetable( gridinfo_id, TTE, NTimeEntries);
 
                        if (readEntries == NTimeEntries)
                        {
                        hsize_t i;
                                F5printf(10, "GRID [%s] iterating over %d time table entries\n", gridname, (int)NTimeEntries);
                                for(i=0; i<readEntries; i++)
                                {
//                                      F5printf(11, "GRID [%s] for %d time is at slice [%s]\n", gridname, i, TTE[i].TimesliceName);
#if     0
                                        printf("GRID [%s] for %d time is at slice [%s]\n", gridname, i, TTE[i].TimesliceName);
                                        fflush(stdout);
#endif
                        /*
                        * in case the time slice name is invalid, we'd need to discard this entire looping
                        * and fall back to the alternative iteration scheme. This needs to be done in two
                        * loops then. Not implemented yet.
                        */
                                        assert( TTE[i].TimesliceName && "Invalid time slice name detected in time table");
                                        That->callback( file_id, gridname, TTE[i].TimeValue, TTE[i].TimesliceName, That->user_data);
                                }
                                free(TTE);
                                return 0;
                        }
                        F5printf(1, "ERROR: Grid [%s] has %d time table entries but only %d could be read!\n",
                                 gridname, (int)NTimeEntries, (int)readEntries);
                        free(TTE);
                }
                else // check if this is the grid itself of an ancient F5 file
                {
                hid_t   TableOfContents = F5Gtry_to_open(file_id, FIBER_CONTENTS );
                        if (TableOfContents < 1)
                        {
#ifdef    F5_BACKWARD_COMPATIBILITY
                                F5printf(1, "Emulating F5iterate_gridevolution() for ancient file's grid=%s...", gridname);
                                // retrieve: (hid_t file_id, const char*gridname, double time, const char*slicename, void *user_data);
 
                        struct  my_grids_per_bundle_emulate_via_timeslice_struct This;
                                This.That = That;
                                This.gridname = gridname;
                                return H5Giterate(file_id, "/", NULL, &my_grids_per_bundle_emulate_via_timeslice, &This);
#else
                                F5printf(1, "No Table of Contents found when trying to look for grid=%s...", gridname);
                                return 01;
#endif
                        }
                        else
                                H5Gclose(TableOfContents);
                }
        }
 
        F5printf(100, "F5iterate_gridevolution()");
        return H5Giterate(gridinfo_id, ".", NULL, my_gridslices, That);
}
 
int     F5iterate_gridevolution(hid_t file_id, int *idx, F5_iterate_gridevolution_per_bundle_t*callback,
                                void *user_data, F5_iterate_grids_per_bundle_t*gridinfo)
{
F5iterate_gridevolution_struct That;
        That.callback  = callback;
        That.user_data = user_data;
        That.file_id   = file_id;
        That.gridinfo  = gridinfo;
 
        F5printf(100, "F5iterate_gridevolution() before F5iterate_grids");
int     ok = F5iterate_grids_per_bundle(file_id, idx, my_grids_per_bundle, &That);
        F5printf(100, "F5iterate_gridevolution() after F5iterate_grids");
        return ok;
}