HDF5 Data Types

# ****************************************************** 
# Example 1: Reading displacement from h5 file
# ****************************************************** 

import h5py
def ex1():
    # file path
    inp_file = "cbar_strstn_static.h5"

    # open file in read-only mode
    f = h5py.File(inp_file, "r")

    # DISPLACEMENT path
    disp_path = "/OPTISTRUCT/RESULT/NODAL/DISPLACEMENT"

    # acquire DISP table
    t = f[disp_path]

    # print data
    print('DISPLACEMENT:\n')
    print(t[:])
    f.close()

if __name__ == "__main__":
    ex1()

# ****************************************************** 
# Example 2: Reading specific data from displacement in h5 file
# ****************************************************** 

# In this example, some senior functions would be used
# to show how to access specific data

import h5py
import numpy as np

def ex1_2():
    # file path
    inp_file = "cbar_strstn_static.h5"

    # open file in read-only mode
    f = h5py.File(inp_file, "r")

    # DISPLACEMENT path
    disp_path = "/OPTISTRUCT/RESULT/NODAL/DISPLACEMENT"

    # acquire DISP table
    t = f[disp_path]

    # 1. query all field name in this table
    print("All fields in DISP table:\n")
    for name in t.dtype.fields.keys():
        print(name, end="  ")

    # 2. filter ID data

    fn = 'ID'
    ids = t[fn]
    print("All ID:\n")
    print(ids[:])

    # 3. get disp of grid 17
    # for this one, numpy is needed

    id = 17
    arr_ids = np.array(ids)
    idx = np.where(arr_ids == id)
    disp_17 = t[idx]

    print("The DISP of grid 17: \n")
    print(disp_17)
    f.close()


if __name__ == "__main__":
    ex1_2()

# ****************************************************** 
# Example 3: Reading CHEXA stresses from h5 file
# ****************************************************** 

import h5py

def printbable(name, n):

    if isinstance(n, h5py.Dataset):
        # this is a dataset(table)
        print("the data of {} is :\n".format(name))
        print(n[:])

def ex2():
    inp_file = "dang_van_tbl_smallshr.h5"

    # open file in read-only mode
    f = h5py.File(inp_file, 'r')

    stress_path = '/OPTISTRUCT/RESULT/ELEMENTAL/STRESS'

    # visit all table under STRESS group and print them out

    g = f[stress_path]
    g.visititems(printbable)


if __name__ == "__main__":
    ex2()


    fn = 'ID'

#include "ex.h"

int main() {
    ex2();
} 

#ifndef CEXPFORH5_EX_H
#define CEXPFORH5_EX_H

int ex1();
int ex2();

#endif //CEXPFORH5_EX_H

# ****************************************************** 
# Example 1: Reading displacements and printing
# ****************************************************** 
#include "hdf5.h"
#include "hdf5_hl.h"
#include <stdlib.h>

#include "ex.h"

#define FILE    "cbar_strstn_static.h5"
#define TABLE_NAME "/OPTISTRUCT/RESULT/NODAL/DISPLACEMENT"

typedef struct Disp {
    long long id;   // grid id
//    double d[6];  // displacement
    double x;
    double y;
    double z;
    double rx;
    double ry;
    double rz;
    long long domid;  //domain_id
} Disp;

int ex1() {

    herr_t re = 0;

    size_t dst_size = sizeof(Disp);
    size_t dst_offset[]=  {
        HOFFSET(Disp,id),
        HOFFSET(Disp, x),
        HOFFSET(Disp, y),
        HOFFSET(Disp, z),
        HOFFSET(Disp, rx),
        HOFFSET(Disp, ry),
        HOFFSET(Disp, rz),
        HOFFSET(Disp,domid)
    };

    Disp disp;
    size_t dst_sizes[] = {
        sizeof(disp.id),
        sizeof(disp.x),
        sizeof(disp.y),
        sizeof(disp.z),
        sizeof(disp.rx),
        sizeof(disp.ry),
        sizeof(disp.rz),
        sizeof(disp.domid)
    };

    //open file in read-only mode
    hid_t file_id = H5Fopen(FILE,H5F_ACC_RDONLY,H5P_DEFAULT);
    if (file_id < 0) {
        printf("Error: file %s is not here\n",FILE);
        return 0;
    }

    hsize_t nfields, nrecords;
    /* Get table info */
    if (H5TBget_table_info(file_id,TABLE_NAME,&nfields,&nrecords) < 0) {
        printf("Error: Table %s is not here\n",TABLE_NAME);
        goto endact;
    }
    if (nrecords == 0 || nfields == 0) {
        printf("The nrecords or nfields of %s is 0, return\n",TABLE_NAME);
        goto endact;
    }

    Disp* dst_buf = NULL;
    dst_buf = (Disp*)malloc(nrecords * dst_size);
    if (!dst_buf) {
        printf("Error: malloc for rstbuf fail\n");
        goto endact;
    }

    // read disp
    if (H5TBread_table(file_id,TABLE_NAME,dst_size,dst_offset,dst_sizes,dst_buf) < 0) {
        printf("Error: read table fail\n");
        goto clearmem;
    }

    //print disp
    for (int i = 0; i < nrecords;i++) {
        printf("GRID %lld: %e, %e, %e, %e, %e, %e, %lld\n",
               dst_buf[i].id,
               dst_buf[i].x,
               dst_buf[i].y,
               dst_buf[i].z,
               dst_buf[i].rx,
               dst_buf[i].ry,
               dst_buf[i].rz,
               dst_buf[i].domid);
    }

clearmem:
    if (dst_buf!=NULL) free(dst_buf);
endact:
    H5Fclose(file_id);

    return 0;
}

# ****************************************************** 
# Example 2: Reading stresses from CHEXA element and printing
# ****************************************************** 

#include "hdf5.h"
#include "hdf5_hl.h"
#include <stdlib.h>

#include "ex.h"
#define FILE    "dang_van_tbl_smallshr.h5"
#define TABLE_NAME "/OPTISTRUCT/RESULT/ELEMENTAL/STRESS/HEXA"
typedef struct HEXA {
    long long id;   // grid id
    long long cid;
    char ctype[8];
    long long nodef;
    long long grid[9];
    double x[9];
    double y[9];
    double z[9];
    double rx[9];
    double ry[9];
    double rz[9];
    long long domid;  //domain_id
} HEXA;

int ex2 () {
    herr_t re = 0;

    size_t dst_size = sizeof(HEXA);
    size_t dst_offset[]=  {
            HOFFSET(HEXA,id),
            HOFFSET(HEXA,cid),
            HOFFSET(HEXA,ctype),
            HOFFSET(HEXA,nodef),
            HOFFSET(HEXA,grid),
            HOFFSET(HEXA, x),
            HOFFSET(HEXA, y),
            HOFFSET(HEXA, z),
            HOFFSET(HEXA, rx),
            HOFFSET(HEXA, ry),
            HOFFSET(HEXA, rz),
            HOFFSET(HEXA,domid)
    };

    HEXA hexa;
    size_t dst_sizes[] = {
            sizeof(hexa.id),
            sizeof(hexa.cid),
            sizeof(hexa.ctype),
            sizeof(hexa.nodef),
            sizeof(hexa.grid),
            sizeof(hexa.x),
            sizeof(hexa.y),
            sizeof(hexa.z),
            sizeof(hexa.rx),
            sizeof(hexa.ry),
            sizeof(hexa.rz),
            sizeof(hexa.domid)
    };

    //open file in read-only mode
    hid_t file_id = H5Fopen(FILE,H5F_ACC_RDONLY,H5P_DEFAULT);
    if (file_id < 0) {
        printf("Error: file %s is not here\n",FILE);
        return 0;
    }

    hsize_t nfields, nrecords;
    /* Get table info */
    if (H5TBget_table_info(file_id,TABLE_NAME,&nfields,&nrecords) < 0) {
        printf("Error: Table %s is not here\n",TABLE_NAME);
        goto endact;
    }
    if (nrecords == 0 || nfields == 0) {
        printf("The nrecords or nfields of %s is 0, return\n",TABLE_NAME);
        goto endact;
    }

    HEXA* dst_buf = NULL;
    dst_buf = (HEXA*)malloc(nrecords * dst_size);
    if (!dst_buf) {
        printf("Error: malloc for rstbuf fail\n");
        goto endact;
    }

    // read disp
    if (H5TBread_table(file_id,TABLE_NAME,dst_size,dst_offset,dst_sizes,dst_buf) < 0) {
        printf("Error: read table fail\n");
        goto clearmem;
    }

    //print disp
    for (int i = 0; i < nrecords;i++) {
        printf("HEXA %lld: %lld, %s, %lld, %lld\n",
               dst_buf[i].id,
               dst_buf[i].cid,
               dst_buf[i].ctype,
               dst_buf[i].nodef,
               dst_buf[i].domid);

        for (int j = 0; j < 9 ;j++) {
            printf("\t %lld, %e, %e, %e, %e, %e, %e",
                   dst_buf[i].grid[j],
                   dst_buf[i].x[j],
                   dst_buf[i].y[j],
                   dst_buf[i].z[j],
                   dst_buf[i].rx[j],
                   dst_buf[i].ry[j],
                   dst_buf[i].rz[j]);
        }
        printf("\n");
    }

    clearmem:
    if (dst_buf!=NULL) free(dst_buf);
    endact:
    H5Fclose(file_id);

    return 0;
}