From 0c60cf78d99b50c64f7232821fdd6435bbbedfd9 Mon Sep 17 00:00:00 2001 From: Anthony Scemama Date: Sat, 20 Feb 2021 18:16:10 +0100 Subject: [PATCH] Example works with no memory leaks --- src/test.c | 95 ++++++++++++++++ src/trio.c | 254 +++++++++++++++++++++++++++++++++++++++++ src/trio.h | 40 +++++++ src/trio.org | 168 +++++++++++++++++++++++++-- src/trio_s.h | 23 ++++ src/trio_text.c | 294 ++++++++++++++++++++++++++++++++++++++++++++++++ src/trio_text.h | 50 ++++++++ 7 files changed, 914 insertions(+), 10 deletions(-) create mode 100644 src/test.c create mode 100644 src/trio.c create mode 100644 src/trio.h create mode 100644 src/trio_s.h create mode 100644 src/trio_text.c create mode 100644 src/trio_text.h diff --git a/src/test.c b/src/test.c new file mode 100644 index 0000000..d5e03d7 --- /dev/null +++ b/src/test.c @@ -0,0 +1,95 @@ +#include "trio.h" +#include +#include +#include +#include + +int test_read(); +int test_write(); + + + +int main() { + test_write(); + test_read(); + return 0 ; +} + +int test_write() { + const char* file_name = "trio_test"; + + trio_t* file = NULL; + trio_exit_code rc; + + + int64_t num = 12; + + double charge[12] = {6., 6., 6., 6., 6., 6., 1., 1., 1., 1., 1., 1.}; + + double coord[36] = { + 0.00000000 , 1.39250319 , 0.00000000 , + -1.20594314 , 0.69625160 , 0.00000000 , + -1.20594314 , -0.69625160 , 0.00000000 , + 0.00000000 , -1.39250319 , 0.00000000 , + 1.20594314 , -0.69625160 , 0.00000000 , + 1.20594314 , 0.69625160 , 0.00000000 , + -2.14171677 , 1.23652075 , 0.00000000 , + -2.14171677 , -1.23652075 , 0.00000000 , + 0.00000000 , -2.47304151 , 0.00000000 , + 2.14171677 , -1.23652075 , 0.00000000 , + 2.14171677 , 1.23652075 , 0.00000000 , + 0.00000000 , 2.47304151 , 0.00000000 , + }; + + file = trio_create(file_name, TRIO_TEXT); + + rc = trio_write_nucleus_num(file,num); + rc = trio_write_nucleus_charge(file,charge); + rc = trio_write_nucleus_coord(file,coord); + + if (rc == TRIO_SUCCESS) { + printf("SUCCESS\n"); + } else { + printf("FAILURE\n"); + } + + trio_close(file); + + return 0; +} + +int test_read() { + const char* file_name = "trio_test"; + + trio_t* file = NULL; + trio_exit_code rc; + + int64_t num; + double* charge; + double* coord; + + file = trio_create(file_name, TRIO_TEXT); + + 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.); + + coord = (double*) calloc(3*num, sizeof(double)); + rc = trio_read_nucleus_coord(file,coord); + double x = coord[30] - 2.14171677; + assert( x*x < 1.e-12); + + if (rc == TRIO_SUCCESS) { + printf("SUCCESS\n"); + } else { + printf("FAILURE\n"); + } + + trio_close(file); + + return 0; +} + diff --git a/src/trio.c b/src/trio.c new file mode 100644 index 0000000..17264f0 --- /dev/null +++ b/src/trio.c @@ -0,0 +1,254 @@ +/* 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 +#include +#include +#include +#include + +#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'); + + /* Check that back_end is valid */ + assert (back_end < TRIO_INVALID_BACK_END); + + trio_t* result = NULL; + + switch (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; +*/ + default: + assert (1 == 0); /* Impossible case */ + } + + /* TODO: Error handling */ + assert (result != NULL); + + result->file_name = (char*) calloc(strlen(file_name)+1,sizeof(char)); + strcpy(result->file_name, file_name); + result->back_end = back_end; + result->mode = 'w'; /* Upon creation, mode=write */ + int irc = pthread_mutex_init ( &(result->thread_lock), NULL); + assert (irc == 0); + + trio_exit_code rc = TRIO_FAILURE; + + switch (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 */ + } + assert (rc == TRIO_SUCCESS); + + return result; +} + +trio_exit_code trio_close(trio_t* file) { + + assert (file != NULL); + + trio_exit_code rc; + + switch (file->back_end) { + + 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; +*/ + default: + assert (1 == 0); /* Impossible case */ + } + + if (rc != TRIO_SUCCESS) { + return TRIO_FAILURE; + } + + free(file->file_name); + file->file_name = NULL; + + int irc = pthread_mutex_destroy( &(file->thread_lock) ); + assert (irc == 0); + + free(file); + + return TRIO_SUCCESS; +} + +trio_exit_code trio_read_nucleus_num(trio_t* file, int64_t* num) { + if (file == NULL) return TRIO_FAILURE; + + switch (file->back_end) { + + 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; +*/ + default: + return TRIO_FAILURE; /* Impossible case */ + } +} + +trio_exit_code trio_write_nucleus_num(trio_t* file, int64_t num) { + if (file == NULL) return TRIO_FAILURE; + + switch (file->back_end) { + + 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; +*/ + default: + return TRIO_FAILURE; /* Impossible case */ + } +} + +trio_exit_code trio_read_nucleus_coord(trio_t* file, double* coord) { + if (file == NULL) return TRIO_FAILURE; + + switch (file->back_end) { + + 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; +*/ + default: + return TRIO_FAILURE; /* Impossible case */ + } +} + +trio_exit_code trio_write_nucleus_coord(trio_t* file, double* coord) { + if (file == NULL) return TRIO_FAILURE; + + switch (file->back_end) { + + 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; +*/ + default: + return TRIO_FAILURE; /* Impossible case */ + } +} + +trio_exit_code trio_read_nucleus_charge(trio_t* file, double* charge) { + if (file == NULL) return TRIO_FAILURE; + + switch (file->back_end) { + + case TRIO_TEXT: + return trio_text_read_nucleus_charge(file, charge); + break; +/* + case TRIO_HDF5: + return trio_hdf5_read_nucleus_charge(file, charge); + break; + + case TRIO_JSON: + return trio_json_read_nucleus_charge(file, charge); + break; +*/ + default: + return TRIO_FAILURE; /* Impossible case */ + } +} + +trio_exit_code trio_write_nucleus_charge(trio_t* file, double* charge) { + if (file == NULL) return TRIO_FAILURE; + + switch (file->back_end) { + + case TRIO_TEXT: + return trio_text_write_nucleus_charge(file, charge); + break; +/* + case TRIO_HDF5: + return trio_hdf5_write_nucleus_charge(file, charge); + break; + + case TRIO_JSON: + return trio_json_write_nucleus_charge(file, charge); + break; +*/ + default: + return TRIO_FAILURE; /* Impossible case */ + } +} diff --git a/src/trio.h b/src/trio.h new file mode 100644 index 0000000..fdb051d --- /dev/null +++ b/src/trio.h @@ -0,0 +1,40 @@ +/* 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_H +#define _TRIO_H + +#include + +typedef int32_t trio_exit_code; + +#define TRIO_SUCCESS ( (trio_exit_code) 0 ) +#define TRIO_FAILURE ( (trio_exit_code) 1 ) + +typedef uint32_t back_end_t; + +#define TRIO_HDF5 ( (back_end_t) 0 ) +#define TRIO_TEXT ( (back_end_t) 1 ) +#define TRIO_JSON ( (back_end_t) 2 ) +#define TRIO_INVALID_BACK_END ( (back_end_t) 3 ) + +typedef struct trio_s trio_t; + +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_coord(trio_t* file, double* coord); +trio_exit_code trio_write_nucleus_coord(trio_t* file, double* coord); + +trio_exit_code trio_read_nucleus_charge(trio_t* file, double* charge); +trio_exit_code trio_write_nucleus_charge(trio_t* file, double* charge); + +#endif diff --git a/src/trio.org b/src/trio.org index 4c86f65..6262792 100644 --- a/src/trio.org +++ b/src/trio.org @@ -2,7 +2,19 @@ * File prefixes :noxport: - #+begin_src c :tangle trio.h + #+NAME:header + #+begin_src c +/* 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 +*/ + + + + #+end_src + + #+begin_src c :tangle trio.h :noweb yes +<
> #ifndef _TRIO_H #define _TRIO_H @@ -10,7 +22,8 @@ #+end_src - #+begin_src c :tangle trio.c + #+begin_src c :tangle trio.c :noweb yes +<
> #include #include #include @@ -28,7 +41,8 @@ #+end_src - #+begin_src c :tangle trio_s.h + #+begin_src c :tangle trio_s.h :noweb yes +<
> #ifndef _TRIO_S_H #define _TRIO_S_H @@ -37,7 +51,8 @@ #include #+end_src - #+begin_src c :tangle trio_text.h + #+begin_src c :tangle trio_text.h :noweb yes +<
> #ifndef _TRIO_TEXT_H #define _TRIO_TEXT_H @@ -48,10 +63,12 @@ #include #include #include +#include #+end_src - #+begin_src c :tangle trio_text.c + #+begin_src c :tangle trio_text.c :noweb yes +<
> #include "trio_text.h" #+end_src @@ -192,7 +209,8 @@ trio_t* trio_create(const char* file_name, back_end_t back_end) { strcpy(result->file_name, file_name); result->back_end = back_end; result->mode = 'w'; /* Upon creation, mode=write */ - pthread_mutex_init ( &(result->thread_lock), NULL); + int irc = pthread_mutex_init ( &(result->thread_lock), NULL); + assert (irc == 0); trio_exit_code rc = TRIO_FAILURE; @@ -219,10 +237,58 @@ trio_t* trio_create(const char* file_name, back_end_t back_end) { } #+end_src + +** File closing + + #+begin_src c :tangle trio.h +trio_exit_code trio_close(trio_t* file); + #+end_src + + #+begin_src c :tangle trio.c +trio_exit_code trio_close(trio_t* file) { + + assert (file != NULL); + + trio_exit_code rc; + + switch (file->back_end) { + + 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; +,*/ + default: + assert (1 == 0); /* Impossible case */ + } + + if (rc != TRIO_SUCCESS) { + return TRIO_FAILURE; + } + + free(file->file_name); + file->file_name = NULL; + + int irc = pthread_mutex_destroy( &(file->thread_lock) ); + assert (irc == 0); + + free(file); + + return TRIO_SUCCESS; +} + #+end_src ** 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); #+end_src #+begin_src c :tangle trio.c @@ -247,11 +313,34 @@ trio_exit_code trio_read_nucleus_num(trio_t* file, int64_t* num) { return TRIO_FAILURE; /* Impossible case */ } } + +trio_exit_code trio_write_nucleus_num(trio_t* file, int64_t num) { + if (file == NULL) return TRIO_FAILURE; + + switch (file->back_end) { + + 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; +*/ + default: + return TRIO_FAILURE; /* Impossible case */ + } +} #+end_src #+begin_src c :tangle trio.h trio_exit_code trio_read_nucleus_coord(trio_t* file, double* coord); +trio_exit_code trio_write_nucleus_coord(trio_t* file, double* coord); #+end_src #+begin_src c :tangle trio.c @@ -271,7 +360,29 @@ trio_exit_code trio_read_nucleus_coord(trio_t* file, double* coord) { case TRIO_JSON: return trio_json_read_nucleus_coord(file, coord); break; -*/ +,*/ + default: + return TRIO_FAILURE; /* Impossible case */ + } +} + +trio_exit_code trio_write_nucleus_coord(trio_t* file, double* coord) { + if (file == NULL) return TRIO_FAILURE; + + switch (file->back_end) { + + 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; +,*/ default: return TRIO_FAILURE; /* Impossible case */ } @@ -281,6 +392,7 @@ trio_exit_code trio_read_nucleus_coord(trio_t* file, double* coord) { #+begin_src c :tangle trio.h trio_exit_code trio_read_nucleus_charge(trio_t* file, double* charge); +trio_exit_code trio_write_nucleus_charge(trio_t* file, double* charge); #+end_src #+begin_src c :tangle trio.c @@ -305,6 +417,28 @@ trio_exit_code trio_read_nucleus_charge(trio_t* file, double* charge) { return TRIO_FAILURE; /* Impossible case */ } } + +trio_exit_code trio_write_nucleus_charge(trio_t* file, double* charge) { + if (file == NULL) return TRIO_FAILURE; + + switch (file->back_end) { + + case TRIO_TEXT: + return trio_text_write_nucleus_charge(file, charge); + break; +/* + case TRIO_HDF5: + return trio_hdf5_write_nucleus_charge(file, charge); + break; + + case TRIO_JSON: + return trio_json_write_nucleus_charge(file, charge); + break; +,*/ + default: + return TRIO_FAILURE; /* Impossible case */ + } +} #+end_src * Back ends @@ -347,20 +481,34 @@ trio_exit_code trio_text_init(trio_t* file) { trio_text_t* f = (trio_text_t*) file; + /* If directory doesn't exist, create it */ + struct stat st; + + if (stat(file->file_name, &st) == 0 && S_ISDIR(st.st_mode)) { + /* Do nothing */ + } else { + if (mkdir(file->file_name, 0777) != 0) { + return TRIO_FAILURE; + } + } + + /* Create name of files in the directory */ const char* nucleus_file_name = "/nucleus.txt"; f->nucleus_file_name = (char*) calloc( strlen(file->file_name) + strlen(nucleus_file_name) + 1, sizeof(char)); assert (f->nucleus_file_name != NULL); + strcpy (f->nucleus_file_name, file->file_name); strcat (f->nucleus_file_name, nucleus_file_name); const char* electron_file_name = "/electron.txt"; - f->nucleus_file_name = (char*) + f->electron_file_name = (char*) calloc( strlen(file->file_name) + strlen(electron_file_name) + 1, sizeof(char)); - assert (f->nucleus_file_name != NULL); - strcat (f->nucleus_file_name, electron_file_name); + assert (f->electron_file_name != NULL); + strcpy (f->electron_file_name, file->file_name); + strcat (f->electron_file_name, electron_file_name); return TRIO_SUCCESS; } diff --git a/src/trio_s.h b/src/trio_s.h new file mode 100644 index 0000000..6c59256 --- /dev/null +++ b/src/trio_s.h @@ -0,0 +1,23 @@ +/* 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_S_H +#define _TRIO_S_H + +#include "trio.h" +#include +#include + +struct trio_s { + char* file_name; + pthread_mutex_t thread_lock; + back_end_t back_end; + char mode; + char padding[7]; /* Ensures the proper alignment of back-ends */ +}; + +#endif diff --git a/src/trio_text.c b/src/trio_text.c new file mode 100644 index 0000000..a75d304 --- /dev/null +++ b/src/trio_text.c @@ -0,0 +1,294 @@ +/* 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_text.h" + +trio_exit_code trio_text_init(trio_t* file) { + + trio_text_t* f = (trio_text_t*) file; + + /* If directory doesn't exist, create it */ + struct stat st; + + if (stat(file->file_name, &st) == 0 && S_ISDIR(st.st_mode)) { + /* Do nothing */ + } else { + if (mkdir(file->file_name, 0777) != 0) { + return TRIO_FAILURE; + } + } + + /* Create name of files in the directory */ + const char* nucleus_file_name = "/nucleus.txt"; + f->nucleus_file_name = (char*) + calloc( strlen(file->file_name) + strlen(nucleus_file_name) + 1, + sizeof(char)); + assert (f->nucleus_file_name != NULL); + strcpy (f->nucleus_file_name, file->file_name); + strcat (f->nucleus_file_name, nucleus_file_name); + + + const char* electron_file_name = "/electron.txt"; + f->electron_file_name = (char*) + calloc( strlen(file->file_name) + strlen(electron_file_name) + 1, + sizeof(char)); + assert (f->electron_file_name != NULL); + strcpy (f->electron_file_name, file->file_name); + strcat (f->electron_file_name, electron_file_name); + + return TRIO_SUCCESS; +} + +trio_exit_code trio_text_finalize(trio_t* file) { + + trio_text_t* f = (trio_text_t*) file; + + free (f->nucleus_file_name); + f->nucleus_file_name = NULL; + + free (f->electron_file_name); + f->electron_file_name = NULL; + + return TRIO_SUCCESS; +} + +nucleus_t* trio_text_read_nucleus(const trio_text_t* file) { + + /* Allocate the data structure */ + nucleus_t* nucleus = (nucleus_t*) malloc(sizeof(nucleus_t)); + assert (nucleus != NULL); + + nucleus->num = 0; + nucleus->coord = NULL; + nucleus->charge = NULL; + + /* Try to open the file. If the file does not exist, return */ + FILE* f = fopen(file->nucleus_file_name,"r"); + if (f == NULL) { + return nucleus; + } + + /* Find size of file to allocate the max size of the string buffer */ + fseek(f, 0L, SEEK_END); + size_t sz = ftell(f); + fseek(f, 0L, SEEK_SET); + char* buffer = (char*) malloc(sz*sizeof(char)); + + /* Read the dimensioning variables */ + fscanf(f, "%s", buffer); + assert (strcmp(buffer, "num") == 0); + + fscanf(f, "%ld", &(nucleus->num)); + assert (nucleus->num > 0); + + /* Allocate arrays */ + nucleus->charge = (double*) calloc(nucleus->num, sizeof(double)); + assert (nucleus->charge != NULL); + + nucleus->coord = (double*) calloc(3 * nucleus->num, sizeof(double)); + assert (nucleus->coord != NULL); + + /* Read arrays */ + fscanf(f, "%s", buffer); + assert (strcmp(buffer, "charge") == 0); + + for (int 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++) { + fscanf(f, "%lf", &(nucleus->coord[i])); + } + free(buffer); + fclose(f); + return nucleus; +} + + +trio_exit_code trio_text_write_nucleus(const trio_text_t* file, nucleus_t* nucleus) { + assert (nucleus != NULL); + + FILE* f = fopen(file->nucleus_file_name,"w"); + assert (f != NULL); + + /* Write the dimensioning variables */ + fprintf(f, "num %ld\n", nucleus->num); + + /* Write arrays */ + fprintf(f, "charge\n"); + for (int i=0 ; inum ; i++) { + fprintf(f, "%lf\n", nucleus->charge[i]); + } + + fprintf(f, "coord\n"); + for (int i=0 ; i<3*nucleus->num ; i++) { + fprintf(f, "%lf\n", nucleus->coord[i]); + } + + fclose(f); + return TRIO_SUCCESS; +} + +trio_exit_code trio_text_free_nucleus(nucleus_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; + + free (nucleus); + return TRIO_SUCCESS; +} + +trio_exit_code trio_text_read_nucleus_num(const trio_t* file, int64_t* num) { + + assert (file != NULL); + assert (num != NULL); + + nucleus_t* nucleus = trio_text_read_nucleus((trio_text_t*) file); + + if (nucleus == NULL) { + return TRIO_FAILURE; + } + + /**/ *num = nucleus->num; + + trio_text_free_nucleus(nucleus); + return TRIO_SUCCESS; +} + + +trio_exit_code trio_text_write_nucleus_num(const trio_t* file, const int64_t num) { + + assert (num > 0L); + assert (file != NULL); + + nucleus_t* nucleus = trio_text_read_nucleus((trio_text_t*) file); + + assert (nucleus != NULL); + + if (nucleus->num != num) { + + 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_text_write_nucleus((trio_text_t*) file, nucleus); + assert (rc == TRIO_SUCCESS); + + trio_text_free_nucleus(nucleus); + + return TRIO_SUCCESS; +} + +trio_exit_code trio_text_read_nucleus_coord(const trio_t* file, double* coord) { + + assert (file != NULL); + assert (file != NULL); + nucleus_t* nucleus = trio_text_read_nucleus((trio_text_t*) file); + + if (nucleus == NULL) { + return TRIO_FAILURE; + } + + assert (coord != NULL); + + for (int i=0 ; i<3*nucleus->num ; i++) { + coord[i] = nucleus->coord[i]; + } + + trio_text_free_nucleus(nucleus); + return TRIO_SUCCESS; +} + + +trio_exit_code trio_text_write_nucleus_coord(const trio_t* file, const double* coord) { + + assert (coord != NULL); + assert (file != NULL); + + nucleus_t* nucleus = trio_text_read_nucleus((trio_text_t*) file); + assert (nucleus != NULL); + + for (int i=0 ; i<3*nucleus->num ; i++) { + nucleus->coord[i] = coord[i]; + } + + trio_exit_code rc = trio_text_write_nucleus((trio_text_t*) file, nucleus); + assert (rc == TRIO_SUCCESS); + + trio_text_free_nucleus(nucleus); + + return TRIO_SUCCESS; +} + +trio_exit_code trio_text_read_nucleus_charge(const trio_t* file, double* charge) { + + assert (file != NULL); + assert (file != NULL); + nucleus_t* nucleus = trio_text_read_nucleus((trio_text_t*)file); + + if (nucleus == NULL) { + return TRIO_FAILURE; + } + + assert (charge != NULL); + + for (int i=0 ; inum ; i++) { + charge[i] = nucleus->charge[i]; + } + + trio_text_free_nucleus(nucleus); + return TRIO_SUCCESS; +} + + +trio_exit_code trio_text_write_nucleus_charge(const trio_t* file, const double* charge) { + + assert (charge != NULL); + assert (file != NULL); + + nucleus_t* nucleus = trio_text_read_nucleus((trio_text_t*)file); + assert (nucleus != NULL); + + for (int i=0 ; inum ; i++) { + nucleus->charge[i] = charge[i]; + } + + trio_exit_code rc = trio_text_write_nucleus((trio_text_t*) file, nucleus); + assert (rc == TRIO_SUCCESS); + + trio_text_free_nucleus(nucleus); + + return TRIO_SUCCESS; +} diff --git a/src/trio_text.h b/src/trio_text.h new file mode 100644 index 0000000..feca94a --- /dev/null +++ b/src/trio_text.h @@ -0,0 +1,50 @@ +/* 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_TEXT_H +#define _TRIO_TEXT_H + +#include "trio.h" +#include "trio_s.h" +#include +#include +#include +#include +#include +#include + +typedef struct nucleus_s { + double* coord; + double* charge; + int64_t num; +} nucleus_t; + +typedef struct electron_s { + int64_t alpha_num; + int64_t beta_num; +} electron_t; + +typedef struct trio_text_s { + trio_t parent ; + char* nucleus_file_name; + char* electron_file_name; +} trio_text_t; + +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_coord(const trio_t* file, double* coord); +trio_exit_code trio_text_write_nucleus_coord(const trio_t* file, const double* coord); + +trio_exit_code trio_text_read_nucleus_charge(const trio_t* file, double* coord); +trio_exit_code trio_text_write_nucleus_charge(const trio_t* file, const double* coord); + +#endif