コード例 #1
0
ファイル: sdmf_pt_db.c プロジェクト: rmvanhees/nadc_tools
/*+++++++++++++++++++++++++
.IDENTifer   SDMF_rd_pt_metaTable
.PURPOSE     read metaTable records from SDMF last-limb/Sun databases
.INPUT/OUTPUT
  call as    SDMF_rd_pt_metaTable( locID, &numIndx, metaIndx, &mtbl );
     input:
           hid_t  locID        :  HDF5 identifier of group
	   size_t *metaIndx    :  array with requested indices
 in/output:
	   size_t *numIndx     :  [input]  dimension of metaIndx (or zero)
                                  [output] number of records read
    output:
           struct mtbl_pt_rec **mtbl : last-limb/Sun meta-table records

.RETURNS     nothing, error status passed by global variable ``nadc_stat''
.COMMENTS    static function
-------------------------*/
void SDMF_rd_pt_metaTable( hid_t locID, size_t *numIndx, size_t *metaIndx,
			     struct mtbl_pt_rec **mtbl_out )
{
     register size_t nr;

     hid_t   ptable;
     hsize_t nrecords;

     struct mtbl_pt_rec *mtbl;
/*
 * initialize return values 
 */
     if ( ! Use_Extern_Alloc ) *mtbl_out = NULL;
/*
 * does the table already exists?
 */
     if ( (ptable = H5PTopen( locID, "metaTable" )) == H5I_BADID ) return;
/*
 * obtain table info
 */
     (void) H5PTget_num_packets( ptable, &nrecords );
     if ( *numIndx == 0 ) {
	  *numIndx = (size_t) nrecords;
	  for ( nr = 0; nr < nrecords; nr++ ) metaIndx[nr] = nr;
     }
     if ( nrecords == 0 ) {
	  (void) H5PTclose( ptable );
          return;
     }
/*
 * allocate memory to store the metaTable records
 */
     if ( ! Use_Extern_Alloc ) {
	  mtbl = (struct mtbl_pt_rec *) 
	       malloc( (size_t) nrecords * sizeof(struct mtbl_pt_rec));
	  if ( mtbl == NULL )
	       NADC_RETURN_ERROR( NADC_ERR_ALLOC, "mtbl" );
     } else if ( (mtbl = mtbl_out[0]) == NULL )
	  NADC_RETURN_ERROR( NADC_ERR_ALLOC, "mtbl_out[0]" );
/*
 * read table records
 */
     if ( (*numIndx) == (size_t) nrecords ) {
	  (void) H5PTread_packets( ptable, 0, (size_t) nrecords, mtbl );
     } else {
	  nr = 0;
	  do {
	       (void) H5PTread_packets( ptable, (hsize_t) metaIndx[nr], 1, 
					mtbl+nr );
	  } while ( ++nr < (*numIndx) );
     }
     *mtbl_out = mtbl;
}
コード例 #2
0
ファイル: test_packet.c プロジェクト: quinoacomputing/HDF5
/*-------------------------------------------------------------------------
 * test_read
 *
 * Tests that the packets appended by test_append can be read back.
 *
 *-------------------------------------------------------------------------
 */
static int test_read(hid_t fid)
{
    herr_t err;
    hid_t table;
    particle_t readBuf[NRECORDS];
    size_t c;

    TESTING("H5PTread_packets");

    /* Open the table */
    table = H5PTopen(fid, PT_NAME);
    if( H5PTis_valid(table) < 0)
        goto out;

    /* Read several particles */
    err = H5PTread_packets(table, (hsize_t)0, 3, &(readBuf[0]));
    if( err < 0)
        goto out;

    /* Read one particle */
    err = H5PTread_packets(table, (hsize_t)3, 1, &(readBuf[3]));
    if( err < 0)
        goto out;

    /* Read several particles */
    err = H5PTread_packets(table, (hsize_t)4, (NRECORDS - 4 ), &(readBuf[4]));
    if( err < 0)
        goto out;

    /* Ensure that particles were read correctly */
    for(c=0; c<NRECORDS; c++)
    {
        if( cmp_par(c%8, c, testPart, readBuf) != 0)
            goto out;
    }

    /* Close the table */
    err = H5PTclose(table);
    if( err < 0)
        goto out;

    PASSED();

    return 0;

out:
    H5_FAILED();
    if( H5PTis_valid(table) < 0)
        H5PTclose(table);
    return -1;
}
コード例 #3
0
ファイル: access_tracing.cpp プロジェクト: Luffy0011/zsim
AccessTraceReader::AccessTraceReader(std::string _fname) : fname(_fname.c_str()) {
    hid_t fid = H5Fopen(fname.c_str(), H5F_ACC_RDONLY, H5P_DEFAULT);
    if (fid == H5I_INVALID_HID) panic("Could not open HDF5 file %s", fname.c_str());

    // Check that the trace finished
    hid_t fAttr = H5Aopen(fid, "finished", H5P_DEFAULT);
    uint32_t finished;
    H5Aread(fAttr, H5T_NATIVE_UINT, &finished);
    H5Aclose(fAttr);

    if (!finished) panic("Trace file %s unfinished (halted simulation?)", fname.c_str());

    // Populate numRecords & numChildren
    hsize_t nPackets;
    hid_t table = H5PTopen(fid, "accs");
    if (table == H5I_INVALID_HID) panic("Could not open HDF5 packet table");
    H5PTget_num_packets(table, &nPackets);
    numRecords = nPackets;

    hid_t ncAttr = H5Aopen(fid, "numChildren", H5P_DEFAULT);
    H5Aread(ncAttr, H5T_NATIVE_UINT, &numChildren);
    H5Aclose(ncAttr);

    curFrameRecord = 0;
    cur = 0;
    max = MIN(PT_CHUNKSIZE, numRecords);
    buf = max? gm_calloc<PackedAccessRecord>(max) : nullptr;

    if (max) {
        H5PTread_packets(table, 0, max, buf);
    }

    H5PTclose(table);
    H5Fclose(fid);
}
コード例 #4
0
/* GetPackets (multiple packets)
 * Gets multiple variable-length packets at once, all packets between
 * startIndex and endIndex inclusive.  Takes a pointer to an array
 * of hvl_t structs in memory in which to store pointers to the packets.
 * Returns 0 on success, negative on failure.
 */
int VL_PacketTable::GetPackets(hsize_t startIndex, hsize_t endIndex, hvl_t * data)
{
    // Make sure the range of indexes is valid
    if (startIndex > endIndex)
        return -1;

    return  H5PTread_packets(table_id, startIndex, endIndex-startIndex+1, data);
}
コード例 #5
0
ファイル: test_packet.c プロジェクト: quinoacomputing/HDF5
/*-------------------------------------------------------------------------
 * test_opaque
 *
 * Tests that the packet table works with an opaque datatype.
 *
 *-------------------------------------------------------------------------
 */
static int    test_opaque(hid_t fid)
{
    herr_t err;
    hid_t table;
    hid_t part_t;
    size_t c;
    particle_t readBuf[NRECORDS];

    TESTING("opaque data");

    /* Create an opaque datatype for the particle struct */
    if ((part_t = H5Tcreate (H5T_OPAQUE, sizeof(particle_t) )) < 0 )
        return -1;

    HDassert(part_t != -1);

    /* Tag the opaque datatype */
    if ( H5Tset_tag(part_t,  "Opaque Particle"  ) < 0)
        return -1;

    /* Create a new table */
    table = H5PTcreate_fl(fid, "Packet Test Dataset3", part_t, (hsize_t)100, -1);
    H5Tclose(part_t);
    if( H5PTis_valid(table) < 0)
        goto out;

    /* Append several particles, starting at particle 1 */
    err = H5PTappend(table, (size_t)(NRECORDS - 1), &(testPart[1]));
    if( err < 0)
        goto out;

    /* Read the particles back */
    err = H5PTread_packets(table, (hsize_t)0, 7, &(readBuf[0]));
    if( err < 0)
        goto out;

    /* Ensure that particles were read correctly */
    for(c=0; c<NRECORDS - 1; c++)
    {
        if( cmp_par(c+1, c, testPart, readBuf) != 0)
            goto out;
    }

    /* Close the table */
    err = H5PTclose(table);
    if( err < 0)
        goto out;

    PASSED();
    return 0;

out:
    H5_FAILED();
    if( H5PTis_valid(table) < 0)
        H5PTclose(table);
    return -1;
}
コード例 #6
0
ファイル: sdmf_pt_db.c プロジェクト: rmvanhees/nadc_tools
/*+++++++++++++++++++++++++
.IDENTifer   SDMF_get_pt_orbitIndex
.PURPOSE     obtain indices to last-limb/Sun records for given orbit number
.INPUT/OUTPUT
  call as    SDMF_get_pt_orbitIndex( locID, absOrbit, &numIndx, metaIndx );
     input:
           hid_t  locID        :  HDF5 identifier of group
	   int    absOrbit     :  orbit number
 in/output:
	   size_t *numIndx     :  [input]  dimension of metaIndx
                                  [output] number of indices found
    output:
	   size_t *metaIndx    :  array with requested indices

.RETURNS     nothing, error status passed by global variable ``nadc_stat''
.COMMENTS    static function
-------------------------*/
void SDMF_get_pt_orbitIndex( hid_t locID, int absOrbit, 
			     size_t *numIndx, size_t *metaIndx )
{
     const size_t dimArray = *numIndx;

     register size_t nr;

     hid_t    ptable;
     hsize_t  nrecords;

     int      *orbitList;
/*
 * initialize return values
 */
     *numIndx = 0;
     *metaIndx = 0;
/*
 * check if orbitList exists
 */
     if ( (ptable = H5PTopen( locID, "orbitList" )) == H5I_BADID )
          NADC_RETURN_ERROR( NADC_ERR_HDF_DATA, "orbitList" );

     (void) H5PTget_num_packets( ptable, &nrecords );
     if ( nrecords == 0 ) {
          (void) H5PTclose( ptable );
          return;
     }
/*
 * read list of orbits stored sofar
 */
     orbitList = (int *) malloc( (size_t) nrecords * sizeof(int) );
     if ( orbitList == NULL )
          NADC_GOTO_ERROR( NADC_ERR_ALLOC, "orbitList" );
     (void) H5PTread_packets( ptable, 0, (size_t) nrecords, orbitList );
/*
 * find all matches
 */
     for ( nr = 0; nr < (size_t) nrecords; nr++ ) {
          if ( orbitList[nr] == absOrbit ) {
	       metaIndx[*numIndx] = nr;
	       if ( ++(*numIndx) == dimArray ) break;
	  }
     }
     free( orbitList );
done:
     (void) H5PTclose( ptable );
}
コード例 #7
0
ファイル: sdmf_pt_db.c プロジェクト: rmvanhees/nadc_tools
/*+++++++++++++++++++++++++
.IDENTifer   SDMF_get_pt_jdayIndex
.PURPOSE     obtain indices to last-limb/Sun records for julianDay interval
.INPUT/OUTPUT
  call as    SDMF_get_pt_jdayIndex( locID, jdayRange, &numIndx, metaIndx );
     input:
           hid_t  locID        :  HDF5 identifier of group
	   double jdayRange[2] :  range in julianDay (min,max)
 in/output:
	   size_t *numIndx     :  [input]  dimension of metaIndx
                                  [output] number of indices found
    output:
	   size_t *metaIndx    :  array with requested indices

.RETURNS     nothing, error status passed by global variable ``nadc_stat''
.COMMENTS    static function
-------------------------*/
void SDMF_get_pt_jdayIndex( hid_t locID, const double jdayRange[],
			    size_t *numIndx, size_t *metaIndx )
{
     const size_t dimArray = *numIndx;

     register size_t nr;

     hid_t    ptable;
     hsize_t  nrecords;

     double   *jdayList;
/*
 * initialize return values
 */
     *numIndx = 0;
     *metaIndx = 0;
/*
 * check if jdayList exists
 */
     if ( (ptable = H5PTopen( locID, "jdayList" )) == H5I_BADID )
          NADC_RETURN_ERROR( NADC_ERR_HDF_DATA, "jdayList" );

     (void) H5PTget_num_packets( ptable, &nrecords );
     if ( nrecords == 0 ) {
          (void) H5PTclose( ptable );
          return;
     }
/*
 * read list of orbits stored sofar
 */
     jdayList = (double *) malloc( (size_t) nrecords * sizeof(double) );
     if ( jdayList == NULL )
          NADC_GOTO_ERROR( NADC_ERR_ALLOC, "jdayList" );
     (void) H5PTread_packets( ptable, 0, (size_t) nrecords, jdayList );
/*
 * find all matches
 */
     for ( nr = 0; nr < (size_t) nrecords; nr++ ) {
          if ( jdayList[nr] >= jdayRange[0] && jdayList[nr] <= jdayRange[1] ) {
	       metaIndx[*numIndx] = nr;
	       if ( ++(*numIndx) == dimArray ) break;
	  }
     }
     free( jdayList );
done:
     (void) H5PTclose( ptable );
}
コード例 #8
0
ファイル: access_tracing.cpp プロジェクト: Luffy0011/zsim
void AccessTraceReader::nextChunk() {
    assert(cur == max);
    curFrameRecord += max;

    if (curFrameRecord < numRecords) {
        cur = 0;
        max = MIN(PT_CHUNKSIZE, numRecords - curFrameRecord);
        hid_t fid = H5Fopen(fname.c_str(), H5F_ACC_RDONLY, H5P_DEFAULT);
        if (fid == H5I_INVALID_HID) panic("Could not open HDF5 file %s", fname.c_str());
        hid_t table = H5PTopen(fid, "accs");
        if (table == H5I_INVALID_HID) panic("Could not open HDF5 packet table");
        H5PTread_packets(table, curFrameRecord, max, buf);
        H5PTclose(table);
        H5Fclose(fid);
    } else {
        assert_msg(curFrameRecord == numRecords, "%ld %ld", curFrameRecord, numRecords);  // aaand we're done
    }
}
コード例 #9
0
ファイル: sdmf_pt_db.c プロジェクト: rmvanhees/nadc_tools
/*+++++++++++++++++++++++++
.IDENTifer   SDMF_rd_pt_pointing
.PURPOSE     read pointing infor for cluster records from SDMF database
.INPUT/OUTPUT
  call as    SDMF_rd_pt_pointing( locID, &numIndx, metaIndx, pointing );
     input:
           hid_t  locID          :  HDF5 identifier of group
	   size_t *metaIndx      :  array with requested indices
 in/output:
	   size_t *numIndx       :  [input]  dimension of metaIndx (or zero)
                                    [output] number of records read
    output:
           struct geo_pt_rec *pointing : pointing of cluster records

.RETURNS     nothing, error status passed by global variable ``nadc_stat''
.COMMENTS    static function
-------------------------*/
void SDMF_rd_pt_pointing( hid_t locID, size_t *numIndx, size_t *metaIndx,
			    struct geo_pt_rec *pointing )
{
     register size_t  nr;

     unsigned short num_obs;

     hid_t   ptable;
     hsize_t nrecords;
/*
 * does the dataset already exists?
 */
     if ( (ptable = H5PTopen( locID, "pointing" )) == H5I_BADID ) return;
/*
 * obtain table info
 */
     (void) H5PTget_num_packets( ptable, &nrecords );
     if ( *numIndx == 0 ) {
	  *numIndx = (size_t) nrecords;
	  for ( nr = 0; nr < nrecords; nr++ ) metaIndx[nr] = nr;
     }
     if ( nrecords == 0 ) {
	  (void) H5PTclose( ptable );
          return;
     }
     (void) H5LTget_attribute_ushort( locID, "pointing", "numObs", &num_obs );
/*
 * read pointing records
 */
     nr = 0;
     do {
	  if ( nr > 0 ) pointing += num_obs;
	  (void) H5PTread_packets( ptable, (hsize_t) metaIndx[nr], 
				   1, pointing );
     } while ( ++nr < (*numIndx) );
}
コード例 #10
0
int main(void)
{
#ifdef VLPT_REMOVED
 hid_t          fid;        /* File identifier */
 hid_t          ptable;     /* Packet table identifier */

 herr_t         err;        /* Function return status */
 hsize_t        count;      /* Number of records in the table */
 int            x;          /* Loop variable */

    /* Buffers to hold data */
 hvl_t writeBuffer[5];
 hvl_t readBuffer[5];

    /* This example has two different sizes of "record": longs and shorts */
 long longBuffer[5];
 short shortBuffer[5];

   /* Initialize buffers */
 for(x=0; x<5; x++)
 {
     longBuffer[x] = -x;
     shortBuffer[x] = x;
 }

    /* Fill the write buffer with a mix of longs and shorts */
    /* We need to supply the length of each record and a pointer to */
    /* the beginning of each record. */
 writeBuffer[0].len = sizeof(long);
 writeBuffer[0].p = &(longBuffer[0]);
 writeBuffer[1].len = sizeof(short);
 writeBuffer[1].p = &(shortBuffer[1]);
 writeBuffer[2].len = sizeof(long);
 writeBuffer[2].p = &(longBuffer[2]);
 writeBuffer[3].len = sizeof(long);
 writeBuffer[3].p = &(longBuffer[3]);
 writeBuffer[4].len = sizeof(short);
 writeBuffer[4].p = &(shortBuffer[4]);

    /* Create a file using default properties */
 fid=H5Fcreate("packet_table_VLexample.h5",H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT);

    /* Create a variable-length packet table within the file */
 ptable = H5PTcreate_vl(fid, "Packet Test Dataset", (hsize_t)1);
 if(ptable == H5I_INVALID_HID)
     goto out;

    /* Write the entire buffer to the packet table */
 err = H5PTappend(ptable, (hsize_t)5, writeBuffer );
 if(err < 0)
     goto out;

    /* Get the number of packets in the packet table.  This should be five. */
 err = H5PTget_num_packets(ptable, &count);
 if(err < 0)
     goto out;

 printf("Number of packets in packet table after five appends: %d\n", count);

    /* Read all five packets back */
 err = H5PTread_packets(ptable, (hsize_t)0, (hsize_t)5, readBuffer );
 if(err < 0)
    goto out;

 for(x=0; x<5; x++)
 {
    printf("Packet %d's length is %d\n", x, readBuffer[x].len);
    if(readBuffer[x].len == sizeof(long))
        printf("Packet %d's value is %d\n", x, *( (long *) readBuffer[x].p) );
    else
        printf("Packet %d's value is %d\n", x, *( (short *) readBuffer[x].p) );
 }

    /* Before we close the packet table, we must free the memory that */
    /* the pointers in readBuffer point to. */
 err = H5PTfree_vlen_readbuff(ptable, (hsize_t)5, readBuffer);
 if(err < 0)
     goto out;

    /* Close the packet table */
 err = H5PTclose(ptable);
 if(err < 0)
     goto out;

    /* Close the file */
 H5Fclose(fid);
#endif /* VLPT_REMOVED */

 return 0;

#ifdef VLPT_REMOVED
 out: /* An error has occurred.  Clean up and exit. */
    fprintf(stderr, "An error has occurred!\n");
    H5PTclose(ptable);
    H5Fclose(fid);
    return -1;
#endif /* VLPT_REMOVED */
}
コード例 #11
0
ファイル: test_packet.c プロジェクト: quinoacomputing/HDF5
/*-------------------------------------------------------------------------
 * test_error
 *
 * ensures that the packet table API throws the correct errors used on
 * objects that are not packet tables.
 *
 *-------------------------------------------------------------------------
 */
static int test_error(hid_t fid)
{
    hid_t id = H5I_BADID;
    int id_open=0;
    particle_t readBuf[1];

    TESTING("error conditions");

    /* Create a HL table */
    if(create_hl_table(fid) < 0)
        goto out;

    /* Try to open things that are not packet tables */
    H5E_BEGIN_TRY
    if(H5PTopen(fid, "Bogus_name") >= 0)
        goto out;
    if(H5PTopen(fid, "group1") >= 0)
        goto out;
    H5E_END_TRY

    /* Try to execute packet table commands on an invalid ID */
    H5E_BEGIN_TRY
    if(H5PTis_valid(id) >= 0)
        goto out;
#ifdef VLPT_REMOVED
    if(H5PTis_varlen(id) >= 0)
        goto out;
#endif /* VLPT_REMOVED */
    if(H5PTclose(id) >= 0)
        goto out;
    if(H5PTappend(id, (size_t)1, testPart) >= 0)
        goto out;
    if(H5PTread_packets(id, (hsize_t)0, 1, readBuf) >= 0)
        goto out;
    if(H5PTcreate_index(id) >= 0)
        goto out;
    if(H5PTset_index(id, (hsize_t)1) >= 0)
        goto out;
    if(H5PTget_index(id, NULL) >= 0)
        goto out;
    H5E_END_TRY

    /* Open a high-level non-packet (H5TB) table and try to */
    /* execute commands on it. */
    if((id=H5Dopen2(fid, H5TB_TABLE_NAME, H5P_DEFAULT)) <0)
        goto out;
    id_open = 1;

    H5E_BEGIN_TRY
    if(H5PTis_valid(id) >= 0)
        goto out;
#ifdef VLPT_REMOVED
    if(H5PTis_varlen(id) >= 0)
        goto out;
#endif /* VLPT_REMOVED */
    if(H5PTclose(id) >= 0)
        goto out;
    if(H5PTappend(id, (size_t)1, testPart) >= 0)
        goto out;
    if(H5PTread_packets(id, (hsize_t)0, 1, readBuf) >= 0)
        goto out;
    if(H5PTcreate_index(id) >= 0)
        goto out;
    if(H5PTset_index(id, (hsize_t)1) >= 0)
        goto out;
    if(H5PTget_index(id, NULL) >= 0)
        goto out;
    H5E_END_TRY

    id_open=0;
    if(H5Dclose(id) <0)
        goto out;

    /* Open and close a packet table.  Try to execute */
    /* commands on the closed ID. */
    if((id=H5PTopen(fid, PT_NAME))<0)
        goto out;
    if(H5PTclose(id) <0)
        goto out;

    H5E_BEGIN_TRY
    if(H5PTis_valid(id) >= 0)
        goto out;
#ifdef VLPT_REMOVED
    if(H5PTis_varlen(id) >= 0)
        goto out;
#endif /* VLPT_REMOVED */
    if(H5PTclose(id) >= 0)
        goto out;
    if(H5PTappend(id, (size_t)1, testPart) >= 0)
        goto out;
    if(H5PTread_packets(id, (hsize_t)0, 1, readBuf) >= 0)
        goto out;
    if(H5PTcreate_index(id) >= 0)
        goto out;
    if(H5PTset_index(id, (hsize_t)1) >= 0)
        goto out;
    if(H5PTget_index(id, NULL) >= 0)
        goto out;
    H5E_END_TRY

    PASSED();
    return 0;

out:
    H5_FAILED();
    if(id_open)
        H5Dclose(id);
    return -1;
}
コード例 #12
0
ファイル: test_packet.c プロジェクト: quinoacomputing/HDF5
/*-------------------------------------------------------------------------
 * test_varlen
 *
 * Tests creation, opening, closing, writing, reading, etc. on a
 * variable-length packet table.
 *
 *-------------------------------------------------------------------------
 */
static int    test_varlen(hid_t fid)
{
    herr_t err;
    hid_t table=H5I_BADID;
    hsize_t count;

    /* Buffers to hold data */
    hvl_t writeBuffer[NRECORDS];
    hvl_t readBuffer[NRECORDS];

    /* This example has three different sizes of "record": longs, shorts, and particles */
    long longBuffer[NRECORDS];
    short shortBuffer[NRECORDS];
    int x;

    TESTING("variable-length packet tables");

    /* Initialize buffers */
    for(x=0; x<NRECORDS; x++)
    {
        longBuffer[x] = -x;
        shortBuffer[x] = x;
    }

    /* Fill the write buffer with a mix of variable types */
    for(x=0; x<8; x+=4)
    {
        writeBuffer[x].len = sizeof(long);
        writeBuffer[x].p = &(longBuffer[x]);
        writeBuffer[x+1].len = sizeof(short);
        writeBuffer[x+1].p = &(shortBuffer[x+1]);
        writeBuffer[x+2].len = sizeof(long);
        writeBuffer[x+2].p = &(longBuffer[x+2]);
        writeBuffer[x+3].len = sizeof(particle_t);
        writeBuffer[x+3].p = &(testPart[x+3]);
    }

    /* Create the table */
    table = H5PTcreate_vl(fid, VL_TABLE_NAME, (hsize_t)1001);
    if( H5PTis_valid(table) < 0)
        goto out;
    if( H5PTis_varlen(table) != 1)
        goto out;

    /* Count the number of packets in the table  */
    err = H5PTget_num_packets(table, &count);
    if( err < 0)
        goto out;
    if( count != 0 )
        goto out;

    /* Close the table */
    err = H5PTclose(table);
    if( err < 0)
        goto out;

    /* Re-open the table */
    table = H5PTopen(fid, VL_TABLE_NAME);
    if( H5PTis_valid(table) < 0)
        goto out;
    if( H5PTis_varlen(table) != 1)
        goto out;

    /* Count the number of packets in the table  */
    err = H5PTget_num_packets(table, &count);
    if( err < 0)
        goto out;
    if( count != 0 )
        goto out;

    /* Add several variable-length packets */
    err = H5PTappend(table, (size_t)8, writeBuffer );
    if(err < 0)
        goto out;

    /* Read them back */
    err = H5PTread_packets(table, (hsize_t)0, 4, &(readBuffer[0]));
    if( err < 0)
        goto out;
    err = H5PTread_packets(table, (hsize_t)4, 1, &(readBuffer[4]));
    if( err < 0)
        goto out;
    err = H5PTread_packets(table, (hsize_t)5, (NRECORDS - 5 ), &(readBuffer[5]));
    if( err < 0)
        goto out;

    /* Ensure that packets were read correctly */
    for(x=0; x<NRECORDS; x++)
    {
        if( readBuffer[x].len != writeBuffer[x%4].len)
            goto out;
        switch(x%4)
        {
        case 0:
        case 2:
            if( *((long*)(readBuffer[x].p)) != *((long*)(writeBuffer[x].p)))
                goto out;
            break;
        case 1:
            if( *((short*)(readBuffer[x].p)) != *((short*)(writeBuffer[x].p)))
                goto out;
            break;
        case 3:
            if( cmp_par(0, 0, readBuffer[x].p, writeBuffer[x].p) < 0)
                goto out;
            break;
        default:
            goto out;
        }
    }

    /* Free memory used by read buffer */
    if(H5PTfree_vlen_readbuff(table, NRECORDS, readBuffer) <0)
        goto out;

    /* Read packets back using get_next */
    for(x=0; x < NRECORDS; x++)
    {
        err = H5PTget_next(table, 1, &readBuffer[x]);
        if(err < 0)
            goto out;
    }

    /* Ensure that packets were read correctly */
    for(x=0; x<NRECORDS; x++)
    {
        if( readBuffer[x].len != writeBuffer[x%4].len)
            goto out;
        switch(x%4)
        {
        case 0:
        case 2:
            if( *((long*)(readBuffer[x].p)) != *((long*)(writeBuffer[x].p)))
                goto out;
            break;
        case 1:
            if( *((short*)(readBuffer[x].p)) != *((short*)(writeBuffer[x].p)))
                goto out;
            break;
        case 3:
            if( cmp_par(0, 0, readBuffer[x].p, writeBuffer[x].p) < 0)
                goto out;
            break;
        default:
            goto out;
        }
    }

    /* Free memory used by read buffer */
    if(H5PTfree_vlen_readbuff(table, NRECORDS, readBuffer) <0)
        goto out;

    /* Close the table */
    err = H5PTclose(table);
    if( err < 0)
        goto out;

    PASSED();
    return 0;

out:
    H5_FAILED();
    H5E_BEGIN_TRY
    H5PTclose(table);
    H5E_END_TRY
    return -1;
}
コード例 #13
0
ファイル: sdmf_pt_db.c プロジェクト: rmvanhees/nadc_tools
/*+++++++++++++++++++++++++
.IDENTifer   SDMF_rd_pt_cluster
.PURPOSE     read cluster records from SDMF last-limb/Sun database
.INPUT/OUTPUT
  call as    SDMF_rd_pt_cluster( locID, clus_id, &numIndx, metaIndx, 
                                   pixel_val );
     input:
           hid_t  locID          :  HDF5 identifier of group
	   unsigned char clus_id :  Cluster ID, range 1 - 40
	   size_t *metaIndx      :  array with requested indices
 in/output:
	   size_t *numIndx       :  [input]  dimension of metaIndx (or zero)
                                    [output] number of records read
    output:
           float *pixel_val      : pixel values of SDMF last-limb/Sun database

.RETURNS     nothing, error status passed by global variable ``nadc_stat''
.COMMENTS    static function
-------------------------*/
void SDMF_rd_pt_cluster( hid_t locID, unsigned char clus_id, 
			   size_t *numIndx, size_t *metaIndx,
			   float *pixel_val )
{
     register size_t  nr, np;

     char           clusName[11];
     unsigned char  coaddf;
     unsigned short num_pixels, num_obs, *usbuff;
     unsigned int   *ubuff;

     hid_t   ptable;
     hsize_t nrecords;
     size_t  total_values;
/*
 * does the dataset already exists?
 */
     (void) snprintf( clusName, 11, "cluster_%02hhu", clus_id );
     if ( (ptable = H5PTopen( locID, clusName )) == H5I_BADID ) return;
/*
 * obtain table info
 */
     (void) H5PTget_num_packets( ptable, &nrecords );
     if ( *numIndx == 0 ) {
	  *numIndx = (size_t) nrecords;
	  for ( nr = 0; nr < nrecords; nr++ ) metaIndx[nr] = nr;
     }
     if ( nrecords == 0 ) {
	  (void) H5PTclose( ptable );
          return;
     }
     (void) H5LTget_attribute_uchar( locID, clusName, "coaddf", &coaddf );
     (void) H5LTget_attribute_ushort( locID, clusName, "numObs", &num_obs );
     (void) H5LTget_attribute_ushort( locID, clusName,"numPixels",&num_pixels );
     total_values = (size_t) num_obs * num_pixels;
/*
 * allocate temporary buffer to store cluster data
 */
     if ( coaddf == (unsigned char) 1 ) {
	  usbuff = (unsigned short *) malloc( total_values * sizeof(short) );
	  ubuff = NULL;
     } else {
	  usbuff = NULL;
	  ubuff = (unsigned int *) malloc( total_values * sizeof(int) );
     }
/*
 * read cluster records
 */
     nr = 0;
     do {
	  if ( coaddf == (unsigned char) 1 ) {
	       (void) H5PTread_packets( ptable, (hsize_t) metaIndx[nr], 
					1, usbuff );
	       for ( np = 0; np < total_values; np++ )
		    *pixel_val++ = (float) usbuff[np];
	  } else {
	       (void) H5PTread_packets( ptable, (hsize_t) metaIndx[nr], 
					1, ubuff );
	       for ( np = 0; np < total_values; np++ ) {
		    *pixel_val++ = (float) ubuff[np];
	       }
	  }
     } while ( ++nr < (*numIndx) );

     if ( usbuff != NULL ) free( usbuff );
     if ( ubuff != NULL  ) free( ubuff );
}
コード例 #14
0
/* GetPacket (indexed)
 * Gets a single variable-length packet from the packet table.  Takes the
 * index of the packet (with 0 being the first packet) and a pointer
 * to a hvl_t struct in which to store the packet's size and location.
 * Returns 0 on success, negative on failure.
 */
int VL_PacketTable::GetPacket(hsize_t index, hvl_t * data)
{
    return H5PTread_packets(table_id, index, 1, data);
}
コード例 #15
0
/* GetPacket (indexed)
 * Gets a single packet from the packet table.  Takes the index
 * of the packet (with 0 being the first packet) and a pointer
 * to memory where the data should be stored.
 * Returns 0 on success, negative on failure
 */
int FL_PacketTable::GetPacket(hsize_t index, void * data)
{
    return H5PTread_packets(table_id, index, 1, data);
}