hdf5_helpers.c

Go to the documentation of this file.

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <hdf5.h>
#include <hdf5_hl.h>
#include "../ascot5.h"
#include "../print.h"

void hdf5_init(void) {
    H5Eset_auto1(NULL, NULL);
}

hid_t hdf5_create(const char* filename) {
    hid_t file;
    file = H5Fcreate(filename, H5F_ACC_EXCL, H5P_DEFAULT, H5P_DEFAULT);
    return file;
}

hid_t hdf5_open(const char *filename) {
    hid_t file;
    file = H5Fopen(filename, H5F_ACC_RDWR, H5P_DEFAULT);
    return file;
}

hid_t hdf5_open_ro(const char *filename) {
    hid_t file;
    file = H5Fopen(filename, H5F_ACC_RDONLY, H5P_DEFAULT);
    return file;
}

herr_t hdf5_close(hid_t file_id) {
    herr_t err;
    err = H5Fclose(file_id);
    return err;
}

hid_t hdf5_create_group(hid_t loc, const char* path) {
    const char* start;
    if(path[0] == '/') {
        start = path + 1;
    } else {
        start = path;
    }
 
    const char* end = strstr(start, "/");
 
    if(end == NULL) {
        hid_t g = H5Gcreate2(loc, start, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
        return g;
    } else {
        char* group = (char*) malloc((strlen(path) + 1) * sizeof(char));
        strncpy(group, start, end-start);
        group[end-start] = '\0';
 
        /* Open or create parent group */
        hid_t g = H5Gopen2(loc, group, H5P_DEFAULT);
        if(g < 0) {
            g = H5Gcreate2(loc, group, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
        }
        free(group);
        hid_t g0 = hdf5_create_group(g, end);
        H5Gclose(g);
        return g0;
    }
}

herr_t hdf5_find_group(hid_t loc, const char* path) {
    return H5Gget_objinfo (loc, path, 0, NULL);
}

char* hdf5_generate_qid_path(const char* original, char* qid, char* path) {
    strcpy(path, original);
    char* ptr = strstr(path,"XXXXXXXXXX");
 
    for(int i = 0; i < 10; i++) {
        ptr[i] = qid[i];
    }
 
    return path;
}

char* hdf5_gen_path(const char* original, char* qid, char* path) {
    strcpy(path, original);
    char* ptr = strstr(path,"XXXXXXXXXX");
 
    for(int i = 0; i < 10; i++) {
        ptr[i] = qid[i];
    }
 
    return path;
}

int hdf5_read_double(const char* var, real* ptr, hid_t file, char* qid,
                     const char* errfile, int errline) {
    char temp[256];
    if( H5LTread_dataset_double(file, hdf5_gen_path(var, qid, temp), ptr) < 0 ){
        print_err("Error: could not read HDF5 dataset %s FILE %s LINE %d\n",
                  temp, errfile, errline);
        return 1;
    }
    return 0;
}

int hdf5_read_int(const char* var, int* ptr, hid_t file, char* qid,
                  const char* errfile, int errline) {
    char temp[256];
    if( H5LTread_dataset_int(file, hdf5_gen_path(var, qid, temp), ptr) < 0 ){
        print_err("Error: could not read HDF5 dataset %s FILE %s LINE %d\n",
                  temp, errfile, errline);
        return 1;
    }
    return 0;
}

int hdf5_read_long(const char* var, long* ptr, hid_t file, char* qid,
                   const char* errfile, int errline) {
    char temp[256];
    if( H5LTread_dataset_long(file, hdf5_gen_path(var, qid, temp), ptr) < 0 ){
        print_err("Error: could not read HDF5 dataset %s FILE %s LINE %d\n",
                  temp, errfile, errline);
        return 1;
    }
    return 0;
}

herr_t hdf5_write_string_attribute(hid_t loc, const char* path,
                                   const char* attrname,  const char* string) {
    herr_t err;
 
    hid_t grp = H5Gopen(loc, path, H5P_DEFAULT);
    hid_t aid = H5Screate(H5S_SCALAR);
    hid_t atype = H5Tcopy(H5T_C_S1);
    H5Tset_size(atype, strlen(string));
    H5Tset_strpad(atype,H5T_STR_NULLPAD);
 
    hid_t attr = H5Aopen(grp, attrname, H5P_DEFAULT);
 
    /* Delete existing attribute with a same name */
    if(attr > 0) {
        H5Adelete(grp, attrname);
        H5Aclose(attr);
    }
 
    attr = H5Acreate2(grp, attrname, atype, aid, H5P_DEFAULT, H5P_DEFAULT);
 
    err = H5Awrite(attr, atype, string);
    if(err) {return err;}
 
    err = H5Sclose(aid);
    if(err) {return err;}
 
    err = H5Tclose(atype);
    if(err) {return err;}
 
    err = H5Aclose(attr);
    if(err) {return err;}
 
    err = H5Gclose(grp);
    if(err) {return err;}
 
    return 0;
}

herr_t hdf5_write_extendible_dataset_double(hid_t group,
                                            const char* datasetname,
                                            int length, double* data) {
    /* Create the data space with unlimited dimensions. */
    hsize_t dim[1]    = {length};
    hsize_t maxdim[1] = {H5S_UNLIMITED};
    hid_t dataspace   = H5Screate_simple(1, dim, maxdim);
 
    /* Modify dataset creation properties, i.e. enable chunking  */
    hsize_t chunk_dim[1] = {(int)ceil(length/2.0)};
    hid_t prop   = H5Pcreate(H5P_DATASET_CREATE);
    H5Pset_chunk (prop, 1, chunk_dim);
 
    /* Create a new dataset within the file using chunk creation properties. */
    hid_t dataset = H5Dcreate2(group, datasetname, H5T_IEEE_F64LE, dataspace,
                               H5P_DEFAULT, prop, H5P_DEFAULT);
 
    /* Write data to dataset */
    int err = 0;
    if( H5Dwrite(dataset, H5T_IEEE_F64LE, H5S_ALL, H5S_ALL,
                 H5P_DEFAULT, data) < 0) {
        err = -1;
    }
    H5Dclose(dataset);
    H5Pclose(prop);
    H5Sclose(dataspace);
 
    return err;
}
 

herr_t hdf5_write_extendible_dataset_long(hid_t group,
                                          const char* datasetname,
                                          int length, long* data) {
    /* Create the data space with unlimited dimensions. */
    hsize_t dim[1]    = {length};
    hsize_t maxdim[1] = {H5S_UNLIMITED};
    hid_t dataspace   = H5Screate_simple(1, dim, maxdim);
 
    /* Modify dataset creation properties, i.e. enable chunking  */
    hsize_t chunk_dim[1] = {(int)ceil(length/2.0)};
    hid_t prop   = H5Pcreate(H5P_DATASET_CREATE);
    H5Pset_chunk (prop, 1, chunk_dim);
 
    /* Create a new dataset within the file using chunk creation properties. */
    hid_t dataset = H5Dcreate2(group, datasetname, H5T_STD_I64LE, dataspace,
                               H5P_DEFAULT, prop, H5P_DEFAULT);
 
    /* Write data to dataset */
    int err = 0;
    if( H5Dwrite(dataset, H5T_STD_I64LE, H5S_ALL, H5S_ALL,
                 H5P_DEFAULT, data) < 0 ) {
        err = -1;
    }
    H5Dclose(dataset);
    H5Pclose(prop);
    H5Sclose(dataspace);
 
    return err;
}

herr_t hdf5_write_extendible_dataset_int(hid_t group,
                                         const char* datasetname,
                                         int length, int* data) {
    /* Create the data space with unlimited dimensions. */
    hsize_t dim[1]    = {length};
    hsize_t maxdim[1] = {H5S_UNLIMITED};
    hid_t dataspace   = H5Screate_simple(1, dim, maxdim);
 
    /* Modify dataset creation properties, i.e. enable chunking  */
    hsize_t chunk_dim[1] = {(int)ceil(length/2.0)};
    hid_t prop   = H5Pcreate(H5P_DATASET_CREATE);
    H5Pset_chunk (prop, 1, chunk_dim);
 
    /* Create a new dataset within the file using chunk creation properties. */
    hid_t dataset = H5Dcreate2(group, datasetname, H5T_STD_I32LE, dataspace,
                               H5P_DEFAULT, prop, H5P_DEFAULT);
 
    /* Write data to dataset */
    int err = 0;
    if( H5Dwrite(dataset, H5T_STD_I32LE, H5S_ALL, H5S_ALL,
                 H5P_DEFAULT, data) < 0 ) {
        err = -1;
    }
    H5Dclose(dataset);
    H5Pclose(prop);
    H5Sclose(dataspace);
 
    return err;
}