1 /* 2 * This file is part of the GROMACS molecular simulation package. 3 * 4 * Copyright (c) 1991-2000, University of Groningen, The Netherlands. 5 * Copyright (c) 2001-2004, The GROMACS development team. 6 * Copyright (c) 2013,2014,2015,2016,2017 by the GROMACS development team. 7 * Copyright (c) 2018,2019,2020, by the GROMACS development team, led by 8 * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl, 9 * and including many others, as listed in the AUTHORS file in the 10 * top-level source directory and at http://www.gromacs.org. 11 * 12 * GROMACS is free software; you can redistribute it and/or 13 * modify it under the terms of the GNU Lesser General Public License 14 * as published by the Free Software Foundation; either version 2.1 15 * of the License, or (at your option) any later version. 16 * 17 * GROMACS is distributed in the hope that it will be useful, 18 * but WITHOUT ANY WARRANTY; without even the implied warranty of 19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 20 * Lesser General Public License for more details. 21 * 22 * You should have received a copy of the GNU Lesser General Public 23 * License along with GROMACS; if not, see 24 * http://www.gnu.org/licenses, or write to the Free Software Foundation, 25 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 26 * 27 * If you want to redistribute modifications to GROMACS, please 28 * consider that scientific software is very special. Version 29 * control is crucial - bugs must be traceable. We will be happy to 30 * consider code for inclusion in the official distribution, but 31 * derived work must not be called official GROMACS. Details are found 32 * in the README & COPYING files - if they are missing, get the 33 * official version at http://www.gromacs.org. 34 * 35 * To help us fund GROMACS development, we humbly ask that you cite 36 * the research papers on the package. Check out http://www.gromacs.org. 37 */ 38 #ifndef GMX_FILEIO_ENXIO_H 39 #define GMX_FILEIO_ENXIO_H 40 41 #include "gromacs/fileio/xdr_datatype.h" 42 #include "gromacs/utility/basedefinitions.h" 43 #include "gromacs/utility/real.h" 44 45 struct SimulationGroups; 46 struct t_energy; 47 struct t_enxframe; 48 struct t_fileio; 49 struct t_inputrec; 50 class t_state; 51 52 /************************************************************** 53 * These are the base datatypes + functions for reading and 54 * writing energy files (.edr). They are either called directly 55 * (as in the processing tools), or indirectly through mdebin.c 56 * during mdrun. 57 * 58 * The routines in the corresponding c-file enxio.c 59 * are based on the lower level routines in gmxfio.c. 60 * The file pointer returned from open_enx 61 * can also be used with the routines in gmxfio.h 62 * 63 **************************************************************/ 64 65 typedef struct 66 { 67 char* name; 68 char* unit; 69 } gmx_enxnm_t; 70 71 /* 72 * Index for the IDs of additional blocks in the energy file. 73 * Blocks can be added without sacrificing backward and forward 74 * compatibility of the energy files. 75 * 76 * For backward compatibility, the order of these should not be changed. 77 */ 78 enum 79 { 80 enxOR, /* Time and ensemble averaged data for orientation restraints */ 81 enxORI, /* Instantaneous data for orientation restraints */ 82 enxORT, /* Order tensor(s) for orientation restraints */ 83 enxDISRE, /* Distance restraint blocks */ 84 85 enxDHCOLL, /* Data about the free energy blocks in this frame. */ 86 enxDHHIST, /* BAR histogram */ 87 enxDH, /* BAR raw delta H data */ 88 89 enxAWH, /* AWH data */ 90 91 enxNR /* Total number of extra blocks in the current code, 92 * note that the enxio code can read files written by 93 * future code which contain more blocks. 94 */ 95 }; 96 97 /* names for the above enum */ 98 extern const char* enx_block_id_name[]; 99 100 101 /* the subblocks that are contained in energy file blocks. Each of these 102 has a number of values of a single data type in a .edr file. */ 103 struct t_enxsubblock 104 { 105 int nr; /* number of items in subblock */ 106 xdr_datatype type; /* the block type */ 107 108 /* the values: pointers for each type */ 109 float* fval; 110 double* dval; 111 int* ival; 112 int64_t* lval; 113 unsigned char* cval; 114 char** sval; 115 116 /* the allocated sizes, defined separately. 117 (nonzero sizes can be free()d later): */ 118 int fval_alloc; 119 int dval_alloc; 120 int ival_alloc; 121 int lval_alloc; 122 int cval_alloc; 123 int sval_alloc; 124 }; 125 126 /* the energy file blocks. Each block contains a number of sub-blocks 127 of a single type that contain the actual data. */ 128 struct t_enxblock 129 { 130 int id; /* block id, from the enx enums above */ 131 int nsub; /* number of subblocks */ 132 t_enxsubblock* sub; /* the subblocks */ 133 int nsub_alloc; /* number of allocated subblocks */ 134 }; 135 136 /* file handle */ 137 typedef struct ener_file* ener_file_t; 138 139 /* 140 * An energy file is read like this: 141 * 142 * ener_file_t fp; 143 * t_enxframe *fr; 144 * 145 * fp = open_enx(...); 146 * do_enxnms(fp,...); 147 * snew(fr,1); 148 * while (do_enx(fp,fr)) { 149 * ... 150 * } 151 * free_enxframe(fr); 152 * sfree(fr); 153 */ 154 /* New energy reading and writing interface */ 155 156 157 /* initialize a pre-allocated frame */ 158 void init_enxframe(t_enxframe* ef); 159 /* delete a frame's memory (except the ef itself) */ 160 void free_enxframe(t_enxframe* ef); 161 162 163 ener_file_t open_enx(const char* fn, const char* mode); 164 165 struct t_fileio* enx_file_pointer(const ener_file* ef); 166 167 /* Free the contents of ef */ 168 void close_enx(ener_file_t ef); 169 170 /* Free the contents of ef, and ef itself */ 171 void done_ener_file(ener_file_t ef); 172 173 void do_enxnms(ener_file_t ef, int* nre, gmx_enxnm_t** enms); 174 175 void free_enxnms(int n, gmx_enxnm_t* nms); 176 /* Frees nms and all strings in it */ 177 178 gmx_bool do_enx(ener_file_t ef, t_enxframe* fr); 179 /* Reads enx_frames, memory in fr is (re)allocated if necessary */ 180 181 void get_enx_state(const char* fn, real t, const SimulationGroups& groups, t_inputrec* ir, t_state* state); 182 /* 183 * Reads state variables from enx file fn at time t. 184 * atoms and ir are required for determining which things must be read. 185 * Currently pcoupl and tcoupl state are read from enx. 186 */ 187 188 189 /* block funtions */ 190 191 /* allocate n blocks to a frame (if neccesary). Don't touch existing blocks */ 192 void add_blocks_enxframe(t_enxframe* ef, int n); 193 194 /* find a block by id number; if prev!=NULL, it searches from 195 that block's next block. 196 Returns NULL if no block is found with the given id. */ 197 t_enxblock* find_block_id_enxframe(t_enxframe* ef, int id, t_enxblock* prev); 198 199 200 /* allocate n subblocks to a block (if neccesary). Don't touch existing 201 subbblocks. */ 202 void add_subblocks_enxblock(t_enxblock* eb, int n); 203 204 void comp_enx(const char* fn1, const char* fn2, real ftol, real abstol, const char* lastener); 205 /* Compare two binary energy files */ 206 207 #endif 208