Changed name from trg to tng

1 files changed, 0 insertions, 760 deletions

diff --git a/src/lib/trg_io.h b/src/lib/trg_io.h
deleted file mode 100644
index d321e6e..0000000
--- a/src/lib/trg_io.h
+++ /dev/null
@@ -1,760 +0,0 @@
-#ifndef _TRGIO_H
-#define _TRGIO_H     1
-
-#include <stdio.h>
-#include <inttypes.h>
-
-#define TRG_VERSION 1
-
-#define TRG_UNCOMPRESSED 0ULL
-#define TRG_XTC 1ULL
-#define TRG_TNG_POSITIONS 2ULL
-#define TRG_TNG_VELOCITIES 3ULL
-#define TRG_TNG_FORCES 4ULL
-
-#define TRG_PARTICLE_DEPENDENT 1
-#define TRG_FRAME_DEPENDENT 2
-
-// #define TRG_MAX_BLOCK_PARTICLES 1000
-#define TRG_MAX_DATE_STR_LEN 24
-#define TRG_HASH_LEN 16
-#define TRG_MAX_STR_LEN 1024
-
-typedef enum {TRG_BIG_ENDIAN_32,
-              TRG_LITTLE_ENDIAN_32,
-              TRG_BYTE_PAIR_SWAP_32} trg_endianness_32;
-
-typedef enum {TRG_BIG_ENDIAN_64,
-              TRG_LITTLE_ENDIAN_64,
-              TRG_QUAD_SWAP_64,
-              TRG_BYTE_PAIR_SWAP_64,
-              TRG_BYTE_SWAP_64} trg_endianness_64;
-
-
-#define min(a,b) \
-    ({ __typeof__ (a) _a = (a); \
-       __typeof__ (b) _b = (b); \
-       _a < _b ? _a : _b; })
-     
-#define max(a,b) \
-    ({ __typeof__ (a) _a = (a); \
-       __typeof__ (b) _b = (b); \
-       _a > _b ? _a : _b; })
-
-typedef enum {TRG_NON_TRAJECTORY_BLOCK, TRG_TRAJECTORY_BLOCK} trg_block_type;
-
-typedef enum {TRG_ENDIANNESS_AND_STRING_LENGTH,
-              TRG_GENERAL_INFO,
-              TRG_MOLECULES,
-              TRG_TRAJECTORY_IDS_AND_NAMES,
-              TRG_TRAJECTORY_FRAME_SET,
-              TRG_BLOCK_TABLE_OF_CONTENTS,
-              TRG_PARTICLE_MAPPING} trg_non_trajectory_block_ids;
-
-typedef enum {TRG_TRAJ_BOX_SHAPE = 10000,
-              TRG_TRAJ_POSITIONS,
-              TRG_TRAJ_VELOCITIES,
-              TRG_TRAJ_FORCES} trg_trajectory_block_ids;
-              
-
-typedef enum {TRG_NON_PARTICLE_BLOCK_DATA,
-              TRG_PARTICLE_BLOCK_DATA} trg_particle_block_data;
-              
-/*typedef enum {TRG_NO_HASH, TRG_OTHER_HASH,
-              TRG_MD5_HASH, TRG_MD6_HASH,
-              TRG_SHA0_HASH, TRG_SHA1_HASH,
-              TRG_SHA256_HASH, TRG_SHA512_HASH} trg_hash_type;*/
-
-typedef enum {FALSE, TRUE} trg_bool;
-
-typedef enum {TRG_KEEP_FILE_OPEN, TRG_CLOSE_FILE} trg_close_file_flag;
-
-typedef enum {TRG_CONSTANT_N_ATOMS, TRG_VARIABLE_N_ATOMS} trg_variable_n_atoms_flag;
-
-typedef enum {TRG_SUCCESS, TRG_FAILURE, TRG_CRITICAL} trg_function_status;
-
-typedef enum {TRG_NORMAL_WRITE, TRG_COPY_EXISTING} write_mode;
-
-typedef enum {TRG_CHAR_DATA,
-              TRG_INT_DATA,
-              TRG_FLOAT_DATA,
-              TRG_DOUBLE_DATA} trg_data_type;
-
-
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-struct trg_bond {
-    int64_t from_atom_id;      /* One of the atoms of the bond */
-    int64_t to_atom_id;        /* The other atom of the bond */
-};
-
-struct trg_atom {
-    struct trg_residue *residue;  /* The molecule containing this atom */
-    int64_t id;                /* A unique (per molecule) ID number of the atom */
-    char *atom_type;            /* The atom_type (depending on the forcefield) */
-    char *name;                 /* The name of the atom */
-};
-
-struct trg_residue {
-    struct trg_chain *chain; /* The chain containing this residue */
-    int64_t id;                /* A unique (per chain) ID number of the residue */
-    char *name;                 /* The name of the residue */
-    int64_t n_atoms;           /* The number of atoms in the residue */
-    struct trg_atom *atoms;     /* A list of atoms in the residue */
-};
-
-struct trg_chain {
-    struct trg_molecule *molecule;  /* The molecule containing this chain */
-    int64_t id;                    /* A unique (per molecule) ID number of the chain */
-    char *name;                     /* The name of the chain */
-    int64_t n_residues;            /* The number of residues in the chain */
-    struct trg_residue *residues;   /* A list of residues in the chain */
-};
-
-struct trg_molecule {
-    int64_t id;                    /* A unique ID number of the molecule */
-    int64_t quaternary_str;        /* Quaternary structure of the molecule.
-                                       1 => monomeric
-                                       2 => dimeric
-                                       3 => trimeric
-                                       etc */
-    int64_t n_chains;              /* The number of chains in the molecule */
-    int64_t n_residues;            /* The number of residues in the molecule */
-    int64_t n_atoms;               /* The number of atoms in the molecule */
-    int64_t n_bonds;               /* The number of bonds in the molecule.
-                                       If the bonds are not specified this
-                                       value can be 0. */
-    char *name;                     /* The name of the molecule */
-    struct trg_chain *chains;       /* A list of chains in the molecule */
-    struct trg_residue *residues;   /* A list of residues in the molecule */
-    struct trg_atom *atoms;         /* A list of the atoms in the molecule */
-    struct trg_bond *bonds;         /* A list of the bonds in the molecule */
-};
-
-struct trg_gen_block {
-    int64_t header_contents_size;      /* The size of the block header in bytes */
-    int64_t block_contents_size;       /* The size of the block contents in bytes */
-    int64_t id;                        /* The ID of the block to determine its type */
-    char hash[TRG_HASH_LEN];            /* The MD5 hash of the block to verify integrity */
-    char *name;                         /* The name of the block */
-    int64_t block_version;             /* The library version used to write the block */
-    char *header_contents;              /* The full block header contents */
-    char *block_contents;               /* The full block contents */
-};
-
-struct trg_frame_set_toc {
-    int64_t n_blocks;                  /* The number of blocks listed in this
-                                           table of contents */
-    char **block_names;             /* A list of block names */
-};
-
-struct trg_particle_mapping {
-    int64_t num_first_particle;        /* The index number of the first particle
-                                           in this mapping block */
-    int64_t n_particles;               /* The number of particles list in this
-                                           mapping block */
-    int64_t *real_particle_numbers;    /* the mapping of index numbers to the
-                                           real particle numbers in the
-                                           trajectory */
-};
-
-struct trg_trajectory_frame_set {
-    struct trg_frame_set_toc contents;  /* The table of contents of this frame set */
-    int64_t n_mapping_blocks;          /* The number of different particle
-                                           mapping blocks present. */
-    struct trg_particle_mapping *mappings; /* The atom mappings of this frame set */
-    int64_t first_frame;               /* The first frame of this frame set */
-    int64_t n_frames;                  /* The number of frames in this frame set */
-    int64_t *molecule_cnt_list;        /* A list of the number of each molecule
-                                           type - only used when using variable
-                                           number of atoms */
-    int64_t n_particles;               /* The number of particles/atoms - only
-                                           used when using variable number of
-                                           atoms */
-    int64_t next_frame_set_file_pos;   /* The file position of the next frame set */
-    int64_t prev_frame_set_file_pos;   /* The file position of the previous
-                                           frame set */
-    int64_t long_stride_next_frame_set_file_pos; /* The file position of the frame
-                                                     set one stride step ahead */
-    int64_t long_stride_prev_frame_set_file_pos; /* The file position of the frame
-                                                     set one stride step behind */
-
-    /* The data blocks in a frame set are trajectory data blocks */
-    int n_particle_data_blocks;            /* The number of data blocks
-                                              of particle dependent data */
-    struct trg_particle_data *tr_particle_data; /* A list of data blocks
-                                                containing particle
-                                                dependent data */
-    int n_data_blocks;
-    struct trg_data *tr_data;
-};
-
-/* Data can be either double, float, int or a string */
-union data_values {
-    double d;
-    float f;
-    int i;
-    char *c;
-};
-
-/* FIXME: Should there be a pointer to a trg_gen_block from each data block? */
-struct trg_particle_data {
-    int64_t block_id;                  /* The block ID of the data block
-                                           containing this particle data.
-                                           This is used to determine the
-                                           kind of data that is stored */
-    char *block_name;                   /* The name of the data block.
-                                           This is used to determine the
-                                           kind of data that is stored */
-    trg_data_type datatype;             /* The type of data stored. */
-    int64_t first_frame_with_data;     /* The first frame number of the
-                                           first data point */
-    int64_t n_frames;                  /* The number of frames in this
-                                           frame set */
-    int64_t n_values_per_frame;        /* The number of values stored per
-                                           frame */
-    int64_t stride_length;             /* The number of frames between
-                                           each data point - e.g. when
-                                           storing sparse data. */
-    int64_t codec_id;                  /* ID of the CODEC used for compression
-                                           0 == no compression. */
-    double compression_multiplier;      /* The multiplier used for getting
-                                           integer values for compression */
-    union data_values ***values;        /* A 3-dimensional array of values,
-                                           sized n_frames x n_particles x
-                                           n_values_per_frame */
-};
-
-struct trg_data {
-    int64_t block_id;
-    char *block_name;                   /* The name of the data block.
-                                           This is used to determine the
-                                           kind of data that is stored */
-    trg_data_type datatype;             /* The type of data stored. */
-    int64_t first_frame_with_data;
-    int64_t n_frames;
-    int64_t n_values_per_frame;
-    int64_t stride_length;
-    int64_t codec_id;                  /* ID of the CODEC used for compression
-                                           0 == no compression. */
-    double compression_multiplier;
-    union data_values **values;         /* A 2-dimensional array of values,
-                                           sized n_frames x n_values_per_frame */
-};
-
-
-
-struct trg_trajectory {
-    char *input_file_path;                /* The path of the input trajectory file */
-    FILE *input_file;                     /* A handle to the input file */
-    long int input_file_pos;              /* The reading position of the file */
-    long int input_file_len;              /* The length of the input file */
-    char *output_file_path;               /* The path of the output trajectory file */
-    FILE *output_file;                    /* A handle to the output file */
-    long int output_file_pos;             /* The writing position of the file */
-    
-    trg_endianness_32 endianness_32;    /* The endianness of 32 bit values of
-                                           the current computer */
-    trg_endianness_64 endianness_64;    /* The endianness of 64 bit values of
-                                           the current computer */
-    
-    char *program_name;                 /* The name of the program producing
-                                           this trajectory */
-    char *forcefield_name;              /* The forcefield used in the simulations */
-    char *user_name;                    /* The name of the user running the
-                                           simulations */
-    int64_t time;                      /* The time (n seconds since 1970) when
-                                           the file was created */
-    char *computer_name;                /* The name of the computer on which the
-                                           simulations were performed */
-    char *pgp_signature;                /* The PGP signature of the user creating
-                                           the file. */
-    char var_num_atoms_flag;            /* A flag indicating if the number of atoms
-                                           can vary throughout the simulation, e.g.
-                                           using a grand canonical ensemble */
-    int64_t frame_set_n_frames;        /* The number of frames in a frame set.
-                                           It is allowed to have frame sets with
-                                           fewer frames, but this will help searching
-                                           for specific frames */
-    int64_t stride_length;             /* The number of frame sets in a long stride
-                                           step */
-
-    int64_t n_molecules;               /* The number of different kinds of
-                                           molecules in the trajectory */
-    struct trg_molecule *molecules;     /* A list of molecules in the trajectory */
-    int64_t *molecule_cnt_list;        /* A list of the count of each molecule -
-                                           if using variable number of particles
-                                           this will be specified in each frame set */
-    int64_t n_particles;               /* The total number of particles/atoms. If
-                                           using variable number of particles this
-                                           will be specified in each frame set */
-    
-    int64_t n_id_name_pairs;                           /* The number of ID-name
-                                                           pairs */
-    struct trg_block_id_name_pair *id_name_pairs;       /* A list of ID-name
-                                                           pairs */
-
-    int64_t first_trajectory_frame_set_input_file_pos;   /* The pos in the src
-                                                           file of the first
-                                                           frame set */
-    int64_t first_trajectory_frame_set_output_file_pos;  /* The pos in the dest
-                                                           file of the first
-                                                           frame set */
-    int64_t last_trajectory_frame_set_input_file_pos;    /* The pos in the src
-                                                           file of the last
-                                                           frame set */
-    int64_t last_trajectory_frame_set_output_file_pos;   /* The pos in the dest
-                                                           file of the last
-                                                           frame set */
-    struct trg_trajectory_frame_set current_trajectory_frame_set; /* The currently
-                                                                     active frame
-                                                                     set */
-    long int current_trajectory_frame_set_input_file_pos; /* The pos in the src
-                                                           file of the current
-                                                           frame set */
-    long int current_trajectory_frame_set_output_file_pos;/* The pos in the dest
-                                                           file of the current
-                                                           frame set */
-    int64_t n_trajectory_frame_sets;                   /* The number of frame sets
-                                                           in the trajectory */
-    
-    int64_t n_trajectory_blocks;       /* The number of trajectory blocks
-                                           in the file */
-    int64_t n_non_trajectory_blocks;   /* The number of non-trajectory blocks
-                                           in the file */
-    struct trg_gen_block non_trajectory_blocks[32]; /* A list of non-trajectory
-                                                       blocks */
-                                                       
-    /* These data blocks are non-trajectory data blocks */
-    int n_particle_data_blocks;                     /* The number of non-frame dependent
-                                                       particle dependent data blocks */
-    struct trg_particle_data *non_tr_particle_data; /* A list of data blocks containing particle
-                                                       dependent data */
-    
-    int n_data_blocks;                  /* The number of frame and particle independent
-                                           data blocks */
-    struct trg_data *non_tr_data;       /* A list of frame and particle indepdendent data blocks */
-};
-
-
-
-/* Setup a trajectory data container.
-   *trg_data is a pointer to pre-allocated memory.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_init_trajectory(struct trg_trajectory *trg_data);
-
-/* Clean up a trajectory data container.
-   *trg_data is a pointer to pre-allocated memory containing trajectory data.
-   All allocated memory in the data structure is freed.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_destroy_trajectory(struct trg_trajectory *trg_data);
-
-/* Set the name of the input file.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_set_input_file(struct trg_trajectory *trg_data,
-                                       const char *file_name);
-
-/* Set the name of the output file.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_set_output_file(struct trg_trajectory *trg_data,
-                                        const char *file_name);
-
-/* Set the program name used when creating the trajectory.
-   *trg_data is a pointer to pre-allocated memory containing trajectory data.
-   *new_name is a pointer to the string containing the wanted name.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */   
-trg_function_status trg_set_program_name(struct trg_trajectory *trg_data,
-                                         const char *new_name);
-
-/* Set the name of the forcefield used in the trajectory.
-   *trg_data is a pointer to pre-allocated memory containing trajectory data.
-   *new_name is a pointer to the string containing the wanted name.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_set_forcefield_name(struct trg_trajectory *trg_data,
-                                            const char *new_name);
-
-/* Set the name of the user creating the trajectory.
-   *trg_data is a pointer to pre-allocated memory containing trajectory data.
-   *new_name is a pointer to the string containing the wanted name.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_set_user_name(struct trg_trajectory *trg_data,
-                                      const char *new_name);
-
-/* Set the name of the computer used when creating the trajectory.
-   *trg_data is a pointer to pre-allocated memory containing trajectory data.
-   *new_name is a pointer to the string containing the wanted name.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_set_computer_name(struct trg_trajectory *trg_data,
-                                          const char *new_name);
-
-/* Set the pgp_signature of the trajectory.
-   *trg_data is a pointer to pre-allocated memory containing trajectory data.
-   *signature is a pointer to the string containing the pgp_signature.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_set_signature(struct trg_trajectory *trg_data,
-                                      const char *signature);
-
-/* Setup a molecule container.
-   *molecule is a pointer to pre-allocated memory.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_init_molecule(struct trg_molecule *molecule);
-
-/* Clean up a molecule container.
-   *molecule is a pointer to pre-allocated memory containing a molecule.
-   All allocated memory in the data structure is freed.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_destroy_molecule(struct trg_molecule *molecule);
-
-/* Setup a data block.
-   *block is a pointer to pre-allocated memory.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_init_block(struct trg_gen_block *block);
-
-/* Clean up a data block.
-   *block is a pointer to pre-allocated memory.
-   All allocated memory in the data structure is freed.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_destroy_block(struct trg_gen_block *block);
-
-/* Set the name of a data block.
-   *trg_data is a pointer to the trajectory containing the block.
-   *block is a pointer to the block to rename.
-   *new_name is a string containing the wanted name.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_set_block_name(struct trg_trajectory *trg_data,
-                                       struct trg_gen_block *block,
-                                       const char *new_name);
-
-/* Add a molecule to the trajectory.
-   *trg_data is a pointer to the trajectory containing the block.
-   *name is a pointer to the string containing the name of the new molecule.
-   **molecule is a pointer to a pointer to the newly created molecule.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_add_molecule(struct trg_trajectory *trg_data,
-                                     const char *name,
-                                     struct trg_molecule **molecule);
-
-/* Set the name of a molecule.
-   *trg_data is a pointer to the trajectory containing the molecule.
-   *molecule is a pointer to the molecule to rename.
-   *new_name is a string containing the wanted name.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_set_molecule_name(struct trg_trajectory *trg_data,
-                                          struct trg_molecule *molecule,
-                                          const char *new_name);
-
-/* Set the count of a molecule.
-   *trg_data is a pointer to the trajectory containing the molecule.
-   *molecule is a pointer to the molecule to rename.
-   *cnt is a pointer to the variable to be populated with the count.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_get_molecule_cnt(struct trg_trajectory *trg_data,
-                                         struct trg_molecule *molecule,
-                                         int64_t *cnt);
-
-/* Set the count of a molecule.
-   *trg_data is a pointer to the trajectory containing the molecule.
-   *molecule is a pointer to the molecule to rename.
-   cnt is the number of instances of this molecule.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_set_molecule_cnt(struct trg_trajectory *trg_data,
-                                         struct trg_molecule *molecule,
-                                         int64_t cnt);
-
-/* Add a chain to a molecule.
-   *trg_data is a pointer to the trajectory containing the molecule.
-   *molecule is a pointer to the molecule to add a chain to.
-   *name is a pointer to a string containing the name of the chain.
-   **chain is a pointer to a pointer to the newly created chain.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_add_chain_to_molecule(struct trg_trajectory *trg_data,
-                                              struct trg_molecule *molecule,
-                                              const char *name,
-                                              struct trg_chain **chain);
-
-/* Set the name of a chain.
-   *trg_data is a pointer to the trajectory containing the atom.
-   *chain is a pointer to the chain to rename.
-   *new_name is a string containing the wanted name.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_set_chain_name(struct trg_trajectory *trg_data,
-                                       struct trg_chain *chain,
-                                       const char *new_name);
-
-/* Add a residue to a chain.
-   *trg_data is a pointer to the trajectory containing the chain.
-   *chain is a pointer to the chain to add a residue to.
-   *name is a pointer to a string containing the name of the residue.
-   **residue is a pointer to a pointer to the newly created residue.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_add_residue_to_chain(struct trg_trajectory *trg_data,
-                                             struct trg_chain *chain,
-                                             const char *name,
-                                             struct trg_residue **residue);
-
-/* Set the name of a residue.
-   *trg_data is a pointer to the trajectory containing the atom.
-   *residue is a pointer to the residue to rename.
-   *new_name is a string containing the wanted name.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_set_residue_name(struct trg_trajectory *trg_data,
-                                         struct trg_residue *residue,
-                                         const char *new_name);
-
-/* Add an atom to a residue.
-   *trg_data is a pointer to the trajectory containing the residue.
-   *residue is a pointer to the residue to add an atom to.
-   *atom_name is a pointer to a string containing the name of the atom.
-   *atom_type is a pointer to a string containing the atom type of the atom.
-   **atom is a pointer to a pointer to the newly created atom.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_add_atom_to_residue(struct trg_trajectory *trg_data,
-                                            struct trg_residue *residue,
-                                            const char *atom_name,
-                                            const char *atom_type,
-                                            struct trg_atom **atom);
-
-/* Set the name of an atom.
-   *trg_data is a pointer to the trajectory containing the atom.
-   *atom is a pointer to the atom to rename.
-   *new_name is a string containing the wanted name.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_set_atom_name(struct trg_trajectory *trg_data,
-                                      struct trg_atom *atom,
-                                      const char *new_name);
-
-/* Set the atom type of an atom.
-   *trg_data is a pointer to the trajectory containing the atom.
-   *atom is a pointer to the atom to change.
-   *new_name is a string containing the atom type.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_set_atom_type(struct trg_trajectory *trg_data,
-                                      struct trg_atom *atom,
-                                      const char *new_type);
-
-/* Read the header blocks from the input_file of trg_data.
-   The trajectory blocks must be read separately and iteratively in chunks
-   to fit in memory.
-   *trg_data is a pointer to trajectory data. trg_data->input_file_path specifies which
-   file to read from. If the file (input_file) is not open it will be opened.
-   If close_file == TRG_CLOSE_FILE (1) the input_file will be closed after reading the data.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_read_file_headers(struct trg_trajectory *trg_data,
-                                          trg_close_file_flag close_file);
-
-/* Write the header blocks to the output_file of trg_data.
-   The trajectory blocks must be written separately and iteratively in chunks
-   to fit in memory.
-   *trg_data is a pointer to trajectory data. trg_data->output_file_path specifies which
-   file to write to. If the file (output_file) is not open it will be opened.
-   If close_file == TRG_CLOSE_FILE (1) the output_file will be closed after writing the data.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_write_file_headers(struct trg_trajectory *trg_data,
-                                           trg_close_file_flag close_file);
-
-
-/* Read one (the next) block (of any kind) from the input_file of trg_data.
-   *trg_data is a pointer to trajectory data. trg_data->input_file_path specifies which
-   file to read from. If the file (input_file) is not open it will be opened.
-   *block_data is a pointer to the struct which will be populated with the
-   data. If block_data->input_file_pos > 0 it is the position from where the reading
-   starts otherwise it starts from the current position.
-   If close_file == TRG_CLOSE_FILE (1) the input_file will be closed after reading the data.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor
-   error has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_read_next_block(struct trg_trajectory *trg_data,
-                                        struct trg_gen_block *block_data,
-                                        trg_close_file_flag close_file);
-
-/* Write one block (of any kind) to the output_file of trg_data.
-   *trg_data is a pointer to trajectory data. trg_data->output_file_path specifies which
-   file to read from. If the file (output_file) is not open it will be opened.
-   *block_data is a pointer to the struct containing the
-   data. If block_data->output_file_pos > 0 it is the position from where the writing
-   starts otherwise it starts from the current position.
-   If close_file == TRG_CLOSE_FILE (1) the input_file will be closed after writing the data.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-// trg_function_status trg_write_block(struct trg_trajectory *trg_data,
-//                                     struct trg_gen_block *block_data,
-//                                     trg_close_file_flag close_file);
-
-
-/* Read one (the next) frame set, including toc, mapping and related data blocks
-   from the input_file of trg_data.
-   *trg_data is a pointer to trajectory data. trg_data->input_file_path specifies which
-   file to read from. If the file (input_file) is not open it will be opened.
-   If close_file == TRG_CLOSE_FILE (1) the input_file will be closed after reading the data.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_read_next_frame_set(struct trg_trajectory *trg_data,
-                                            trg_close_file_flag close_file);
-
-/* Write one (the next) frame set, including toc, mapping and related data blocks
-   to the output_file of trg_data.
-   *trg_data is a pointer to trajectory data. trg_data->output_file_path specifies which
-   file to write to. If the file (output_file) is not open it will be opened.
-   If close_file == TRG_CLOSE_FILE (1) the output_file will be closed after writing the data.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_write_frame_set(struct trg_trajectory *trg_data,
-                                        trg_close_file_flag close_file);
-
-trg_function_status trg_new_frame_set(struct trg_trajectory *trg_data,
-                                      const int64_t first_frame,
-                                      const int64_t n_frames);
-
-trg_function_status trg_add_particle_data_block(struct trg_trajectory *trg_data,
-                                        const int64_t id,
-                                        const char *block_name,
-                                        const char datatype,
-                                        const int64_t n_frames,
-                                        const int64_t n_values_per_frame,
-                                        const int64_t stride_length,
-                                        const int64_t first_particle_number,
-                                        const int64_t n_particles,
-                                        int64_t codec_id,
-                                        void *new_data);
-
-
-/* Read one (the next) trajectory block from the input_file of trg_data.
-   *trg_data is a pointer to trajectory data. trg_data->input_file_path specifies which
-   file to read from. If the file (input_file) is not open it will be opened.
-   If close_file == TRG_CLOSE_FILE (1) the input_file will be closed after reading the data.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_read_next_traj_block(struct trg_trajectory *trg_data,
-                                             trg_close_file_flag close_file);
-
-/* Write one (the next) trajectory block to the output_file of trg_data.
-   *trg_data is a pointer to trajectory data. trg_data->output_file_path specifies which
-   file to write to. If the file (output_file) is not open it will be opened.
-   If close_file == TRG_CLOSE_FILE (1) the output_file will be closed after writing the data.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_write_next_traj_block(struct trg_trajectory *trg_data,
-                                              trg_close_file_flag close_file);
-
-/* Read one trajectory block from the input_file of trg_data.
-   *trg_data is a pointer to trajectory data. trg_data->input_file_path specifies which
-   file to read from. If the file (input_file) is not open it will be opened.
-   block_id is the ID of the block to read.
-   If close_file == TRG_CLOSE_FILE (1) the input_file will be closed after reading the data.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_read_traj_block(struct trg_trajectory *trg_data,
-                                        int64_t block_id,
-                                        trg_close_file_flag close_file);
-        
-/* Write one trajectory block to the output_file of trg_data.
-   *trg_data is a pointer to trajectory data. trg_data->output_file_path specifies which
-   file to write to. If the file (output_file) is not open it will be opened.
-   block_id is the ID of the block to write.
-   If close_file == TRG_CLOSE_FILE (1) the output_file will be closed after writing the data.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_write_traj_block(struct trg_trajectory *trg_data,
-                                         int64_t block_id,
-                                         trg_close_file_flag close_file);
-
-/* Read a requested frame set.
-   *trg_data is a pointer to trajectory data. trg_data->current_trajectory_frame_set
-   will be the read frame set.
-   frame_set_nr is the number of the frame set to return (starting from 0).
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_read_frame_set_nr(struct trg_trajectory *trg_data,
-                                          int64_t frame_set_nr);
-
-/* Read one trajectory frame from the input_file of trg_data.
-   *trg_data is a pointer to trajectory data. trg_data->input_file_path specifies which
-   file to read from. If the file (input_file) is not open it will be opened.
-   frame_nr is the index number of the frame to read.
-   If close_file == TRG_CLOSE_FILE (1) the input_file will be closed after reading the data.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_read_frame_nr(struct trg_trajectory *trg_data,
-                                      int64_t frame_nr,
-                                      trg_close_file_flag close_file);
-        
-/* Write one trajectory frame to the output_file of trg_data.
-   *trg_data is a pointer to trajectory data. trg_data->output_file_path specifies which
-   file to write to. If the file (output_file) is not open it will be opened.
-   frame_nr is the index number of the frame to write.
-   If close_file == TRG_CLOSE_FILE (1) the output_file will be closed after writing the data.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_write_frame_nr(struct trg_trajectory *trg_data,
-                                       int64_t frame_nr,
-                                       trg_close_file_flag close_file);
-
-/* Read a number of consecutive trajectory frames from the input_file of trg_data.
-   *trg_data is a pointer to trajectory data. trg_data->input_file_path specifies which
-   file to read from. If the file (input_file) is not open it will be opened.
-   start_frame_nr is the index number of the first frame to read.
-   end_frame_nr is the index number of the last frame to read.
-   If close_file == TRG_CLOSE_FILE (1) the input_file will be closed after reading the data.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_read_frame_nrs(struct trg_trajectory *trg_data,
-                                       int64_t start_frame_nr,
-                                       int64_t end_frame_nr,
-                                       trg_close_file_flag close_file);
-
-/* Write a number of consecutive trajectory frames to the output_file of trg_data.
-   *trg_data is a pointer to trajectory data. trg_data->output_file_path specifies which
-   file to write to. If the file (input_file) is not open it will be opened.
-   start_frame_nr is the index number of the first frame to write.
-   end_frame_nr is the index number of the last frame to write.
-   If close_file == TRG_CLOSE_FILE (1) the output_file will be closed after writing the data.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_write_frame_nrs(struct trg_trajectory *trg_data,
-                                        int64_t start_frame_nr,
-                                        int64_t end_frame_nr,
-                                        trg_close_file_flag close_file);
-
-/* Get the date and time of initial file creation in ISO format (string).
-   *trg_data is a pointer to trajectory data.
-   *time is a pointer to the string in which the date will be stored. Memory
-   must be reserved beforehand.
-   Returns TRG_SUCCESS (0) if successful, TRG_FAILURE (1) if a minor error
-   has occurred or TRG_CRITICAL (2) if a major error has occured. */
-trg_function_status trg_get_time_str(struct trg_trajectory *trg_data, char *time);
-
-#ifdef __cplusplus
-}  /* end extern "C" */
-#endif
-
-#endif /* _TRGIO_H */
\ No newline at end of file