philipp/hdf5
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[svn-r3659]

Browse Source 
Added html files with references to the fortran 90 files.
(under examples/)
This commit is contained in:
Barbara Jones
2001-03-19 09:26:47 -05:00
parent 380eb42bc5
commit f11cef2c56
30 changed files with 2967 additions and 3139 deletions
Download Patch File Download Diff File Expand all files Collapse all files

239
doc/html/Tutor/compound.html
View File

@@ -1,5 +1,5 @@
<HTML><HEAD>
<TITLE>HDF5 Tutorial - Compound Data Types
<TITLE>HDF5 Tutorial - Compound Datatypes
</TITLE>
</HEAD>
@@ -13,7 +13,7 @@ width=78 height=27 alt="NCSA"><P></A>
[ <A HREF="title.html"><I>HDF5 Tutorial Top</I></A> ]
<H1>
<BIG><BIG><BIG><FONT COLOR="#c101cd">Compound Data Types</FONT>
<BIG><BIG><BIG><FONT COLOR="#c101cd">Compound Datatypes</FONT>
</BIG></BIG></BIG></H1>
<hr noshade size=1>
@@ -21,7 +21,7 @@ width=78 height=27 alt="NCSA"><P></A>
<BODY>
<H2>Contents:</H2>
<UL>
<LI><A HREF="#def">Creating Compound Data Types</A>
<LI><A HREF="#def">Creating Compound Datatypes</A>
<LI>Programming Example
<UL>
<LI> <A HREF="#desc">Description</A>
@@ -31,192 +31,48 @@ width=78 height=27 alt="NCSA"><P></A>
</UL>
<HR>
<A NAME="def">
<H2>Creating Compound Data Types</H2>
A compound data type is similar to a struct in C or a common block in
Fortran. It is a collection of one or more atomic types or small arrays of
such types. To create and use a compound data type you need to refer to
various properties of the data compound data type:
<H2>Creating Compound Datatypes</H2>
A compound datatype is similar to a struct in C or a common block in
FORTRAN. It is a collection of one or more atomic types or small arrays of
such types. To create and use a compound datatype you need to be familiar
with various properties of the compound datatype:
<UL>
<LI>It is of class compound.
<LI>It is of class <strong>compound</strong>.
<LI>It has a fixed total size, in bytes.
<LI>It consists of zero or more members (defined in any order) with
unique names and which occupy non-overlapping regions within the datum.
<LI>Each member has its own data type.
<LI>Each member is referenced by an index number between zero and N-1,
where N is the number of members in the compound data type.
unique names and occupying non-overlapping regions within the datum.
<LI>Each member has its own datatype.
<LI>Each member is referenced by an index number between zero and <em>N</em>-1,
where <em>N</em> is the number of members in the compound datatype.
<LI>Each member has a name which is unique among its siblings in a
compound data type.
<LI>Each member has a fixed byte offset, which is the first byte
(smallest byte address) of that member in a compound data type.
compound datatype.
<LI>Each member has a fixed byte offset, which locates the first byte
(smallest byte address) of that member in the compound datatype.
<LI>Each member can be a small array of up to four dimensions.
</UL>
Properties of members of a compound data type are defined when the
member is added to the compound type and cannot be subsequently modified.
Properties of members of a compound datatype are defined when the
member is added to the compound datatype and cannot be subsequently modified.
<P>
Compound data types must be built out of other data types. First, one
creates an empty compound data type and specifies its total size. Then
members are added to the compound data type in any order.
Compound datatypes must be built out of other datatypes. First, one
creates an empty compound datatype and specifies its total size. Then
members are added to the compound datatype in any order.
<H2> Programming Example</H2>
<A NAME="desc">
<H3><U>Description</U></H3>
This example shows how to create a compound data type, write an array
to the file which uses the compound data type, and read back subsets of
the members.<BR>
[<A HREF="examples/h5_compound.c">Download h5_compound.c</A>]
<PRE>
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#include "hdf5.h"
#define FILE "SDScompound.h5"
#define DATASETNAME "ArrayOfStructures"
#define LENGTH 10
#define RANK 1
int
main(void)
{
/* First structure and dataset*/
typedef struct s1_t {
int a;
float b;
double c;
} s1_t;
s1_t s1[LENGTH];
hid_t s1_tid; /* File datatype identifier */
/* Second structure (subset of s1_t) and dataset*/
typedef struct s2_t {
double c;
int a;
} s2_t;
s2_t s2[LENGTH];
hid_t s2_tid; /* Memory datatype handle */
/* Third "structure" ( will be used to read float field of s1) */
hid_t s3_tid; /* Memory datatype handle */
float s3[LENGTH];
int i;
hid_t file, dataset, space; /* Handles */
herr_t status;
hsize_t dim[] = {LENGTH}; /* Dataspace dimensions */
/*
* Initialize the data
*/
for (i = 0; i &lt; LENGTH; i++) {
s1[i].a = i;
s1[i].b = i*i;
s1[i].c = 1./(i+1);
}
/*
* Create the data space.
*/
space = H5Screate_simple(RANK, dim, NULL);
/*
* Create the file.
*/
file = H5Fcreate(FILE, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
/*
* Create the memory data type.
*/
s1_tid = H5Tcreate (H5T_COMPOUND, sizeof(s1_t));
H5Tinsert(s1_tid, "a_name", HOFFSET(s1_t, a), H5T_NATIVE_INT);
H5Tinsert(s1_tid, "c_name", HOFFSET(s1_t, c), H5T_NATIVE_DOUBLE);
H5Tinsert(s1_tid, "b_name", HOFFSET(s1_t, b), H5T_NATIVE_FLOAT);
/*
* Create the dataset.
*/
dataset = H5Dcreate(file, DATASETNAME, s1_tid, space, H5P_DEFAULT);
/*
* Wtite data to the dataset;
*/
status = H5Dwrite(dataset, s1_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, s1);
/*
* Release resources
*/
H5Tclose(s1_tid);
H5Sclose(space);
H5Dclose(dataset);
H5Fclose(file);
/*
* Open the file and the dataset.
*/
file = H5Fopen(FILE, H5F_ACC_RDONLY, H5P_DEFAULT);
dataset = H5Dopen(file, DATASETNAME);
/*
* Create a data type for s2
*/
s2_tid = H5Tcreate(H5T_COMPOUND, sizeof(s2_t));
H5Tinsert(s2_tid, "c_name", HOFFSET(s2_t, c), H5T_NATIVE_DOUBLE);
H5Tinsert(s2_tid, "a_name", HOFFSET(s2_t, a), H5T_NATIVE_INT);
/*
* Read two fields c and a from s1 dataset. Fields in the file
* are found by their names "c_name" and "a_name".
*/
status = H5Dread(dataset, s2_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, s2);
/*
* Display the fields
*/
printf("\n");
printf("Field c : \n");
for( i = 0; i &lt; LENGTH; i++) printf("%.4f ", s2[i].c);
printf("\n");
printf("\n");
printf("Field a : \n");
for( i = 0; i &lt; LENGTH; i++) printf("%d ", s2[i].a);
printf("\n");
/*
* Create a data type for s3.
*/
s3_tid = H5Tcreate(H5T_COMPOUND, sizeof(float));
status = H5Tinsert(s3_tid, "b_name", 0, H5T_NATIVE_FLOAT);
/*
* Read field b from s1 dataset. Field in the file is found by its name.
*/
status = H5Dread(dataset, s3_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, s3);
/*
* Display the field
*/
printf("\n");
printf("Field b : \n");
for( i = 0; i &lt; LENGTH; i++) printf("%.4f ", s3[i]);
printf("\n");
/*
* Release resources
*/
H5Tclose(s2_tid);
H5Tclose(s3_tid);
H5Dclose(dataset);
H5Fclose(file);
return 0;
}
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
</PRE>
This example shows how to create a compound datatype, write an array
to the file which uses the compound datatype, and read back subsets of
the members.
<p>
<UL>
[ <A HREF="examples/h5_compound.c">C Example</A> ] - <code>h5_compound.c</code>
<BR>
[ <A HREF="examples/compound.f90">Fortran 90 Example</A> ]
- <code>compound.f90</code>
<BR>
[ <A HREF="examples/java/Compound.java">Java Example</A> ] - <code>Compound.java</code>
</UL>
The program outputs the following:
<PRE>
@@ -235,33 +91,34 @@ Field b :
<A NAME="rem">
<H3><U>Remarks</U></H3>
<UL>
<LI>H5Tcreate creates a new data type of the specified class with
<LI><CODE>H5Tcreate</CODE> creates a new datatype of the specified class with
the specified number of bytes.
<PRE>
hid_t H5Tcreate ( H5T_class_t class, size_t size )
</PRE>
<UL>
<LI>The <I>class</I> parameter specifies the data type to create.
Currently only the H5T_COMPOUND data type class is supported with this
<LI>The <I>class</I> parameter specifies the datatype to create.
Currently only the <CODE>H5T_COMPOUND</CODE> datatype class is supported with this
function.
<LI>The <I>size</I> parameter specifies the number of bytes in the
data type to create.
datatype to create.
</UL>
<P>
<LI>H5Tinsert adds a member to the compound data type specified by
<LI><CODE>H5Tinsert</CODE> adds a member to the compound datatype specified by
<I>type_id</I>.
<PRE>
herr_t H5Tinsert ( hid_t type_id, const char * name, off_t offset, hid_t field_id )
herr_t H5Tinsert ( hid_t type_id, const char * name, off_t offset,
hid_t field_id )
</PRE>
<UL>
<LI>The <I>type_id</I> parameter is the identifier of the compound data type
<LI>The <I>type_id</I> parameter is the identifier of the compound datatype
to modify.
<LI>The <I>name</I> parameter is the name of the field to insert. The new
member name must be unique within a compound data type.
member name must be unique within a compound datatype.
<LI>The <I>offset</I> parameter is the offset in the memory structure of
the field to insert.
The library defines the HOFFSET macro to compute the offset of a member within
The library defines the <CODE>HOFFSET</CODE> macro to compute the offset of a member within
a struct:
<PRE>
HOFFSET ( s, m )
@@ -269,15 +126,15 @@ a struct:
This macro computes the offset of member <I>m</I> within a struct
variable <I>s</I>.
<LI>The <I>field_id</I> parameter is the data type identifier of the
<LI>The <I>field_id</I> parameter is the datatype identifier of the
field to insert.
</UL>
<P>
<LI>H5Tclose releases a data type.
<LI><CODE>H5Tclose</CODE> releases a datatype.
<PRE>
herr_t H5Tclose ( hid_t type_id )
</PRE>
The <I>type_id</I> parameter is the identifier of the data type to release.
The <I>type_id</I> parameter is the identifier of the datatype to release.
</UL>
<A NAME="fc">
<H3><U>File Contents</U></H3>
@@ -365,8 +222,10 @@ GROUP "/" {
<!-- <A HREF="helpdesk.mail.html"> -->
<A HREF="mailto:hdfhelp@ncsa.uiuc.edu">
hdfhelp@ncsa.uiuc.edu</A>
<BR> <H6>Last Modified: August 27, 1999</H6><BR>
<br>
<BR> <H6>Last Modified: March 9, 2001</H6><BR>
<!-- modified by Barbara Jones - bljones@ncsa.uiuc.edu -->
<!-- modified by Frank Baker - fbaker@ncsa.uiuc.edu -->
</FONT>
<BR>
<!-- <A HREF="mailto:hdfhelp@ncsa.uiuc.edu"> -->