Iterator Functions

Typedefs
typedef herr_t	F5_iterate_representations_t(F5Path *Representation, void *operator_data, const char *Representer_name, F5Path *RepresentationTarget)
typedef herr_t	F5_iterate_timeslices_t(F5Path *path, double time, void *user_data)
typedef herr_t	F5_iterate_grids_t(F5Path *F5Grid, const char *gridname, void *user_data)
typedef herr_t	F5_iterate_topologies_t(F5Path *field, const char *topologyname, int index_depth, int topological_dimension, void *operator_data)
typedef herr_t	F5_iterate_fields_t(F5Path *field, const char *fieldname, void *operator_data, const char *representer_name)
typedef int	F5_fieldtype_t(hid_t type_id)
typedef herr_t	F5_iterate_grid_atlas_t(F5Path *grid, const char *coordinate_name, hid_t global_chart_hid, hid_t domain_group_hid, void *operator_data)
typedef herr_t	F5_iterate_grids_per_bundle_t(hid_t file_id, hid_t gridinfo_id, const char *gridname, void *user_data)
typedef herr_t	F5_iterate_gridevolution_per_bundle_t(hid_t file_id, const char *gridname, double time, const char *slicename, void *user_data)
F5_API int	F5Iignore (const char *s)
F5_API int	F5iterate_paramspace (hid_t file_id, int *idx, const F5ParameterSpace *selection, F5_iterate_paramspace_t *callback, void *user_data)
F5_API int	F5iterate_timeslices (hid_t file_id, hsize_t *idx, F5_iterate_timeslices_t *callback, void *user_data)
F5_API int	F5iterate_grids (F5Path *F5Slice, int *idx, F5_iterate_grids_t *callback, void *operator_data, F5_gridproperty_t **gridtypes, const char *coordinate_system)
F5_API int	F5iterate_topologies (F5Path *grid, int *idx, F5_iterate_topologies_t *callback, void *operator_data)
F5_API int	F5iterate_representations (F5Path *skeleton, int *idx, F5_iterate_representations_t *callback, void *operator_data)
F5_API int	F5iterate_fields (F5Path *representation, int *idx, const char *representer_name, F5_iterate_fields_t *callback, void *operator_data)
F5_API int	F5iterate_vertex_fields (F5Path *grid, int *idx, F5_iterate_fields_t *callback, void *operator_data, const char *coordinate_system, F5_fieldtype_t *what)
F5_API int	F5iterate_topology_fields (F5Path *skeleton, int *idx, F5_iterate_fields_t *callback, void *operator_data, const char *coordinate_system, F5_fieldtype_t *what)
F5_API int	F5has_standard_vertex_fields (F5Path *grid)
F5_API int	F5iterate_grids_per_bundle (hid_t file_id, int *idx, F5_iterate_grids_per_bundle_t *callback, void *user_data)
F5_API 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)

Detailed Description

Synopsis:

1. Open a file
2. Call F5iterate_timeslices() on it
3. Let the timeslice callback function call F5iterate_grids()
4. Let the grid callback function call F5iterate_vertex_fields() if you are interested in all available vertex-related fields.

The current implementation status only allows to scan all fields given on the default Topology of Grid objects.

Typedef Documentation

F5_fieldtype_t

typedef int F5_fieldtype_t(hid_t type_id)

Prototype of a function that allows only certain types.

Definition at line 164 of file F5iterate.h.

F5_iterate_fields_t

typedef herr_t F5_iterate_fields_t(F5Path *field, const char *fieldname, void *operator_data, const char *representer_name)

Called per grid function.

Parameters

field_id	The HDF5 ID of the respective field. Note that it may be an HDF5 group ID or a dataset ID. Call H5Gclose() or H5Dclose() in the iterator function.
representer_name	The name of the containing group where this field resides.

Definition at line 145 of file F5iterate.h.

F5_iterate_grid_atlas_t

typedef herr_t F5_iterate_grid_atlas_t(F5Path *grid, const char *coordinate_name, hid_t global_chart_hid, hid_t domain_group_hid, void *operator_data)

Parameters

grid	An F5Path pointing to the current grid with its members myChart and FileIDs being defined.

Definition at line 186 of file F5iterate.h.

F5_iterate_gridevolution_per_bundle_t

typedef herr_t F5_iterate_gridevolution_per_bundle_t(hid_t file_id, const char *gridname, double time, const char *slicename, void *user_data)

Callback function type for F5iterate_gridevolution().

Parameters

file_id	The HDF5 file ID.
gridname	The name of the current grid under investigation.
time	The time at which this grid exists.
slicename	The name of the time slice group where this grid resides in.

Definition at line 229 of file F5iterate.h.

F5_iterate_grids_per_bundle_t

typedef herr_t F5_iterate_grids_per_bundle_t(hid_t file_id, hid_t gridinfo_id, const char *gridname, void *user_data)

The iterator function that is called for each grid that is found in the file.

See also

F5iterate_grids_per_bundle().

Definition at line 212 of file F5iterate.h.

F5_iterate_grids_t

typedef herr_t F5_iterate_grids_t(F5Path *F5Grid, const char *gridname, void *user_data)

The iterator callback function that is called for each grid of a time slice that fullfills the specified grid property.

See also

F5iterate_grids().

Parameters

F5Grid

An F5 path with a valid Grid identifier.

Definition at line 81 of file F5iterate.h.

F5_iterate_representations_t

typedef herr_t F5_iterate_representations_t(F5Path *Representation, void *operator_data, const char *Representer_name, F5Path *RepresentationTarget)

Parameters

Representation	The F5Path to the currently traversed Represention
RepresentationTarget	The location of the Representer if its from another Grid. ()

Definition at line 432 of file F5iterate.c.

F5_iterate_timeslices_t

typedef herr_t F5_iterate_timeslices_t(F5Path *path, double time, void *user_data)

The iterator function that is called for each time slice.

See also

F5iterate_timeslices().

Parameters

slice_id

An HDF5 group identifier. Call H5Gclose() in the iterater function.

Definition at line 66 of file F5iterate.h.

F5_iterate_topologies_t

typedef herr_t F5_iterate_topologies_t(F5Path *field, const char *topologyname, int index_depth, int topological_dimension, void *operator_data)

The call back function that will be invoked by F5iterate_topologies(). It traverses all Skeletons of a Grid object.

Parameters

index_depth	The number of "hops" that are required to go from the elements described in this group to vertex coordinates in a chart.
topological_dimension	The dimension of the k-cells that are stored within this Skeleton group.

Definition at line 106 of file F5iterate.h.

Function Documentation

F5has_standard_vertex_fields()

F5_API int F5has_standard_vertex_fields

(

F5Path *

grid

)

Check whether this grid object has some fields in the standard vertex topology, i.e. an Points/ entry.

Definition at line 278 of file F5iterate.c.

{
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;
}

References FIBER_HDF5_POINTS, F5Path::Grid_hid, and H5Gclose.

F5Iignore()

F5_API int F5Iignore

(

const char *

s

)

Simple (mostly internal) helper function to detect which attributes or groups shall be ignored generally. F5 ignores all groups starting with a dot or underline. Normally this function will not be used by application code.

Returns

non-zero if the string shall be ignored.

Note

returns true if the string is invalid (i.e.: "ignore invalid strings")

Definition at line 18 of file F5iterate.c.

{
        if (!s)        return 1;
        if (*s == '.') return 1;
        if (*s == '_') return 1;
        return 0;
}

F5iterate_fields()

F5_API int F5iterate_fields	(	F5Path *	representation,
		int *	idx,
		const char *	representer_name,
		F5_iterate_fields_t *	callback,
		void *	operator_data )

Traverses all fields per representation. Typically invoked by the callback function of F5iterate_representations().

See also

Higher level functionality provided by F5iterate_vertex_fields() and F5iterate_topology_fields().

Parameters

representer_name

The name of the representation group, as come callbacks want to know this.

Definition at line 582 of file F5iterate.c.

{
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);
}

References VertexFieldParams::callback, VertexFieldParams::coordinate_system, VertexFieldParams::operator_data, VertexFieldParams::path, F5Path::Representation_hid, and VertexFieldParams::what.

F5iterate_gridevolution()

F5_API 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 )

Parameters

gridinfo

Optional per-grid callback function. May be just NULL.

Definition at line 1372 of file F5iterate.c.

{
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;
}

References F5iterate_gridevolution_struct::callback, F5iterate_grids_per_bundle(), F5printf, F5iterate_gridevolution_struct::file_id, F5iterate_gridevolution_struct::gridinfo, ok, my_grids_per_bundle_emulate_via_timeslice_struct::That, and F5iterate_gridevolution_struct::user_data.

F5iterate_grids()

F5_API int F5iterate_grids	(	F5Path *	F5Slice,
		int *	idx,
		F5_iterate_grids_t *	callback,
		void *	operator_data,
		F5_gridproperty_t **	gridtypes,
		const char *	coordinate_system )

Iterate over all grids within a slice.

Parameters

gridtypes	NULL-terminated array of grid property functions. May be NULL to retrieve all grids.
coordinate_system	The coordinate system in which to check for grid properties. E.g. a grid may be uniform in one coordinate system, but is just regular in another one. May be NULL to specify the default cartesian coordinate system.
F5Slice	An F5 path with a valid slice identifier.

Definition at line 206 of file F5iterate.c.

{
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);
}

References IterateGrids::callback, IterateGrids::coordinate_system, F5printf, FIBER_HDF5_DEFAULT_CHART, IterateGrids::gridtypes, IterateGrids::operator_data, IterateGrids::path, and F5Path::Slice_hid.

F5iterate_grids_per_bundle()

F5_API int F5iterate_grids_per_bundle	(	hid_t	file_id,
		int *	idx,
		F5_iterate_grids_per_bundle_t *	callback,
		void *	user_data )

Iterate over all grids slices within a file.

Definition at line 1145 of file F5iterate.c.

{
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;
}

References H5G_iterate_grids_per_bundle_struct::callback, F5Gtry_to_open(), F5printf, FIBER_CONTENT_GRIDS, FIBER_CONTENTS, H5G_iterate_grids_per_bundle_struct::file_id, H5Gclose, and H5G_iterate_grids_per_bundle_struct::operator_data.

Referenced by F5iterate_gridevolution().

F5iterate_paramspace()

F5_API int F5iterate_paramspace	(	hid_t	file_id,
		int *	idx,
		const F5ParameterSpace *	selection,
		F5_iterate_paramspace_t *	callback,
		void *	user_data )

Todo

Implement, and reformulate F5iterate_timeslices() via this function.

References F5_API.

F5iterate_representations()

F5_API int F5iterate_representations	(	F5Path *	skeleton,
		int *	idx,
		F5_iterate_representations_t *	callback,
		void *	operator_data )

Traverses all Representations per skeleton. Typically invoked by the callback function of F5iterate_topologies() .

Definition at line 465 of file F5iterate.c.

{
/*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
}

References DomainParams::callback, F5Gtry_to_open(), F5printf, FIBER_HDF5_CHARTS_PER_GRID, FIBER_HDF5_DEFAULT_CHART, FIBER_HDF5_DEPRECATED_OLD_DEFAULT_CHART, H5Gclose, DomainParams::operator_data, F5Path::Representation_hid, DomainParams::skeleton, and F5Path::Topology_hid.

F5iterate_timeslices()

F5_API int F5iterate_timeslices	(	hid_t	file_id,
		hsize_t *	idx,
		F5_iterate_timeslices_t *	callback,
		void *	user_data )

Iterate over all time slices within a file.

Definition at line 105 of file F5iterate.c.

{
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;
}

References H5G_iterate_timeslices_struct::callback, F5Binitialize_path(), F5close(), F5printf, H5G_iterate_timeslices_struct::operator_data, and H5G_iterate_timeslices_struct::path.

F5iterate_topologies()

F5_API int F5iterate_topologies	(	F5Path *	grid,
		int *	idx,
		F5_iterate_topologies_t *	callback,
		void *	operator_data )

Traverses all Skeletons of a Grid object. Usually it is invoked via F5iterate_grids() and invokes F5iterate_topology_fields();

Definition at line 689 of file F5iterate.c.

{
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;
}

References TopologyParams::callback, TopologyParams::cells_done, F5Path::Chart_hid, F5Path::Charts_hid, TopologyParams::do_index_depth, F5_MAX_INDEX_DEPTH, F5_MIN_INDEX_DEPTH, F5LTget_skeleton_dimensionality(), F5printf, FIBER_HDF5_CELLS, FIBER_HDF5_CHARTS_PER_GRID, FIBER_HDF5_INVALID_SKELETON_DIMENSIONALITY, FIBER_HDF5_POINTS, F5Path::Grid_hid, H5Gclose, TopologyParams::operator_data, TopologyParams::path, TopologyParams::points_done, F5Path::Representation_hid, and F5Path::Topology_hid.

F5iterate_topology_fields()

F5_API int F5iterate_topology_fields	(	F5Path *	skeleton,
		int *	idx,
		F5_iterate_fields_t *	callback,
		void *	operator_data,
		const char *	coordinate_system,
		F5_fieldtype_t *	what )

Iterate over an arbitrary topology group. The group ID grid->Topology_id must be a valid group ID when calling this function.

Definition at line 296 of file F5iterate.c.

{
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;
}

References VertexFieldParams::callback, F5Path::Chart_hid, F5Path::Charts_hid, VertexFieldParams::coordinate_system, F5Gtry_to_open(), F5printf, FIBER_HDF5_CHARTS_PER_GRID, FIBER_HDF5_DEFAULT_CHART, FIBER_HDF5_DEPRECATED_OLD_DEFAULT_CHART, F5Path::Grid_hid, H5Gclose, VertexFieldParams::operator_data, VertexFieldParams::path, F5Path::Representation_hid, F5Path::Topology_hid, and VertexFieldParams::what.

Referenced by F5iterate_vertex_fields().

F5iterate_vertex_fields()

F5_API int F5iterate_vertex_fields	(	F5Path *	grid,
		int *	idx,
		F5_iterate_fields_t *	callback,
		void *	operator_data,
		const char *	coordinate_system,
		F5_fieldtype_t *	what )

Iterate over all fields given on the vertices per grid in the specified coordinate system.

Parameters

what	Function to select which field types are allowed. May be a NULL pointer to retrieve all fields on the grid.

Definition at line 405 of file F5iterate.c.

{
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;
}

References VertexFieldParams::callback, VertexFieldParams::coordinate_system, F5iterate_topology_fields(), FIBER_HDF5_POINTS, F5Path::Grid_hid, H5Gclose, VertexFieldParams::operator_data, F5Path::Topology_hid, and VertexFieldParams::what.