Creating F5Path objects and field representations.

Functions
F5Path *	F5Rcreate_relative_vertex_Qrefinement3D (hid_t File_id, double time, const char *gridname, const hsize_t current_refinement[3], double target_time, const hsize_t target_refinement[3])
F5Path *	F5Rcreate_relative_vertex_Irefinement3D (hid_t File_id, double time, const char *gridname, const hsize_t current_refinement[3], double target_time, const hsize_t target_refinement[3])
int	F5Rlink_default_vertex_topology (F5Path *grid, const hsize_t target_refinement[3])
F5_API F5Path *	F5Rcreate_cartesian_3D (hid_t File_id, double time, const char *gridname, const char *coordinate_system)
F5_API F5Path *	F5Rcreate_cartesian_nD (hid_t File_id, double time, const char *gridname, int Dims, const char *coordinate_system)
F5_API F5Path *	F5Rcreate_static_cartesian (hid_t File_id, const char *gridname, const char *coordinate_system)
F5_API F5Path *	F5Rcreate_coordinate_topology (hid_t File_id, const double *time, const char *gridname, const char *coordinate_system, const char *TopologyName, int IndexDepth, int SkeletonDimensionality, int Dimensionality, const hsize_t *refinement)
F5_API F5Path *	F5Rcreate_triangles_as_vertices_topology (hid_t File_id, double time, const char *gridname)
F5_API F5Path *	F5Rcreate_edges_as_vertices_topology (hid_t File_id, double time, const char *gridname)
F5_API F5Path *	F5Rcreate_faces_as_vertices_topology (hid_t File_id, double time, const char *gridname)
F5_API F5Path *	F5Rcreate_tetrahedrons_as_vertices_topology (hid_t File_id, double time, const char *gridname)
F5_API F5Path *	F5Rcreate_hexaedrons_as_vertices_topology (hid_t File_id, double time, const char *gridname)
F5_API F5Path *	F5Rcreate_vertex_refinement3D (hid_t File_id, double time, const char *gridname, const hsize_t refinement[3], const char *coordinate_system)
F5_API void	F5Rcreate_downsampling (F5Path *Topology, const hsize_t *downsampling)
F5_API void	F5Rcreate_subsampling (F5Path *Topology, const hsize_t *subsampling)
F5_API int	F5Rset_timestep (F5Path *path, long timestep)
F5_API long *	F5Rget_timestep (F5Path *path, long *timestep)

Detailed Description

These functions create F5Path objects for subsequent usage by F5F field functions. They are created directly from HDF5 id's and native types.

Function Documentation

F5Rcreate_cartesian_3D()

F5_API F5Path * F5Rcreate_cartesian_3D	(	hid_t	File_id,
		double	time,
		const char *	gridname,
		const char *	coordinate_system )

Create a Field object for a given representation of a grid's vertices in a certain coordinate system for a three-dimensional distribution of vertices, i.e. a 3D grid. Not to be used for surfaces, lines or point clouds - use F5Rcreate_cartesian_nD() for this case.

Returns

A new F5Path pointer. Call F5close() if it is no longer used.

Definition at line 135 of file F5R.c.

{
        return F5Rcreate_cartesian_nD(File_id, time,
                                      gridname, 3, coordinate_system);
}

References F5Rcreate_cartesian_nD().

Referenced by F5Rcreate_curvilinear_cartesian3D(), F5Rcreate_rectilinear(), F5Rcreate_uniform_cartesian3D(), F5Rcreate_uniform_cartesian3Dbbox(), F5Rcreate_uniformd(), and F5Rcreate_uniformf().

F5Rcreate_cartesian_nD()

F5_API F5Path * F5Rcreate_cartesian_nD	(	hid_t	File_id,
		double	time,
		const char *	gridname,
		int	Dims,
		const char *	coordinate_system )

Create a Field object for a given representation of a grid's vertices in a certain coordinate system, specifying the dimensionality of the grid vertices.

Returns

A new F5Path pointer. Call F5close() if it is no longer used.

Definition at line 116 of file F5R.c.

{
F5Path*myPath;
        F5printf(3, "  ---- F5Rcreate_cartesian(T=%g, grid=`%s', coordinates=`%s')",
                 time, gridname, (coordinate_system?coordinate_system:"Default coordinates"));
 
        F5printf_indent++;
        myPath = F5Rcreate_coordinate_topology(File_id, &time,
                                               gridname,
                                               coordinate_system,
                                               FIBER_HDF5_POINTS,
                                               0, Dims, Dims, 0);
        F5printf_indent--;
        return myPath;
}

References F5printf, F5printf_indent, F5Rcreate_coordinate_topology(), and FIBER_HDF5_POINTS.

Referenced by F5Cwrite_regular_surface(), F5Cwrite_triangular_surface_vc(), F5Flink_triangular_surface(), F5Rcreate_cartesian_3D(), F5Rcreate_uniform_sparse2(), F5write_particle_cartesian3Dv(), F5write_particle_cartesian3DvU(), F5write_particle_double_cartesian3Dv(), F5write_particle_positions(), and saveF5image().

F5Rcreate_coordinate_topology()

F5_API F5Path * F5Rcreate_coordinate_topology	(	hid_t	File_id,
		const double *	time,
		const char *	gridname,
		const char *	coordinate_system,
		const char *	TopologyName,
		int	IndexDepth,
		int	SkeletonDimensionality,
		int	Dimensionality,
		const hsize_t *	refinement )

Create a representation for a specific topological space on the grid in a certain coordinate system. Mostly of internal use.

A convenience function to create a 3D cartesian chart topology. To create topologies in different coordinate systems call F5LTcreate( ... ) directly.

Definition at line 80 of file F5R.c.

{
const char*cs = coordinate_system ? coordinate_system : FIBER_HDF5_DEFAULT_CHART;
ChartDomain_IDs*ChartDomain = (strcmp(cs, FIBER_HDF5_DEFAULT_CHART)==0)
                                ? F5B_standard_cartesian_chart3D() : 0;
F5Path*f;
/*
        if (ChartDomain == F5B_standard_cartesian_chart3D() )
        {
                F5printf(45, "F5Rcreate_coordinate_topology(): Using Std chart.");
                //assert(ChartDomain->perm_vector == F5_FORTRAN_ORDER);
        }
        if (!ChartDomain) F5printf(45, "F5Rcreate_coordinate_topology(): No chart domain.");
*/
        f = F5LTcreate(File_id, time,
                       gridname,
                       ChartDomain,
                       F5B_new_global_cartesian_chart3D,
                       cs,
                       TopologyName,
                       IndexDepth,
                       SkeletonDimensionality, Dimensionality,
                       refinement);
 
        if (f)  F5LTmake_enum_type(f);
 
        return f;
}

References F5B_new_global_cartesian_chart3D(), F5B_standard_cartesian_chart3D(), F5LTcreate(), F5LTmake_enum_type(), FIBER_HDF5_DEFAULT_CHART, and TopologyName().

Referenced by F5Rcreate_cartesian_nD(), F5Rcreate_static_cartesian_3D(), and F5Rcreate_vertex_refinement3D().

F5Rcreate_downsampling()

F5_API void F5Rcreate_downsampling	(	F5Path *	Topology,
		const hsize_t *	downsampling )

Create a topology suitable for downsampled data, i.e. where the average of another topology's cells are stored. The index depth of the new topology will be one more than that of the original one.

Definition at line 590 of file F5R.c.

{
        F5Rcreate_sampling(Topology, downsampling, +1, '@');
}

F5Rcreate_edges_as_vertices_topology()

F5_API F5Path * F5Rcreate_edges_as_vertices_topology	(	hid_t	File_id,
		double	time,
		const char *	gridname )

Create the default topology of the edges of a grid, as specified by vertices.

Returns

An F5Path object referring to the edges. All subsequent field operations on this F5Path object will refer to fields on the edges.

Definition at line 177 of file F5R.c.

{
F5Path*f = F5LTcreate(File_id, &time,
                      gridname,
                      F5B_standard_edge_cells(),   /* ChartDomain */
                      F5B_new_global_edge_cells,   /* F5B_new_global_cartesian_chart3D*/
                      FIBER_HDF5_POINTS,
                      FIBER_HDF5_EDGES,
                      1,   /* IndexDepth */
                      1,   /* SkeletonDimensionality */
                      1,   /* Dimensionality */
                      0);  /* Refinement */
 
        if (f)  F5LTmake_enum_type(f);
 
        return f;
}

References F5B_new_global_edge_cells(), F5B_standard_edge_cells(), F5LTcreate(), F5LTmake_enum_type(), FIBER_HDF5_EDGES, and FIBER_HDF5_POINTS.

F5Rcreate_faces_as_vertices_topology()

F5_API F5Path * F5Rcreate_faces_as_vertices_topology	(	hid_t	File_id,
		double	time,
		const char *	gridname )

Create the default topology of the facet of a grid, as specified by vertices.

Returns

An F5Path object referring to the facet. All subsequent field operations on this F5Path object will refer to fields on the facet.

References F5_API, and name.

F5Rcreate_hexaedrons_as_vertices_topology()

F5_API F5Path * F5Rcreate_hexaedrons_as_vertices_topology	(	hid_t	File_id,
		double	time,
		const char *	gridname )

Create the default topology of the cells of a grid as hexahedrons, as specified by vertices. It will be a 3-dimensional grid.

Returns

An F5Path object referring to the hexahedral cells. All subsequent field operations on this F5Path object will refer to fields on the hexahedrons.

Definition at line 233 of file F5R.c.

{
F5Path*f = F5LTcreate(File_id, &time,
                      gridname,
                      F5B_standard_hexahedral_cells(), /* ChartDomain */
                      F5B_new_global_hexahedral_cells, /*F5B_new_global_cartesian_chart3D*/
                      FIBER_HDF5_POINTS,
                      FIBER_HDF5_CELLS,
                      1, /* IndexDepth */
                      3, /* int SkeletonDimensionality */
                      3, /* Dimensionality */
                      0); /* refinement */
 
        if (f)  F5LTmake_enum_type(f);
 
        return f;
}

References F5B_new_global_hexahedral_cells(), F5B_standard_hexahedral_cells(), F5LTcreate(), F5LTmake_enum_type(), FIBER_HDF5_CELLS, and FIBER_HDF5_POINTS.

F5Rcreate_relative_vertex_Irefinement3D()

F5_API F5Path * F5Rcreate_relative_vertex_Irefinement3D	(	hid_t	File_id,
		double	time,
		const char *	gridname,
		const hsize_t	current_refinement[3],
		double	target_time,
		const hsize_t	target_refinement[3] )

Define refinement by integer numbers. Here, the vertices of the refined objects have to match up exactly with the vertices of the coarse levels. It is only possible to refine entire cells on the coarse grid.

Create a refinement topology whose refined cells fully cover coarse cells. The border vertices line up exactly, i.e. the positions of a subregion may be given in integers of a coarse region.

Definition at line 423 of file F5R.c.

{
char    CurrentTname[1024];
char    TargetTname[1024];
F5Path* retval;
char    timename[128];
char    FullTargetTname[2048];
        assert(current_refinement);
        assert(target_refinement);
        TopologyName(CurrentTname, sizeof(CurrentTname), current_refinement, 0,3);
        TopologyName(TargetTname , sizeof(TargetTname) , target_refinement, 0,3);
 
        retval = F5LTcreate(File_id, &time,
                            gridname,
                            0,
                            F5B_new_integer_regular_domain3D,
                            TargetTname, /* representation_name */
                            CurrentTname, /* TopologyName */
                            0,            /* IndexDepth */
                            3,          /* int SkeletonDimensionality */
                            3,            /* Dimensionality */
                            current_refinement);  /* const hsize_t*refinement */
 
 
        F5I_timegroup(&target_time, timename, sizeof(timename) );
#ifdef  _MSC_VER
        _snprintf
#else
        snprintf
#endif
                (FullTargetTname, sizeof(FullTargetTname),
                 "/%s/%s/%s",
                 timename, gridname, TargetTname );
 
/* TODO: Check for existing representer, and if another value exists, create unique one! */
        F5Glink(retval->Representation_hid, H5G_LINK_SOFT, FullTargetTname, FIBER_HDF5_REPRESENTER);
 
        return retval;
}

References F5B_new_integer_regular_domain3D(), F5Glink(), F5I_timegroup(), F5LTcreate(), FIBER_HDF5_REPRESENTER, F5Path::Representation_hid, and TopologyName().

F5Rcreate_relative_vertex_Qrefinement3D()

F5_API F5Path * F5Rcreate_relative_vertex_Qrefinement3D	(	hid_t	File_id,
		double	time,
		const char *	gridname,
		const hsize_t	current_refinement[3],
		double	target_time,
		const hsize_t	target_refinement[3] )

Define refinement by rational numbers. Here, the vertices of the refined objects may cover fractions of the coarser cells. Still, vertices have to line up exactly and no refined cell may be split by the boundary of a coarser cell.

Create a refinement topology whose refined cells may partially cover coarse cells. The refinement coordinates are given as rational numbers.

Definition at line 369 of file F5R.c.

{
char    CurrentTname[1024];
char    TargetTname[1024];
F5Path* retval;
char    timename[128];
char    FullTargetTname[2048];
        assert(current_refinement);
        assert(target_refinement);
        TopologyName(CurrentTname, sizeof(CurrentTname), current_refinement, 0,3);
        TopologyName(TargetTname , sizeof(TargetTname) , target_refinement, 0,3);
 
        F5printf(30, "F5Rcreate_relative_vertex_Qrefinement3D()\n");
        retval = F5LTcreate(File_id, &time,
                            gridname,
                            0,
                            F5B_new_rational_regular_domain3D,
                            TargetTname, /* representation_name */
                            CurrentTname, /* TopologyName */
                            0,            /* IndexDepth */
                            3,          /* int SkeletonDimensionality, */
                            3,            /* Dimensionality */
                            current_refinement);  /* const hsize_t*refinement */
 
 
        F5printf(30, "F5Rcreate_relative_vertex_Qrefinement3D() - timegroup\n");
        F5I_timegroup(&target_time, timename, sizeof(timename) );
#ifdef  _MSC_VER
        _snprintf
#else
        snprintf
#endif
                (FullTargetTname, sizeof(FullTargetTname),
                 "/%s/%s/%s",
                 timename, gridname, TargetTname );
 
/* TODO: Check for existing representer, and if another value exists, create unique one! */
        F5Glink(retval->Representation_hid, H5G_LINK_SOFT, FullTargetTname, FIBER_HDF5_REPRESENTER);
 
        F5printf(30, "~F5Rcreate_relative_vertex_Qrefinement3D()\n");
 
        return retval;
}

References F5B_new_rational_regular_domain3D(), F5Glink(), F5I_timegroup(), F5LTcreate(), F5printf, FIBER_HDF5_REPRESENTER, F5Path::Representation_hid, and TopologyName().

F5Rcreate_static_cartesian()

F5_API F5Path * F5Rcreate_static_cartesian	(	hid_t	File_id,
		const char *	gridname,
		const char *	coordinate_system )

Construct a Field object for a representation of a grid's vertices in a certain coordinate system.

Parameters

ChartDomain	A coordinate system domain object. It may be NULL to create a new one via the coord_creator parameter locally for this field. If a class of coordinate systems shall be used for multiple grids (which is required to enable interpolation), then a shared ChartDomain object needs to be given. If is reference counted among all grids that use it (taken care of in F5close() ).
coord_creator	A procedure to create a new class of coordinate systems.
coordinate_system	A name for an instance of the coordinate system, i.e. for the current chart object to use.
TopologyName	On which topological space of the grid to create the coordinate representation (e.g. vertices, cells, edges, refinement level ...)
time	The time to which the succeeding data will be attached. Use F5Rcreate_static_cartesian() if no time information is reasonable for the given data. Note that static data currently requires special handling when reading data, so it is recommended to adjust any data to a timeslice, except if there is an absolute requirement to specify that these data are constant for all thinkable times.

Returns

A new F5Path pointer. Call F5close() if it is no longer used.

Construct a Field object for a representation of a grid's vertices in a certain coordinate system that is independent from any time information.

Parameters

ChartDomain	A coordinate system domain object. It may be NULL to create a new one via the coord_creator parameter locally for this field. If a class of coordinate systems shall be used for multiple grids (which is required to enable interpolation), then a shared ChartDomain object needs to be given. If is reference counted among all grids that use it (taken care of in F5close() ).
coord_creator	A procedure to create a new class of coordinate systems.
coordinate_system	A name for an instance of the coordinate system, i.e. for the current chart object to use.
TopologyName	On which topological space of the grid to create the coordinate representation (e.g. vertices, cells, edges, refinement level ...)

Returns

A new F5Path pointer. Call F5close() if it is no longer used.

References F5_API, and TopologyName().

F5Rcreate_subsampling()

F5_API void F5Rcreate_subsampling	(	F5Path *	Topology,
		const hsize_t *	subsampling )

Create a topology suitable for subsampled data, i.e. where a subset of another topology's cells are stored. Note that the same data can also be retrieved by HDF5 hyperslabbing, but storing an hyperslab as a contigous data set may be helpful for faster data access. The index depth of the new topology will be identical to the original one.

Definition at line 607 of file F5R.c.

{
        F5Rcreate_sampling(Topology, subsampling, 0, ':');
}

F5Rcreate_tetrahedrons_as_vertices_topology()

F5_API F5Path * F5Rcreate_tetrahedrons_as_vertices_topology	(	hid_t	File_id,
		double	time,
		const char *	gridname )

Create the default topology of the cells of a grid as tetrahedra, as specified by vertices. It will be a 3-dimensional grid.

Returns

An F5Path object referring to the cells. All subsequent field operations on this F5Path object will refer to fields on the cells.

Definition at line 214 of file F5R.c.

{
F5Path*f = F5LTcreate(File_id, &time,
                      gridname,
                      F5B_standard_tetrahedral_cells(), /* ChartDomain */
                      F5B_new_global_tetrahedral_cells, /*F5B_new_global_cartesian_chart3D*/
                      FIBER_HDF5_POINTS,
                      FIBER_HDF5_CELLS,
                      1,  /* IndexDepth*/
                      3, /* int SkeletonDimensionality */
                      3,  /* Dimensionality*/
                      0); /* refinement*/
 
        if (f)  F5LTmake_enum_type(f);
 
        return f;
}

References F5B_new_global_tetrahedral_cells(), F5B_standard_tetrahedral_cells(), F5LTcreate(), F5LTmake_enum_type(), FIBER_HDF5_CELLS, and FIBER_HDF5_POINTS.

F5Rcreate_triangles_as_vertices_topology()

F5_API F5Path * F5Rcreate_triangles_as_vertices_topology	(	hid_t	File_id,
		double	time,
		const char *	gridname )

Create the default topology of the cells of a grid as triangles, as specified by vertices. It will result in a two-dimensional grid.

Returns

An F5Path object referring to the cells (i.e. triangles). All subsequent field operations on this F5Path object will refer to fields on the triangles.

Definition at line 158 of file F5R.c.

{
F5Path*f = F5LTcreate(File_id, &time,
                      gridname,
                      F5B_standard_triangle_cells(), /* ChartDomain */
                      F5B_new_global_triangle_cells, /*F5B_new_global_cartesian_chart3D*/
                      FIBER_HDF5_POINTS,
                      FIBER_HDF5_FACES,
                      1,   /* IndexDepth     */
                      2,   /* Dimensionality */
                      2,
                      0 ); /* refinement     */
 
        if (f)  F5LTmake_enum_type(f);
 
        return f;
}

References F5B_new_global_triangle_cells(), F5B_standard_triangle_cells(), F5LTcreate(), F5LTmake_enum_type(), FIBER_HDF5_FACES, and FIBER_HDF5_POINTS.

Referenced by F5Cwrite_triangular_surface_vc(), and F5Flink_triangular_surface().

F5Rcreate_vertex_refinement3D()

F5_API F5Path * F5Rcreate_vertex_refinement3D	(	hid_t	File_id,
		double	time,
		const char *	gridname,
		const hsize_t	refinement[3],
		const char *	coordinate_system )

Create an Field object for vertices of a grid in a certain coordinate system that is intended to store subsampled data of the full grid. Note that this function is intended to store contigous datasets, which can be hyperslabs of other datasets. It can be used as a "cache" for hyperslabbed data such that they require less disc space.

Note

This function only refers to the vertices of a grid. Use the AMR functions for more handling cell, face or edge-related data and/or if refined data only exist on a subset of the full coordinate space.

See also

F5Lwrite_fraction(), Adaptive Hierarchical Meshes

Parameters

refinement

The refinement factor as compared to the finest resolution. It will most likely be a power of two. Note that the coarsest resolution should get the smallest number and the finest resolution (i.e. the complete dataset) the largest number. It is recommended to start counting at zero, given a refinement level, this refinement to be given here will be a power of two given the level number.

Returns

A new F5Path pointer. Call F5close() if it is no longer used.

Definition at line 346 of file F5R.c.

{
char    Tname[1024];
        assert(refinement);
        TopologyName(Tname, sizeof(Tname), refinement, 0,3);
 
        return F5Rcreate_coordinate_topology(File_id, &time,
                                             gridname,
                                             coordinate_system,
                                             Tname,
                                             0, 3, 3, refinement);
 
}

References F5Rcreate_coordinate_topology(), and TopologyName().

F5Rget_timestep()

F5_API long * F5Rget_timestep	(	F5Path *	path,
		long *	timestep )

Get information about the optional integer timestep of an Grid object. All fields per grid object must refer to the same integer timestep. If a Grid object does not provide such timestep information, it may be an interpolated grid that can be computed from others that contain such timestep information. The timestep value by itself is arbitrary, but must be unique among all Grid objects with the same Grid identifier.

Returns

NULL, if no timestep information was found, or the F5Path does not refer to a Grid object.

Definition at line 44 of file F5R.c.

{
hid_t   attr_id,
        space_id;
 
        if (!path || path->Grid_hid<0 || !timestep)
        {
                F5printf(1,"F5Rget_timestep(): got invalid grid or parameter.");
                return NULL;
        }
 
        H5E_BEGIN_TRY
        attr_id = F5Aopen_name(path->Grid_hid, FIBER_HDF5_TIMESTEP_ATTRIB);
        H5E_END_TRY
 
        if (attr_id<0)
                return NULL;
 
        space_id = H5Aget_space(attr_id);
        assert( space_id >0);;
        if (H5Sget_simple_extent_npoints(space_id) != 1)
                return NULL;
 
        F_H5Aread(attr_id, H5T_NATIVE_LONG, timestep, FIBER_HDF5_TIMESTEP_ATTRIB);
 
        H5Aclose(attr_id);
        H5Sclose(space_id);
 
        return timestep;
}

References F5Aopen_name(), F5printf, F_H5Aread(), FIBER_HDF5_TIMESTEP_ATTRIB, and F5Path::Grid_hid.

Referenced by F5Rset_timestep().

F5Rlink_default_vertex_topology()

F5_API int F5Rlink_default_vertex_topology	(	F5Path *	grid,
		const hsize_t	target_refinement[3] )

Treat some refinement level as the default level for refinement-unaware readers.

Creates a symbolic link from some refinement level on vertices to appear as the default points topology.

Parameters

grid	A valid F5Path object pointing to some grid.
target_refinement	The refinement level that shall be visible as default.

Note

Currently only 3D refinements are supported.

If a point topology already exists, it will not be touched.

Create a symbolic links from some vertex refinement topology group to the default group "Points".

Returns

non-zero in case of errors, like invalid arguments.

Parameters

grid	Pointer to an F5Path object. It must contain a valid Grid_id identifiert.

Todo

Check for an eventually existing "Points" group and handle HDF5 error codes.

Definition at line 478 of file F5R.c.

{
char    TargetTname[1024];
        if (!grid) return -1;
        if (grid->Grid_hid<1) return -2;
        if (!target_refinement) return -3;
        TopologyName(TargetTname, sizeof(TargetTname),  target_refinement, 0,3);
        {
                F5Glink(grid->Grid_hid, H5G_LINK_SOFT, TargetTname, FIBER_HDF5_POINTS);
        }
        return 0;
}

References F5Glink(), FIBER_HDF5_POINTS, F5Path::Grid_hid, and TopologyName().

F5Rset_timestep()

F5_API int F5Rset_timestep	(	F5Path *	path,
		long	timestep )

Set information about an integer timestep (per Grid object!) This is an recommended attribute for data originating from subsequent simulations. It may be omitted on interpolated grid objects to specify that these are secondary data that can be reproduced from grids with Timestep information.

Returns

non-zero if the timestep could be set, and zero (false) if the grid object in charge already has a timestep attached with it but is inconsistent with the specified one.

Definition at line 10 of file F5R.c.

{
hid_t   attr_id,
        space_id;
long    have_timestep;
 
        if (!path || path->Grid_hid<0)
        {
                F5printf(1,"F5Rset_timestep(,%ld): got invalid grid", timestep);
                return 0;
        }
        if (F5Rget_timestep(path, &have_timestep) )
        {
                if (have_timestep==timestep)
                        return 1;
 
                F5printf(1,"F5Rset_timestep(%ld): invalid timestep specified, "
                         "grid is already bound to %ld!", timestep, have_timestep);
                return 0;
        }
 
        space_id= H5Screate(H5S_SCALAR);
 
        attr_id = H5Acreate2(path->Grid_hid,
                            FIBER_HDF5_TIMESTEP_ATTRIB, H5T_NATIVE_LONG, space_id,
                            H5P_DEFAULT, H5P_DEFAULT);
 
        H5Awrite(attr_id, H5T_NATIVE_LONG, &timestep);
 
        H5Aclose(attr_id);
        H5Sclose(space_id);
        return 1;
}

References F5printf, F5Rget_timestep(), FIBER_HDF5_TIMESTEP_ATTRIB, and F5Path::Grid_hid.