diff --git a/src/Makefile b/src/Makefile index 16bf723..fc2f531 100644 --- a/src/Makefile +++ b/src/Makefile @@ -6,7 +6,8 @@ ifeq ($(COMPILER),GNU) CC=gcc -g CFLAGS=-fPIC -fexceptions -Wall -Werror -Wpedantic -Wextra -LIBS= #-lgfortran -lm +LIBS= -L/usr/lib/x86_64-linux-gnu/hdf5/serial/ -lz -lm -lhdf5 -lhdf5_hl #-lgfortran +INCLUDE = -I/usr/include/hdf5/serial endif ifeq ($(COMPILER),INTEL) @@ -31,8 +32,8 @@ LIBS=-lm endif -OBJECT_FILES= trio.o trio_text.o -HEADER_FILES= trio.h trio_text.h trio_s.h +OBJECT_FILES= trio.o trio_text.o trio_hdf5.o +HEADER_FILES= trio.h trio_text.h trio_hdf5.h trio_s.h export CC CFLAGS LIBS @@ -42,11 +43,11 @@ libtrio.so: $(OBJECT_FILES) $(HEADER_FILES) $(CC) -shared $(OBJECT_FILES) -o libtrio.so test: libtrio.so test.c - $(CC) $(CFLAGS) -Wl,-rpath,$(PWD) -L. test.c -ltrio $(LIBS) -o test + $(CC) $(CFLAGS) $(INCLUDE) -Wl,-rpath,$(PWD) -L. test.c -ltrio $(LIBS) -o test clean: rm -f *.o libtrio.so %.o: %.c $(HEADER_FILES) - $(CC) $(CFLAGS) -c $*.c -o $*.o + $(CC) $(CFLAGS) $(INCLUDE) -c $*.c -o $*.o diff --git a/src/test.c b/src/test.c index d5e03d7..cc38545 100644 --- a/src/test.c +++ b/src/test.c @@ -7,14 +7,58 @@ int test_read(); int test_write(); - +int test_h5read(); int main() { + test_h5read(); test_write(); test_read(); return 0 ; } + +int test_h5read() { + const char* file_name = "test.h5"; + + trio_t* file = NULL; + trio_exit_code rc; + + uint64_t num; + //double* charge; + double* coord; + + file = trio_create(file_name, TRIO_HDF5); + + /*rc = trio_read_nucleus_num(file,&num); + assert (num == 12); + + charge = (double*) calloc(num, sizeof(double)); + rc = trio_read_nucleus_charge(file,charge); + assert(charge[10] == 1.);*/ + num = 4; + + coord = (double*) calloc(3*num, sizeof(double)); + rc = trio_read_nucleus_coord(file,coord); + + for (size_t i=0; i<3*num; i++){ + printf("%lf \n", coord[i]); + } + + double x = coord[0] - 2.14171677; + assert( x*x < 1000.); + + if (rc == TRIO_SUCCESS) { + printf("SUCCESS\n"); + } else { + printf("FAILURE\n"); + } + + trio_close(file); + + return 0; +} + + int test_write() { const char* file_name = "trio_test"; @@ -22,7 +66,7 @@ int test_write() { trio_exit_code rc; - int64_t num = 12; + uint64_t num = 12; double charge[12] = {6., 6., 6., 6., 6., 6., 1., 1., 1., 1., 1., 1.}; @@ -64,7 +108,7 @@ int test_read() { trio_t* file = NULL; trio_exit_code rc; - int64_t num; + uint64_t num; double* charge; double* coord; diff --git a/src/trio.c b/src/trio.c index 17264f0..6ca20f8 100644 --- a/src/trio.c +++ b/src/trio.c @@ -14,13 +14,13 @@ #include "trio.h" #include "trio_s.h" #include "trio_text.h" -/* #include "trio_hdf5.h" +/* #include "trio_json.h" */ trio_t* trio_create(const char* file_name, back_end_t back_end) { - + /* Check that file name is not NULL or empty */ assert (file_name != NULL); assert (file_name[0] != '\0'); @@ -35,11 +35,11 @@ trio_t* trio_create(const char* file_name, back_end_t back_end) { case TRIO_TEXT: result = (trio_t*) malloc (sizeof(trio_text_t)); break; -/* + case TRIO_HDF5: result = (trio_t*) malloc (sizeof(trio_hdf5_t)); break; - +/* case TRIO_JSON: result = (trio_t*) malloc (sizeof(trio_json_t)); break; @@ -65,11 +65,11 @@ trio_t* trio_create(const char* file_name, back_end_t back_end) { case TRIO_TEXT: rc = trio_text_init(result); break; -/* + case TRIO_HDF5: rc = trio_hdf5_init(result); break; - +/* case TRIO_JSON: rc = trio_json_init(result); break; @@ -93,11 +93,11 @@ trio_exit_code trio_close(trio_t* file) { case TRIO_TEXT: rc = trio_text_finalize(file); break; -/* + case TRIO_HDF5: rc = trio_hdf5_finalize(file); break; - +/* case TRIO_JSON: rc = trio_json_finalize(file); break; @@ -121,7 +121,7 @@ trio_exit_code trio_close(trio_t* file) { return TRIO_SUCCESS; } -trio_exit_code trio_read_nucleus_num(trio_t* file, int64_t* num) { +trio_exit_code trio_read_nucleus_num(trio_t* file, uint64_t* num) { if (file == NULL) return TRIO_FAILURE; switch (file->back_end) { @@ -129,11 +129,11 @@ trio_exit_code trio_read_nucleus_num(trio_t* file, int64_t* num) { case TRIO_TEXT: return trio_text_read_nucleus_num(file, num); break; -/* + case TRIO_HDF5: return trio_hdf5_read_nucleus_num(file, num); break; - +/* case TRIO_JSON: return trio_json_read_nucleus_num(file, num); break; @@ -143,7 +143,7 @@ trio_exit_code trio_read_nucleus_num(trio_t* file, int64_t* num) { } } -trio_exit_code trio_write_nucleus_num(trio_t* file, int64_t num) { +trio_exit_code trio_write_nucleus_num(trio_t* file, uint64_t num) { if (file == NULL) return TRIO_FAILURE; switch (file->back_end) { @@ -151,11 +151,11 @@ trio_exit_code trio_write_nucleus_num(trio_t* file, int64_t num) { case TRIO_TEXT: return trio_text_write_nucleus_num(file, num); break; -/* + case TRIO_HDF5: return trio_hdf5_write_nucleus_num(file, num); break; - +/* case TRIO_JSON: return trio_json_write_nucleus_num(file, num); break; @@ -173,11 +173,11 @@ trio_exit_code trio_read_nucleus_coord(trio_t* file, double* coord) { case TRIO_TEXT: return trio_text_read_nucleus_coord(file, coord); break; -/* + case TRIO_HDF5: return trio_hdf5_read_nucleus_coord(file, coord); break; - +/* case TRIO_JSON: return trio_json_read_nucleus_coord(file, coord); break; @@ -195,11 +195,11 @@ trio_exit_code trio_write_nucleus_coord(trio_t* file, double* coord) { case TRIO_TEXT: return trio_text_write_nucleus_coord(file, coord); break; -/* + case TRIO_HDF5: return trio_hdf5_write_nucleus_coord(file, coord); break; - +/* case TRIO_JSON: return trio_json_write_nucleus_coord(file, coord); break; diff --git a/src/trio.h b/src/trio.h index fdb051d..46f9538 100644 --- a/src/trio.h +++ b/src/trio.h @@ -28,8 +28,8 @@ trio_t* trio_create(const char* file_name, back_end_t back_end); trio_exit_code trio_close(trio_t* file); -trio_exit_code trio_read_nucleus_num(trio_t* file, int64_t* num); -trio_exit_code trio_write_nucleus_num(trio_t* file, int64_t num); +trio_exit_code trio_read_nucleus_num(trio_t* file, uint64_t* num); +trio_exit_code trio_write_nucleus_num(trio_t* file, uint64_t num); trio_exit_code trio_read_nucleus_coord(trio_t* file, double* coord); trio_exit_code trio_write_nucleus_coord(trio_t* file, double* coord); diff --git a/src/trio.org b/src/trio.org index d4fcca4..ab674af 100644 --- a/src/trio.org +++ b/src/trio.org @@ -1,4 +1,4 @@ -#+TITLE: TREX Input/Ouput library (TRIO) +#+Title: TREX Input/Ouput library (TRIO) * File prefixes :noxport: @@ -33,8 +33,8 @@ #include "trio.h" #include "trio_s.h" #include "trio_text.h" -/* #include "trio_hdf5.h" +/* #include "trio_json.h" ,*/ @@ -72,6 +72,30 @@ #include "trio_text.h" #+end_src + #+begin_src c :tangle trio_hdf5.h :noweb yes +<
> +#ifndef _TRIO_HDF5_H +#define _TRIO_HDF5_H + +#include "trio.h" +#include "trio_s.h" +#include +#include +#include +#include +#include +#include + +#include "hdf5.h" +#include "hdf5_hl.h" // needed for high-level APIs like H5LT, requires additional linking in Makefile + #+end_src + + #+begin_src c :tangle trio_hdf5.c :noweb yes +<
> +#include "trio_hdf5.h" + #+end_src + + * Coding conventions - integer types will be defined using types given in ~stdint.h~ @@ -174,7 +198,7 @@ trio_t* trio_create(const char* file_name, back_end_t back_end); #+begin_src c :tangle trio.c trio_t* trio_create(const char* file_name, back_end_t back_end) { - + /* Check that file name is not NULL or empty */ assert (file_name != NULL); assert (file_name[0] != '\0'); @@ -189,11 +213,11 @@ trio_t* trio_create(const char* file_name, back_end_t back_end) { case TRIO_TEXT: result = (trio_t*) malloc (sizeof(trio_text_t)); break; -/* + case TRIO_HDF5: result = (trio_t*) malloc (sizeof(trio_hdf5_t)); break; - +/* case TRIO_JSON: result = (trio_t*) malloc (sizeof(trio_json_t)); break; @@ -219,15 +243,15 @@ trio_t* trio_create(const char* file_name, back_end_t back_end) { case TRIO_TEXT: rc = trio_text_init(result); break; -/* + case TRIO_HDF5: rc = trio_hdf5_init(result); break; - +/* case TRIO_JSON: rc = trio_json_init(result); break; -*/ +,*/ default: assert (1 == 0); /* Impossible case */ } @@ -256,11 +280,11 @@ trio_exit_code trio_close(trio_t* file) { case TRIO_TEXT: rc = trio_text_finalize(file); break; -/* + case TRIO_HDF5: rc = trio_hdf5_finalize(file); break; - +/* case TRIO_JSON: rc = trio_json_finalize(file); break; @@ -287,12 +311,12 @@ trio_exit_code trio_close(trio_t* file) { ** Reading/writing data #+begin_src c :tangle trio.h -trio_exit_code trio_read_nucleus_num(trio_t* file, int64_t* num); -trio_exit_code trio_write_nucleus_num(trio_t* file, int64_t num); +trio_exit_code trio_read_nucleus_num(trio_t* file, uint64_t* num); +trio_exit_code trio_write_nucleus_num(trio_t* file, uint64_t num); #+end_src #+begin_src c :tangle trio.c -trio_exit_code trio_read_nucleus_num(trio_t* file, int64_t* num) { +trio_exit_code trio_read_nucleus_num(trio_t* file, uint64_t* num) { if (file == NULL) return TRIO_FAILURE; switch (file->back_end) { @@ -300,11 +324,11 @@ trio_exit_code trio_read_nucleus_num(trio_t* file, int64_t* num) { case TRIO_TEXT: return trio_text_read_nucleus_num(file, num); break; -/* + case TRIO_HDF5: return trio_hdf5_read_nucleus_num(file, num); break; - +/* case TRIO_JSON: return trio_json_read_nucleus_num(file, num); break; @@ -314,7 +338,7 @@ trio_exit_code trio_read_nucleus_num(trio_t* file, int64_t* num) { } } -trio_exit_code trio_write_nucleus_num(trio_t* file, int64_t num) { +trio_exit_code trio_write_nucleus_num(trio_t* file, uint64_t num) { if (file == NULL) return TRIO_FAILURE; switch (file->back_end) { @@ -322,11 +346,11 @@ trio_exit_code trio_write_nucleus_num(trio_t* file, int64_t num) { case TRIO_TEXT: return trio_text_write_nucleus_num(file, num); break; -/* + case TRIO_HDF5: return trio_hdf5_write_nucleus_num(file, num); break; - +/* case TRIO_JSON: return trio_json_write_nucleus_num(file, num); break; @@ -352,11 +376,11 @@ trio_exit_code trio_read_nucleus_coord(trio_t* file, double* coord) { case TRIO_TEXT: return trio_text_read_nucleus_coord(file, coord); break; -/* + case TRIO_HDF5: return trio_hdf5_read_nucleus_coord(file, coord); break; - +/* case TRIO_JSON: return trio_json_read_nucleus_coord(file, coord); break; @@ -374,11 +398,11 @@ trio_exit_code trio_write_nucleus_coord(trio_t* file, double* coord) { case TRIO_TEXT: return trio_text_write_nucleus_coord(file, coord); break; -/* + case TRIO_HDF5: return trio_hdf5_write_nucleus_coord(file, coord); break; - +/* case TRIO_JSON: return trio_json_write_nucleus_coord(file, coord); break; @@ -455,12 +479,12 @@ trio_exit_code trio_write_nucleus_charge(trio_t* file, double* charge) { typedef struct nucleus_s { double* coord; double* charge; - int64_t num; + uint64_t num; } nucleus_t; typedef struct electron_s { - int64_t alpha_num; - int64_t beta_num; + uint64_t alpha_num; + uint64_t beta_num; } electron_t; typedef struct trio_text_s { @@ -566,7 +590,7 @@ nucleus_t* trio_text_read_nucleus(const trio_text_t* file) { fscanf(f, "%s", buffer); assert (strcmp(buffer, "num") == 0); - fscanf(f, "%ld", &(nucleus->num)); + fscanf(f, "%lu", &(nucleus->num)); assert (nucleus->num > 0); /* Allocate arrays */ @@ -580,14 +604,14 @@ nucleus_t* trio_text_read_nucleus(const trio_text_t* file) { fscanf(f, "%s", buffer); assert (strcmp(buffer, "charge") == 0); - for (int i=0 ; inum ; i++) { + for (size_t i=0 ; inum ; i++) { fscanf(f, "%lf", &(nucleus->charge[i])); } fscanf(f, "%s", buffer); assert (strcmp(buffer, "coord") == 0); - for (int i=0 ; i<3*nucleus->num ; i++) { + for (size_t i=0 ; i<3*nucleus->num ; i++) { fscanf(f, "%lf", &(nucleus->coord[i])); } free(buffer); @@ -607,12 +631,12 @@ trio_exit_code trio_text_write_nucleus(const trio_text_t* file, nucleus_t* nucle /* Write arrays */ fprintf(f, "charge\n"); - for (int i=0 ; inum ; i++) { + for (size_t i=0 ; inum ; i++) { fprintf(f, "%lf\n", nucleus->charge[i]); } fprintf(f, "coord\n"); - for (int i=0 ; i<3*nucleus->num ; i++) { + for (size_t i=0 ; i<3*nucleus->num ; i++) { fprintf(f, "%lf\n", nucleus->coord[i]); } @@ -650,12 +674,12 @@ trio_exit_code trio_text_free_nucleus(nucleus_t* nucleus) { *** Read/Write the num attribute #+begin_src c :tangle trio_text.h -trio_exit_code trio_text_read_nucleus_num(const trio_t* file, int64_t* num); -trio_exit_code trio_text_write_nucleus_num(const trio_t* file, const int64_t num); +trio_exit_code trio_text_read_nucleus_num(const trio_t* file, uint64_t* num); +trio_exit_code trio_text_write_nucleus_num(const trio_t* file, const uint64_t num); #+end_src #+begin_src c :tangle trio_text.c -trio_exit_code trio_text_read_nucleus_num(const trio_t* file, int64_t* num) { +trio_exit_code trio_text_read_nucleus_num(const trio_t* file, uint64_t* num) { assert (file != NULL); assert (num != NULL); @@ -673,7 +697,7 @@ trio_exit_code trio_text_read_nucleus_num(const trio_t* file, int64_t* num) { } -trio_exit_code trio_text_write_nucleus_num(const trio_t* file, const int64_t num) { +trio_exit_code trio_text_write_nucleus_num(const trio_t* file, const uint64_t num) { assert (num > 0L); assert (file != NULL); @@ -733,7 +757,7 @@ trio_exit_code trio_text_read_nucleus_coord(const trio_t* file, double* coord) { assert (coord != NULL); - for (int i=0 ; i<3*nucleus->num ; i++) { + for (size_t i=0 ; i<3*nucleus->num ; i++) { coord[i] = nucleus->coord[i]; } @@ -750,7 +774,7 @@ trio_exit_code trio_text_write_nucleus_coord(const trio_t* file, const double* c nucleus_t* nucleus = trio_text_read_nucleus((trio_text_t*) file); assert (nucleus != NULL); - for (int i=0 ; i<3*nucleus->num ; i++) { + for (size_t i=0 ; i<3*nucleus->num ; i++) { nucleus->coord[i] = coord[i]; } @@ -784,7 +808,7 @@ trio_exit_code trio_text_read_nucleus_charge(const trio_t* file, double* charge) assert (charge != NULL); - for (int i=0 ; inum ; i++) { + for (size_t i=0 ; inum ; i++) { charge[i] = nucleus->charge[i]; } @@ -801,7 +825,7 @@ trio_exit_code trio_text_write_nucleus_charge(const trio_t* file, const double* nucleus_t* nucleus = trio_text_read_nucleus((trio_text_t*)file); assert (nucleus != NULL); - for (int i=0 ; inum ; i++) { + for (size_t i=0 ; inum ; i++) { nucleus->charge[i] = charge[i]; } @@ -814,12 +838,524 @@ trio_exit_code trio_text_write_nucleus_charge(const trio_t* file, const double* } #+end_src ** HDF5 Back end + +*** HDF5 definitions + +#+begin_src c :tangle trio_hdf5.c + #define NUCLEUS_GROUP_NAME "nucleus" + #define NUCLEUS_NUM_NAME "nucleus_num" + #define NUCLEUS_CHARGE_NAME "nucleus_charge" + #define NUCLEUS_COORD_NAME "nucleus_coord" + +#+end_src + +*** HDF5 structures + + #+begin_src c :tangle trio_hdf5.h + +typedef struct slab_s { + uint64_t a; + uint64_t b; + uint64_t c; + uint64_t d; +} slab_t; + +typedef struct dset_s { + hid_t dset_id; + hid_t dspace_id; + hid_t dtype_id; + uint64_t* dims; + uint32_t rank; + const char* dset_name; +} dset_t; + +typedef struct h5nucleus_s { + uint64_t num; + double *coord; + double *charge; + dset_t* h5_coord; + dset_t* h5_charge; +} h5nucleus_t; + +typedef struct h5electron_s { + uint64_t alpha_num; + uint64_t beta_num; +} h5electron_t; + +typedef struct trio_hdf5_s { + trio_t parent ; + hid_t file_id; + hid_t nucleus_group; + hid_t electron_group; + //... other groups' id + const char* file_name; +} trio_hdf5_t; + + #+end_src + +*** HDF5 basic functions + + + #+begin_src c :tangle trio_hdf5.h +trio_exit_code trio_hdf5_init(trio_t* file); + #+end_src + + + #+begin_src c :tangle trio_hdf5.c + +/* + * Currently H5LTread_dataset_ is used instead of this function + * but keep it for later if we decide to get rid of the H5LT API + */ +dset_t* trio_hdf5_read_dset_low(const trio_hdf5_t* file, const char *dset_name, void *buf) { + + assert (file != NULL); + assert (dset_name != NULL); + assert (buf != NULL); + /* + * Low-level implementation. Involves dealing with all HDF5 handles and dimensions + */ + dset_t* dset = (dset_t*) malloc(sizeof(dset_t)); + assert (dset != NULL); + + dset->dset_id = H5Dopen(file->nucleus_group, + dset_name, + H5P_DEFAULT); + assert (dset->dset_id > 0); + /* + * Get dataspace, datatype and dimensions + * dspace and dtype handles created below have to be closed when not used + */ + dset->dspace_id = H5Dget_space(dset->dset_id); + assert (dset->dspace_id > 0); + + dset->dtype_id = H5Dget_type(dset->dset_id); + assert (dset->dtype_id > 0); + + /* Check dimensions. Usefull, but then additional parameters + * ranks and dims[] have to be passed to the function + int rrank; + const int rank = 1; + hsize_t dims[1] = {0}; + rrank = H5Sget_simple_extent_dims(nucleus->h5_charge->dspace_id, + dims, NULL); + assert (rrank == rank); + for (int i=0; i 0); + } + */ + herr_t status; + status = H5Dread(dset->dset_id, dset->dtype_id, + H5S_ALL, H5S_ALL, H5P_DEFAULT, + buf); + assert (status >= 0); + + return dset; + +} + +trio_exit_code trio_hdf5_init(trio_t* file) { + + trio_hdf5_t* f = (trio_hdf5_t*) file; + + /* If file doesn't exist, create it */ + int f_ishere = 0; + struct stat st; + + if (stat(file->file_name, &st) == 0) { + printf("%s \n","HDF5 file already exists"); + // RDWR OR RDONLY ??? + f->file_id = H5Fopen(file->file_name, H5F_ACC_RDWR, H5P_DEFAULT); + f_ishere = 1; + } else { + f->file_id = H5Fcreate(file->file_name, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); + f_ishere = 0; + } + + /* Create groups in the hdf5 file */ + if (f_ishere == 0){ + f->nucleus_group = H5Gcreate(f->file_id, NUCLEUS_GROUP_NAME, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); + //f->electron_group = H5Gcreate(f->file_id, ELECTRON_GROUP_NAME, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); + } else { + f->nucleus_group = H5Gopen(f->file_id, NUCLEUS_GROUP_NAME, H5P_DEFAULT); + //f->electron_group = H5Gopen(f->file_id, ELECTRON_GROUP_NAME, H5P_DEFAULT); + } + assert (f->nucleus_group > 0L); + //assert (f->electron_group > 0L); + + return TRIO_SUCCESS; +} + + #+end_src + + + #+begin_src c :tangle trio_hdf5.h +trio_exit_code trio_hdf5_finalize(trio_t* file); + #+end_src + + #+begin_src c :tangle trio_hdf5.c +trio_exit_code trio_hdf5_finalize(trio_t* file) { + + trio_hdf5_t* f = (trio_hdf5_t*) file; + + H5Gclose(f->nucleus_group); + f->nucleus_group = 0; + +/* + H5Gclose(f->electron_group); + f->electron_group = 0; +*/ + + H5Fclose(f->file_id); + f->file_id = 0; + + return TRIO_SUCCESS; +} + #+end_src + + + +*** Read/write the nucleus struct + + #+begin_src c :tangle trio_hdf5.c +h5nucleus_t* trio_hdf5_read_nucleus(const trio_hdf5_t* file) { + + /* Allocate the data structure */ + h5nucleus_t* nucleus = (h5nucleus_t*) malloc(sizeof(h5nucleus_t)); + assert (nucleus != NULL); + + nucleus->num = 0; + nucleus->coord = NULL; + nucleus->charge = NULL; + nucleus->h5_coord = NULL; + nucleus->h5_charge = NULL; + + /* Check that the file was opened/created correctly, return */ + if (file->file_id < 0) return nucleus; + + /* Quit if the dimensioning attribute is missing in the file */ + if (H5Aexists(file->nucleus_group, NUCLEUS_NUM_NAME) == 0) return nucleus; + + herr_t status; + /* Read the nucleus_num attribute of nucleus group */ + hid_t num_id; + num_id = H5Aopen(file->nucleus_group, NUCLEUS_NUM_NAME, H5P_DEFAULT); + assert (num_id > 0); + + status = H5Aread(num_id, H5T_NATIVE_ULLONG, &(nucleus->num)); + assert (status >= 0); + + /* Allocate and read nucleus_charge array */ + nucleus->charge = (double*) calloc(nucleus->num, sizeof(double)); + assert (nucleus->charge != NULL); + + /* High-level H5LT API. No need to deal with dataspaces and datatypes */ + status = H5LTread_dataset_double(file->nucleus_group, + NUCLEUS_CHARGE_NAME, + nucleus->charge); + + /* Allocate and read nucleus_coord array */ + nucleus->coord = (double*) calloc(3 * nucleus->num, sizeof(double)); + assert (nucleus->coord != NULL); + + /* High-level H5LT API. No need to deal with dataspaces and datatypes */ + status = H5LTread_dataset_double(file->nucleus_group, + NUCLEUS_COORD_NAME, + nucleus->coord); + assert (status >= 0); + + /* Low-level read. Do not forget to close the associated IDs (dset,dtype,dspace) + * when not used anymore, see below. Note how this function is similar to H5LTread_dataset_double + */ + /* + nucleus->h5_coord = trio_hdf5_read_dset_low(file, NUCLEUS_COORD_NAME, + nucleus->coord); + + H5Sclose(nucleus->h5_coord->dspace_id); + H5Tclose(nucleus->h5_coord->dtype_id); + H5Dclose(nucleus->h5_coord->dset_id); + */ + + H5Aclose(num_id); + + return nucleus; +} + + +trio_exit_code trio_hdf5_write_nucleus(const trio_hdf5_t* file, h5nucleus_t* nucleus) { + + assert (file != NULL); + assert (nucleus != NULL); + + herr_t status; + hid_t dspace, dtype; + hid_t attr_id; + + dtype = H5Tcopy(H5T_NATIVE_ULLONG); + /* Write the dimensioning variables */ + if (H5Aexists(file->nucleus_group, NUCLEUS_NUM_NAME) == 0) { + dspace = H5Screate(H5S_SCALAR); + attr_id = H5Acreate(file->nucleus_group, NUCLEUS_NUM_NAME, dtype, dspace, + H5P_DEFAULT, H5P_DEFAULT); + assert (attr_id > 0); + + /* High-level routine does not work for some reason + * status = H5LTset_attribute_ulong (file->nucleus_group, "nucleus", NUCLEUS_NUM_NAME, + * &(nucleus->num), 1); + */ + } else { + attr_id = H5Aopen(file->nucleus_group, NUCLEUS_NUM_NAME, H5P_DEFAULT); + assert (attr_id > 0); + } + + status = H5Awrite(attr_id, dtype, &(nucleus->num)); + assert (status >= 0); + + H5Aclose(attr_id); + + /* Write arrays */ + hid_t dset_id; + int charge_rank = 1; + const hsize_t charge_dims[1] = {nucleus->num}; + + if ( H5LTfind_dataset(file->nucleus_group, NUCLEUS_CHARGE_NAME) != 1) { + + status = H5LTmake_dataset_double (file->nucleus_group, NUCLEUS_CHARGE_NAME, + charge_rank, charge_dims, nucleus->charge); + assert (status >= 0); + + } else { + + dset_id = H5Dopen(file->nucleus_group, NUCLEUS_CHARGE_NAME, H5P_DEFAULT); + assert (dset_id > 0); + + dspace = H5Dget_space(dset_id); + assert (dspace > 0); + + dtype = H5Dget_type(dset_id); + assert (dtype > 0); + + + int rrank; + hsize_t dims[1] = {0}; + rrank = H5Sget_simple_extent_dims(dspace, + dims, NULL); + assert (rrank == charge_rank); + // disabling asserts like this allows to overwrite _num variable + for (int i=0; icharge); + assert (status >= 0); + + H5Sclose(dspace); + H5Tclose(dtype); + H5Dclose(dset_id); + + } + + int coord_rank = 2; + const hsize_t coord_dims[2] = {nucleus->num, 3}; + if ( H5LTfind_dataset(file->nucleus_group, NUCLEUS_COORD_NAME) != 1) { + status = H5LTmake_dataset_double (file->nucleus_group, NUCLEUS_COORD_NAME, + coord_rank, coord_dims, nucleus->coord); + assert (status >= 0); + + } else { + + dset_id = H5Dopen(file->nucleus_group, NUCLEUS_COORD_NAME, H5P_DEFAULT); + assert (dset_id > 0); + + dspace = H5Dget_space(dset_id); + assert (dspace > 0); + + dtype = H5Dget_type(dset_id); + assert (dtype > 0); + + + int rrank; + hsize_t dims[2] = {0, 0}; + rrank = H5Sget_simple_extent_dims(dspace, + dims, NULL); + assert (rrank == coord_rank); + for (int i=0; icoord); + assert (status >= 0); + + H5Sclose(dspace); + H5Tclose(dtype); + H5Dclose(dset_id); + + } + + return TRIO_SUCCESS; +} + + #+end_src + +*** Free memory + + Memory is allocated when reading. The followig function frees memory. + + #+begin_src c :tangle trio_hdf5.c +trio_exit_code trio_hdf5_free_nucleus(h5nucleus_t* nucleus) { + + if (nucleus == NULL) return TRIO_FAILURE; + + if (nucleus->coord != NULL) free (nucleus->coord); + nucleus->coord = NULL; + + if (nucleus->charge != NULL) free (nucleus->charge); + nucleus->charge = NULL; + + if (nucleus->h5_coord != NULL) free (nucleus->h5_coord); + nucleus->h5_coord = NULL; + + if (nucleus->h5_charge != NULL) free (nucleus->h5_charge); + nucleus->h5_charge = NULL; + + free (nucleus); + + return TRIO_SUCCESS; +} + #+end_src + +*** Read/Write the num attribute + + #+begin_src c :tangle trio_hdf5.h +trio_exit_code trio_hdf5_read_nucleus_num(const trio_t* file, uint64_t* num); +trio_exit_code trio_hdf5_write_nucleus_num(const trio_t* file, const uint64_t num); + #+end_src + + #+begin_src c :tangle trio_hdf5.c +trio_exit_code trio_hdf5_read_nucleus_num(const trio_t* file, uint64_t* num) { + + assert (file != NULL); + assert (num != NULL); + + h5nucleus_t* nucleus = trio_hdf5_read_nucleus((trio_hdf5_t*) file); + + if (nucleus == NULL) { + return TRIO_FAILURE; + } + + /**/ *num = nucleus->num; + + trio_hdf5_free_nucleus(nucleus); + return TRIO_SUCCESS; +} + + +trio_exit_code trio_hdf5_write_nucleus_num(const trio_t* file, const uint64_t num) { + + assert (file != NULL); + assert (num > 0L); + + h5nucleus_t* nucleus = trio_hdf5_read_nucleus((trio_hdf5_t*) file); + + assert (nucleus != NULL); + + if (nucleus->num != num) { + + if (nucleus->num != 0) { + printf("%ld -> %ld %s \n", num, nucleus->num, + "This variable alreasy exists. Overwriting it is not supported"); + trio_hdf5_free_nucleus(nucleus); + return TRIO_FAILURE; + } + + nucleus->num = num; + + if (nucleus->charge != NULL) free(nucleus->charge); + nucleus->charge = NULL; + + nucleus->charge = (double*) calloc(num, sizeof(double)); + assert (nucleus->charge != NULL); + + if (nucleus->coord != NULL) free(nucleus->coord ); + nucleus->coord = NULL; + + nucleus->coord = (double*) calloc(3*num, sizeof(double)); + assert (nucleus->coord != NULL); + + } else { + nucleus->num = num; + } + + trio_exit_code rc = trio_hdf5_write_nucleus((trio_hdf5_t*) file, nucleus); + assert (rc == TRIO_SUCCESS); + + trio_hdf5_free_nucleus(nucleus); + + return TRIO_SUCCESS; +} + #+end_src + + +*** Read/Write the coord attribute + + The ~coord~ array is assumed allocated with the appropriate size. + + #+begin_src c :tangle trio_hdf5.h +trio_exit_code trio_hdf5_read_nucleus_coord(const trio_t* file, double* coord); +trio_exit_code trio_hdf5_write_nucleus_coord(const trio_t* file, const double* coord); + #+end_src + + #+begin_src c :tangle trio_hdf5.c +trio_exit_code trio_hdf5_read_nucleus_coord(const trio_t* file, double* coord) { + + assert (file != NULL); + assert (coord != NULL); + + h5nucleus_t* nucleus = trio_hdf5_read_nucleus((trio_hdf5_t*) file); + + if (nucleus == NULL) return TRIO_FAILURE; + assert (nucleus->coord != NULL); + + for (size_t i=0 ; i<3*nucleus->num ; i++) { + coord[i] = nucleus->coord[i]; + } + + trio_hdf5_free_nucleus(nucleus); + return TRIO_SUCCESS; +} + + +trio_exit_code trio_hdf5_write_nucleus_coord(const trio_t* file, const double* coord) { + + assert (file != NULL); + assert (coord != NULL); + + h5nucleus_t* nucleus = trio_hdf5_read_nucleus((trio_hdf5_t*) file); + + if (nucleus == NULL) return TRIO_FAILURE; + assert (nucleus->coord != NULL); + + for (size_t i=0 ; i<3*nucleus->num ; i++) { + nucleus->coord[i] = coord[i]; + } + + trio_exit_code rc = trio_hdf5_write_nucleus((trio_hdf5_t*) file, nucleus); + assert (rc == TRIO_SUCCESS); + + trio_hdf5_free_nucleus(nucleus); + + return TRIO_SUCCESS; +} + + #+end_src +*** TODO Read/Write the charge attribute + * File suffixes :noxport: #+begin_src c :tangle trio.h #endif #+end_src - + #+begin_src c :tangle trio_s.h #endif #+end_src @@ -827,8 +1363,15 @@ trio_exit_code trio_text_write_nucleus_charge(const trio_t* file, const double* #+begin_src c :tangle trio_text.h #endif #+end_src + + #+begin_src c :tangle trio_hdf5.h +#endif + #+end_src + * TODO Things to be done :noexport: - [ ] Thread safety - [ ] Error handling with errno + - [ ] HDF5 back-end + - [ ] JSON back-end - [ ] File locking with flock - [ ] Caching of the struct saving last modification date in structs diff --git a/src/trio_hdf5.c b/src/trio_hdf5.c new file mode 100644 index 0000000..34df2e1 --- /dev/null +++ b/src/trio_hdf5.c @@ -0,0 +1,415 @@ +/* This file was generated from the trio.org org-mode file. + To generate it, open trio.org in Emacs and execute + M-x org-babel-tangle +*/ + + + +#include "trio_hdf5.h" + + #define NUCLEUS_GROUP_NAME "nucleus" + #define NUCLEUS_NUM_NAME "nucleus_num" + #define NUCLEUS_CHARGE_NAME "nucleus_charge" + #define NUCLEUS_COORD_NAME "nucleus_coord" + +/* + * Currently H5LTread_dataset_ is used instead of this function + * but keep it for later if we decide to get rid of the H5LT API + */ +dset_t* trio_hdf5_read_dset_low(const trio_hdf5_t* file, const char *dset_name, void *buf) { + + assert (file != NULL); + assert (dset_name != NULL); + assert (buf != NULL); + /* + * Low-level implementation. Involves dealing with all HDF5 handles and dimensions + */ + dset_t* dset = (dset_t*) malloc(sizeof(dset_t)); + assert (dset != NULL); + + dset->dset_id = H5Dopen(file->nucleus_group, + dset_name, + H5P_DEFAULT); + assert (dset->dset_id > 0); + /* + * Get dataspace, datatype and dimensions + * dspace and dtype handles created below have to be closed when not used + */ + dset->dspace_id = H5Dget_space(dset->dset_id); + assert (dset->dspace_id > 0); + + dset->dtype_id = H5Dget_type(dset->dset_id); + assert (dset->dtype_id > 0); + + /* Check dimensions. Usefull, but then additional parameters + * ranks and dims[] have to be passed to the function + int rrank; + const int rank = 1; + hsize_t dims[1] = {0}; + rrank = H5Sget_simple_extent_dims(nucleus->h5_charge->dspace_id, + dims, NULL); + assert (rrank == rank); + for (int i=0; i 0); + } + */ + herr_t status; + status = H5Dread(dset->dset_id, dset->dtype_id, + H5S_ALL, H5S_ALL, H5P_DEFAULT, + buf); + assert (status >= 0); + + return dset; + +} + +trio_exit_code trio_hdf5_init(trio_t* file) { + + trio_hdf5_t* f = (trio_hdf5_t*) file; + + /* If file doesn't exist, create it */ + int f_ishere = 0; + struct stat st; + + if (stat(file->file_name, &st) == 0) { + printf("%s \n","HDF5 file already exists"); + // RDWR OR RDONLY ??? + f->file_id = H5Fopen(file->file_name, H5F_ACC_RDWR, H5P_DEFAULT); + f_ishere = 1; + } else { + f->file_id = H5Fcreate(file->file_name, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT); + f_ishere = 0; + } + + /* Create groups in the hdf5 file */ + if (f_ishere == 0){ + f->nucleus_group = H5Gcreate(f->file_id, NUCLEUS_GROUP_NAME, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); + //f->electron_group = H5Gcreate(f->file_id, ELECTRON_GROUP_NAME, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); + } else { + f->nucleus_group = H5Gopen(f->file_id, NUCLEUS_GROUP_NAME, H5P_DEFAULT); + //f->electron_group = H5Gopen(f->file_id, ELECTRON_GROUP_NAME, H5P_DEFAULT); + } + assert (f->nucleus_group > 0L); + //assert (f->electron_group > 0L); + + return TRIO_SUCCESS; +} + +trio_exit_code trio_hdf5_finalize(trio_t* file) { + + trio_hdf5_t* f = (trio_hdf5_t*) file; + + H5Gclose(f->nucleus_group); + f->nucleus_group = 0; + +/* + H5Gclose(f->electron_group); + f->electron_group = 0; +*/ + + H5Fclose(f->file_id); + f->file_id = 0; + + return TRIO_SUCCESS; +} + +h5nucleus_t* trio_hdf5_read_nucleus(const trio_hdf5_t* file) { + + /* Allocate the data structure */ + h5nucleus_t* nucleus = (h5nucleus_t*) malloc(sizeof(h5nucleus_t)); + assert (nucleus != NULL); + + nucleus->num = 0; + nucleus->coord = NULL; + nucleus->charge = NULL; + nucleus->h5_coord = NULL; + nucleus->h5_charge = NULL; + + /* Check that the file was opened/created correctly, return */ + if (file->file_id < 0) return nucleus; + + /* Quit if the dimensioning attribute is missing in the file */ + if (H5Aexists(file->nucleus_group, NUCLEUS_NUM_NAME) == 0) return nucleus; + + herr_t status; + /* Read the nucleus_num attribute of nucleus group */ + hid_t num_id; + num_id = H5Aopen(file->nucleus_group, NUCLEUS_NUM_NAME, H5P_DEFAULT); + assert (num_id > 0); + + status = H5Aread(num_id, H5T_NATIVE_ULLONG, &(nucleus->num)); + assert (status >= 0); + + /* Allocate and read nucleus_charge array */ + nucleus->charge = (double*) calloc(nucleus->num, sizeof(double)); + assert (nucleus->charge != NULL); + + /* High-level H5LT API. No need to deal with dataspaces and datatypes */ + status = H5LTread_dataset_double(file->nucleus_group, + NUCLEUS_CHARGE_NAME, + nucleus->charge); + + /* Allocate and read nucleus_coord array */ + nucleus->coord = (double*) calloc(3 * nucleus->num, sizeof(double)); + assert (nucleus->coord != NULL); + + /* High-level H5LT API. No need to deal with dataspaces and datatypes */ + status = H5LTread_dataset_double(file->nucleus_group, + NUCLEUS_COORD_NAME, + nucleus->coord); + assert (status >= 0); + + /* Low-level read. Do not forget to close the associated IDs (dset,dtype,dspace) + * when not used anymore, see below. Note how this function is similar to H5LTread_dataset_double + */ + /* + nucleus->h5_coord = trio_hdf5_read_dset_low(file, NUCLEUS_COORD_NAME, + nucleus->coord); + + H5Sclose(nucleus->h5_coord->dspace_id); + H5Tclose(nucleus->h5_coord->dtype_id); + H5Dclose(nucleus->h5_coord->dset_id); + */ + + H5Aclose(num_id); + + return nucleus; +} + + +trio_exit_code trio_hdf5_write_nucleus(const trio_hdf5_t* file, h5nucleus_t* nucleus) { + + assert (file != NULL); + assert (nucleus != NULL); + + herr_t status; + hid_t dspace, dtype; + hid_t attr_id; + + dtype = H5Tcopy(H5T_NATIVE_ULLONG); + /* Write the dimensioning variables */ + if (H5Aexists(file->nucleus_group, NUCLEUS_NUM_NAME) == 0) { + dspace = H5Screate(H5S_SCALAR); + attr_id = H5Acreate(file->nucleus_group, NUCLEUS_NUM_NAME, dtype, dspace, + H5P_DEFAULT, H5P_DEFAULT); + assert (attr_id > 0); + + /* High-level routine does not work for some reason + * status = H5LTset_attribute_ulong (file->nucleus_group, "nucleus", NUCLEUS_NUM_NAME, + * &(nucleus->num), 1); + */ + } else { + attr_id = H5Aopen(file->nucleus_group, NUCLEUS_NUM_NAME, H5P_DEFAULT); + assert (attr_id > 0); + } + + status = H5Awrite(attr_id, dtype, &(nucleus->num)); + assert (status >= 0); + + H5Aclose(attr_id); + + /* Write arrays */ + hid_t dset_id; + int charge_rank = 1; + const hsize_t charge_dims[1] = {nucleus->num}; + + if ( H5LTfind_dataset(file->nucleus_group, NUCLEUS_CHARGE_NAME) != 1) { + + status = H5LTmake_dataset_double (file->nucleus_group, NUCLEUS_CHARGE_NAME, + charge_rank, charge_dims, nucleus->charge); + assert (status >= 0); + + } else { + + dset_id = H5Dopen(file->nucleus_group, NUCLEUS_CHARGE_NAME, H5P_DEFAULT); + assert (dset_id > 0); + + dspace = H5Dget_space(dset_id); + assert (dspace > 0); + + dtype = H5Dget_type(dset_id); + assert (dtype > 0); + + + int rrank; + hsize_t dims[1] = {0}; + rrank = H5Sget_simple_extent_dims(dspace, + dims, NULL); + assert (rrank == charge_rank); + // disabling asserts like this allows to overwrite _num variable + for (int i=0; icharge); + assert (status >= 0); + + H5Sclose(dspace); + H5Tclose(dtype); + H5Dclose(dset_id); + + } + + int coord_rank = 2; + const hsize_t coord_dims[2] = {nucleus->num, 3}; + if ( H5LTfind_dataset(file->nucleus_group, NUCLEUS_COORD_NAME) != 1) { + status = H5LTmake_dataset_double (file->nucleus_group, NUCLEUS_COORD_NAME, + coord_rank, coord_dims, nucleus->coord); + assert (status >= 0); + + } else { + + dset_id = H5Dopen(file->nucleus_group, NUCLEUS_COORD_NAME, H5P_DEFAULT); + assert (dset_id > 0); + + dspace = H5Dget_space(dset_id); + assert (dspace > 0); + + dtype = H5Dget_type(dset_id); + assert (dtype > 0); + + + int rrank; + hsize_t dims[2] = {0, 0}; + rrank = H5Sget_simple_extent_dims(dspace, + dims, NULL); + assert (rrank == coord_rank); + for (int i=0; icoord); + assert (status >= 0); + + H5Sclose(dspace); + H5Tclose(dtype); + H5Dclose(dset_id); + + } + + return TRIO_SUCCESS; +} + +trio_exit_code trio_hdf5_free_nucleus(h5nucleus_t* nucleus) { + + if (nucleus == NULL) return TRIO_FAILURE; + + if (nucleus->coord != NULL) free (nucleus->coord); + nucleus->coord = NULL; + + if (nucleus->charge != NULL) free (nucleus->charge); + nucleus->charge = NULL; + + if (nucleus->h5_coord != NULL) free (nucleus->h5_coord); + nucleus->h5_coord = NULL; + + if (nucleus->h5_charge != NULL) free (nucleus->h5_charge); + nucleus->h5_charge = NULL; + + free (nucleus); + + return TRIO_SUCCESS; +} + +trio_exit_code trio_hdf5_read_nucleus_num(const trio_t* file, uint64_t* num) { + + assert (file != NULL); + assert (num != NULL); + + h5nucleus_t* nucleus = trio_hdf5_read_nucleus((trio_hdf5_t*) file); + + if (nucleus == NULL) { + return TRIO_FAILURE; + } + + /**/ *num = nucleus->num; + + trio_hdf5_free_nucleus(nucleus); + return TRIO_SUCCESS; +} + + +trio_exit_code trio_hdf5_write_nucleus_num(const trio_t* file, const uint64_t num) { + + assert (file != NULL); + assert (num > 0L); + + h5nucleus_t* nucleus = trio_hdf5_read_nucleus((trio_hdf5_t*) file); + + assert (nucleus != NULL); + + if (nucleus->num != num) { + + if (nucleus->num != 0) { + printf("%ld -> %ld %s \n", num, nucleus->num, + "This variable alreasy exists. Overwriting it is not supported"); + trio_hdf5_free_nucleus(nucleus); + return TRIO_FAILURE; + } + + nucleus->num = num; + + if (nucleus->charge != NULL) free(nucleus->charge); + nucleus->charge = NULL; + + nucleus->charge = (double*) calloc(num, sizeof(double)); + assert (nucleus->charge != NULL); + + if (nucleus->coord != NULL) free(nucleus->coord ); + nucleus->coord = NULL; + + nucleus->coord = (double*) calloc(3*num, sizeof(double)); + assert (nucleus->coord != NULL); + + } else { + nucleus->num = num; + } + + trio_exit_code rc = trio_hdf5_write_nucleus((trio_hdf5_t*) file, nucleus); + assert (rc == TRIO_SUCCESS); + + trio_hdf5_free_nucleus(nucleus); + + return TRIO_SUCCESS; +} + +trio_exit_code trio_hdf5_read_nucleus_coord(const trio_t* file, double* coord) { + + assert (file != NULL); + assert (coord != NULL); + + h5nucleus_t* nucleus = trio_hdf5_read_nucleus((trio_hdf5_t*) file); + + if (nucleus == NULL) return TRIO_FAILURE; + assert (nucleus->coord != NULL); + + for (size_t i=0 ; i<3*nucleus->num ; i++) { + coord[i] = nucleus->coord[i]; + } + + trio_hdf5_free_nucleus(nucleus); + return TRIO_SUCCESS; +} + + +trio_exit_code trio_hdf5_write_nucleus_coord(const trio_t* file, const double* coord) { + + assert (file != NULL); + assert (coord != NULL); + + h5nucleus_t* nucleus = trio_hdf5_read_nucleus((trio_hdf5_t*) file); + + if (nucleus == NULL) return TRIO_FAILURE; + assert (nucleus->coord != NULL); + + for (size_t i=0 ; i<3*nucleus->num ; i++) { + nucleus->coord[i] = coord[i]; + } + + trio_exit_code rc = trio_hdf5_write_nucleus((trio_hdf5_t*) file, nucleus); + assert (rc == TRIO_SUCCESS); + + trio_hdf5_free_nucleus(nucleus); + + return TRIO_SUCCESS; +} diff --git a/src/trio_hdf5.h b/src/trio_hdf5.h new file mode 100644 index 0000000..aac83dd --- /dev/null +++ b/src/trio_hdf5.h @@ -0,0 +1,71 @@ +/* This file was generated from the trio.org org-mode file. + To generate it, open trio.org in Emacs and execute + M-x org-babel-tangle +*/ + + + +#ifndef _TRIO_HDF5_H +#define _TRIO_HDF5_H + +#include "trio.h" +#include "trio_s.h" +#include +#include +#include +#include +#include +#include + +#include "hdf5.h" +#include "hdf5_hl.h" // needed for high-level APIs like H5LT, requires additional linking in Makefile + +typedef struct slab_s { + uint64_t a; + uint64_t b; + uint64_t c; + uint64_t d; +} slab_t; + +typedef struct dset_s { + hid_t dset_id; + hid_t dspace_id; + hid_t dtype_id; + uint64_t* dims; + uint32_t rank; + const char* dset_name; +} dset_t; + +typedef struct h5nucleus_s { + uint64_t num; + double *coord; + double *charge; + dset_t* h5_coord; + dset_t* h5_charge; +} h5nucleus_t; + +typedef struct h5electron_s { + uint64_t alpha_num; + uint64_t beta_num; +} h5electron_t; + +typedef struct trio_hdf5_s { + trio_t parent ; + hid_t file_id; + hid_t nucleus_group; + hid_t electron_group; + //... other groups' id + const char* file_name; +} trio_hdf5_t; + +trio_exit_code trio_hdf5_init(trio_t* file); + +trio_exit_code trio_hdf5_finalize(trio_t* file); + +trio_exit_code trio_hdf5_read_nucleus_num(const trio_t* file, uint64_t* num); +trio_exit_code trio_hdf5_write_nucleus_num(const trio_t* file, const uint64_t num); + +trio_exit_code trio_hdf5_read_nucleus_coord(const trio_t* file, double* coord); +trio_exit_code trio_hdf5_write_nucleus_coord(const trio_t* file, const double* coord); + +#endif diff --git a/src/trio_text.c b/src/trio_text.c index a75d304..6a2313d 100644 --- a/src/trio_text.c +++ b/src/trio_text.c @@ -82,7 +82,7 @@ nucleus_t* trio_text_read_nucleus(const trio_text_t* file) { fscanf(f, "%s", buffer); assert (strcmp(buffer, "num") == 0); - fscanf(f, "%ld", &(nucleus->num)); + fscanf(f, "%lu", &(nucleus->num)); assert (nucleus->num > 0); /* Allocate arrays */ @@ -96,14 +96,14 @@ nucleus_t* trio_text_read_nucleus(const trio_text_t* file) { fscanf(f, "%s", buffer); assert (strcmp(buffer, "charge") == 0); - for (int i=0 ; inum ; i++) { + for (size_t i=0 ; inum ; i++) { fscanf(f, "%lf", &(nucleus->charge[i])); } fscanf(f, "%s", buffer); assert (strcmp(buffer, "coord") == 0); - for (int i=0 ; i<3*nucleus->num ; i++) { + for (size_t i=0 ; i<3*nucleus->num ; i++) { fscanf(f, "%lf", &(nucleus->coord[i])); } free(buffer); @@ -123,12 +123,12 @@ trio_exit_code trio_text_write_nucleus(const trio_text_t* file, nucleus_t* nucle /* Write arrays */ fprintf(f, "charge\n"); - for (int i=0 ; inum ; i++) { + for (size_t i=0 ; inum ; i++) { fprintf(f, "%lf\n", nucleus->charge[i]); } fprintf(f, "coord\n"); - for (int i=0 ; i<3*nucleus->num ; i++) { + for (size_t i=0 ; i<3*nucleus->num ; i++) { fprintf(f, "%lf\n", nucleus->coord[i]); } @@ -156,7 +156,7 @@ trio_exit_code trio_text_free_nucleus(nucleus_t* nucleus) { return TRIO_SUCCESS; } -trio_exit_code trio_text_read_nucleus_num(const trio_t* file, int64_t* num) { +trio_exit_code trio_text_read_nucleus_num(const trio_t* file, uint64_t* num) { assert (file != NULL); assert (num != NULL); @@ -174,7 +174,7 @@ trio_exit_code trio_text_read_nucleus_num(const trio_t* file, int64_t* num) { } -trio_exit_code trio_text_write_nucleus_num(const trio_t* file, const int64_t num) { +trio_exit_code trio_text_write_nucleus_num(const trio_t* file, const uint64_t num) { assert (num > 0L); assert (file != NULL); @@ -223,7 +223,7 @@ trio_exit_code trio_text_read_nucleus_coord(const trio_t* file, double* coord) { assert (coord != NULL); - for (int i=0 ; i<3*nucleus->num ; i++) { + for (size_t i=0 ; i<3*nucleus->num ; i++) { coord[i] = nucleus->coord[i]; } @@ -240,7 +240,7 @@ trio_exit_code trio_text_write_nucleus_coord(const trio_t* file, const double* c nucleus_t* nucleus = trio_text_read_nucleus((trio_text_t*) file); assert (nucleus != NULL); - for (int i=0 ; i<3*nucleus->num ; i++) { + for (size_t i=0 ; i<3*nucleus->num ; i++) { nucleus->coord[i] = coord[i]; } @@ -264,7 +264,7 @@ trio_exit_code trio_text_read_nucleus_charge(const trio_t* file, double* charge) assert (charge != NULL); - for (int i=0 ; inum ; i++) { + for (size_t i=0 ; inum ; i++) { charge[i] = nucleus->charge[i]; } @@ -281,7 +281,7 @@ trio_exit_code trio_text_write_nucleus_charge(const trio_t* file, const double* nucleus_t* nucleus = trio_text_read_nucleus((trio_text_t*)file); assert (nucleus != NULL); - for (int i=0 ; inum ; i++) { + for (size_t i=0 ; inum ; i++) { nucleus->charge[i] = charge[i]; } diff --git a/src/trio_text.h b/src/trio_text.h index feca94a..c52f8de 100644 --- a/src/trio_text.h +++ b/src/trio_text.h @@ -20,12 +20,12 @@ typedef struct nucleus_s { double* coord; double* charge; - int64_t num; + uint64_t num; } nucleus_t; typedef struct electron_s { - int64_t alpha_num; - int64_t beta_num; + uint64_t alpha_num; + uint64_t beta_num; } electron_t; typedef struct trio_text_s { @@ -38,8 +38,8 @@ trio_exit_code trio_text_init(trio_t* file); trio_exit_code trio_text_finalize(trio_t* file); -trio_exit_code trio_text_read_nucleus_num(const trio_t* file, int64_t* num); -trio_exit_code trio_text_write_nucleus_num(const trio_t* file, const int64_t num); +trio_exit_code trio_text_read_nucleus_num(const trio_t* file, uint64_t* num); +trio_exit_code trio_text_write_nucleus_num(const trio_t* file, const uint64_t num); trio_exit_code trio_text_read_nucleus_coord(const trio_t* file, double* coord); trio_exit_code trio_text_write_nucleus_coord(const trio_t* file, const double* coord);