The HDF Group

HDF User’s Guide

Version 4.2r4


[Top] [Prev][Next]


create_vdatas.c
#include "hdf.h" 
#define  FILE1_NAME     "General_Vdatas.hdf"  
#define  FILE2_NAME     "Two_Vdatas.hdf"  
#define  VDATA_NAME     "Vdata 1" 
#define  VDATA_CLASS    "Empty Vdatas" 
main( ) 
{ 
   /************************* Variable declaration **************************/ 
   intn  status_n;      /* returned status for functions returning an intn  */ 
   int32 status_32,     /* returned status for functions returning an int32 */ 
         file1_id, file2_id, 
         vdata_id, vdata1_id, vdata2_id, 
         vdata_ref = -1;     /* ref number of a vdata, set to -1 to create  */ 
   /********************** End of variable declaration **********************/ 
   /*  
   * Create the first HDF file.  
   */ 
   file1_id = Hopen (FILE1_NAME, DFACC_CREATE, 0); 
   /*  
   * Initialize the VS interface associated with the first HDF file.  
   */ 
   status_n = Vstart (file1_id); 
   /*  
   * Create a vdata in the first HDF file.  
   */ 
   vdata_id = VSattach (file1_id, vdata_ref, "w"); 
   /* 
   * Assign a name to the vdata. 
   */ 
   status_32 = VSsetname (vdata_id, VDATA_NAME); 
   /*  
   * Other operations on the vdata identified by vdata_id can be carried 
   * out starting from this point. 
   */ 
   /*  
   * Create the second HDF file.  
   */ 
   file2_id = Hopen (FILE2_NAME, DFACC_CREATE, 0); 
   /*  
   * Initialize the VS interface associated with the second HDF file.  
   */ 
   status_n = Vstart (file2_id); 
   /*  
   * Create the first vdata in the second HDF file.  
   */ 
   vdata1_id = VSattach (file2_id, vdata_ref, "w"); 
   /*  
   * Create the second vdata in the second HDF file.  
   */ 
   vdata2_id = VSattach (file2_id, vdata_ref, "w"); 
   /* 
   * Assign a class name to these vdatas. 
   */ 
   status_32 = VSsetclass (vdata1_id, VDATA_CLASS); 
   status_32 = VSsetclass (vdata2_id, VDATA_CLASS); 
   /*  
   * Other operations on the vdatas identified by vdata1_id and vdata2_id  
   * can be carried out starting from this point. 
   */ 
   /*  
   * Terminate access to the first vdata in the second HDF file.  
   */ 
   status_32 = VSdetach (vdata1_id); 
   /*  
   * Terminate access to the second vdata in the second HDF file.  
   */ 
   status_32 = VSdetach (vdata2_id); 
   /*  
   * From this point on, any operations on the vdatas identified by vdata1_id  
   and vdata2_id are invalid but not on the vdata identified by vdata_id. 
   */ 
   /*  
   * Terminate access to the VS interface associated with the second HDF file.  
   */ 
   status_n = Vend (file2_id); 
   /*  
   * Close the second HDF file.  
   */ 
   status_n = Hclose (file2_id); 
   /*  
   * Terminate access to the vdata in the first HDF file.  
   */ 
   status_32 = VSdetach (vdata_id); 
   /*  
   * Terminate access to the VS interface associated with the first HDF file.  
   */ 
   status_n = Vend (file1_id); 
   /*  
   * Close the first HDF file.  
   */ 
   status_n = Hclose (file1_id); 
} 
create_vdatas.f
      program create_vdatas 
      implicit none 
C 
C     Parameter declaration 
C 
      character*18 FILE1_NAME 
      character*14 FILE2_NAME 
      character*7  VDATA_NAME 
      character*12 VDATA_CLASS 
C 
      parameter (FILE1_NAME  = `General_Vdatas.hdf', 
     +           FILE2_NAME  = `Two_Vdatas.hdf', 
     +           VDATA_NAME  = `Vdata 1', 
     +           VDATA_CLASS = `Empty Vdatas') 
      integer DFACC_CREATE 
      parameter (DFACC_CREATE = 4) 
C 
C     Function declaration 
C 
      integer hopen, hclose 
      integer vfstart, vsfatch, vsfsnam, vsfscls, vsfdtch, vfend  
C 
C**** Variable declaration ******************************************* 
C 
      integer status 
      integer file1_id, file2_id 
      integer vdata_id, vdata1_id, vdata2_id  
      integer vdata_ref 
C 
C**** End of variable declaration ************************************ 
C 
C 
C     Create the first HDF file. 
C 
      file1_id = hopen(FILE1_NAME, DFACC_CREATE, 0) 
C 
C     Initialize the VS interface associated with the first HDF file. 
C 
      status = vfstart(file1_id)  
C 
C     Create a vdata in the first HDF file. 
C 
      vdata_ref = -1 
      vdata_id = vsfatch(file1_id, vdata_ref, `w') 
C 
C     Assign a name to the vdata. 
C 
      status = vsfsnam(vdata_id, VDATA_NAME) 
C 
C     Other operations on the vdata identified by vdata_id can be carried out 
C     starting from this point. 
C 
C     Create the second HDF file. 
C 
      file2_id = hopen(FILE2_NAME, DFACC_CREATE, 0)  
C 
C     Initialize the VS interface associated with the second HDF file. 
C 
      status = vfstart(file2_id)  
C 
C     Create the first vdata in the second HDF file. 
C 
      vdata1_id = vsfatch(file2_id, vdata_ref, `w') 
C 
C     Create the second vdata in the second HDF file. 
C 
      vdata2_id = vsfatch(file2_id, vdata_ref, `w') 
C 
C     Assign a class name to these vdatas. 
C 
      status = vsfscls(vdata1_id, VDATA_CLASS) 
      status = vsfscls(vdata2_id, VDATA_CLASS) 
C 
C     Other operations on the vdatas identified by vdata1_id and vdata2_id 
C     can be carried out starting from this point. 
C 
C 
C     Terminate access to the first vdata in the second HDF file. 
C 
      status = vsfdtch(vdata1_id) 
C 
C     Terminate access to the second vdata in the second HDF file. 
C 
      status = vsfdtch(vdata2_id) 
C 
C     Terminate access to the VS interface associated with the second HDF file. 
C 
      status = vfend(file2_id) 
C 
C     Close the second HDF file. 
C 
      status = hclose(file2_id) 
C 
C     Terminate access to the vdata in the first HDF file. 
C 
      status = vsfdtch(vdata_id) 
C 
C     terminate access to the VS interface associated with the first HDF file. 
C 
      status = vfend(file1_id) 
C 
C     Close the first HDF file. 
C 
      status = hclose(file1_id) 
      end 
create_onefield_vdata.c
#include "hdf.h"  
#define  FILE_NAME      "General_Vdatas.hdf" 
#define  CLASS1_NAME    "5x1 Array" 
#define  CLASS2_NAME    "6x4 Array" 
#define  VDATA1_NAME    "First Vdata" 
#define  VDATA2_NAME    "Second Vdata" 
#define  FIELD1_NAME    "Single-component Field" 
#define  FIELD2_NAME    "Multi-component Field" 
#define  N_RECORDS_1    5    /* number of records the first vdata contains  */ 
#define  N_RECORDS_2    6    /* number of records the second vdata contains */ 
#define  ORDER_2        4    /* order of the field in the second vdata      */ 
                /* Note that the order of the field in the first vdata is 1 */ 
main( ) 
{ 
   /************************* Variable declaration **************************/ 
   intn  status_n;      /* returned status for functions returning an intn  */ 
   int32 status_32;     /* returned status for functions returning an int32 */ 
   int32 file_id, vdata1_ref, vdata2_ref;  
   /* 
   * Define an array to buffer the data of the first vdata. 
   */ 
   char8 vdata1_buf [N_RECORDS_1] = {`V', `D', `A', `T', `A'}; 
   /* 
   * Define an array to buffer the data of the second vdata. 
   */ 
   int32 vdata2_buf [N_RECORDS_2][ORDER_2] = {{1, 2, 3, 4}, {2, 4, 6, 8}, 
                                              {3, 6, 9, 12}, {4, 8, 12, 16}, 
                                              {5, 10, 15, 20}, {6, 12, 18, 24}}; 
   /********************** End of variable declaration **********************/ 
   /* 
   * Open the HDF file for writing. 
   */ 
   file_id = Hopen (FILE_NAME, DFACC_WRITE, 0); 
   /* 
   * Initialize the VS interface. 
   */ 
   status_n = Vstart (file_id); 
     
   /* 
   * Create the first vdata and populate it with data from the vdata1_buf  
   * array. Note that the buffer vdata1_buf is cast to (uint8 *) for the  
   * benefit of generic data type. 
   */ 
   vdata1_ref = VHstoredata (file_id, FIELD1_NAME, (uint8 *)vdata1_buf,  
                       N_RECORDS_1, DFNT_CHAR8, VDATA1_NAME, CLASS1_NAME);  
   /*  
   * Create the second vdata and populate it with data from the vdata2_buf  
   * array.  
   */ 
   vdata2_ref = VHstoredatam (file_id, FIELD2_NAME, (uint8 *)vdata2_buf,  
               N_RECORDS_2, DFNT_INT32, VDATA2_NAME, CLASS2_NAME, ORDER_2);  
   /*  
   * Terminate access to the VS interface and close the HDF file. 
   */ 
   status_n = Vend (file_id); 
   status_32 = Hclose (file_id); 
} 
create_onefield_vdata.f
      program create_onefield_vdatas 
      implicit none 
C 
C     Parameter declaration 
C 
      character*18 FILE_NAME 
      character*9  CLASS1_NAME 
      character*9  CLASS2_NAME 
      character*11 VDATA1_NAME 
      character*12 VDATA2_NAME 
      character*22 FIELD1_NAME 
      character*21 FIELD2_NAME 
      integer      N_RECORDS_1, N_RECORDS_2 
      integer      ORDER_2 
C 
      parameter (FILE_NAME   = `General_Vdatas.hdf', 
     +           CLASS1_NAME = `5x1 Array', 
     +           CLASS2_NAME = `6x4 Array', 
     +           VDATA1_NAME = `First Vdata', 
     +           VDATA2_NAME = `Second Vdata', 
     +           FIELD1_NAME = `Single-component Field', 
     +           FIELD2_NAME = `Multi-component Field') 
      parameter (N_RECORDS_1 = 5, 
     +           N_RECORDS_2 = 6, 
     +           ORDER_2     = 4)                
    
      integer DFACC_WRITE, DFNT_CHAR8, DFNT_INT32 
      parameter (DFACC_WRITE = 2, 
     +           DFNT_CHAR8  = 4, 
     +           DFNT_INT32  = 24) 
C 
C     Function declaration 
C 
      integer hopen, hclose 
      integer vfstart, vhfscd, vhfsdm, vfend  
C 
C**** Variable declaration ******************************************* 
C 
      integer   status 
      integer   file_id 
      integer   vdata1_ref, vdata2_ref  
      character vdata1_buf(N_RECORDS_1) 
      integer   vdata2_buf(ORDER_2, N_RECORDS_2) 
      data vdata1_buf /'V','D','A','T','A'/ 
      data vdata2_buf / 1,  2,  3,  4, 
     +                  2,  4,  6,  8, 
     +                  3,  6,  9, 12, 
     +                  4,  8, 12, 16, 
     +                  5, 10, 15, 20, 
     +                  6, 12, 18, 24/ 
C 
C**** End of variable declaration ************************************ 
C 
C 
C     Open the HDF file for writing. 
C 
      file_id = hopen(FILE_NAME, DFACC_WRITE, 0) 
C 
C     Initialize the VS interface. 
C 
      status = vfstart(file_id)  
C 
C     Create the first vdata and populate it with data from vdata1_buf array. 
C      
      vdata1_ref = vhfscd(file_id, FIELD1_NAME, vdata1_buf, N_RECORDS_1, 
     +                    DFNT_CHAR8, VDATA1_NAME, CLASS1_NAME) 
C 
C     Create the second vdata and populate it with data from vdata2_buf array. 
C      
      vdata2_ref = vhfsdm(file_id, FIELD2_NAME, vdata2_buf, N_RECORDS_2, 
     +                    DFNT_INT32, VDATA2_NAME, CLASS2_NAME, 
     +                    ORDER_2) 
C 
C     Terminate access to the VS interface and close the HDF file. 
C 
      status = vfend(file_id) 
      status = hclose(file_id) 
      end 
write_to_vdata.c
#include "hdf.h" 
#define  FILE_NAME        "General_Vdatas.hdf" 
#define  N_RECORDS        10        /* number of records the vdata contains */ 
#define  ORDER_1          3         /* order of first field */ 
#define  ORDER_2          1         /* order of second field */ 
#define  ORDER_3          2         /* order of third field */ 
#define  CLASS_NAME       "Particle Data" 
#define  VDATA_NAME       "Solid Particle" 
#define  FIELD1_NAME      "Position"      /* contains x, y, z values */ 
#define  FIELD2_NAME      "Mass"          /* contains weight values */ 
#define  FIELD3_NAME      "Temperature"   /* contains min and max values */ 
#define  FIELDNAME_LIST   "Position,Mass,Temperature" /* No spaces b/w names */ 
/* number of values per record */ 
#define  N_VALS_PER_REC   (ORDER_1 + ORDER_2 + ORDER_3) 
main( )  
{ 
   /************************* Variable declaration **************************/ 
   intn   status_n;     /* returned status for functions returning an intn  */ 
   int32  status_32,    /* returned status for functions returning an int32 */ 
          file_id, vdata_id, 
          vdata_ref = -1,    /* ref number of a vdata, set to -1 to create  */ 
          num_of_records;    /* number of records actually written to vdata */ 
   int16  rec_num;           /* current record number */ 
   float32  data_buf[N_RECORDS][N_VALS_PER_REC]; /* buffer for vdata values */ 
   /********************** End of variable declaration **********************/ 
   /*  
   * Open the HDF file for writing. 
   */ 
   file_id = Hopen (FILE_NAME, DFACC_WRITE, 0); 
   /*  
   * Initialize the VS interface. 
   */ 
   status_n = Vstart (file_id); 
   /*  
   * Create a new vdata. 
   */ 
   vdata_id = VSattach (file_id, vdata_ref, "w"); 
   /*  
   * Set name and class name of the vdata. 
   */ 
   status_32 = VSsetname (vdata_id, VDATA_NAME); 
   status_32 = VSsetclass (vdata_id, CLASS_NAME); 
   /*  
   * Introduce each field's name, data type, and order.  This is the first 
   * part in defining a field. 
   */ 
   status_n = VSfdefine (vdata_id, FIELD1_NAME, DFNT_FLOAT32, ORDER_1 ); 
   status_n = VSfdefine (vdata_id, FIELD2_NAME, DFNT_FLOAT32, ORDER_2 ); 
   status_n = VSfdefine (vdata_id, FIELD3_NAME, DFNT_FLOAT32, ORDER_3 ); 
   /*  
   * Finalize the definition of the fields. 
   */ 
   status_n = VSsetfields (vdata_id, FIELDNAME_LIST); 
   /*  
   * Buffer the data by the record for fully interlaced mode.  Note that the 
   * first three elements contain the three values of the first field, the 
   * fourth element contains the value of the second field, and the last two 
   * elements contain the two values of the third field. 
   */ 
   for (rec_num = 0; rec_num < N_RECORDS; rec_num++) 
   { 
      data_buf[rec_num][0] = 1.0 * rec_num; 
      data_buf[rec_num][1] = 2.0 * rec_num; 
      data_buf[rec_num][2] = 3.0 * rec_num; 
      data_buf[rec_num][3] = 0.1 + rec_num; 
      data_buf[rec_num][4] = 0.0; 
      data_buf[rec_num][5] = 65.0; 
   } 
   /*  
   * Write the data from data_buf to the vdata with full interlacing mode. 
   */ 
   num_of_records = VSwrite (vdata_id, (uint8 *)data_buf, N_RECORDS,  
                             FULL_INTERLACE); 
   /*  
   * Terminate access to the vdata and to the VS interface, then close  
   * the HDF file. 
   */ 
   status_32 = VSdetach (vdata_id); 
   status_n  = Vend (file_id); 
   status_32 = Hclose (file_id); 
} 
write_to_vdata.f
      program write_to_vdata  
      implicit none 
C 
C     Parameter declaration 
C 
      character*18 FILE_NAME 
      character*13 CLASS_NAME 
      character*14 VDATA_NAME 
      character*8  FIELD1_NAME 
      character*4  FIELD2_NAME 
      character*11 FIELD3_NAME 
      character*27 FIELDNAME_LIST 
      integer      N_RECORDS 
      integer      ORDER_1, ORDER_2, ORDER_3 
      integer      N_VALS_PER_REC 
C 
      parameter (FILE_NAME       = `General_Vdatas.hdf', 
     +           CLASS_NAME      = `Particle Data', 
     +           VDATA_NAME      = `Solid Particle', 
     +           FIELD1_NAME     = `Position', 
     +           FIELD2_NAME     = `Mass', 
     +           FIELD3_NAME     = `Temperature', 
     +           FIELDNAME_LIST = `Position,Mass,Temperature') 
      parameter (N_RECORDS = 10, 
     +           ORDER_1   = 3, 
     +           ORDER_2   = 1, 
     +           ORDER_3   = 2, 
     +           N_VALS_PER_REC = ORDER_1 + ORDER_2 + ORDER_3)                
    
      integer DFACC_WRITE, DFNT_FLOAT32, FULL_INTERLACE 
      parameter (DFACC_WRITE    = 2, 
     +           DFNT_FLOAT32   = 5, 
     +           FULL_INTERLACE = 0) 
C 
C     Function declaration 
C 
      integer hopen, hclose 
      integer vfstart, vsfatch, vsfsnam, vsfscls, vsffdef, vsfsfld, 
     +        vsfwrt, vsfdtch, vfend  
C 
C**** Variable declaration ******************************************* 
C 
      integer status 
      integer file_id, vdata_id 
      integer vdata_ref, rec_num, num_of_records 
      real    data_buf(N_VALS_PER_REC, N_RECORDS) 
C 
C**** End of variable declaration ************************************ 
C 
C 
C     Open the HDF file for writing. 
C 
      file_id = hopen(FILE_NAME, DFACC_WRITE, 0) 
C 
C     Initialize the VS interface. 
C 
      status = vfstart(file_id)  
C 
C     Create a new vdata. 
C      
      vdata_ref = -1 
      vdata_id = vsfatch(file_id, vdata_ref, `w')  
C 
C     Set name and class name of the vdata. 
C 
      status = vsfsnam(vdata_id, VDATA_NAME) 
      status = vsfscls(vdata_id, CLASS_NAME) 
C 
C     Introduce each field's name, data type, and order. This is the 
C     first part in defining a field. 
C 
      status = vsffdef(vdata_id, FIELD1_NAME, DFNT_FLOAT32, ORDER_1) 
      status = vsffdef(vdata_id, FIELD2_NAME, DFNT_FLOAT32, ORDER_2) 
      status = vsffdef(vdata_id, FIELD3_NAME, DFNT_FLOAT32, ORDER_3) 
C 
C     Finalize the definition of the fields. 
C 
      status = vsfsfld(vdata_id, FIELDNAME_LIST) 
C 
C     Buffer the data by the record for fully interlaced mode. Note that the 
C     first three elements contain the three values of the first field, 
C     the forth element contains the value of the second field, and the last two 
C     elements contain the two values of the third field. 
C 
      do 10 rec_num = 1, N_RECORDS 
         data_buf(1, rec_num) = 1.0 * rec_num 
         data_buf(2, rec_num) = 2.0 * rec_num 
         data_buf(3, rec_num) = 3.0 * rec_num 
         data_buf(4, rec_num) = 0.1 + rec_num 
         data_buf(5, rec_num) = 0.0 
         data_buf(6, rec_num) = 65.0 
10    continue 
C 
C     Write the data from data_buf to the vdata with the full interlacing mode. 
C 
      num_of_records = vsfwrt(vdata_id, data_buf, N_RECORDS, 
     +                        FULL_INTERLACE) 
C 
C     Terminate access to the vdata and to the VS interface, and 
C     close the HDF file. 
C 
      status = vsfdtch(vdata_id) 
      status = vfend(file_id) 
      status = hclose(file_id) 
      end 
write_mixed_vdata.c
#include "hdf.h" 
#define  FILE_NAME        "Packed_Vdata.hdf" 
#define  VDATA_NAME       "Mixed Data Vdata" 
#define  CLASS_NAME       "General Data Class" 
#define  FIELD1_NAME      "Temp"  
#define  FIELD2_NAME      "Height"  
#define  FIELD3_NAME      "Speed"  
#define  FIELD4_NAME      "Ident" 
#define  ORDER            1        /* number of values in the field         */ 
#define  N_RECORDS        20       /* number of records the vdata contains  */ 
#define  N_FIELDS         4        /* number of fields in the vdata         */ 
#define  FIELDNAME_LIST   "Temp,Height,Speed,Ident"  /* No spaces b/w names */ 
/* number of bytes of the data to be written, i.e., the size of all the 
   field values combined times the number of records */ 
#define BUF_SIZE (2*sizeof(float32) + sizeof(int16) + sizeof(char)) * N_RECORDS 
main( )  
{ 
   /************************* Variable declaration **************************/ 
   intn  status_n;      /* returned status for functions returning an intn  */ 
   int32 status_32,     /* returned status for functions returning an int32 */ 
         file_id, vdata_id, 
         vdata_ref = -1,   /* vdata's reference number, set to -1 to create */ 
         num_of_records; /* number of records actually written to the vdata */ 
   float32 temp[N_RECORDS];       /* buffer to hold values of first field   */ 
   int16   height[N_RECORDS];     /* buffer to hold values of second field  */ 
   float32 speed[N_RECORDS];      /* buffer to hold values of third field   */ 
   char8   ident[N_RECORDS];      /* buffer to hold values of fourth field  */ 
   VOIDP   fldbufptrs[N_FIELDS];/*pointers to be pointing to the field buffers*/ 
   uint16  databuf[BUF_SIZE]; /* buffer to hold the data after being packed*/ 
   int     i; 
   /********************** End of variable declaration **********************/ 
   /*  
   * Create an HDF file.  
   */ 
   file_id = Hopen (FILE_NAME, DFACC_CREATE, 0); 
   /*  
   * Initialize the VS interface.  
   */ 
   status_n = Vstart (file_id); 
   /*  
   * Create a new vdata.  
   */ 
   vdata_id = VSattach (file_id, vdata_ref, "w"); 
   /*  
   * Set name and class name of the vdata.  
   */ 
   status_32 = VSsetname (vdata_id, VDATA_NAME); 
   status_32 = VSsetclass (vdata_id, CLASS_NAME); 
   /*  
   * Introduce each field's name, data type, and order.  This is the first 
   * part in defining a vdata field. 
   */ 
   status_n = VSfdefine (vdata_id, FIELD1_NAME, DFNT_FLOAT32, ORDER);  
   status_n = VSfdefine (vdata_id, FIELD2_NAME, DFNT_INT16, ORDER);  
   status_n = VSfdefine (vdata_id, FIELD3_NAME, DFNT_FLOAT32, ORDER);  
   status_n = VSfdefine (vdata_id, FIELD4_NAME, DFNT_CHAR8, ORDER);  
   /* 
   * Finalize the definition of the fields of the vdata. 
   */ 
   status_n = VSsetfields (vdata_id, FIELDNAME_LIST); 
   /*  
   * Enter data values into the field buffers by the records. 
   */ 
   for (i = 0; i < N_RECORDS; i++) 
   { 
      temp[i] = 1.11 * (i+1); 
      height[i] = i; 
      speed[i] = 1.11 * (i+1); 
      ident[i] = `A' + i; 
   } 
   /*  
   * Build an array of pointers each of which points to a field buffer that 
   * holds all values of the field. 
   */ 
   fldbufptrs[0] = &temp[0]; 
   fldbufptrs[1] = &height[0]; 
   fldbufptrs[2] = &speed[0]; 
   fldbufptrs[3] = &ident[0]; 
   /*  
   * Pack all data in the field buffers that are pointed to by the set of 
   * pointers fldbufptrs, and store the packed data into the buffer  
   * databuf.  Note that the second parameter is _HDF_VSPACK for packing. 
   */ 
   status_n = VSfpack (vdata_id,_HDF_VSPACK, NULL, (VOIDP)databuf, 
           BUF_SIZE, N_RECORDS, NULL, (VOIDP)fldbufptrs); 
   /*  
   * Write all records of the packed data to the vdata.  
   */ 
   num_of_records = VSwrite (vdata_id, (uint8 *)databuf, N_RECORDS,  
                             FULL_INTERLACE);  
   /*  
   * Terminate access to the vdata and the VS interface, then close  
   * the HDF file. 
   */ 
   status_32 = VSdetach (vdata_id); 
   status_n = Vend (file_id); 
   status_32 = Hclose (file_id); 
} 
write_mixed_vdata.f
      program write_mixed_vdata  
      implicit none 
C 
C     Parameter declaration 
C 
      character*16 FILE_NAME 
      character*18 CLASS_NAME 
      character*16 VDATA_NAME 
      character*4  FIELD1_NAME 
      character*6  FIELD2_NAME 
      character*5  FIELD3_NAME 
      character*5  FIELD4_NAME 
      character*23 FIELDNAME_LIST 
      integer      N_RECORDS, N_FIELDS, ORDER 
      integer      BUF_SIZE  
C 
      parameter (FILE_NAME       = `Packed_Vdata.hdf', 
     +           CLASS_NAME      = `General Data Class', 
     +           VDATA_NAME      = `Mixed Data Vdata', 
     +           FIELD1_NAME     = `Temp', 
     +           FIELD2_NAME     = `Height', 
     +           FIELD3_NAME     = `Speed', 
     +           FIELD4_NAME     = `Ident', 
     +           FIELDNAME_LIST = `Temp,Height,Speed,Ident') 
      parameter (N_RECORDS = 20, 
     +           N_FIELDS  = 4,  
     +           ORDER     = 1, 
     +           BUF_SIZE = (4 + 2 + 4 + 1)*N_RECORDS)                
    
      integer DFACC_WRITE, DFNT_FLOAT32, DFNT_INT16, DFNT_CHAR8, 
     +        FULL_INTERLACE, HDF_VSPACK   
      parameter (DFACC_WRITE    = 2, 
     +           DFNT_FLOAT32   = 5, 
     +           DFNT_INT16     = 22, 
     +           DFNT_CHAR8     = 4, 
     +           FULL_INTERLACE = 0, 
     +           HDF_VSPACK     = 0) 
C 
C     Function declaration 
C 
      integer hopen, hclose 
      integer vfstart, vsfatch, vsfsnam, vsfscls, vsffdef, vsfsfld, 
     +        vsfnpak, vsfcpak, vsfwrit, vsfdtch, vfend  
C 
C**** Variable declaration ******************************************* 
C 
      integer   status 
      integer   file_id, vdata_id 
      integer   vdata_ref, num_of_records 
      real      temp(N_RECORDS) 
      integer*2 height(N_RECORDS) 
      real      speed(N_RECORDS) 
      character ident(N_RECORDS)  
      integer   i 
C 
C     Buffer for packed data should be big enough to hold N_RECORDS. 
C 
      integer   databuf(BUF_SIZE/4 + 1) 
C 
C**** End of variable declaration ************************************ 
C 
C 
C     Open the HDF file for writing. 
C 
      file_id = hopen(FILE_NAME, DFACC_WRITE, 0) 
C 
C     Initialize the VS interface. 
C 
      status = vfstart(file_id)  
C 
C     Create a new vdata. 
C      
      vdata_ref = -1 
      vdata_id = vsfatch(file_id, vdata_ref, `w')  
C 
C     Set name and class name of the vdata. 
C 
      status = vsfsnam(vdata_id, VDATA_NAME) 
      status = vsfscls(vdata_id, CLASS_NAME) 
C 
C     Introduce each field's name, data type, and order. This is the 
C     first part in defining a field. 
C 
      status = vsffdef(vdata_id, FIELD1_NAME, DFNT_FLOAT32, ORDER) 
      status = vsffdef(vdata_id, FIELD2_NAME, DFNT_INT16, ORDER) 
      status = vsffdef(vdata_id, FIELD3_NAME, DFNT_FLOAT32, ORDER) 
      status = vsffdef(vdata_id, FIELD4_NAME, DFNT_CHAR8, ORDER) 
C 
C     Finalize the definition of the fields. 
C 
      status = vsfsfld(vdata_id, FIELDNAME_LIST) 
C 
C     Enter data values into the field databufs by the records. 
C 
      do 10 i = 1, N_RECORDS 
         temp(i)   = 1.11 * i 
         height(i) = i - 1 
         speed(i)  = 1.11 * i 
         ident(i)  = char(64+i) 
10    continue 
C 
C     Pack N_RECORDS of data into databuf. In Fortran, each field is packed  
C     using separate calls to vsfnpak or vsfcpak. 
C 
      status = vsfnpak(vdata_id, HDF_VSPACK, ` `, databuf, BUF_SIZE, 
     +                 N_RECORDS, FIELD1_NAME, temp)  
      status = vsfnpak(vdata_id, HDF_VSPACK, ` `, databuf, BUF_SIZE, 
     +                 N_RECORDS, FIELD2_NAME, height)  
      status = vsfnpak(vdata_id, HDF_VSPACK, ` `, databuf, BUF_SIZE, 
     +                 N_RECORDS, FIELD3_NAME, speed)  
      status = vsfcpak(vdata_id, HDF_VSPACK, ` `, databuf, BUF_SIZE, 
     +                 N_RECORDS, FIELD4_NAME, ident)  
C 
C     Write all the records of the packed data to the vdata. 
C 
      num_of_records = vsfwrit(vdata_id, databuf, N_RECORDS, 
     +                         FULL_INTERLACE) 
C 
C     Terminate access to the vdata and to the VS interface, and 
C     close the HDF file. 
C 
      status = vsfdtch(vdata_id) 
      status = vfend(file_id) 
      status = hclose(file_id) 
      end 
read_from_vdata.c
#include "hdf.h" 
#define  FILE_NAME       "General_Vdatas.hdf" 
#define  VDATA_NAME      "Solid Particle" 
#define  N_RECORDS       5    /* number of records the vdata contains */ 
#define  RECORD_INDEX    3    /* position where reading starts - 4th record */ 
#define  ORDER_1         3    /* order of first field to be read */ 
#define  ORDER_2         2    /* order of second field to be read */ 
#define  FIELDNAME_LIST  "Position,Temperature" /* only two fields are read */ 
#define  N_VALS_PER_REC  (ORDER_1 + ORDER_2)    
                         /* number of values per record */ 
main( )  
{ 
   /************************* Variable declaration **************************/ 
   intn  status_n;      /* returned status for functions returning an intn  */ 
   int32 status_32,     /* returned status for functions returning an int32 */ 
         file_id, vdata_id,  
         vdata_ref,     /* vdata's reference number */ 
         num_of_records, /* number of records actually written to the vdata */ 
         record_pos;    /* position of the current record */ 
   int16 i, rec_num;    /* current record number in the vdata */ 
   float32 databuf[N_RECORDS][N_VALS_PER_REC];   /* buffer for vdata values */ 
   /********************** End of variable declaration **********************/ 
   /*  
   * Open the HDF file for reading. 
   */ 
   file_id = Hopen (FILE_NAME, DFACC_READ, 0); 
   /*  
   * Initialize the VS interface. 
   */ 
   status_n = Vstart (file_id); 
   /* 
   * Get the reference number of the vdata, whose name is specified in  
   * VDATA_NAME, using VSfind, which will be discussed in Section 4.7.3. 
   */ 
   vdata_ref = VSfind (file_id, VDATA_NAME); 
   /*  
   * Attach to the vdata for reading if it is found, otherwise  
   * exit the program. 
   */ 
   if (vdata_ref == 0) exit; 
   vdata_id = VSattach (file_id, vdata_ref, "r"); 
   /*  
   * Specify the fields that will be read. 
   */ 
   status_n = VSsetfields (vdata_id, FIELDNAME_LIST); 
   /* 
   * Place the current point to the position specified in RECORD_INDEX. 
   */ 
   record_pos = VSseek (vdata_id, RECORD_INDEX); 
   /*  
   * Read the next N_RECORDS records from the vdata and store the data  
   * in the buffer databuf with fully interlaced mode. 
   */ 
   num_of_records = VSread (vdata_id, (uint8 *)databuf, N_RECORDS,  
                            FULL_INTERLACE); 
   /* 
   * Display the read data as many records as the number of records  
   * returned by VSread. 
   */ 
   printf ("\n       Particle Position        Temperature Range\n\n"); 
   for (rec_num = 0; rec_num < num_of_records; rec_num++) 
   { 
      printf ("   %6.2f, %6.2f, %6.2f        %6.2f, %6.2f\n",  
        databuf[rec_num][0], databuf[rec_num][1], databuf[rec_num][2],  
        databuf[rec_num][3], databuf[rec_num][4]); 
   } 
   /*  
   * Terminate access to the vdata and to the VS interface, then close  
   * the HDF file. 
   */ 
   status_32 = VSdetach (vdata_id); 
   status_n = Vend (file_id); 
   status_32 = Hclose (file_id); 
} 
read_from_vdata.f
      program read_from_vdata  
      implicit none 
C 
C     Parameter declaration 
C 
      character*18 FILE_NAME 
      character*14 VDATA_NAME 
      character*20 FIELDNAME_LIST 
      integer      N_RECORDS, RECORD_INDEX 
      integer      ORDER_1, ORDER_2 
      integer      N_VALS_PER_REC 
C 
      parameter (FILE_NAME       = `General_Vdatas.hdf', 
     +           VDATA_NAME      = `Solid Particle', 
     +           FIELDNAME_LIST = `Position,Temperature') 
      parameter (N_RECORDS  = 5, 
     +           RECORD_INDEX = 3, 
     +           ORDER_1    = 3, 
     +           ORDER_2    = 2, 
     +           N_VALS_PER_REC = ORDER_1 + ORDER_2 )                
    
      integer DFACC_READ, FULL_INTERLACE 
      parameter (DFACC_READ     = 1, 
     +           FULL_INTERLACE = 0) 
C 
C     Function declaration 
C 
      integer hopen, hclose 
      integer vfstart, vsffnd, vsfatch, vsfsfld, vsfrd, vsfseek, 
     +        vsfdtch, vfend  
C 
C**** Variable declaration ******************************************* 
C 
      integer status 
      integer file_id, vdata_id 
      integer vdata_ref, rec_num, num_of_records, rec_pos 
      real    databuf(N_VALS_PER_REC, N_RECORDS) 
      integer i 
C 
C**** End of variable declaration ************************************ 
C 
C 
C     Open the HDF file for reading. 
C 
      file_id = hopen(FILE_NAME, DFACC_READ, 0) 
C 
C     Initialize the VS interface. 
C 
      status = vfstart(file_id)  
C 
C     Get the reference number of the vdata, whose name is specified in 
C     VDATA_NAME, using vsffnd, which will be discussed in Section 4.7.3.  
C      
      vdata_ref = vsffnd(file_id, VDATA_NAME) 
C 
C     Attach to the vdata for reading if it is found,  
C     otherwise exit the program. 
C 
      if (vdata_ref .eq. 0) stop 
      vdata_id = vsfatch(file_id, vdata_ref, `r')  
C 
C     Specify the fields that will be read.  
C 
      status = vsfsfld(vdata_id, FIELDNAME_LIST) 
C 
C     Place the current point to the position specified in RECORD_INDEX. 
C 
      rec_pos = vsfseek(vdata_id, RECORD_INDEX)  
C 
C     Read the next N_RECORDS from the vdata and store the data in the buffer  
C     databuf with fully interlace mode.  
C 
      num_of_records = vsfrd(vdata_id, databuf, N_RECORDS, 
     +                        FULL_INTERLACE) 
C 
C     Display the read data as many records as the number of records returned 
C     by vsfrd. 
C 
      write(*,*) `  Particle Position     Temperature Range' 
      write(*,*) 
      do 10 rec_num = 1, num_of_records 
         write(*,1000) (databuf(i, rec_num), i = 1, N_VALS_PER_REC) 
10    continue  
1000  format(1x,3(f6.2), 8x,2(f6.2)) 
C 
C     Terminate access to the vdata and to the VS interface, and 
C     close the HDF file. 
C 
      status = vsfdtch(vdata_id) 
      status = vfend(file_id) 
      status = hclose(file_id) 
      end 
read_mixed_vdata.c
#include "hdf.h" 
#define  N_RECORDS       20      /* number of records to be read */ 
#define  N_FIELDS        2       /* number of fields to be read */ 
#define  FILE_NAME       "Packed_Vdata.hdf" 
#define  VDATA_NAME      "Mixed Data Vdata" 
#define  FIELDNAME_LIST  "Temp,Ident" 
/* number of bytes of the data to be read */ 
#define  BUFFER_SIZE     ( sizeof(float32) + sizeof(char)) * N_RECORDS  
main () 
{ 
   /************************* Variable declaration **************************/ 
   intn  status_n;      /* returned status for functions returning an intn  */ 
   int32 status_32,     /* returned status for functions returning an int32 */ 
         file_id, vdata_id,  
         num_of_records,        /* number of records actually read */ 
         vdata_ref,             /* reference number of the vdata to be read */ 
         buffer_size;           /* number of bytes the vdata can hold       */ 
   float32 itemp[N_RECORDS];    /* buffer to hold values of first field     */ 
   char  idents[N_RECORDS];     /* buffer to hold values of fourth field    */ 
   uint8 databuf[BUFFER_SIZE];  /* buffer to hold read data, still packed   */ 
   VOIDP fldbufptrs[N_FIELDS];/*pointers to be pointing to the field buffers*/ 
   int   i; 
   /********************** End of variable declaration **********************/ 
   /* 
   * Open the HDF file for reading.  
   */ 
   file_id = Hopen (FILE_NAME, DFACC_READ, 0); 
   /* 
   * Initialize the VS interface.  
   */ 
   status_n = Vstart (file_id); 
   /* 
   * Get the reference number of the vdata, whose name is specified in 
   * VDATA_NAME, using VSfind, which will be discussed in Section 4.7.3. 
   */ 
   vdata_ref = VSfind (file_id, VDATA_NAME); 
   /* 
   * Attach to the vdata for reading.  
   */ 
   vdata_id = VSattach (file_id, vdata_ref, "r"); 
   /* 
   * Specify the fields that will be read.  
   */ 
   status_n = VSsetfields(vdata_id, FIELDNAME_LIST); 
   /* 
   * Read N_RECORDS records of the vdata and store the values into the  
   * buffer databuf.  
   */ 
   num_of_records = VSread (vdata_id, (uint8 *)databuf, N_RECORDS,  
                            FULL_INTERLACE); 
   /* 
   * Build an array of pointers each of which points to an array that 
   * will hold all values of a field after being unpacked. 
   */ 
   fldbufptrs[0] = &itemp[0]; 
   fldbufptrs[1] = &idents[0]; 
    
   /* 
   * Unpack the data from the buffer databuf and store the values into the  
   * appropriate field buffers pointed to by the set of pointers fldbufptrs. 
   * Note that the second parameter is _HDF_VSUNPACK for unpacking and the 
   * number of records is the one returned by VSread. 
   */ 
   status_n = VSfpack (vdata_id, _HDF_VSUNPACK, FIELDNAME_LIST, (VOIDP)databuf, 
               BUFFER_SIZE, num_of_records, NULL, (VOIDP)fldbufptrs); 
   /* 
   * Display the read data being stored in the field buffers. 
   */ 
   printf ("\n     Temp      Ident\n"); 
   for (i=0; i < num_of_records; i++) 
       printf ("   %6.2f        %c\n", itemp[i], idents[i]); 
   /* 
   * Terminate access to the vdata and the VS interface, then close  
   * the HDF file.  
   */ 
   status_32 = VSdetach (vdata_id); 
   status_n = Vend (file_id); 
   status_32 = Hclose (file_id); 
} 
read_mixed_vdata.f
      program read_mixed_vdata  
      implicit none 
C 
C     Parameter declaration 
C 
      character*16 FILE_NAME 
      character*16 VDATA_NAME 
      character*4  FIELD1_NAME 
      character*5  FIELD2_NAME 
      character*10 FIELDNAME_LIST 
      integer      N_RECORDS, N_FIELDS 
      integer      BUFFER_SIZE  
C 
      parameter (FILE_NAME       = `Packed_Vdata.hdf', 
     +           VDATA_NAME      = `Mixed Data Vdata', 
     +           FIELD1_NAME     = `Temp', 
     +           FIELD2_NAME     = `Ident', 
     +           FIELDNAME_LIST = `Temp,Ident') 
      parameter (N_RECORDS   = 20, 
     +           N_FIELDS    = 2,  
     +           BUFFER_SIZE = (4 + 1)*N_RECORDS)                
    
      integer DFACC_READ, DFNT_FLOAT32, DFNT_CHAR8, 
     +        FULL_INTERLACE, HDF_VSUNPACK   
      parameter (DFACC_READ       = 1, 
     +           DFNT_FLOAT32     = 5, 
     +           DFNT_CHAR8       = 4, 
     +           FULL_INTERLACE   = 0, 
     +           HDF_VSUNPACK     = 1) 
C 
C     Function declaration 
C 
      integer hopen, hclose 
      integer vfstart, vsfatch, vsffnd, vsfsfld, 
     +        vsfnpak, vsfcpak, vsfread, vsfdtch, vfend  
C 
C**** Variable declaration ******************************************* 
C 
      integer   status 
      integer   file_id, vdata_id 
      integer   vdata_ref, num_of_records 
      real      temp(N_RECORDS) 
      character ident(N_RECORDS)  
      integer   i 
C 
C     Buffer for read packed data should be big enough to hold N_RECORDS. 
C 
      integer   databuf(BUFFER_SIZE/4 + 1) 
C 
C**** End of variable declaration ************************************ 
C 
C 
C     Open the HDF file for reading. 
C 
      file_id = hopen(FILE_NAME, DFACC_READ, 0) 
C 
C     Initialize the VS interface. 
C 
      status = vfstart(file_id)  
C 
C     Get the reference number of the vdata, whose name is specified in 
C     VDATA_NAME, using vsffnd, which will be discussed in Section 4.7.3.  
C      
      vdata_ref = vsffnd(file_id, VDATA_NAME) 
C 
C     Attach to the vdata for reading if it is found,  
C     otherwise exit the program. 
C 
      if (vdata_ref .eq. 0) stop 
      vdata_id = vsfatch(file_id, vdata_ref, `r')  
C 
C     Specify the fields that will be read.  
C 
      status = vsfsfld(vdata_id, FIELDNAME_LIST) 
C 
C     Read N_RECORDS records of the vdata and store the values into the databuf. 
C 
      num_of_records = vsfread(vdata_id, databuf, N_RECORDS, 
     +                         FULL_INTERLACE) 
C 
C     Unpack N_RECORDS from databuf into temp and ident arrays. 
C     In Fortran, each field is unpacked using separate calls to  
C     vsfnpak or vsfcpak. 
C 
      status = vsfnpak(vdata_id, HDF_VSUNPACK, FIELDNAME_LIST, databuf, 
     +                 BUFFER_SIZE, num_of_records, FIELD1_NAME, temp)  
      status = vsfcpak(vdata_id, HDF_VSUNPACK, FIELDNAME_LIST, databuf, 
     +                 BUFFER_SIZE, num_of_records, FIELD2_NAME, ident)  
C 
C     Display the read data being stored in the field databufs. 
C 
      write (*,*) `    Temp  Ident' 
      do 10 i = 1, num_of_records 
         write(*,1000) temp(i), ident(i) 
10    continue  
1000  format (3x,F6.2, 4x, a) 
C 
C     Terminate access to the vdata and to the VS interface, and 
C     close the HDF file. 
C 
      status = vsfdtch(vdata_id) 
      status = vfend(file_id) 
      status = hclose(file_id) 
      end 
locate_vdata.c
#include "hdf.h" 
#define  FILE_NAME         "General_Vdatas.hdf" 
#define  SEARCHED_FIELDS   "Position,Temperature" 
main( ) 
{ 
   /************************* Variable declaration **************************/ 
   intn  status_n;      /* returned status for functions returning an intn  */ 
   int32 status_32,     /* returned status for functions returning an int32 */ 
         file_id, vdata_id, vdata_ref, 
         index = 0;     /* index of the vdata in the file - manually kept   */ 
   int8  found_fields;  /* TRUE if the specified fields exist in the vdata  */ 
   /********************** End of variable declaration **********************/ 
   /* 
   * Open the HDF file for reading. 
   */ 
   file_id = Hopen (FILE_NAME, DFACC_READ, 0); 
   /* 
   * Initialize the VS interface. 
   */ 
   status_n = Vstart (file_id); 
   /* 
   * Set the reference number to -1 to start the search from  
   * the beginning of file. 
   */ 
   vdata_ref = -1; 
   /* 
   * Assume that the specified fields are not found in the current vdata. 
   */ 
   found_fields = FALSE; 
    
   /* 
   * Use VSgetid to obtain each vdata by its reference number then 
   * attach to the vdata and search for the fields.  The loop 
   * terminates when the last vdata is reached or when a vdata which 
   * contains the fields listed in SEARCHED_FIELDS is found.   
   */ 
   while ((vdata_ref = VSgetid (file_id, vdata_ref)) != FAIL) 
   { 
      vdata_id = VSattach (file_id, vdata_ref, "r"); 
      if ((status_n = VSfexist (vdata_id, SEARCHED_FIELDS)) != FAIL) 
      { 
         found_fields = TRUE; 
         break; 
      } 
      /* 
      * Detach from the current vdata before continuing searching. 
      */ 
      status_32 = VSdetach (vdata_id); 
      index++;		/* advance the index by 1 for the next vdata */ 
   } 
    
   /* 
   * Print the index of the vdata containing the fields or a "not found"  
   * message if no such vdata is found.  Also detach from the vdata found. 
   */ 
   if (!found_fields)  
      printf ("Fields Position and Temperature were not found.\n"); 
   else  
   { 
      printf 
     ("Fields Position and Temperature found in the vdata at position %d\n",  
       index); 
      status_32 = VSdetach (vdata_id); 
   } 
   /* 
   * Terminate access to the VS interface and close the HDF file. 
   */ 
   status_n = Vend (file_id); 
   status_32 = Hclose (file_id); 
} 
locate_vdata.f
      program locate_vdata  
      implicit none 
C 
C     Parameter declaration 
C 
      character*18 FILE_NAME 
      character*20 SEARCHED_FIELDS  
C 
      parameter (FILE_NAME       = `General_Vdatas.hdf', 
     +           SEARCHED_FIELDS = `Position,Temperature') 
      integer DFACC_READ 
      parameter (DFACC_READ = 1) 
C 
C     Function declaration 
C 
      integer hopen, hclose 
      integer vfstart, vsfatch, vsfgid, vsfex, vsfdtch, vfend  
C 
C**** Variable declaration ******************************************* 
C 
      integer status 
      integer file_id, vdata_id, vdata_ref 
      integer index  
      logical found_fields  
C 
C**** End of variable declaration ************************************ 
C 
C 
C     Open the HDF file for reading. 
C 
      file_id = hopen(FILE_NAME, DFACC_READ, 0) 
C 
C     Initialize the VS interface. 
C 
      status = vfstart(file_id)  
      index = 0 
C 
C     Set the reference number to -1 to start the search from the beginning 
C     of the file.  
C      
      vdata_ref = -1 
C 
C     Assume that the specified fields are not found in the current vdata. 
C 
      found_fields = .FALSE. 
10    continue 
C 
C     Use vsfgid to obtain each vdata by its reference number then 
C     attach to the vdata and search for the fields. The loop terminates 
C     when the last vdata is reached or when a vdata which contains the 
C     fields listed in SEARCHED_FIELDS is found. 
C 
      vdata_ref = vsfgid(file_id, vdata_ref) 
      if (vdata_ref .eq. -1) goto 100 
      vdata_id = vsfatch(file_id, vdata_ref, `r') 
      status = vsfex(vdata_id, SEARCHED_FIELDS) 
      if (status .ne. -1) then 
          found_fields = .TRUE. 
          goto 100 
      endif 
      status = vsfdtch(vdata_id) 
      index = index + 1  
      goto 10 
100   continue 
C 
C     Print the index of the vdata containing the fields or a `not found' 
C     message if no such vdata is found. Also detach from the vdata found. 
C 
      if(.NOT.found_fields) then 
         write(*,*) `Fields Positions and Temperature were not found' 
      else 
         write(*,*) 
     +   `Fields Positions and Temperature were found in the vdata', 
     +   ` at position `, index 
C 
C        Terminate access to the vdata 
C 
         status = vsfdtch(vdata_id) 
      endif   
C 
C     Terminate access to the VS interface and close the HDF file. 
C 
      status = vsfdtch(vdata_id) 
      status = vfend(file_id) 
      status = hclose(file_id) 
      end 
set_get_vdata_attr.c
#include "hdf.h" 
#define  FILE_NAME        "General_Vdatas.hdf" 
#define  VDATA_NAME       "Solid Particle" 
#define  FIELD_NAME       "Mass" 
#define  VATTR_NAME       "Site Ident"      /* name of the vdata attribute  */ 
#define  FATTR_NAME       "Scales"          /* name of the field attribute  */ 
#define  VATTR_N_VALUES   3      /* number of values in the vdata attribute */ 
#define  FATTR_N_VALUES   4      /* number of values in the field attribute */ 
main( ) 
{    
   /************************* Variable declaration **************************/ 
   intn  status_n;      /* returned status for functions returning an intn  */ 
   int32 status_32,     /* returned status for functions returning an int32 */ 
         file_id, vdata_ref, vdata_id, 
         field_index,   /* index of a field within the vdata */ 
         n_vdattrs,     /* number of vdata attributes */ 
         n_fldattrs,    /* number of field attributes */ 
         vdata_type,    /* to hold the type of vdata's attribute */  
         vdata_n_values,/* to hold the number of vdata's attribute values   */  
         vdata_size,    /* to hold the size of vdata's attribute values     */  
         field_type,    /* to hold the type of field's attribute            */  
         field_n_values,/* to hold the number of field's attribute values   */  
         field_size;    /* to hold the size of field's attribute values     */ 
   char  vd_attr[VATTR_N_VALUES] = {`A', `B', `C'};/* vdata attribute values*/ 
   int32 fld_attr[FATTR_N_VALUES] = {2, 4, 6, 8};  /* field attribute values*/ 
   char  vattr_buf[VATTR_N_VALUES];     /* to hold vdata attribute's values */ 
   int32 fattr_buf[FATTR_N_VALUES];     /* to hold field attribute's values */ 
   char  vattr_name[30],                /* name of vdata attribute */ 
         fattr_name[30];                /* name of field attribute */ 
   /********************** End of variable declaration **********************/ 
   /* 
   * Open the HDF file for writing. 
   */ 
   file_id = Hopen (FILE_NAME, DFACC_WRITE, 0); 
   /*  
   * Initialize the VS interface.  
   */ 
   status_n = Vstart (file_id); 
   /*  
   * Get the reference number of the vdata named VDATA_NAME. 
   */ 
   vdata_ref = VSfind (file_id, VDATA_NAME); 
   /* 
   * Attach to the vdata for writing.  
   */ 
   vdata_id = VSattach (file_id, vdata_ref, "w"); 
   /* 
   * Attach an attribute to the vdata, i.e., indicated by the second parameter. 
   */ 
   status_n = VSsetattr (vdata_id, _HDF_VDATA, VATTR_NAME, DFNT_CHAR, 
                                                   VATTR_N_VALUES, vd_attr); 
   /* 
   * Get the index of the field FIELD_NAME within the vdata. 
   */ 
   status_n = VSfindex (vdata_id, FIELD_NAME, &field_index); 
   /* 
   * Attach an attribute to the field field_index. 
   */ 
   status_n = VSsetattr (vdata_id, field_index, FATTR_NAME, DFNT_INT32,  
                                                   FATTR_N_VALUES, fld_attr); 
   /* 
   * Get the number of attributes attached to the vdata's first  
   * field - should be 0.  
   */ 
   n_fldattrs = VSfnattrs (vdata_id, 0); 
   printf ( "Number of attributes of the first field of the vdata: %d\n",  
             n_fldattrs); 
   /* 
   * Get the number of attributes attached to the field specified by  
   * field_index - should be 1. 
   */ 
   n_fldattrs = VSfnattrs (vdata_id, field_index); 
   printf ( "Number of attributes of field %s: %d\n", FIELD_NAME, n_fldattrs); 
   /* 
   * Get the total number of the field's and vdata's attributes - should be 2.  
   */ 
   n_vdattrs = VSnattrs (vdata_id); 
   printf ( "Number of attributes of the vdata and its fields: %d\n",  
             n_vdattrs); 
   /* 
   * Get information about the vdata's first attribute, indicated 
   * by the third parameter which is the index of the attribute.  
   */ 
   status_n = VSattrinfo (vdata_id, _HDF_VDATA, 0, vattr_name,  
                          &vdata_type, &vdata_n_values, &vdata_size); 
   /* 
   * Get information about the first attribute of the field specified by  
   * field_index.  
   */ 
   status_n = VSattrinfo (vdata_id, field_index, 0, fattr_name, &field_type,  
                          &field_n_values, &field_size); 
   /* 
   * Get the vdata's first attribute.  
   */ 
   status_n = VSgetattr (vdata_id, _HDF_VDATA, 0, vattr_buf); 
   printf("Values of the vdata attribute = %c %c %c\n", vattr_buf[0], 
                          vattr_buf[1], vattr_buf[2]); 
   /* 
   * Get the first attribute of the field specified by field_index. 
   */ 
   status_n = VSgetattr (vdata_id, field_index, 0, fattr_buf); 
   printf("Values of the field attribute = %d %d %d %d\n", fattr_buf[0],  
                          fattr_buf[1], fattr_buf[2], fattr_buf[3]); 
   /* 
   * Terminate access to the vdata and to the VS interface, then close  
   * the HDF file.  
   */ 
   status_32 = VSdetach (vdata_id); 
   status_n  = Vend (file_id); 
   status_32 = Hclose (file_id); 
} 
set_get_vdata_attr.f
      program vdata_attributes  
      implicit none 
C 
C     Parameter declaration 
C 
      character*18 FILE_NAME 
      character*14 VDATA_NAME 
      character*4  FIELD_NAME 
      character*10 VATTR_NAME 
      character*6  FATTR_NAME 
      integer      VATTR_N_VALUES, FATTR_N_VALUES  
C 
      parameter (FILE_NAME    = `General_Vdatas.hdf', 
     +           VDATA_NAME   = `Solid Particle', 
     +           FIELD_NAME   = `Mass', 
     +           VATTR_NAME   = `Site Ident', 
     +           FATTR_NAME   = `Scales') 
      parameter (VATTR_N_VALUES = 3, 
     +           FATTR_N_VALUES = 4) 
    
      integer DFACC_WRITE, FULL_INTERLACE, HDF_VDATA 
      integer DFNT_INT32, DFNT_CHAR8 
      parameter (DFACC_WRITE    =  2, 
     +           FULL_INTERLACE =  0, 
     +           HDF_VDATA      = -1, 
     +           DFNT_INT32     = 24, 
     +           DFNT_CHAR8     =  4) 
C 
C     Function declaration 
C 
      integer hopen, hclose 
      integer vfstart, vsffnd, vsfatch, vsfscat, vsfsnat,  
     +        vsffnas, vsffidx, vsfnats, vsfainf, vsfgcat, vsfgnat, 
     +        vsfdtch, vfend  
C 
C**** Variable declaration ******************************************* 
C 
      integer   status 
      integer   file_id, vdata_id, vdata_ref 
      integer   field_index, n_vdattrs, n_fldattrs 
      integer   vdata_type, vdata_n_values, vdata_size 
      integer   field_type, field_n_values, field_size  
      character vd_attr(VATTR_N_VALUES) 
      integer   fld_attr(FATTR_N_VALUES) 
      character vattr_buf(VATTR_N_VALUES) 
      integer   fattr_buf(FATTR_N_VALUES) 
      character vattr_name_out(30), fattr_name_out(30) 
      data vd_attr /'A', `B', `C'/ 
      data fld_attr /2, 4, 6, 8/ 
C 
C**** End of variable declaration ************************************ 
C 
C 
C     Open the HDF file for writing. 
C 
      file_id = hopen(FILE_NAME, DFACC_WRITE, 0) 
C 
C     Initialize the VS interface. 
C 
      status = vfstart(file_id)  
C 
C     Get the reference number of the vdata named VDATA_NAME. 
C      
      vdata_ref = vsffnd(file_id, VDATA_NAME) 
C 
C     Attach to the vdata for writing.  
C 
      vdata_id = vsfatch(file_id, vdata_ref, `w')  
C 
C     Attach an attribute to the vdata, as it is indicated by second parameter. 
C 
      status = vsfscat(vdata_id, HDF_VDATA, VATTR_NAME, DFNT_CHAR8, 
     +                  VATTR_N_VALUES, vd_attr) 
C 
C     Get the index of the field FIELD_NAME within the vdata. 
C 
      status = vsffidx(vdata_id, FIELD_NAME, field_index) 
C 
C     Attach an attribute to the field with the index field_index. 
C 
      status = vsfsnat(vdata_id, field_index, FATTR_NAME, DFNT_INT32, 
     +                  FATTR_N_VALUES, fld_attr) 
       
C 
C     Get the number of attributes attached to the vdata's first 
C     field - should be 0. 
C 
      n_fldattrs = vsffnas(vdata_id, 0) 
      write(*,*) `Number of attributes of the first field'  
      write(*,*) ` of the vdata: `, n_fldattrs 
C 
C     Get the number of the attributes attached to the field specified by 
C     index field_index - should be 1. 
C 
      n_fldattrs = vsffnas(vdata_id, field_index) 
      write(*,*) `Number of attributes of field `, FIELD_NAME, 
     +           n_fldattrs 
C 
C     Get the total number of the field's and vdata's attributes - should be 2. 
C 
      n_vdattrs = vsfnats(vdata_id) 
      write(*,*) `Number of attributes of the vdata and its fields: `, 
     +           n_vdattrs 
C 
C     Get information about the vdata's first attribute, indicated by  
C     the third parameter, which is the index of the attribute. 
C 
      status = vsfainf(vdata_id, HDF_VDATA, 0, vattr_name_out, 
     +                 vdata_type, vdata_n_values, vdata_size) 
C 
C     Get information about the first attribute of the field specified by 
C     field_index. 
C 
      status = vsfainf(vdata_id, field_index, 0, fattr_name_out,  
     +                 field_type, field_n_values, field_size) 
C 
C     Get the vdata's first attribute. 
C 
      status = vsfgcat(vdata_id, HDF_VDATA, 0, vattr_buf) 
      write(*,*) `Values of vdata attribute  `, vattr_buf 
C 
C     Get the first attribute of the field specified by field_index. 
C 
      status = vsfgnat(vdata_id, field_index, 0, fattr_buf) 
      write(*,*)  `Values of the field attribute = `, fattr_buf 
C        
C     Terminate access to the vdata and to the VS interface, and 
C     close the HDF file. 
C 
      status = vsfdtch(vdata_id) 
      status = vfend(file_id) 
      status = hclose(file_id) 
      end 
get_vdata_info.c
#include "hdf.h" 
#define  FILE_NAME      "General_Vdatas.hdf" 
#define  FIELD_SIZE     80         /* maximum length of all the field names */ 
main( ) 
{ 
   /************************* Variable declaration **************************/ 
   intn  status_n;      /* returned status for functions returning an intn  */ 
   int32 status_32,     /* returned status for functions returning an int32 */ 
         n_records,     /* to retrieve the number of records in the vdata   */ 
         interlace_mode,/* to retrieve the interlace mode of the vdata      */ 
         vdata_size,    /* to retrieve the size of all specified fields     */ 
         file_id, vdata_ref, vdata_id; 
   char  fieldname_list[FIELD_SIZE], /* buffer to retrieve the vdata data   */ 
         vdata_name[VSNAMELENMAX];   /* buffer to retrieve the vdata name   */ 
   /********************** End of variable declaration **********************/ 
   /* 
   * Open the HDF file for reading.  
   */ 
   file_id = Hopen (FILE_NAME, DFACC_READ, 0); 
   /* 
   * Initialize the VS interface.  
   */ 
   status_n = Vstart (file_id); 
   /* 
   * Set vdata_ref to -1 to start the search from the beginning of file. 
   */ 
   vdata_ref = -1; 
   /* 
   * Use VSgetid to obtain each vdata by its reference number then attach  
   * to the vdata and get its information.  The loop terminates when  
   * the last vdata is reached. 
   */ 
   while ((vdata_ref = VSgetid (file_id, vdata_ref)) != FAIL) 
   { 
      /* 
      * Attach to the current vdata for reading. 
      */ 
      vdata_id = VSattach (file_id, vdata_ref, "r"); 
      /* 
      * Test whether the current vdata is not a storage of an attribute, then 
      * obtain and display its information. 
      */ 
      if( VSisattr (vdata_id) != TRUE ) 
      { 
         status_n = VSinquire (vdata_id, &n_records, &interlace_mode,  
                            fieldname_list, &vdata_size, vdata_name); 
         printf ("Vdata %s: - contains %d records\n\tInterlace mode: %s \ 
                 \n\tFields: %s - %d bytes\n\t\n", vdata_name, n_records, 
                 interlace_mode == FULL_INTERLACE ? "FULL" : "NONE",  
                 fieldname_list, vdata_size ); 
      } 
      /* 
      * Detach from the current vdata. 
      */ 
      status_32 = VSdetach (vdata_id); 
   } /* while */ 
   /* 
   * Terminate access to the VS interface and close the HDF file.  
   */ 
   status_n = Vend (file_id); 
   status_32 = Hclose (file_id); 
} 
get_vdata_info.f
      program vdata_info  
      implicit none 
C 
C     Parameter declaration 
C 
      character*18 FILE_NAME 
      integer      DFACC_READ, FULL_INTERLACE 
      integer      FIELD_SIZE 
C 
      parameter (FILE_NAME      = `General_Vdatas.hdf', 
     +           DFACC_READ     = 1, 
     +           FULL_INTERLACE = 0, 
     +           FIELD_SIZE     = 80) 
       
C 
C     Function declaration 
C 
      integer hopen, hclose 
      integer vfstart, vsfatch, vsfgid, vsfinq, 
     +        vsfisat, vsfdtch, vfend  
C 
C**** Variable declaration ******************************************* 
C 
      integer      status 
      integer      file_id, vdata_id, vdata_ref 
      integer      n_records, interlace_mode, vdata_size 
      character*64 vdata_name 
      character*80 fieldname_list  
C 
C**** End of variable declaration ************************************ 
C 
C 
C     Open the HDF file for reading. 
C 
      file_id = hopen(FILE_NAME, DFACC_READ, 0) 
C 
C     Initialize the VS interface. 
C 
      status = vfstart(file_id)  
C 
C     Set the reference number to -1 to start the search from the beginning 
C     of the file.  
C      
      vdata_ref = -1 
10    continue 
C 
C     Use vsfgid to obtain each vdata by its reference number then 
C     attach to the vdata and get information. The loop terminates 
C     when the last vdata is reached. 
C 
      vdata_ref = vsfgid(file_id, vdata_ref) 
      if (vdata_ref .eq. -1) goto 100 
C 
C     Attach to the current vdata for reading. 
C 
      vdata_id = vsfatch(file_id, vdata_ref, `r') 
C 
C     Test whether the current vdata is not a storage for an attribute, 
C     then obtain and display its information. 
      if (vsfisat(vdata_id) .ne. 1) then 
          status = vsfinq(vdata_id, n_records, interlace_mode, 
     +                    fieldname_list, vdata_size, vdata_name) 
          write(*,*) `Vdata: `, vdata_name 
          write(*,*) `contains `, n_records, ` records' 
          if (interlace_mode .eq. 0) then 
              write(*,*) `Interlace mode: FULL' 
          else	  
              write(*,*) `Interlace mode: NONE' 
          endif 
          write(*,*) `Fields: `, fieldname_list(1:30) 
          write(*,*) `Vdata record size in bytes :', vdata_size 
          write(*,*) 
      endif 
C 
C     Detach from the current vdata. 
C 
      status = vsfdtch(vdata_id) 
      goto 10  
100   continue 
C 
C     Terminate access to the vdata and to the VS interface, and 
C     close the HDF file. 
C 
      status = vsfdtch(vdata_id) 
      status = vfend(file_id) 
      status = hclose(file_id) 
      end 

HDF4.2r4 - February 2009
Copyright
The HDF Group
www.hdfgroup.org
The HDF Group