2 * This file is part of the GROMACS molecular simulation package.
4 * Copyright (c) 2008,2009,2010,2011,2012,2013,2014, by the GROMACS development team, led by
5 * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
6 * and including many others, as listed in the AUTHORS file in the
7 * top-level source directory and at http://www.gromacs.org.
9 * GROMACS is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public License
11 * as published by the Free Software Foundation; either version 2.1
12 * of the License, or (at your option) any later version.
14 * GROMACS is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with GROMACS; if not, see
21 * http://www.gnu.org/licenses, or write to the Free Software Foundation,
22 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
24 * If you want to redistribute modifications to GROMACS, please
25 * consider that scientific software is very special. Version
26 * control is crucial - bugs must be traceable. We will be happy to
27 * consider code for inclusion in the official distribution, but
28 * derived work must not be called official GROMACS. Details are found
29 * in the README & COPYING files - if they are missing, get the
30 * official version at http://www.gromacs.org.
32 * To help us fund GROMACS development, we humbly ask that you cite
33 * the research papers on the package. Check out http://www.gromacs.org.
36 /* The source code in this file should be thread-safe.
37 Please keep it that way. */
47 #ifdef HAVE_SYS_TIME_H
55 #ifdef GMX_NATIVE_WINDOWS
58 #include <sys/locking.h>
64 #include "types/commrec.h"
65 #include "gromacs/utility/smalloc.h"
69 #include "checkpoint.h"
74 #include "gromacs/fileio/filenm.h"
75 #include "gromacs/fileio/futil.h"
76 #include "gromacs/fileio/gmxfio.h"
77 #include "gromacs/fileio/xdrf.h"
78 #include "gromacs/fileio/xdr_datatype.h"
79 #include "gromacs/utility/baseversion.h"
81 #include "buildinfo.h"
87 #define CPT_MAGIC1 171817
88 #define CPT_MAGIC2 171819
89 #define CPTSTRLEN 1024
92 #define GMX_CPT_BUILD_DP 1
94 #define GMX_CPT_BUILD_DP 0
97 /* cpt_version should normally only be changed
98 * when the header of footer format changes.
99 * The state data format itself is backward and forward compatible.
100 * But old code can not read a new entry that is present in the file
101 * (but can read a new format when new entries are not present).
103 static const int cpt_version = 16;
106 const char *est_names[estNR] =
109 "box", "box-rel", "box-v", "pres_prev",
110 "nosehoover-xi", "thermostat-integral",
111 "x", "v", "SDx", "CGp", "LD-rng", "LD-rng-i",
112 "disre_initf", "disre_rm3tav",
113 "orire_initf", "orire_Dtav",
114 "svir_prev", "nosehoover-vxi", "v_eta", "vol0", "nhpres_xi", "nhpres_vxi", "fvir_prev", "fep_state", "MC-rng", "MC-rng-i"
118 eeksEKIN_N, eeksEKINH, eeksDEKINDL, eeksMVCOS, eeksEKINF, eeksEKINO, eeksEKINSCALEF, eeksEKINSCALEH, eeksVSCALE, eeksEKINTOTAL, eeksNR
121 const char *eeks_names[eeksNR] =
123 "Ekin_n", "Ekinh", "dEkindlambda", "mv_cos",
124 "Ekinf", "Ekinh_old", "EkinScaleF_NHC", "EkinScaleH_NHC", "Vscale_NHC", "Ekin_Total"
128 eenhENERGY_N, eenhENERGY_AVER, eenhENERGY_SUM, eenhENERGY_NSUM,
129 eenhENERGY_SUM_SIM, eenhENERGY_NSUM_SIM,
130 eenhENERGY_NSTEPS, eenhENERGY_NSTEPS_SIM,
131 eenhENERGY_DELTA_H_NN,
132 eenhENERGY_DELTA_H_LIST,
133 eenhENERGY_DELTA_H_STARTTIME,
134 eenhENERGY_DELTA_H_STARTLAMBDA,
138 const char *eenh_names[eenhNR] =
140 "energy_n", "energy_aver", "energy_sum", "energy_nsum",
141 "energy_sum_sim", "energy_nsum_sim",
142 "energy_nsteps", "energy_nsteps_sim",
144 "energy_delta_h_list",
145 "energy_delta_h_start_time",
146 "energy_delta_h_start_lambda"
149 /* free energy history variables -- need to be preserved over checkpoint */
151 edfhBEQUIL, edfhNATLAMBDA, edfhWLHISTO, edfhWLDELTA, edfhSUMWEIGHTS, edfhSUMDG, edfhSUMMINVAR, edfhSUMVAR,
152 edfhACCUMP, edfhACCUMM, edfhACCUMP2, edfhACCUMM2, edfhTIJ, edfhTIJEMP, edfhNR
154 /* free energy history variable names */
155 const char *edfh_names[edfhNR] =
157 "bEquilibrated", "N_at_state", "Wang-Landau Histogram", "Wang-Landau Delta", "Weights", "Free Energies", "minvar", "variance",
158 "accumulated_plus", "accumulated_minus", "accumulated_plus_2", "accumulated_minus_2", "Tij", "Tij_empirical"
161 #ifdef GMX_NATIVE_WINDOWS
163 gmx_wintruncate(const char *filename, __int64 size)
166 /*we do this elsewhere*/
172 fp = fopen(filename, "rb+");
179 return _chsize_s( fileno(fp), size);
186 ecprREAL, ecprRVEC, ecprMATRIX
190 cptpEST, cptpEEKS, cptpEENH, cptpEDFH
192 /* enums for the different components of checkpoint variables, replacing the hard coded ones.
193 cptpEST - state variables.
194 cptpEEKS - Kinetic energy state variables.
195 cptpEENH - Energy history state variables.
196 cptpEDFH - free energy history variables.
200 static const char *st_names(int cptp, int ecpt)
204 case cptpEST: return est_names [ecpt]; break;
205 case cptpEEKS: return eeks_names[ecpt]; break;
206 case cptpEENH: return eenh_names[ecpt]; break;
207 case cptpEDFH: return edfh_names[ecpt]; break;
213 static void cp_warning(FILE *fp)
215 fprintf(fp, "\nWARNING: Checkpoint file is corrupted or truncated\n\n");
218 static void cp_error()
220 gmx_fatal(FARGS, "Checkpoint file corrupted/truncated, or maybe you are out of disk space?");
223 static void do_cpt_string_err(XDR *xd, gmx_bool bRead, const char *desc, char **s, FILE *list)
231 res = xdr_string(xd, s, CPTSTRLEN);
238 fprintf(list, "%s = %s\n", desc, *s);
243 static int do_cpt_int(XDR *xd, const char *desc, int *i, FILE *list)
247 res = xdr_int(xd, i);
254 fprintf(list, "%s = %d\n", desc, *i);
259 static int do_cpt_u_chars(XDR *xd, const char *desc, int n, unsigned char *i, FILE *list)
265 fprintf(list, "%s = ", desc);
267 for (j = 0; j < n && res; j++)
269 res &= xdr_u_char(xd, &i[j]);
272 fprintf(list, "%02x", i[j]);
287 static void do_cpt_int_err(XDR *xd, const char *desc, int *i, FILE *list)
289 if (do_cpt_int(xd, desc, i, list) < 0)
295 static void do_cpt_step_err(XDR *xd, const char *desc, gmx_int64_t *i, FILE *list)
298 char buf[STEPSTRSIZE];
300 res = xdr_int64(xd, i);
307 fprintf(list, "%s = %s\n", desc, gmx_step_str(*i, buf));
311 static void do_cpt_double_err(XDR *xd, const char *desc, double *f, FILE *list)
315 res = xdr_double(xd, f);
322 fprintf(list, "%s = %f\n", desc, *f);
326 static void do_cpt_real_err(XDR *xd, real *f)
331 res = xdr_double(xd, f);
333 res = xdr_float(xd, f);
341 static void do_cpt_n_rvecs_err(XDR *xd, const char *desc, int n, rvec f[], FILE *list)
345 for (i = 0; i < n; i++)
347 for (j = 0; j < DIM; j++)
349 do_cpt_real_err(xd, &f[i][j]);
355 pr_rvecs(list, 0, desc, f, n);
359 /* If nval >= 0, nval is used; on read this should match the passed value.
360 * If nval n<0, *nptr is used; on read the value is stored in nptr
362 static int do_cpte_reals_low(XDR *xd, int cptp, int ecpt, int sflags,
363 int nval, int *nptr, real **v,
364 FILE *list, int erealtype)
368 int dtc = xdr_datatype_float;
370 int dtc = xdr_datatype_double;
372 real *vp, *va = NULL;
387 gmx_incons("*ntpr=NULL in do_cpte_reals_low");
392 res = xdr_int(xd, &nf);
403 gmx_fatal(FARGS, "Count mismatch for state entry %s, code count is %d, file count is %d\n", st_names(cptp, ecpt), nval, nf);
412 res = xdr_int(xd, &dt);
419 fprintf(stderr, "Precision mismatch for state entry %s, code precision is %s, file precision is %s\n",
420 st_names(cptp, ecpt), xdr_datatype_names[dtc],
421 xdr_datatype_names[dt]);
423 if (list || !(sflags & (1<<ecpt)))
436 if (dt == xdr_datatype_float)
438 if (dtc == xdr_datatype_float)
446 res = xdr_vector(xd, (char *)vf, nf,
447 (unsigned int)sizeof(float), (xdrproc_t)xdr_float);
452 if (dtc != xdr_datatype_float)
454 for (i = 0; i < nf; i++)
463 if (dtc == xdr_datatype_double)
471 res = xdr_vector(xd, (char *)vd, nf,
472 (unsigned int)sizeof(double), (xdrproc_t)xdr_double);
477 if (dtc != xdr_datatype_double)
479 for (i = 0; i < nf; i++)
492 pr_reals(list, 0, st_names(cptp, ecpt), vp, nf);
495 pr_rvecs(list, 0, st_names(cptp, ecpt), (rvec *)vp, nf/3);
498 gmx_incons("Unknown checkpoint real type");
510 /* This function stores n along with the reals for reading,
511 * but on reading it assumes that n matches the value in the checkpoint file,
512 * a fatal error is generated when this is not the case.
514 static int do_cpte_reals(XDR *xd, int cptp, int ecpt, int sflags,
515 int n, real **v, FILE *list)
517 return do_cpte_reals_low(xd, cptp, ecpt, sflags, n, NULL, v, list, ecprREAL);
520 /* This function does the same as do_cpte_reals,
521 * except that on reading it ignores the passed value of *n
522 * and stored the value read from the checkpoint file in *n.
524 static int do_cpte_n_reals(XDR *xd, int cptp, int ecpt, int sflags,
525 int *n, real **v, FILE *list)
527 return do_cpte_reals_low(xd, cptp, ecpt, sflags, -1, n, v, list, ecprREAL);
530 static int do_cpte_real(XDR *xd, int cptp, int ecpt, int sflags,
535 return do_cpte_reals_low(xd, cptp, ecpt, sflags, 1, NULL, &r, list, ecprREAL);
538 static int do_cpte_ints(XDR *xd, int cptp, int ecpt, int sflags,
539 int n, int **v, FILE *list)
542 int dtc = xdr_datatype_int;
547 res = xdr_int(xd, &nf);
552 if (list == NULL && v != NULL && nf != n)
554 gmx_fatal(FARGS, "Count mismatch for state entry %s, code count is %d, file count is %d\n", st_names(cptp, ecpt), n, nf);
557 res = xdr_int(xd, &dt);
564 gmx_fatal(FARGS, "Type mismatch for state entry %s, code type is %s, file type is %s\n",
565 st_names(cptp, ecpt), xdr_datatype_names[dtc],
566 xdr_datatype_names[dt]);
568 if (list || !(sflags & (1<<ecpt)) || v == NULL)
581 res = xdr_vector(xd, (char *)vp, nf,
582 (unsigned int)sizeof(int), (xdrproc_t)xdr_int);
589 pr_ivec(list, 0, st_names(cptp, ecpt), vp, nf, TRUE);
599 static int do_cpte_int(XDR *xd, int cptp, int ecpt, int sflags,
602 return do_cpte_ints(xd, cptp, ecpt, sflags, 1, &i, list);
605 static int do_cpte_doubles(XDR *xd, int cptp, int ecpt, int sflags,
606 int n, double **v, FILE *list)
609 int dtc = xdr_datatype_double;
610 double *vp, *va = NULL;
614 res = xdr_int(xd, &nf);
619 if (list == NULL && nf != n)
621 gmx_fatal(FARGS, "Count mismatch for state entry %s, code count is %d, file count is %d\n", st_names(cptp, ecpt), n, nf);
624 res = xdr_int(xd, &dt);
631 gmx_fatal(FARGS, "Precision mismatch for state entry %s, code precision is %s, file precision is %s\n",
632 st_names(cptp, ecpt), xdr_datatype_names[dtc],
633 xdr_datatype_names[dt]);
635 if (list || !(sflags & (1<<ecpt)))
648 res = xdr_vector(xd, (char *)vp, nf,
649 (unsigned int)sizeof(double), (xdrproc_t)xdr_double);
656 pr_doubles(list, 0, st_names(cptp, ecpt), vp, nf);
666 static int do_cpte_double(XDR *xd, int cptp, int ecpt, int sflags,
667 double *r, FILE *list)
669 return do_cpte_doubles(xd, cptp, ecpt, sflags, 1, &r, list);
673 static int do_cpte_rvecs(XDR *xd, int cptp, int ecpt, int sflags,
674 int n, rvec **v, FILE *list)
678 return do_cpte_reals_low(xd, cptp, ecpt, sflags,
679 n*DIM, NULL, (real **)v, list, ecprRVEC);
682 static int do_cpte_matrix(XDR *xd, int cptp, int ecpt, int sflags,
683 matrix v, FILE *list)
688 vr = (real *)&(v[0][0]);
689 ret = do_cpte_reals_low(xd, cptp, ecpt, sflags,
690 DIM*DIM, NULL, &vr, NULL, ecprMATRIX);
692 if (list && ret == 0)
694 pr_rvecs(list, 0, st_names(cptp, ecpt), v, DIM);
701 static int do_cpte_nmatrix(XDR *xd, int cptp, int ecpt, int sflags,
702 int n, real **v, FILE *list)
707 char name[CPTSTRLEN];
714 for (i = 0; i < n; i++)
718 reti = do_cpte_reals_low(xd, cptp, ecpt, sflags, n, NULL, &(v[i]), NULL, ecprREAL);
719 if (list && reti == 0)
721 sprintf(name, "%s[%d]", st_names(cptp, ecpt), i);
722 pr_reals(list, 0, name, v[i], n);
732 static int do_cpte_matrices(XDR *xd, int cptp, int ecpt, int sflags,
733 int n, matrix **v, FILE *list)
736 matrix *vp, *va = NULL;
742 res = xdr_int(xd, &nf);
747 if (list == NULL && nf != n)
749 gmx_fatal(FARGS, "Count mismatch for state entry %s, code count is %d, file count is %d\n", st_names(cptp, ecpt), n, nf);
751 if (list || !(sflags & (1<<ecpt)))
764 snew(vr, nf*DIM*DIM);
765 for (i = 0; i < nf; i++)
767 for (j = 0; j < DIM; j++)
769 for (k = 0; k < DIM; k++)
771 vr[(i*DIM+j)*DIM+k] = vp[i][j][k];
775 ret = do_cpte_reals_low(xd, cptp, ecpt, sflags,
776 nf*DIM*DIM, NULL, &vr, NULL, ecprMATRIX);
777 for (i = 0; i < nf; i++)
779 for (j = 0; j < DIM; j++)
781 for (k = 0; k < DIM; k++)
783 vp[i][j][k] = vr[(i*DIM+j)*DIM+k];
789 if (list && ret == 0)
791 for (i = 0; i < nf; i++)
793 pr_rvecs(list, 0, st_names(cptp, ecpt), vp[i], DIM);
804 static void do_cpt_header(XDR *xd, gmx_bool bRead, int *file_version,
805 char **version, char **btime, char **buser, char **bhost,
807 char **fprog, char **ftime,
808 int *eIntegrator, int *simulation_part,
809 gmx_int64_t *step, double *t,
810 int *nnodes, int *dd_nc, int *npme,
811 int *natoms, int *ngtc, int *nnhpres, int *nhchainlength,
812 int *nlambda, int *flags_state,
813 int *flags_eks, int *flags_enh, int *flags_dfh,
814 int *nED, int *eSwapCoords,
831 res = xdr_int(xd, &magic);
834 gmx_fatal(FARGS, "The checkpoint file is empty/corrupted, or maybe you are out of disk space?");
836 if (magic != CPT_MAGIC1)
838 gmx_fatal(FARGS, "Start of file magic number mismatch, checkpoint file has %d, should be %d\n"
839 "The checkpoint file is corrupted or not a checkpoint file",
845 gmx_gethostname(fhost, 255);
847 do_cpt_string_err(xd, bRead, "GROMACS version", version, list);
848 do_cpt_string_err(xd, bRead, "GROMACS build time", btime, list);
849 do_cpt_string_err(xd, bRead, "GROMACS build user", buser, list);
850 do_cpt_string_err(xd, bRead, "GROMACS build host", bhost, list);
851 do_cpt_string_err(xd, bRead, "generating program", fprog, list);
852 do_cpt_string_err(xd, bRead, "generation time", ftime, list);
853 *file_version = cpt_version;
854 do_cpt_int_err(xd, "checkpoint file version", file_version, list);
855 if (*file_version > cpt_version)
857 gmx_fatal(FARGS, "Attempting to read a checkpoint file of version %d with code of version %d\n", *file_version, cpt_version);
859 if (*file_version >= 13)
861 do_cpt_int_err(xd, "GROMACS double precision", double_prec, list);
867 if (*file_version >= 12)
869 do_cpt_string_err(xd, bRead, "generating host", &fhost, list);
875 do_cpt_int_err(xd, "#atoms", natoms, list);
876 do_cpt_int_err(xd, "#T-coupling groups", ngtc, list);
877 if (*file_version >= 10)
879 do_cpt_int_err(xd, "#Nose-Hoover T-chains", nhchainlength, list);
885 if (*file_version >= 11)
887 do_cpt_int_err(xd, "#Nose-Hoover T-chains for barostat ", nnhpres, list);
893 if (*file_version >= 14)
895 do_cpt_int_err(xd, "# of total lambda states ", nlambda, list);
901 do_cpt_int_err(xd, "integrator", eIntegrator, list);
902 if (*file_version >= 3)
904 do_cpt_int_err(xd, "simulation part #", simulation_part, list);
908 *simulation_part = 1;
910 if (*file_version >= 5)
912 do_cpt_step_err(xd, "step", step, list);
916 do_cpt_int_err(xd, "step", &idum, list);
919 do_cpt_double_err(xd, "t", t, list);
920 do_cpt_int_err(xd, "#PP-nodes", nnodes, list);
922 do_cpt_int_err(xd, "dd_nc[x]", dd_nc ? &(dd_nc[0]) : &idum, list);
923 do_cpt_int_err(xd, "dd_nc[y]", dd_nc ? &(dd_nc[1]) : &idum, list);
924 do_cpt_int_err(xd, "dd_nc[z]", dd_nc ? &(dd_nc[2]) : &idum, list);
925 do_cpt_int_err(xd, "#PME-only nodes", npme, list);
926 do_cpt_int_err(xd, "state flags", flags_state, list);
927 if (*file_version >= 4)
929 do_cpt_int_err(xd, "ekin data flags", flags_eks, list);
930 do_cpt_int_err(xd, "energy history flags", flags_enh, list);
935 *flags_enh = (*flags_state >> (estORIRE_DTAV+1));
936 *flags_state = (*flags_state & ~((1<<(estORIRE_DTAV+1)) |
937 (1<<(estORIRE_DTAV+2)) |
938 (1<<(estORIRE_DTAV+3))));
940 if (*file_version >= 14)
942 do_cpt_int_err(xd, "df history flags", flags_dfh, list);
949 if (*file_version >= 15)
951 do_cpt_int_err(xd, "ED data sets", nED, list);
957 if (*file_version >= 16)
959 do_cpt_int_err(xd, "swap", eSwapCoords, list);
963 static int do_cpt_footer(XDR *xd, int file_version)
968 if (file_version >= 2)
971 res = xdr_int(xd, &magic);
976 if (magic != CPT_MAGIC2)
985 static int do_cpt_state(XDR *xd, gmx_bool bRead,
986 int fflags, t_state *state,
996 nnht = state->nhchainlength*state->ngtc;
997 nnhtp = state->nhchainlength*state->nnhpres;
999 if (bRead) /* we need to allocate space for dfhist if we are reading */
1001 init_df_history(&state->dfhist, state->dfhist.nlambda);
1004 sflags = state->flags;
1005 for (i = 0; (i < estNR && ret == 0); i++)
1007 if (fflags & (1<<i))
1011 case estLAMBDA: ret = do_cpte_reals(xd, cptpEST, i, sflags, efptNR, &(state->lambda), list); break;
1012 case estFEPSTATE: ret = do_cpte_int (xd, cptpEST, i, sflags, &state->fep_state, list); break;
1013 case estBOX: ret = do_cpte_matrix(xd, cptpEST, i, sflags, state->box, list); break;
1014 case estBOX_REL: ret = do_cpte_matrix(xd, cptpEST, i, sflags, state->box_rel, list); break;
1015 case estBOXV: ret = do_cpte_matrix(xd, cptpEST, i, sflags, state->boxv, list); break;
1016 case estPRES_PREV: ret = do_cpte_matrix(xd, cptpEST, i, sflags, state->pres_prev, list); break;
1017 case estSVIR_PREV: ret = do_cpte_matrix(xd, cptpEST, i, sflags, state->svir_prev, list); break;
1018 case estFVIR_PREV: ret = do_cpte_matrix(xd, cptpEST, i, sflags, state->fvir_prev, list); break;
1019 case estNH_XI: ret = do_cpte_doubles(xd, cptpEST, i, sflags, nnht, &state->nosehoover_xi, list); break;
1020 case estNH_VXI: ret = do_cpte_doubles(xd, cptpEST, i, sflags, nnht, &state->nosehoover_vxi, list); break;
1021 case estNHPRES_XI: ret = do_cpte_doubles(xd, cptpEST, i, sflags, nnhtp, &state->nhpres_xi, list); break;
1022 case estNHPRES_VXI: ret = do_cpte_doubles(xd, cptpEST, i, sflags, nnhtp, &state->nhpres_vxi, list); break;
1023 case estTC_INT: ret = do_cpte_doubles(xd, cptpEST, i, sflags, state->ngtc, &state->therm_integral, list); break;
1024 case estVETA: ret = do_cpte_real(xd, cptpEST, i, sflags, &state->veta, list); break;
1025 case estVOL0: ret = do_cpte_real(xd, cptpEST, i, sflags, &state->vol0, list); break;
1026 case estX: ret = do_cpte_rvecs(xd, cptpEST, i, sflags, state->natoms, &state->x, list); break;
1027 case estV: ret = do_cpte_rvecs(xd, cptpEST, i, sflags, state->natoms, &state->v, list); break;
1028 case estSDX: ret = do_cpte_rvecs(xd, cptpEST, i, sflags, state->natoms, &state->sd_X, list); break;
1029 /* The RNG entries are no longer written,
1030 * the next 4 lines are only for reading old files.
1032 case estLD_RNG: ret = do_cpte_ints(xd, cptpEST, i, sflags, 0, NULL, list); break;
1033 case estLD_RNGI: ret = do_cpte_ints(xd, cptpEST, i, sflags, 0, NULL, list); break;
1034 case estMC_RNG: ret = do_cpte_ints(xd, cptpEST, i, sflags, 0, NULL, list); break;
1035 case estMC_RNGI: ret = do_cpte_ints(xd, cptpEST, i, sflags, 0, NULL, list); break;
1036 case estDISRE_INITF: ret = do_cpte_real (xd, cptpEST, i, sflags, &state->hist.disre_initf, list); break;
1037 case estDISRE_RM3TAV: ret = do_cpte_n_reals(xd, cptpEST, i, sflags, &state->hist.ndisrepairs, &state->hist.disre_rm3tav, list); break;
1038 case estORIRE_INITF: ret = do_cpte_real (xd, cptpEST, i, sflags, &state->hist.orire_initf, list); break;
1039 case estORIRE_DTAV: ret = do_cpte_n_reals(xd, cptpEST, i, sflags, &state->hist.norire_Dtav, &state->hist.orire_Dtav, list); break;
1041 gmx_fatal(FARGS, "Unknown state entry %d\n"
1042 "You are probably reading a new checkpoint file with old code", i);
1050 static int do_cpt_ekinstate(XDR *xd, int fflags, ekinstate_t *ekins,
1058 for (i = 0; (i < eeksNR && ret == 0); i++)
1060 if (fflags & (1<<i))
1065 case eeksEKIN_N: ret = do_cpte_int(xd, cptpEEKS, i, fflags, &ekins->ekin_n, list); break;
1066 case eeksEKINH: ret = do_cpte_matrices(xd, cptpEEKS, i, fflags, ekins->ekin_n, &ekins->ekinh, list); break;
1067 case eeksEKINF: ret = do_cpte_matrices(xd, cptpEEKS, i, fflags, ekins->ekin_n, &ekins->ekinf, list); break;
1068 case eeksEKINO: ret = do_cpte_matrices(xd, cptpEEKS, i, fflags, ekins->ekin_n, &ekins->ekinh_old, list); break;
1069 case eeksEKINTOTAL: ret = do_cpte_matrix(xd, cptpEEKS, i, fflags, ekins->ekin_total, list); break;
1070 case eeksEKINSCALEF: ret = do_cpte_doubles(xd, cptpEEKS, i, fflags, ekins->ekin_n, &ekins->ekinscalef_nhc, list); break;
1071 case eeksVSCALE: ret = do_cpte_doubles(xd, 1, cptpEEKS, fflags, ekins->ekin_n, &ekins->vscale_nhc, list); break;
1072 case eeksEKINSCALEH: ret = do_cpte_doubles(xd, 1, cptpEEKS, fflags, ekins->ekin_n, &ekins->ekinscaleh_nhc, list); break;
1073 case eeksDEKINDL: ret = do_cpte_real(xd, 1, cptpEEKS, fflags, &ekins->dekindl, list); break;
1074 case eeksMVCOS: ret = do_cpte_real(xd, 1, cptpEEKS, fflags, &ekins->mvcos, list); break;
1076 gmx_fatal(FARGS, "Unknown ekin data state entry %d\n"
1077 "You are probably reading a new checkpoint file with old code", i);
1086 static int do_cpt_swapstate(XDR *xd, gmx_bool bRead, swapstate_t *swapstate, FILE *list)
1090 int swap_cpt_version = 1;
1093 if (eswapNO == swapstate->eSwapCoords)
1098 swapstate->bFromCpt = bRead;
1100 do_cpt_int_err(xd, "swap checkpoint version", &swap_cpt_version, list);
1101 do_cpt_int_err(xd, "swap coupling steps", &swapstate->nAverage, list);
1103 /* When reading, init_swapcoords has not been called yet,
1104 * so we have to allocate memory first. */
1106 for (ic = 0; ic < eCompNR; ic++)
1108 for (ii = 0; ii < eIonNR; ii++)
1112 do_cpt_int_err(xd, "swap requested atoms", &swapstate->nat_req[ic][ii], list);
1116 do_cpt_int_err(xd, "swap requested atoms p", swapstate->nat_req_p[ic][ii], list);
1121 do_cpt_int_err(xd, "swap influx netto", &swapstate->inflow_netto[ic][ii], list);
1125 do_cpt_int_err(xd, "swap influx netto p", swapstate->inflow_netto_p[ic][ii], list);
1128 if (bRead && (NULL == swapstate->nat_past[ic][ii]) )
1130 snew(swapstate->nat_past[ic][ii], swapstate->nAverage);
1133 for (j = 0; j < swapstate->nAverage; j++)
1137 do_cpt_int_err(xd, "swap past atom counts", &swapstate->nat_past[ic][ii][j], list);
1141 do_cpt_int_err(xd, "swap past atom counts p", &swapstate->nat_past_p[ic][ii][j], list);
1147 /* Ion flux per channel */
1148 for (ic = 0; ic < eChanNR; ic++)
1150 for (ii = 0; ii < eIonNR; ii++)
1154 do_cpt_int_err(xd, "channel flux", &swapstate->fluxfromAtoB[ic][ii], list);
1158 do_cpt_int_err(xd, "channel flux p", swapstate->fluxfromAtoB_p[ic][ii], list);
1163 /* Ion flux leakage */
1166 snew(swapstate->fluxleak, 1);
1168 do_cpt_int_err(xd, "flux leakage", swapstate->fluxleak, list);
1171 do_cpt_int_err(xd, "number of ions", &swapstate->nions, list);
1175 snew(swapstate->channel_label, swapstate->nions);
1176 snew(swapstate->comp_from, swapstate->nions);
1179 do_cpt_u_chars(xd, "channel history", swapstate->nions, swapstate->channel_label, list);
1180 do_cpt_u_chars(xd, "domain history", swapstate->nions, swapstate->comp_from, list);
1182 /* Save the last known whole positions to checkpoint
1183 * file to be able to also make multimeric channels whole in PBC */
1184 do_cpt_int_err(xd, "Ch0 atoms", &swapstate->nat[eChan0], list);
1185 do_cpt_int_err(xd, "Ch1 atoms", &swapstate->nat[eChan1], list);
1188 snew(swapstate->xc_old_whole[eChan0], swapstate->nat[eChan0]);
1189 snew(swapstate->xc_old_whole[eChan1], swapstate->nat[eChan1]);
1190 do_cpt_n_rvecs_err(xd, "Ch0 whole x", swapstate->nat[eChan0], swapstate->xc_old_whole[eChan0], list);
1191 do_cpt_n_rvecs_err(xd, "Ch1 whole x", swapstate->nat[eChan1], swapstate->xc_old_whole[eChan1], list);
1195 do_cpt_n_rvecs_err(xd, "Ch0 whole x", swapstate->nat[eChan0], *swapstate->xc_old_whole_p[eChan0], list);
1196 do_cpt_n_rvecs_err(xd, "Ch1 whole x", swapstate->nat[eChan1], *swapstate->xc_old_whole_p[eChan1], list);
1203 static int do_cpt_enerhist(XDR *xd, gmx_bool bRead,
1204 int fflags, energyhistory_t *enerhist,
1215 enerhist->nsteps = 0;
1217 enerhist->nsteps_sim = 0;
1218 enerhist->nsum_sim = 0;
1219 enerhist->dht = NULL;
1221 if (fflags & (1<< eenhENERGY_DELTA_H_NN) )
1223 snew(enerhist->dht, 1);
1224 enerhist->dht->ndh = NULL;
1225 enerhist->dht->dh = NULL;
1226 enerhist->dht->start_lambda_set = FALSE;
1230 for (i = 0; (i < eenhNR && ret == 0); i++)
1232 if (fflags & (1<<i))
1236 case eenhENERGY_N: ret = do_cpte_int(xd, cptpEENH, i, fflags, &enerhist->nener, list); break;
1237 case eenhENERGY_AVER: ret = do_cpte_doubles(xd, cptpEENH, i, fflags, enerhist->nener, &enerhist->ener_ave, list); break;
1238 case eenhENERGY_SUM: ret = do_cpte_doubles(xd, cptpEENH, i, fflags, enerhist->nener, &enerhist->ener_sum, list); break;
1239 case eenhENERGY_NSUM: do_cpt_step_err(xd, eenh_names[i], &enerhist->nsum, list); break;
1240 case eenhENERGY_SUM_SIM: ret = do_cpte_doubles(xd, cptpEENH, i, fflags, enerhist->nener, &enerhist->ener_sum_sim, list); break;
1241 case eenhENERGY_NSUM_SIM: do_cpt_step_err(xd, eenh_names[i], &enerhist->nsum_sim, list); break;
1242 case eenhENERGY_NSTEPS: do_cpt_step_err(xd, eenh_names[i], &enerhist->nsteps, list); break;
1243 case eenhENERGY_NSTEPS_SIM: do_cpt_step_err(xd, eenh_names[i], &enerhist->nsteps_sim, list); break;
1244 case eenhENERGY_DELTA_H_NN: do_cpt_int_err(xd, eenh_names[i], &(enerhist->dht->nndh), list);
1245 if (bRead) /* now allocate memory for it */
1247 snew(enerhist->dht->dh, enerhist->dht->nndh);
1248 snew(enerhist->dht->ndh, enerhist->dht->nndh);
1249 for (j = 0; j < enerhist->dht->nndh; j++)
1251 enerhist->dht->ndh[j] = 0;
1252 enerhist->dht->dh[j] = NULL;
1256 case eenhENERGY_DELTA_H_LIST:
1257 for (j = 0; j < enerhist->dht->nndh; j++)
1259 ret = do_cpte_n_reals(xd, cptpEENH, i, fflags, &enerhist->dht->ndh[j], &(enerhist->dht->dh[j]), list);
1262 case eenhENERGY_DELTA_H_STARTTIME:
1263 ret = do_cpte_double(xd, cptpEENH, i, fflags, &(enerhist->dht->start_time), list); break;
1264 case eenhENERGY_DELTA_H_STARTLAMBDA:
1265 ret = do_cpte_double(xd, cptpEENH, i, fflags, &(enerhist->dht->start_lambda), list); break;
1267 gmx_fatal(FARGS, "Unknown energy history entry %d\n"
1268 "You are probably reading a new checkpoint file with old code", i);
1273 if ((fflags & (1<<eenhENERGY_SUM)) && !(fflags & (1<<eenhENERGY_SUM_SIM)))
1275 /* Assume we have an old file format and copy sum to sum_sim */
1276 srenew(enerhist->ener_sum_sim, enerhist->nener);
1277 for (i = 0; i < enerhist->nener; i++)
1279 enerhist->ener_sum_sim[i] = enerhist->ener_sum[i];
1281 fflags |= (1<<eenhENERGY_SUM_SIM);
1284 if ( (fflags & (1<<eenhENERGY_NSUM)) &&
1285 !(fflags & (1<<eenhENERGY_NSTEPS)))
1287 /* Assume we have an old file format and copy nsum to nsteps */
1288 enerhist->nsteps = enerhist->nsum;
1289 fflags |= (1<<eenhENERGY_NSTEPS);
1291 if ( (fflags & (1<<eenhENERGY_NSUM_SIM)) &&
1292 !(fflags & (1<<eenhENERGY_NSTEPS_SIM)))
1294 /* Assume we have an old file format and copy nsum to nsteps */
1295 enerhist->nsteps_sim = enerhist->nsum_sim;
1296 fflags |= (1<<eenhENERGY_NSTEPS_SIM);
1302 static int do_cpt_df_hist(XDR *xd, int fflags, df_history_t *dfhist, FILE *list)
1307 nlambda = dfhist->nlambda;
1310 for (i = 0; (i < edfhNR && ret == 0); i++)
1312 if (fflags & (1<<i))
1316 case edfhBEQUIL: ret = do_cpte_int(xd, cptpEDFH, i, fflags, &dfhist->bEquil, list); break;
1317 case edfhNATLAMBDA: ret = do_cpte_ints(xd, cptpEDFH, i, fflags, nlambda, &dfhist->n_at_lam, list); break;
1318 case edfhWLHISTO: ret = do_cpte_reals(xd, cptpEDFH, i, fflags, nlambda, &dfhist->wl_histo, list); break;
1319 case edfhWLDELTA: ret = do_cpte_real(xd, cptpEDFH, i, fflags, &dfhist->wl_delta, list); break;
1320 case edfhSUMWEIGHTS: ret = do_cpte_reals(xd, cptpEDFH, i, fflags, nlambda, &dfhist->sum_weights, list); break;
1321 case edfhSUMDG: ret = do_cpte_reals(xd, cptpEDFH, i, fflags, nlambda, &dfhist->sum_dg, list); break;
1322 case edfhSUMMINVAR: ret = do_cpte_reals(xd, cptpEDFH, i, fflags, nlambda, &dfhist->sum_minvar, list); break;
1323 case edfhSUMVAR: ret = do_cpte_reals(xd, cptpEDFH, i, fflags, nlambda, &dfhist->sum_variance, list); break;
1324 case edfhACCUMP: ret = do_cpte_nmatrix(xd, cptpEDFH, i, fflags, nlambda, dfhist->accum_p, list); break;
1325 case edfhACCUMM: ret = do_cpte_nmatrix(xd, cptpEDFH, i, fflags, nlambda, dfhist->accum_m, list); break;
1326 case edfhACCUMP2: ret = do_cpte_nmatrix(xd, cptpEDFH, i, fflags, nlambda, dfhist->accum_p2, list); break;
1327 case edfhACCUMM2: ret = do_cpte_nmatrix(xd, cptpEDFH, i, fflags, nlambda, dfhist->accum_m2, list); break;
1328 case edfhTIJ: ret = do_cpte_nmatrix(xd, cptpEDFH, i, fflags, nlambda, dfhist->Tij, list); break;
1329 case edfhTIJEMP: ret = do_cpte_nmatrix(xd, cptpEDFH, i, fflags, nlambda, dfhist->Tij_empirical, list); break;
1332 gmx_fatal(FARGS, "Unknown df history entry %d\n"
1333 "You are probably reading a new checkpoint file with old code", i);
1342 /* This function stores the last whole configuration of the reference and
1343 * average structure in the .cpt file
1345 static int do_cpt_EDstate(XDR *xd, gmx_bool bRead,
1346 edsamstate_t *EDstate, FILE *list)
1353 EDstate->bFromCpt = bRead;
1355 if (EDstate->nED <= 0)
1360 /* When reading, init_edsam has not been called yet,
1361 * so we have to allocate memory first. */
1364 snew(EDstate->nref, EDstate->nED);
1365 snew(EDstate->old_sref, EDstate->nED);
1366 snew(EDstate->nav, EDstate->nED);
1367 snew(EDstate->old_sav, EDstate->nED);
1370 /* Read/write the last whole conformation of SREF and SAV for each ED dataset (usually only one) */
1371 for (i = 0; i < EDstate->nED; i++)
1373 /* Reference structure SREF */
1374 sprintf(buf, "ED%d # of atoms in reference structure", i+1);
1375 do_cpt_int_err(xd, buf, &EDstate->nref[i], list);
1376 sprintf(buf, "ED%d x_ref", i+1);
1379 snew(EDstate->old_sref[i], EDstate->nref[i]);
1380 do_cpt_n_rvecs_err(xd, buf, EDstate->nref[i], EDstate->old_sref[i], list);
1384 do_cpt_n_rvecs_err(xd, buf, EDstate->nref[i], EDstate->old_sref_p[i], list);
1387 /* Average structure SAV */
1388 sprintf(buf, "ED%d # of atoms in average structure", i+1);
1389 do_cpt_int_err(xd, buf, &EDstate->nav[i], list);
1390 sprintf(buf, "ED%d x_av", i+1);
1393 snew(EDstate->old_sav[i], EDstate->nav[i]);
1394 do_cpt_n_rvecs_err(xd, buf, EDstate->nav[i], EDstate->old_sav[i], list);
1398 do_cpt_n_rvecs_err(xd, buf, EDstate->nav[i], EDstate->old_sav_p[i], list);
1406 static int do_cpt_files(XDR *xd, gmx_bool bRead,
1407 gmx_file_position_t **p_outputfiles, int *nfiles,
1408 FILE *list, int file_version)
1412 gmx_off_t mask = 0xFFFFFFFFL;
1413 int offset_high, offset_low;
1415 gmx_file_position_t *outputfiles;
1417 if (do_cpt_int(xd, "number of output files", nfiles, list) != 0)
1424 snew(*p_outputfiles, *nfiles);
1427 outputfiles = *p_outputfiles;
1429 for (i = 0; i < *nfiles; i++)
1431 /* 64-bit XDR numbers are not portable, so it is stored as separate high/low fractions */
1434 do_cpt_string_err(xd, bRead, "output filename", &buf, list);
1435 strncpy(outputfiles[i].filename, buf, CPTSTRLEN-1);
1441 if (do_cpt_int(xd, "file_offset_high", &offset_high, list) != 0)
1445 if (do_cpt_int(xd, "file_offset_low", &offset_low, list) != 0)
1449 outputfiles[i].offset = ( ((gmx_off_t) offset_high) << 32 ) | ( (gmx_off_t) offset_low & mask );
1453 buf = outputfiles[i].filename;
1454 do_cpt_string_err(xd, bRead, "output filename", &buf, list);
1456 offset = outputfiles[i].offset;
1464 offset_low = (int) (offset & mask);
1465 offset_high = (int) ((offset >> 32) & mask);
1467 if (do_cpt_int(xd, "file_offset_high", &offset_high, list) != 0)
1471 if (do_cpt_int(xd, "file_offset_low", &offset_low, list) != 0)
1476 if (file_version >= 8)
1478 if (do_cpt_int(xd, "file_checksum_size", &(outputfiles[i].chksum_size),
1483 if (do_cpt_u_chars(xd, "file_checksum", 16, outputfiles[i].chksum, list) != 0)
1490 outputfiles[i].chksum_size = -1;
1497 void write_checkpoint(const char *fn, gmx_bool bNumberAndKeep,
1498 FILE *fplog, t_commrec *cr,
1499 int eIntegrator, int simulation_part,
1500 gmx_bool bExpanded, int elamstats,
1501 gmx_int64_t step, double t, t_state *state)
1511 char *fntemp; /* the temporary checkpoint file name */
1513 char timebuf[STRLEN];
1514 int nppnodes, npmenodes, flag_64bit;
1515 char buf[1024], suffix[5+STEPSTRSIZE], sbuf[STEPSTRSIZE];
1516 gmx_file_position_t *outputfiles;
1519 int flags_eks, flags_enh, flags_dfh, i;
1522 if (DOMAINDECOMP(cr))
1524 nppnodes = cr->dd->nnodes;
1525 npmenodes = cr->npmenodes;
1533 #ifndef GMX_NO_RENAME
1534 /* make the new temporary filename */
1535 snew(fntemp, strlen(fn)+5+STEPSTRSIZE);
1537 fntemp[strlen(fn) - strlen(ftp2ext(fn2ftp(fn))) - 1] = '\0';
1538 sprintf(suffix, "_%s%s", "step", gmx_step_str(step, sbuf));
1539 strcat(fntemp, suffix);
1540 strcat(fntemp, fn+strlen(fn) - strlen(ftp2ext(fn2ftp(fn))) - 1);
1542 /* if we can't rename, we just overwrite the cpt file.
1543 * dangerous if interrupted.
1545 snew(fntemp, strlen(fn));
1549 gmx_ctime_r(&now, timebuf, STRLEN);
1553 fprintf(fplog, "Writing checkpoint, step %s at %s\n\n",
1554 gmx_step_str(step, buf), timebuf);
1557 /* Get offsets for open files */
1558 gmx_fio_get_output_file_positions(&outputfiles, &noutputfiles);
1560 fp = gmx_fio_open(fntemp, "w");
1562 if (state->ekinstate.bUpToDate)
1565 ((1<<eeksEKIN_N) | (1<<eeksEKINH) | (1<<eeksEKINF) |
1566 (1<<eeksEKINO) | (1<<eeksEKINSCALEF) | (1<<eeksEKINSCALEH) |
1567 (1<<eeksVSCALE) | (1<<eeksDEKINDL) | (1<<eeksMVCOS));
1575 if (state->enerhist.nsum > 0 || state->enerhist.nsum_sim > 0)
1577 flags_enh |= (1<<eenhENERGY_N);
1578 if (state->enerhist.nsum > 0)
1580 flags_enh |= ((1<<eenhENERGY_AVER) | (1<<eenhENERGY_SUM) |
1581 (1<<eenhENERGY_NSTEPS) | (1<<eenhENERGY_NSUM));
1583 if (state->enerhist.nsum_sim > 0)
1585 flags_enh |= ((1<<eenhENERGY_SUM_SIM) | (1<<eenhENERGY_NSTEPS_SIM) |
1586 (1<<eenhENERGY_NSUM_SIM));
1588 if (state->enerhist.dht)
1590 flags_enh |= ( (1<< eenhENERGY_DELTA_H_NN) |
1591 (1<< eenhENERGY_DELTA_H_LIST) |
1592 (1<< eenhENERGY_DELTA_H_STARTTIME) |
1593 (1<< eenhENERGY_DELTA_H_STARTLAMBDA) );
1599 flags_dfh = ((1<<edfhBEQUIL) | (1<<edfhNATLAMBDA) | (1<<edfhSUMWEIGHTS) | (1<<edfhSUMDG) |
1600 (1<<edfhTIJ) | (1<<edfhTIJEMP));
1603 flags_dfh |= ((1<<edfhWLDELTA) | (1<<edfhWLHISTO));
1605 if ((elamstats == elamstatsMINVAR) || (elamstats == elamstatsBARKER) || (elamstats == elamstatsMETROPOLIS))
1607 flags_dfh |= ((1<<edfhACCUMP) | (1<<edfhACCUMM) | (1<<edfhACCUMP2) | (1<<edfhACCUMM2)
1608 | (1<<edfhSUMMINVAR) | (1<<edfhSUMVAR));
1616 /* We can check many more things now (CPU, acceleration, etc), but
1617 * it is highly unlikely to have two separate builds with exactly
1618 * the same version, user, time, and build host!
1621 version = gmx_strdup(gmx_version());
1622 btime = gmx_strdup(BUILD_TIME);
1623 buser = gmx_strdup(BUILD_USER);
1624 bhost = gmx_strdup(BUILD_HOST);
1626 double_prec = GMX_CPT_BUILD_DP;
1627 fprog = gmx_strdup(Program());
1629 ftime = &(timebuf[0]);
1631 do_cpt_header(gmx_fio_getxdr(fp), FALSE, &file_version,
1632 &version, &btime, &buser, &bhost, &double_prec, &fprog, &ftime,
1633 &eIntegrator, &simulation_part, &step, &t, &nppnodes,
1634 DOMAINDECOMP(cr) ? cr->dd->nc : NULL, &npmenodes,
1635 &state->natoms, &state->ngtc, &state->nnhpres,
1636 &state->nhchainlength, &(state->dfhist.nlambda), &state->flags, &flags_eks, &flags_enh, &flags_dfh,
1637 &state->edsamstate.nED, &state->swapstate.eSwapCoords,
1646 if ((do_cpt_state(gmx_fio_getxdr(fp), FALSE, state->flags, state, NULL) < 0) ||
1647 (do_cpt_ekinstate(gmx_fio_getxdr(fp), flags_eks, &state->ekinstate, NULL) < 0) ||
1648 (do_cpt_enerhist(gmx_fio_getxdr(fp), FALSE, flags_enh, &state->enerhist, NULL) < 0) ||
1649 (do_cpt_df_hist(gmx_fio_getxdr(fp), flags_dfh, &state->dfhist, NULL) < 0) ||
1650 (do_cpt_EDstate(gmx_fio_getxdr(fp), FALSE, &state->edsamstate, NULL) < 0) ||
1651 (do_cpt_swapstate(gmx_fio_getxdr(fp), FALSE, &state->swapstate, NULL) < 0) ||
1652 (do_cpt_files(gmx_fio_getxdr(fp), FALSE, &outputfiles, &noutputfiles, NULL,
1655 gmx_file("Cannot read/write checkpoint; corrupt file, or maybe you are out of disk space?");
1658 do_cpt_footer(gmx_fio_getxdr(fp), file_version);
1660 /* we really, REALLY, want to make sure to physically write the checkpoint,
1661 and all the files it depends on, out to disk. Because we've
1662 opened the checkpoint with gmx_fio_open(), it's in our list
1664 ret = gmx_fio_all_output_fsync();
1670 "Cannot fsync '%s'; maybe you are out of disk space?",
1671 gmx_fio_getname(ret));
1673 if (getenv(GMX_IGNORE_FSYNC_FAILURE_ENV) == NULL)
1683 if (gmx_fio_close(fp) != 0)
1685 gmx_file("Cannot read/write checkpoint; corrupt file, or maybe you are out of disk space?");
1688 /* we don't move the checkpoint if the user specified they didn't want it,
1689 or if the fsyncs failed */
1690 #ifndef GMX_NO_RENAME
1691 if (!bNumberAndKeep && !ret)
1695 /* Rename the previous checkpoint file */
1697 buf[strlen(fn) - strlen(ftp2ext(fn2ftp(fn))) - 1] = '\0';
1698 strcat(buf, "_prev");
1699 strcat(buf, fn+strlen(fn) - strlen(ftp2ext(fn2ftp(fn))) - 1);
1701 /* we copy here so that if something goes wrong between now and
1702 * the rename below, there's always a state.cpt.
1703 * If renames are atomic (such as in POSIX systems),
1704 * this copying should be unneccesary.
1706 gmx_file_copy(fn, buf, FALSE);
1707 /* We don't really care if this fails:
1708 * there's already a new checkpoint.
1711 gmx_file_rename(fn, buf);
1714 if (gmx_file_rename(fntemp, fn) != 0)
1716 gmx_file("Cannot rename checkpoint file; maybe you are out of disk space?");
1719 #endif /* GMX_NO_RENAME */
1725 /*code for alternate checkpointing scheme. moved from top of loop over
1727 fcRequestCheckPoint();
1728 if (fcCheckPointParallel( cr->nodeid, NULL, 0) == 0)
1730 gmx_fatal( 3, __FILE__, __LINE__, "Checkpoint error on step %d\n", step );
1732 #endif /* end GMX_FAHCORE block */
1735 static void print_flag_mismatch(FILE *fplog, int sflags, int fflags)
1739 fprintf(fplog, "\nState entry mismatch between the simulation and the checkpoint file\n");
1740 fprintf(fplog, "Entries which are not present in the checkpoint file will not be updated\n");
1741 fprintf(fplog, " %24s %11s %11s\n", "", "simulation", "checkpoint");
1742 for (i = 0; i < estNR; i++)
1744 if ((sflags & (1<<i)) || (fflags & (1<<i)))
1746 fprintf(fplog, " %24s %11s %11s\n",
1748 (sflags & (1<<i)) ? " present " : "not present",
1749 (fflags & (1<<i)) ? " present " : "not present");
1754 static void check_int(FILE *fplog, const char *type, int p, int f, gmx_bool *mm)
1756 FILE *fp = fplog ? fplog : stderr;
1760 fprintf(fp, " %s mismatch,\n", type);
1761 fprintf(fp, " current program: %d\n", p);
1762 fprintf(fp, " checkpoint file: %d\n", f);
1768 static void check_string(FILE *fplog, const char *type, const char *p,
1769 const char *f, gmx_bool *mm)
1771 FILE *fp = fplog ? fplog : stderr;
1773 if (strcmp(p, f) != 0)
1775 fprintf(fp, " %s mismatch,\n", type);
1776 fprintf(fp, " current program: %s\n", p);
1777 fprintf(fp, " checkpoint file: %s\n", f);
1783 static void check_match(FILE *fplog,
1785 char *btime, char *buser, char *bhost, int double_prec,
1787 t_commrec *cr, int npp_f, int npme_f,
1788 ivec dd_nc, ivec dd_nc_f)
1795 check_string(fplog, "Version", gmx_version(), version, &mm);
1796 check_string(fplog, "Build time", BUILD_TIME, btime, &mm);
1797 check_string(fplog, "Build user", BUILD_USER, buser, &mm);
1798 check_string(fplog, "Build host", BUILD_HOST, bhost, &mm);
1799 check_int (fplog, "Double prec.", GMX_CPT_BUILD_DP, double_prec, &mm);
1800 check_string(fplog, "Program name", Program(), fprog, &mm);
1802 check_int (fplog, "#nodes", cr->nnodes, npp_f+npme_f, &mm);
1805 check_int (fplog, "#PME-nodes", cr->npmenodes, npme_f, &mm);
1808 if (cr->npmenodes >= 0)
1810 npp -= cr->npmenodes;
1814 check_int (fplog, "#DD-cells[x]", dd_nc[XX], dd_nc_f[XX], &mm);
1815 check_int (fplog, "#DD-cells[y]", dd_nc[YY], dd_nc_f[YY], &mm);
1816 check_int (fplog, "#DD-cells[z]", dd_nc[ZZ], dd_nc_f[ZZ], &mm);
1823 "Gromacs binary or parallel settings not identical to previous run.\n"
1824 "Continuation is exact, but is not guaranteed to be binary identical%s.\n\n",
1825 fplog ? ",\n see the log file for details" : "");
1830 "Gromacs binary or parallel settings not identical to previous run.\n"
1831 "Continuation is exact, but is not guaranteed to be binary identical.\n\n");
1836 static void read_checkpoint(const char *fn, FILE **pfplog,
1837 t_commrec *cr, ivec dd_nc,
1838 int eIntegrator, int *init_fep_state, gmx_int64_t *step, double *t,
1839 t_state *state, gmx_bool *bReadEkin,
1840 int *simulation_part,
1841 gmx_bool bAppendOutputFiles, gmx_bool bForceAppend)
1846 char *version, *btime, *buser, *bhost, *fprog, *ftime;
1848 char filename[STRLEN], buf[STEPSTRSIZE];
1849 int nppnodes, eIntegrator_f, nppnodes_f, npmenodes_f;
1851 int natoms, ngtc, nnhpres, nhchainlength, nlambda, fflags, flags_eks, flags_enh, flags_dfh;
1854 gmx_file_position_t *outputfiles;
1856 t_fileio *chksum_file;
1857 FILE * fplog = *pfplog;
1858 unsigned char digest[16];
1859 #if !defined __native_client__ && !defined GMX_NATIVE_WINDOWS
1860 struct flock fl; /* don't initialize here: the struct order is OS
1864 const char *int_warn =
1865 "WARNING: The checkpoint file was generated with integrator %s,\n"
1866 " while the simulation uses integrator %s\n\n";
1868 #if !defined __native_client__ && !defined GMX_NATIVE_WINDOWS
1869 fl.l_type = F_WRLCK;
1870 fl.l_whence = SEEK_SET;
1876 fp = gmx_fio_open(fn, "r");
1877 do_cpt_header(gmx_fio_getxdr(fp), TRUE, &file_version,
1878 &version, &btime, &buser, &bhost, &double_prec, &fprog, &ftime,
1879 &eIntegrator_f, simulation_part, step, t,
1880 &nppnodes_f, dd_nc_f, &npmenodes_f,
1881 &natoms, &ngtc, &nnhpres, &nhchainlength, &nlambda,
1882 &fflags, &flags_eks, &flags_enh, &flags_dfh,
1883 &state->edsamstate.nED, &state->swapstate.eSwapCoords, NULL);
1885 if (bAppendOutputFiles &&
1886 file_version >= 13 && double_prec != GMX_CPT_BUILD_DP)
1888 gmx_fatal(FARGS, "Output file appending requested, but the code and checkpoint file precision (single/double) don't match");
1891 if (cr == NULL || MASTER(cr))
1893 fprintf(stderr, "\nReading checkpoint file %s generated: %s\n\n",
1897 /* This will not be written if we do appending, since fplog is still NULL then */
1900 fprintf(fplog, "\n");
1901 fprintf(fplog, "Reading checkpoint file %s\n", fn);
1902 fprintf(fplog, " file generated by: %s\n", fprog);
1903 fprintf(fplog, " file generated at: %s\n", ftime);
1904 fprintf(fplog, " GROMACS build time: %s\n", btime);
1905 fprintf(fplog, " GROMACS build user: %s\n", buser);
1906 fprintf(fplog, " GROMACS build host: %s\n", bhost);
1907 fprintf(fplog, " GROMACS double prec.: %d\n", double_prec);
1908 fprintf(fplog, " simulation part #: %d\n", *simulation_part);
1909 fprintf(fplog, " step: %s\n", gmx_step_str(*step, buf));
1910 fprintf(fplog, " time: %f\n", *t);
1911 fprintf(fplog, "\n");
1914 if (natoms != state->natoms)
1916 gmx_fatal(FARGS, "Checkpoint file is for a system of %d atoms, while the current system consists of %d atoms", natoms, state->natoms);
1918 if (ngtc != state->ngtc)
1920 gmx_fatal(FARGS, "Checkpoint file is for a system of %d T-coupling groups, while the current system consists of %d T-coupling groups", ngtc, state->ngtc);
1922 if (nnhpres != state->nnhpres)
1924 gmx_fatal(FARGS, "Checkpoint file is for a system of %d NH-pressure-coupling variables, while the current system consists of %d NH-pressure-coupling variables", nnhpres, state->nnhpres);
1927 if (nlambda != state->dfhist.nlambda)
1929 gmx_fatal(FARGS, "Checkpoint file is for a system with %d lambda states, while the current system consists of %d lambda states", nlambda, state->dfhist.nlambda);
1932 init_gtc_state(state, state->ngtc, state->nnhpres, nhchainlength); /* need to keep this here to keep the tpr format working */
1933 /* write over whatever was read; we use the number of Nose-Hoover chains from the checkpoint */
1935 if (eIntegrator_f != eIntegrator)
1939 fprintf(stderr, int_warn, EI(eIntegrator_f), EI(eIntegrator));
1941 if (bAppendOutputFiles)
1944 "Output file appending requested, but input/checkpoint integrators do not match.\n"
1945 "Stopping the run to prevent you from ruining all your data...\n"
1946 "If you _really_ know what you are doing, try with the -noappend option.\n");
1950 fprintf(fplog, int_warn, EI(eIntegrator_f), EI(eIntegrator));
1959 else if (cr->nnodes == nppnodes_f + npmenodes_f)
1961 if (cr->npmenodes < 0)
1963 cr->npmenodes = npmenodes_f;
1965 nppnodes = cr->nnodes - cr->npmenodes;
1966 if (nppnodes == nppnodes_f)
1968 for (d = 0; d < DIM; d++)
1972 dd_nc[d] = dd_nc_f[d];
1979 /* The number of PP nodes has not been set yet */
1983 if (fflags != state->flags)
1988 if (bAppendOutputFiles)
1991 "Output file appending requested, but input and checkpoint states are not identical.\n"
1992 "Stopping the run to prevent you from ruining all your data...\n"
1993 "You can try with the -noappend option, and get more info in the log file.\n");
1996 if (getenv("GMX_ALLOW_CPT_MISMATCH") == NULL)
1998 gmx_fatal(FARGS, "You seem to have switched ensemble, integrator, T and/or P-coupling algorithm between the cpt and tpr file. The recommended way of doing this is passing the cpt file to grompp (with option -t) instead of to mdrun. If you know what you are doing, you can override this error by setting the env.var. GMX_ALLOW_CPT_MISMATCH");
2003 "WARNING: The checkpoint state entries do not match the simulation,\n"
2004 " see the log file for details\n\n");
2010 print_flag_mismatch(fplog, state->flags, fflags);
2017 check_match(fplog, version, btime, buser, bhost, double_prec, fprog,
2018 cr, nppnodes_f, npmenodes_f, dd_nc, dd_nc_f);
2021 ret = do_cpt_state(gmx_fio_getxdr(fp), TRUE, fflags, state, NULL);
2022 *init_fep_state = state->fep_state; /* there should be a better way to do this than setting it here.
2023 Investigate for 5.0. */
2028 ret = do_cpt_ekinstate(gmx_fio_getxdr(fp), flags_eks, &state->ekinstate, NULL);
2033 *bReadEkin = ((flags_eks & (1<<eeksEKINH)) || (flags_eks & (1<<eeksEKINF)) || (flags_eks & (1<<eeksEKINO)) ||
2034 ((flags_eks & (1<<eeksEKINSCALEF)) | (flags_eks & (1<<eeksEKINSCALEH)) | (flags_eks & (1<<eeksVSCALE))));
2036 ret = do_cpt_enerhist(gmx_fio_getxdr(fp), TRUE,
2037 flags_enh, &state->enerhist, NULL);
2043 if (file_version < 6)
2045 const char *warn = "Reading checkpoint file in old format, assuming that the run that generated this file started at step 0, if this is not the case the averages stored in the energy file will be incorrect.";
2047 fprintf(stderr, "\nWARNING: %s\n\n", warn);
2050 fprintf(fplog, "\nWARNING: %s\n\n", warn);
2052 state->enerhist.nsum = *step;
2053 state->enerhist.nsum_sim = *step;
2056 ret = do_cpt_df_hist(gmx_fio_getxdr(fp), flags_dfh, &state->dfhist, NULL);
2062 ret = do_cpt_swapstate(gmx_fio_getxdr(fp), TRUE, &state->swapstate, NULL);
2068 ret = do_cpt_EDstate(gmx_fio_getxdr(fp), TRUE, &state->edsamstate, NULL);
2074 ret = do_cpt_files(gmx_fio_getxdr(fp), TRUE, &outputfiles, &nfiles, NULL, file_version);
2080 ret = do_cpt_footer(gmx_fio_getxdr(fp), file_version);
2085 if (gmx_fio_close(fp) != 0)
2087 gmx_file("Cannot read/write checkpoint; corrupt file, or maybe you are out of disk space?");
2096 /* If the user wants to append to output files,
2097 * we use the file pointer positions of the output files stored
2098 * in the checkpoint file and truncate the files such that any frames
2099 * written after the checkpoint time are removed.
2100 * All files are md5sum checked such that we can be sure that
2101 * we do not truncate other (maybe imprortant) files.
2103 if (bAppendOutputFiles)
2105 if (fn2ftp(outputfiles[0].filename) != efLOG)
2107 /* make sure first file is log file so that it is OK to use it for
2110 gmx_fatal(FARGS, "The first output file should always be the log "
2111 "file but instead is: %s. Cannot do appending because of this condition.", outputfiles[0].filename);
2113 for (i = 0; i < nfiles; i++)
2115 if (outputfiles[i].offset < 0)
2117 gmx_fatal(FARGS, "The original run wrote a file called '%s' which "
2118 "is larger than 2 GB, but mdrun did not support large file"
2119 " offsets. Can not append. Run mdrun with -noappend",
2120 outputfiles[i].filename);
2123 chksum_file = gmx_fio_open(outputfiles[i].filename, "a");
2126 chksum_file = gmx_fio_open(outputfiles[i].filename, "r+");
2131 /* Note that there are systems where the lock operation
2132 * will succeed, but a second process can also lock the file.
2133 * We should probably try to detect this.
2135 #if defined __native_client__
2139 #elif defined GMX_NATIVE_WINDOWS
2140 if (_locking(fileno(gmx_fio_getfp(chksum_file)), _LK_NBLCK, LONG_MAX) == -1)
2142 if (fcntl(fileno(gmx_fio_getfp(chksum_file)), F_SETLK, &fl) == -1)
2145 if (errno == ENOSYS)
2149 gmx_fatal(FARGS, "File locking is not supported on this system. Use -noappend or specify -append explicitly to append anyhow.");
2153 fprintf(stderr, "\nNOTE: File locking is not supported on this system, will not lock %s\n\n", outputfiles[i].filename);
2156 fprintf(fplog, "\nNOTE: File locking not supported on this system, will not lock %s\n\n", outputfiles[i].filename);
2160 else if (errno == EACCES || errno == EAGAIN)
2162 gmx_fatal(FARGS, "Failed to lock: %s. Already running "
2163 "simulation?", outputfiles[i].filename);
2167 gmx_fatal(FARGS, "Failed to lock: %s. %s.",
2168 outputfiles[i].filename, strerror(errno));
2173 /* compute md5 chksum */
2174 if (outputfiles[i].chksum_size != -1)
2176 if (gmx_fio_get_file_md5(chksum_file, outputfiles[i].offset,
2177 digest) != outputfiles[i].chksum_size) /*at the end of the call the file position is at the end of the file*/
2179 gmx_fatal(FARGS, "Can't read %d bytes of '%s' to compute checksum. The file has been replaced or its contents have been modified. Cannot do appending because of this condition.",
2180 outputfiles[i].chksum_size,
2181 outputfiles[i].filename);
2184 if (i == 0) /*log file needs to be seeked in case we need to truncate (other files are truncated below)*/
2186 if (gmx_fio_seek(chksum_file, outputfiles[i].offset))
2188 gmx_fatal(FARGS, "Seek error! Failed to truncate log-file: %s.", strerror(errno));
2193 if (i == 0) /*open log file here - so that lock is never lifted
2194 after chksum is calculated */
2196 *pfplog = gmx_fio_getfp(chksum_file);
2200 gmx_fio_close(chksum_file);
2203 /* compare md5 chksum */
2204 if (outputfiles[i].chksum_size != -1 &&
2205 memcmp(digest, outputfiles[i].chksum, 16) != 0)
2209 fprintf(debug, "chksum for %s: ", outputfiles[i].filename);
2210 for (j = 0; j < 16; j++)
2212 fprintf(debug, "%02x", digest[j]);
2214 fprintf(debug, "\n");
2216 gmx_fatal(FARGS, "Checksum wrong for '%s'. The file has been replaced or its contents have been modified. Cannot do appending because of this condition.",
2217 outputfiles[i].filename);
2222 if (i != 0) /*log file is already seeked to correct position */
2224 #ifdef GMX_NATIVE_WINDOWS
2225 rc = gmx_wintruncate(outputfiles[i].filename, outputfiles[i].offset);
2227 rc = truncate(outputfiles[i].filename, outputfiles[i].offset);
2231 gmx_fatal(FARGS, "Truncation of file %s failed. Cannot do appending because of this failure.", outputfiles[i].filename);
2241 void load_checkpoint(const char *fn, FILE **fplog,
2242 t_commrec *cr, ivec dd_nc,
2243 t_inputrec *ir, t_state *state,
2244 gmx_bool *bReadEkin,
2245 gmx_bool bAppend, gmx_bool bForceAppend)
2252 /* Read the state from the checkpoint file */
2253 read_checkpoint(fn, fplog,
2255 ir->eI, &(ir->fepvals->init_fep_state), &step, &t, state, bReadEkin,
2256 &ir->simulation_part, bAppend, bForceAppend);
2260 gmx_bcast(sizeof(cr->npmenodes), &cr->npmenodes, cr);
2261 gmx_bcast(DIM*sizeof(dd_nc[0]), dd_nc, cr);
2262 gmx_bcast(sizeof(step), &step, cr);
2263 gmx_bcast(sizeof(*bReadEkin), bReadEkin, cr);
2265 ir->bContinuation = TRUE;
2266 if (ir->nsteps >= 0)
2268 ir->nsteps += ir->init_step - step;
2270 ir->init_step = step;
2271 ir->simulation_part += 1;
2274 static void read_checkpoint_data(t_fileio *fp, int *simulation_part,
2275 gmx_int64_t *step, double *t, t_state *state,
2276 int *nfiles, gmx_file_position_t **outputfiles)
2279 char *version, *btime, *buser, *bhost, *fprog, *ftime;
2284 int flags_eks, flags_enh, flags_dfh;
2286 gmx_file_position_t *files_loc = NULL;
2289 do_cpt_header(gmx_fio_getxdr(fp), TRUE, &file_version,
2290 &version, &btime, &buser, &bhost, &double_prec, &fprog, &ftime,
2291 &eIntegrator, simulation_part, step, t, &nppnodes, dd_nc, &npme,
2292 &state->natoms, &state->ngtc, &state->nnhpres, &state->nhchainlength,
2293 &(state->dfhist.nlambda), &state->flags, &flags_eks, &flags_enh, &flags_dfh,
2294 &state->edsamstate.nED, &state->swapstate.eSwapCoords, NULL);
2296 do_cpt_state(gmx_fio_getxdr(fp), TRUE, state->flags, state, NULL);
2301 ret = do_cpt_ekinstate(gmx_fio_getxdr(fp), flags_eks, &state->ekinstate, NULL);
2306 ret = do_cpt_enerhist(gmx_fio_getxdr(fp), TRUE,
2307 flags_enh, &state->enerhist, NULL);
2312 ret = do_cpt_df_hist(gmx_fio_getxdr(fp), flags_dfh, &state->dfhist, NULL);
2318 ret = do_cpt_EDstate(gmx_fio_getxdr(fp), TRUE, &state->edsamstate, NULL);
2324 ret = do_cpt_swapstate(gmx_fio_getxdr(fp), TRUE, &state->swapstate, NULL);
2330 ret = do_cpt_files(gmx_fio_getxdr(fp), TRUE,
2331 outputfiles != NULL ? outputfiles : &files_loc,
2332 outputfiles != NULL ? nfiles : &nfiles_loc,
2333 NULL, file_version);
2334 if (files_loc != NULL)
2344 ret = do_cpt_footer(gmx_fio_getxdr(fp), file_version);
2358 read_checkpoint_state(const char *fn, int *simulation_part,
2359 gmx_int64_t *step, double *t, t_state *state)
2363 fp = gmx_fio_open(fn, "r");
2364 read_checkpoint_data(fp, simulation_part, step, t, state, NULL, NULL);
2365 if (gmx_fio_close(fp) != 0)
2367 gmx_file("Cannot read/write checkpoint; corrupt file, or maybe you are out of disk space?");
2371 void read_checkpoint_trxframe(t_fileio *fp, t_trxframe *fr)
2373 /* This next line is nasty because the sub-structures of t_state
2374 * cannot be assumed to be zeroed (or even initialized in ways the
2375 * rest of the code might assume). Using snew would be better, but
2376 * this will all go away for 5.0. */
2378 int simulation_part;
2382 init_state(&state, 0, 0, 0, 0, 0);
2384 read_checkpoint_data(fp, &simulation_part, &step, &t, &state, NULL, NULL);
2386 fr->natoms = state.natoms;
2389 fr->step = gmx_int64_to_int(step,
2390 "conversion of checkpoint to trajectory");
2394 fr->lambda = state.lambda[efptFEP];
2395 fr->fep_state = state.fep_state;
2397 fr->bX = (state.flags & (1<<estX));
2403 fr->bV = (state.flags & (1<<estV));
2410 fr->bBox = (state.flags & (1<<estBOX));
2413 copy_mat(state.box, fr->box);
2418 void list_checkpoint(const char *fn, FILE *out)
2422 char *version, *btime, *buser, *bhost, *fprog, *ftime;
2424 int eIntegrator, simulation_part, nppnodes, npme;
2429 int flags_eks, flags_enh, flags_dfh;
2433 gmx_file_position_t *outputfiles;
2436 init_state(&state, -1, -1, -1, -1, 0);
2438 fp = gmx_fio_open(fn, "r");
2439 do_cpt_header(gmx_fio_getxdr(fp), TRUE, &file_version,
2440 &version, &btime, &buser, &bhost, &double_prec, &fprog, &ftime,
2441 &eIntegrator, &simulation_part, &step, &t, &nppnodes, dd_nc, &npme,
2442 &state.natoms, &state.ngtc, &state.nnhpres, &state.nhchainlength,
2443 &(state.dfhist.nlambda), &state.flags,
2444 &flags_eks, &flags_enh, &flags_dfh, &state.edsamstate.nED,
2445 &state.swapstate.eSwapCoords, out);
2446 ret = do_cpt_state(gmx_fio_getxdr(fp), TRUE, state.flags, &state, out);
2451 ret = do_cpt_ekinstate(gmx_fio_getxdr(fp), flags_eks, &state.ekinstate, out);
2456 ret = do_cpt_enerhist(gmx_fio_getxdr(fp), TRUE,
2457 flags_enh, &state.enerhist, out);
2461 ret = do_cpt_df_hist(gmx_fio_getxdr(fp),
2462 flags_dfh, &state.dfhist, out);
2467 ret = do_cpt_EDstate(gmx_fio_getxdr(fp), TRUE, &state.edsamstate, out);
2472 ret = do_cpt_swapstate(gmx_fio_getxdr(fp), TRUE, &state.swapstate, out);
2477 do_cpt_files(gmx_fio_getxdr(fp), TRUE, &outputfiles, &nfiles, out, file_version);
2482 ret = do_cpt_footer(gmx_fio_getxdr(fp), file_version);
2489 if (gmx_fio_close(fp) != 0)
2491 gmx_file("Cannot read/write checkpoint; corrupt file, or maybe you are out of disk space?");
2498 static gmx_bool exist_output_file(const char *fnm_cp, int nfile, const t_filenm fnm[])
2502 /* Check if the output file name stored in the checkpoint file
2503 * is one of the output file names of mdrun.
2507 !(is_output(&fnm[i]) && strcmp(fnm_cp, fnm[i].fns[0]) == 0))
2512 return (i < nfile && gmx_fexist(fnm_cp));
2515 /* This routine cannot print tons of data, since it is called before the log file is opened. */
2516 gmx_bool read_checkpoint_simulation_part(const char *filename, int *simulation_part,
2517 gmx_int64_t *cpt_step, t_commrec *cr,
2518 gmx_bool bAppendReq,
2519 int nfile, const t_filenm fnm[],
2520 const char *part_suffix, gmx_bool *bAddPart)
2523 gmx_int64_t step = 0;
2525 /* This next line is nasty because the sub-structures of t_state
2526 * cannot be assumed to be zeroed (or even initialized in ways the
2527 * rest of the code might assume). Using snew would be better, but
2528 * this will all go away for 5.0. */
2531 gmx_file_position_t *outputfiles;
2534 char *fn, suf_up[STRLEN];
2540 if (!gmx_fexist(filename) || (!(fp = gmx_fio_open(filename, "r")) ))
2542 *simulation_part = 0;
2546 init_state(&state, 0, 0, 0, 0, 0);
2548 read_checkpoint_data(fp, simulation_part, &step, &t, &state,
2549 &nfiles, &outputfiles);
2550 if (gmx_fio_close(fp) != 0)
2552 gmx_file("Cannot read/write checkpoint; corrupt file, or maybe you are out of disk space?");
2559 for (f = 0; f < nfiles; f++)
2561 if (exist_output_file(outputfiles[f].filename, nfile, fnm))
2566 if (nexist == nfiles)
2568 bAppend = bAppendReq;
2570 else if (nexist > 0)
2573 "Output file appending has been requested,\n"
2574 "but some output files listed in the checkpoint file %s\n"
2575 "are not present or are named differently by the current program:\n",
2577 fprintf(stderr, "output files present:");
2578 for (f = 0; f < nfiles; f++)
2580 if (exist_output_file(outputfiles[f].filename,
2583 fprintf(stderr, " %s", outputfiles[f].filename);
2586 fprintf(stderr, "\n");
2587 fprintf(stderr, "output files not present or named differently:");
2588 for (f = 0; f < nfiles; f++)
2590 if (!exist_output_file(outputfiles[f].filename,
2593 fprintf(stderr, " %s", outputfiles[f].filename);
2596 fprintf(stderr, "\n");
2598 gmx_fatal(FARGS, "File appending requested, but only %d of the %d output files are present", nexist, nfiles);
2606 gmx_fatal(FARGS, "File appending requested, but no output file information is stored in the checkpoint file");
2608 fn = outputfiles[0].filename;
2609 if (strlen(fn) < 4 ||
2610 gmx_strcasecmp(fn+strlen(fn)-4, ftp2ext(efLOG)) == 0)
2612 gmx_fatal(FARGS, "File appending requested, but the log file is not the first file listed in the checkpoint file");
2614 /* Set bAddPart to whether the suffix string '.part' is present
2615 * in the log file name.
2617 strcpy(suf_up, part_suffix);
2619 *bAddPart = (strstr(fn, part_suffix) != NULL ||
2620 strstr(fn, suf_up) != NULL);
2628 gmx_bcast(sizeof(*simulation_part), simulation_part, cr);
2630 if (*simulation_part > 0 && bAppendReq)
2632 gmx_bcast(sizeof(bAppend), &bAppend, cr);
2633 gmx_bcast(sizeof(*bAddPart), bAddPart, cr);
2636 if (NULL != cpt_step)