Bug Summary

File:gromacs/gmxlib/checkpoint.c
Location:line 1959, column 9
Description:Value stored to 'nppnodes' is never read

Annotated Source Code

1/*
2 * This file is part of the GROMACS molecular simulation package.
3 *
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.
8 *
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.
13 *
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.
18 *
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.
23 *
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.
31 *
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.
34 */
35
36/* The source code in this file should be thread-safe.
37 Please keep it that way. */
38
39
40#ifdef HAVE_CONFIG_H1
41#include <config.h>
42#endif
43
44#include <errno(*__errno_location ()).h>
45#include <stdlib.h>
46#include <string.h>
47#include <time.h>
48
49#include <fcntl.h>
50#ifdef HAVE_SYS_TIME_H
51#include <sys/time.h>
52#endif
53
54#ifdef HAVE_UNISTD_H
55#include <unistd.h>
56#endif
57
58#ifdef GMX_NATIVE_WINDOWS
59/* _chsize_s */
60#include <io.h>
61#include <sys/locking.h>
62#endif
63
64#include "copyrite.h"
65#include "names.h"
66#include "typedefs.h"
67#include "types/commrec.h"
68#include "gromacs/utility/smalloc.h"
69#include "txtdump.h"
70#include "gromacs/math/vec.h"
71#include "network.h"
72#include "checkpoint.h"
73#include "gromacs/utility/cstringutil.h"
74
75#include "gromacs/fileio/filenm.h"
76#include "gromacs/utility/futil.h"
77#include "gromacs/fileio/gmxfio.h"
78#include "gromacs/fileio/xdrf.h"
79#include "gromacs/fileio/xdr_datatype.h"
80#include "gromacs/utility/basenetwork.h"
81#include "gromacs/utility/baseversion.h"
82#include "gromacs/utility/fatalerror.h"
83
84#include "buildinfo.h"
85
86#ifdef GMX_FAHCORE
87#include "corewrap.h"
88#endif
89
90#define CPT_MAGIC1171817 171817
91#define CPT_MAGIC2171819 171819
92#define CPTSTRLEN1024 1024
93
94#ifdef GMX_DOUBLE
95#define GMX_CPT_BUILD_DP0 1
96#else
97#define GMX_CPT_BUILD_DP0 0
98#endif
99
100/* cpt_version should normally only be changed
101 * when the header of footer format changes.
102 * The state data format itself is backward and forward compatible.
103 * But old code can not read a new entry that is present in the file
104 * (but can read a new format when new entries are not present).
105 */
106static const int cpt_version = 16;
107
108
109const char *est_names[estNR] =
110{
111 "FE-lambda",
112 "box", "box-rel", "box-v", "pres_prev",
113 "nosehoover-xi", "thermostat-integral",
114 "x", "v", "SDx", "CGp", "LD-rng", "LD-rng-i",
115 "disre_initf", "disre_rm3tav",
116 "orire_initf", "orire_Dtav",
117 "svir_prev", "nosehoover-vxi", "v_eta", "vol0", "nhpres_xi", "nhpres_vxi", "fvir_prev", "fep_state", "MC-rng", "MC-rng-i"
118};
119
120enum {
121 eeksEKIN_N, eeksEKINH, eeksDEKINDL, eeksMVCOS, eeksEKINF, eeksEKINO, eeksEKINSCALEF, eeksEKINSCALEH, eeksVSCALE, eeksEKINTOTAL, eeksNR
122};
123
124const char *eeks_names[eeksNR] =
125{
126 "Ekin_n", "Ekinh", "dEkindlambda", "mv_cos",
127 "Ekinf", "Ekinh_old", "EkinScaleF_NHC", "EkinScaleH_NHC", "Vscale_NHC", "Ekin_Total"
128};
129
130enum {
131 eenhENERGY_N, eenhENERGY_AVER, eenhENERGY_SUM, eenhENERGY_NSUM,
132 eenhENERGY_SUM_SIM, eenhENERGY_NSUM_SIM,
133 eenhENERGY_NSTEPS, eenhENERGY_NSTEPS_SIM,
134 eenhENERGY_DELTA_H_NN,
135 eenhENERGY_DELTA_H_LIST,
136 eenhENERGY_DELTA_H_STARTTIME,
137 eenhENERGY_DELTA_H_STARTLAMBDA,
138 eenhNR
139};
140
141const char *eenh_names[eenhNR] =
142{
143 "energy_n", "energy_aver", "energy_sum", "energy_nsum",
144 "energy_sum_sim", "energy_nsum_sim",
145 "energy_nsteps", "energy_nsteps_sim",
146 "energy_delta_h_nn",
147 "energy_delta_h_list",
148 "energy_delta_h_start_time",
149 "energy_delta_h_start_lambda"
150};
151
152/* free energy history variables -- need to be preserved over checkpoint */
153enum {
154 edfhBEQUIL, edfhNATLAMBDA, edfhWLHISTO, edfhWLDELTA, edfhSUMWEIGHTS, edfhSUMDG, edfhSUMMINVAR, edfhSUMVAR,
155 edfhACCUMP, edfhACCUMM, edfhACCUMP2, edfhACCUMM2, edfhTIJ, edfhTIJEMP, edfhNR
156};
157/* free energy history variable names */
158const char *edfh_names[edfhNR] =
159{
160 "bEquilibrated", "N_at_state", "Wang-Landau Histogram", "Wang-Landau Delta", "Weights", "Free Energies", "minvar", "variance",
161 "accumulated_plus", "accumulated_minus", "accumulated_plus_2", "accumulated_minus_2", "Tij", "Tij_empirical"
162};
163
164#ifdef GMX_NATIVE_WINDOWS
165static int
166gmx_wintruncate(const char *filename, __int64 size)
167{
168#ifdef GMX_FAHCORE
169 /*we do this elsewhere*/
170 return 0;
171#else
172 FILE *fp;
173 int rc;
174
175 fp = fopen(filename, "rb+");
176
177 if (fp == NULL((void*)0))
178 {
179 return -1;
180 }
181
182 return _chsize_s( fileno(fp), size);
183#endif
184}
185#endif
186
187
188enum {
189 ecprREAL, ecprRVEC, ecprMATRIX
190};
191
192enum {
193 cptpEST, cptpEEKS, cptpEENH, cptpEDFH
194};
195/* enums for the different components of checkpoint variables, replacing the hard coded ones.
196 cptpEST - state variables.
197 cptpEEKS - Kinetic energy state variables.
198 cptpEENH - Energy history state variables.
199 cptpEDFH - free energy history variables.
200 */
201
202
203static const char *st_names(int cptp, int ecpt)
204{
205 switch (cptp)
206 {
207 case cptpEST: return est_names [ecpt]; break;
208 case cptpEEKS: return eeks_names[ecpt]; break;
209 case cptpEENH: return eenh_names[ecpt]; break;
210 case cptpEDFH: return edfh_names[ecpt]; break;
211 }
212
213 return NULL((void*)0);
214}
215
216static void cp_warning(FILE *fp)
217{
218 fprintf(fp, "\nWARNING: Checkpoint file is corrupted or truncated\n\n");
219}
220
221static void cp_error()
222{
223 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 223, "Checkpoint file corrupted/truncated, or maybe you are out of disk space?");
224}
225
226static void do_cpt_string_err(XDR *xd, gmx_bool bRead, const char *desc, char **s, FILE *list)
227{
228 bool_t res = 0;
229
230 if (bRead)
231 {
232 snew(*s, CPTSTRLEN)(*s) = save_calloc("*s", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 232, (1024), sizeof(*(*s)));
233 }
234 res = xdr_string(xd, s, CPTSTRLEN1024);
235 if (res == 0)
236 {
237 cp_error();
238 }
239 if (list)
240 {
241 fprintf(list, "%s = %s\n", desc, *s);
242 sfree(*s)save_free("*s", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 242, (*s));
243 }
244}
245
246static int do_cpt_int(XDR *xd, const char *desc, int *i, FILE *list)
247{
248 bool_t res = 0;
249
250 res = xdr_int(xd, i);
251 if (res == 0)
252 {
253 return -1;
254 }
255 if (list)
256 {
257 fprintf(list, "%s = %d\n", desc, *i);
258 }
259 return 0;
260}
261
262static int do_cpt_u_chars(XDR *xd, const char *desc, int n, unsigned char *i, FILE *list)
263{
264 bool_t res = 1;
265 int j;
266 if (list)
267 {
268 fprintf(list, "%s = ", desc);
269 }
270 for (j = 0; j < n && res; j++)
271 {
272 res &= xdr_u_char(xd, &i[j]);
273 if (list)
274 {
275 fprintf(list, "%02x", i[j]);
276 }
277 }
278 if (list)
279 {
280 fprintf(list, "\n");
281 }
282 if (res == 0)
283 {
284 return -1;
285 }
286
287 return 0;
288}
289
290static void do_cpt_int_err(XDR *xd, const char *desc, int *i, FILE *list)
291{
292 if (do_cpt_int(xd, desc, i, list) < 0)
293 {
294 cp_error();
295 }
296}
297
298static void do_cpt_step_err(XDR *xd, const char *desc, gmx_int64_t *i, FILE *list)
299{
300 bool_t res = 0;
301 char buf[STEPSTRSIZE22];
302
303 res = xdr_int64(xd, i);
304 if (res == 0)
305 {
306 cp_error();
307 }
308 if (list)
309 {
310 fprintf(list, "%s = %s\n", desc, gmx_step_str(*i, buf));
311 }
312}
313
314static void do_cpt_double_err(XDR *xd, const char *desc, double *f, FILE *list)
315{
316 bool_t res = 0;
317
318 res = xdr_double(xd, f);
319 if (res == 0)
320 {
321 cp_error();
322 }
323 if (list)
324 {
325 fprintf(list, "%s = %f\n", desc, *f);
326 }
327}
328
329static void do_cpt_real_err(XDR *xd, real *f)
330{
331 bool_t res = 0;
332
333#ifdef GMX_DOUBLE
334 res = xdr_double(xd, f);
335#else
336 res = xdr_float(xd, f);
337#endif
338 if (res == 0)
339 {
340 cp_error();
341 }
342}
343
344static void do_cpt_n_rvecs_err(XDR *xd, const char *desc, int n, rvec f[], FILE *list)
345{
346 int i, j;
347
348 for (i = 0; i < n; i++)
349 {
350 for (j = 0; j < DIM3; j++)
351 {
352 do_cpt_real_err(xd, &f[i][j]);
353 }
354 }
355
356 if (list)
357 {
358 pr_rvecs(list, 0, desc, f, n);
359 }
360}
361
362/* If nval >= 0, nval is used; on read this should match the passed value.
363 * If nval n<0, *nptr is used; on read the value is stored in nptr
364 */
365static int do_cpte_reals_low(XDR *xd, int cptp, int ecpt, int sflags,
366 int nval, int *nptr, real **v,
367 FILE *list, int erealtype)
368{
369 bool_t res = 0;
370#ifndef GMX_DOUBLE
371 int dtc = xdr_datatype_float;
372#else
373 int dtc = xdr_datatype_double;
374#endif
375 real *vp, *va = NULL((void*)0);
376 float *vf;
377 double *vd;
378 int nf, dt, i;
379
380 if (list == NULL((void*)0))
381 {
382 if (nval >= 0)
383 {
384 nf = nval;
385 }
386 else
387 {
388 if (nptr == NULL((void*)0))
389 {
390 gmx_incons("*ntpr=NULL in do_cpte_reals_low")_gmx_error("incons", "*ntpr=NULL in do_cpte_reals_low", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 390);
391 }
392 nf = *nptr;
393 }
394 }
395 res = xdr_int(xd, &nf);
396 if (res == 0)
397 {
398 return -1;
399 }
400 if (list == NULL((void*)0))
401 {
402 if (nval >= 0)
403 {
404 if (nf != nval)
405 {
406 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 406, "Count mismatch for state entry %s, code count is %d, file count is %d\n", st_names(cptp, ecpt), nval, nf);
407 }
408 }
409 else
410 {
411 *nptr = nf;
412 }
413 }
414 dt = dtc;
415 res = xdr_int(xd, &dt);
416 if (res == 0)
417 {
418 return -1;
419 }
420 if (dt != dtc)
421 {
422 fprintf(stderrstderr, "Precision mismatch for state entry %s, code precision is %s, file precision is %s\n",
423 st_names(cptp, ecpt), xdr_datatype_names[dtc],
424 xdr_datatype_names[dt]);
425 }
426 if (list || !(sflags & (1<<ecpt)))
427 {
428 snew(va, nf)(va) = save_calloc("va", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 428, (nf), sizeof(*(va)));
429 vp = va;
430 }
431 else
432 {
433 if (*v == NULL((void*)0))
434 {
435 snew(*v, nf)(*v) = save_calloc("*v", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 435, (nf), sizeof(*(*v)));
436 }
437 vp = *v;
438 }
439 if (dt == xdr_datatype_float)
440 {
441 if (dtc == xdr_datatype_float)
442 {
443 vf = (float *)vp;
444 }
445 else
446 {
447 snew(vf, nf)(vf) = save_calloc("vf", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 447, (nf), sizeof(*(vf)));
448 }
449 res = xdr_vector(xd, (char *)vf, nf,
450 (unsigned int)sizeof(float), (xdrproc_t)xdr_float);
451 if (res == 0)
452 {
453 return -1;
454 }
455 if (dtc != xdr_datatype_float)
456 {
457 for (i = 0; i < nf; i++)
458 {
459 vp[i] = vf[i];
460 }
461 sfree(vf)save_free("vf", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 461, (vf));
462 }
463 }
464 else
465 {
466 if (dtc == xdr_datatype_double)
467 {
468 vd = (double *)vp;
469 }
470 else
471 {
472 snew(vd, nf)(vd) = save_calloc("vd", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 472, (nf), sizeof(*(vd)));
473 }
474 res = xdr_vector(xd, (char *)vd, nf,
475 (unsigned int)sizeof(double), (xdrproc_t)xdr_double);
476 if (res == 0)
477 {
478 return -1;
479 }
480 if (dtc != xdr_datatype_double)
481 {
482 for (i = 0; i < nf; i++)
483 {
484 vp[i] = vd[i];
485 }
486 sfree(vd)save_free("vd", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 486, (vd));
487 }
488 }
489
490 if (list)
491 {
492 switch (erealtype)
493 {
494 case ecprREAL:
495 pr_reals(list, 0, st_names(cptp, ecpt), vp, nf);
496 break;
497 case ecprRVEC:
498 pr_rvecs(list, 0, st_names(cptp, ecpt), (rvec *)vp, nf/3);
499 break;
500 default:
501 gmx_incons("Unknown checkpoint real type")_gmx_error("incons", "Unknown checkpoint real type", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 501);
502 }
503 }
504 if (va)
505 {
506 sfree(va)save_free("va", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 506, (va));
507 }
508
509 return 0;
510}
511
512
513/* This function stores n along with the reals for reading,
514 * but on reading it assumes that n matches the value in the checkpoint file,
515 * a fatal error is generated when this is not the case.
516 */
517static int do_cpte_reals(XDR *xd, int cptp, int ecpt, int sflags,
518 int n, real **v, FILE *list)
519{
520 return do_cpte_reals_low(xd, cptp, ecpt, sflags, n, NULL((void*)0), v, list, ecprREAL);
521}
522
523/* This function does the same as do_cpte_reals,
524 * except that on reading it ignores the passed value of *n
525 * and stored the value read from the checkpoint file in *n.
526 */
527static int do_cpte_n_reals(XDR *xd, int cptp, int ecpt, int sflags,
528 int *n, real **v, FILE *list)
529{
530 return do_cpte_reals_low(xd, cptp, ecpt, sflags, -1, n, v, list, ecprREAL);
531}
532
533static int do_cpte_real(XDR *xd, int cptp, int ecpt, int sflags,
534 real *r, FILE *list)
535{
536 int n;
537
538 return do_cpte_reals_low(xd, cptp, ecpt, sflags, 1, NULL((void*)0), &r, list, ecprREAL);
539}
540
541static int do_cpte_ints(XDR *xd, int cptp, int ecpt, int sflags,
542 int n, int **v, FILE *list)
543{
544 bool_t res = 0;
545 int dtc = xdr_datatype_int;
546 int *vp, *va = NULL((void*)0);
547 int nf, dt, i;
548
549 nf = n;
550 res = xdr_int(xd, &nf);
551 if (res == 0)
552 {
553 return -1;
554 }
555 if (list == NULL((void*)0) && v != NULL((void*)0) && nf != n)
556 {
557 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 557, "Count mismatch for state entry %s, code count is %d, file count is %d\n", st_names(cptp, ecpt), n, nf);
558 }
559 dt = dtc;
560 res = xdr_int(xd, &dt);
561 if (res == 0)
562 {
563 return -1;
564 }
565 if (dt != dtc)
566 {
567 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 567, "Type mismatch for state entry %s, code type is %s, file type is %s\n",
568 st_names(cptp, ecpt), xdr_datatype_names[dtc],
569 xdr_datatype_names[dt]);
570 }
571 if (list || !(sflags & (1<<ecpt)) || v == NULL((void*)0))
572 {
573 snew(va, nf)(va) = save_calloc("va", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 573, (nf), sizeof(*(va)));
574 vp = va;
575 }
576 else
577 {
578 if (*v == NULL((void*)0))
579 {
580 snew(*v, nf)(*v) = save_calloc("*v", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 580, (nf), sizeof(*(*v)));
581 }
582 vp = *v;
583 }
584 res = xdr_vector(xd, (char *)vp, nf,
585 (unsigned int)sizeof(int), (xdrproc_t)xdr_int);
586 if (res == 0)
587 {
588 return -1;
589 }
590 if (list)
591 {
592 pr_ivec(list, 0, st_names(cptp, ecpt), vp, nf, TRUE1);
593 }
594 if (va)
595 {
596 sfree(va)save_free("va", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 596, (va));
597 }
598
599 return 0;
600}
601
602static int do_cpte_int(XDR *xd, int cptp, int ecpt, int sflags,
603 int *i, FILE *list)
604{
605 return do_cpte_ints(xd, cptp, ecpt, sflags, 1, &i, list);
606}
607
608static int do_cpte_doubles(XDR *xd, int cptp, int ecpt, int sflags,
609 int n, double **v, FILE *list)
610{
611 bool_t res = 0;
612 int dtc = xdr_datatype_double;
613 double *vp, *va = NULL((void*)0);
614 int nf, dt, i;
615
616 nf = n;
617 res = xdr_int(xd, &nf);
618 if (res == 0)
619 {
620 return -1;
621 }
622 if (list == NULL((void*)0) && nf != n)
623 {
624 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 624, "Count mismatch for state entry %s, code count is %d, file count is %d\n", st_names(cptp, ecpt), n, nf);
625 }
626 dt = dtc;
627 res = xdr_int(xd, &dt);
628 if (res == 0)
629 {
630 return -1;
631 }
632 if (dt != dtc)
633 {
634 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 634, "Precision mismatch for state entry %s, code precision is %s, file precision is %s\n",
635 st_names(cptp, ecpt), xdr_datatype_names[dtc],
636 xdr_datatype_names[dt]);
637 }
638 if (list || !(sflags & (1<<ecpt)))
639 {
640 snew(va, nf)(va) = save_calloc("va", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 640, (nf), sizeof(*(va)));
641 vp = va;
642 }
643 else
644 {
645 if (*v == NULL((void*)0))
646 {
647 snew(*v, nf)(*v) = save_calloc("*v", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 647, (nf), sizeof(*(*v)));
648 }
649 vp = *v;
650 }
651 res = xdr_vector(xd, (char *)vp, nf,
652 (unsigned int)sizeof(double), (xdrproc_t)xdr_double);
653 if (res == 0)
654 {
655 return -1;
656 }
657 if (list)
658 {
659 pr_doubles(list, 0, st_names(cptp, ecpt), vp, nf);
660 }
661 if (va)
662 {
663 sfree(va)save_free("va", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 663, (va));
664 }
665
666 return 0;
667}
668
669static int do_cpte_double(XDR *xd, int cptp, int ecpt, int sflags,
670 double *r, FILE *list)
671{
672 return do_cpte_doubles(xd, cptp, ecpt, sflags, 1, &r, list);
673}
674
675
676static int do_cpte_rvecs(XDR *xd, int cptp, int ecpt, int sflags,
677 int n, rvec **v, FILE *list)
678{
679 int n3;
680
681 return do_cpte_reals_low(xd, cptp, ecpt, sflags,
682 n*DIM3, NULL((void*)0), (real **)v, list, ecprRVEC);
683}
684
685static int do_cpte_matrix(XDR *xd, int cptp, int ecpt, int sflags,
686 matrix v, FILE *list)
687{
688 real *vr;
689 real ret;
690
691 vr = (real *)&(v[0][0]);
692 ret = do_cpte_reals_low(xd, cptp, ecpt, sflags,
693 DIM3*DIM3, NULL((void*)0), &vr, NULL((void*)0), ecprMATRIX);
694
695 if (list && ret == 0)
696 {
697 pr_rvecs(list, 0, st_names(cptp, ecpt), v, DIM3);
698 }
699
700 return ret;
701}
702
703
704static int do_cpte_nmatrix(XDR *xd, int cptp, int ecpt, int sflags,
705 int n, real **v, FILE *list)
706{
707 int i;
708 real *vr;
709 real ret, reti;
710 char name[CPTSTRLEN1024];
711
712 ret = 0;
713 if (v == NULL((void*)0))
714 {
715 snew(v, n)(v) = save_calloc("v", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 715, (n), sizeof(*(v)));
716 }
717 for (i = 0; i < n; i++)
718 {
719 reti = 0;
720 vr = v[i];
721 reti = do_cpte_reals_low(xd, cptp, ecpt, sflags, n, NULL((void*)0), &(v[i]), NULL((void*)0), ecprREAL);
722 if (list && reti == 0)
723 {
724 sprintf(name, "%s[%d]", st_names(cptp, ecpt), i);
725 pr_reals(list, 0, name, v[i], n);
726 }
727 if (reti == 0)
728 {
729 ret = 0;
730 }
731 }
732 return ret;
733}
734
735static int do_cpte_matrices(XDR *xd, int cptp, int ecpt, int sflags,
736 int n, matrix **v, FILE *list)
737{
738 bool_t res = 0;
739 matrix *vp, *va = NULL((void*)0);
740 real *vr;
741 int nf, i, j, k;
742 int ret;
743
744 nf = n;
745 res = xdr_int(xd, &nf);
746 if (res == 0)
747 {
748 return -1;
749 }
750 if (list == NULL((void*)0) && nf != n)
751 {
752 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 752, "Count mismatch for state entry %s, code count is %d, file count is %d\n", st_names(cptp, ecpt), n, nf);
753 }
754 if (list || !(sflags & (1<<ecpt)))
755 {
756 snew(va, nf)(va) = save_calloc("va", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 756, (nf), sizeof(*(va)));
757 vp = va;
758 }
759 else
760 {
761 if (*v == NULL((void*)0))
762 {
763 snew(*v, nf)(*v) = save_calloc("*v", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 763, (nf), sizeof(*(*v)));
764 }
765 vp = *v;
766 }
767 snew(vr, nf*DIM*DIM)(vr) = save_calloc("vr", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 767, (nf*3*3), sizeof(*(vr)));
768 for (i = 0; i < nf; i++)
769 {
770 for (j = 0; j < DIM3; j++)
771 {
772 for (k = 0; k < DIM3; k++)
773 {
774 vr[(i*DIM3+j)*DIM3+k] = vp[i][j][k];
775 }
776 }
777 }
778 ret = do_cpte_reals_low(xd, cptp, ecpt, sflags,
779 nf*DIM3*DIM3, NULL((void*)0), &vr, NULL((void*)0), ecprMATRIX);
780 for (i = 0; i < nf; i++)
781 {
782 for (j = 0; j < DIM3; j++)
783 {
784 for (k = 0; k < DIM3; k++)
785 {
786 vp[i][j][k] = vr[(i*DIM3+j)*DIM3+k];
787 }
788 }
789 }
790 sfree(vr)save_free("vr", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 790, (vr));
791
792 if (list && ret == 0)
793 {
794 for (i = 0; i < nf; i++)
795 {
796 pr_rvecs(list, 0, st_names(cptp, ecpt), vp[i], DIM3);
797 }
798 }
799 if (va)
800 {
801 sfree(va)save_free("va", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 801, (va));
802 }
803
804 return ret;
805}
806
807static void do_cpt_header(XDR *xd, gmx_bool bRead, int *file_version,
808 char **version, char **btime, char **buser, char **bhost,
809 int *double_prec,
810 char **fprog, char **ftime,
811 int *eIntegrator, int *simulation_part,
812 gmx_int64_t *step, double *t,
813 int *nnodes, int *dd_nc, int *npme,
814 int *natoms, int *ngtc, int *nnhpres, int *nhchainlength,
815 int *nlambda, int *flags_state,
816 int *flags_eks, int *flags_enh, int *flags_dfh,
817 int *nED, int *eSwapCoords,
818 FILE *list)
819{
820 bool_t res = 0;
821 int magic;
822 int idum = 0;
823 int i;
824 char *fhost;
825
826 if (bRead)
827 {
828 magic = -1;
829 }
830 else
831 {
832 magic = CPT_MAGIC1171817;
833 }
834 res = xdr_int(xd, &magic);
835 if (res == 0)
836 {
837 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 837, "The checkpoint file is empty/corrupted, or maybe you are out of disk space?");
838 }
839 if (magic != CPT_MAGIC1171817)
840 {
841 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 841, "Start of file magic number mismatch, checkpoint file has %d, should be %d\n"
842 "The checkpoint file is corrupted or not a checkpoint file",
843 magic, CPT_MAGIC1171817);
844 }
845 if (!bRead)
846 {
847 snew(fhost, 255)(fhost) = save_calloc("fhost", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 847, (255), sizeof(*(fhost)));
848 gmx_gethostname(fhost, 255);
849 }
850 do_cpt_string_err(xd, bRead, "GROMACS version", version, list);
851 do_cpt_string_err(xd, bRead, "GROMACS build time", btime, list);
852 do_cpt_string_err(xd, bRead, "GROMACS build user", buser, list);
853 do_cpt_string_err(xd, bRead, "GROMACS build host", bhost, list);
854 do_cpt_string_err(xd, bRead, "generating program", fprog, list);
855 do_cpt_string_err(xd, bRead, "generation time", ftime, list);
856 *file_version = cpt_version;
857 do_cpt_int_err(xd, "checkpoint file version", file_version, list);
858 if (*file_version > cpt_version)
859 {
860 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 860, "Attempting to read a checkpoint file of version %d with code of version %d\n", *file_version, cpt_version);
861 }
862 if (*file_version >= 13)
863 {
864 do_cpt_int_err(xd, "GROMACS double precision", double_prec, list);
865 }
866 else
867 {
868 *double_prec = -1;
869 }
870 if (*file_version >= 12)
871 {
872 do_cpt_string_err(xd, bRead, "generating host", &fhost, list);
873 if (list == NULL((void*)0))
874 {
875 sfree(fhost)save_free("fhost", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 875, (fhost));
876 }
877 }
878 do_cpt_int_err(xd, "#atoms", natoms, list);
879 do_cpt_int_err(xd, "#T-coupling groups", ngtc, list);
880 if (*file_version >= 10)
881 {
882 do_cpt_int_err(xd, "#Nose-Hoover T-chains", nhchainlength, list);
883 }
884 else
885 {
886 *nhchainlength = 1;
887 }
888 if (*file_version >= 11)
889 {
890 do_cpt_int_err(xd, "#Nose-Hoover T-chains for barostat ", nnhpres, list);
891 }
892 else
893 {
894 *nnhpres = 0;
895 }
896 if (*file_version >= 14)
897 {
898 do_cpt_int_err(xd, "# of total lambda states ", nlambda, list);
899 }
900 else
901 {
902 *nlambda = 0;
903 }
904 do_cpt_int_err(xd, "integrator", eIntegrator, list);
905 if (*file_version >= 3)
906 {
907 do_cpt_int_err(xd, "simulation part #", simulation_part, list);
908 }
909 else
910 {
911 *simulation_part = 1;
912 }
913 if (*file_version >= 5)
914 {
915 do_cpt_step_err(xd, "step", step, list);
916 }
917 else
918 {
919 do_cpt_int_err(xd, "step", &idum, list);
920 *step = idum;
921 }
922 do_cpt_double_err(xd, "t", t, list);
923 do_cpt_int_err(xd, "#PP-nodes", nnodes, list);
924 idum = 1;
925 do_cpt_int_err(xd, "dd_nc[x]", dd_nc ? &(dd_nc[0]) : &idum, list);
926 do_cpt_int_err(xd, "dd_nc[y]", dd_nc ? &(dd_nc[1]) : &idum, list);
927 do_cpt_int_err(xd, "dd_nc[z]", dd_nc ? &(dd_nc[2]) : &idum, list);
928 do_cpt_int_err(xd, "#PME-only nodes", npme, list);
929 do_cpt_int_err(xd, "state flags", flags_state, list);
930 if (*file_version >= 4)
931 {
932 do_cpt_int_err(xd, "ekin data flags", flags_eks, list);
933 do_cpt_int_err(xd, "energy history flags", flags_enh, list);
934 }
935 else
936 {
937 *flags_eks = 0;
938 *flags_enh = (*flags_state >> (estORIRE_DTAV+1));
939 *flags_state = (*flags_state & ~((1<<(estORIRE_DTAV+1)) |
940 (1<<(estORIRE_DTAV+2)) |
941 (1<<(estORIRE_DTAV+3))));
942 }
943 if (*file_version >= 14)
944 {
945 do_cpt_int_err(xd, "df history flags", flags_dfh, list);
946 }
947 else
948 {
949 *flags_dfh = 0;
950 }
951
952 if (*file_version >= 15)
953 {
954 do_cpt_int_err(xd, "ED data sets", nED, list);
955 }
956 else
957 {
958 *nED = 0;
959 }
960 if (*file_version >= 16)
961 {
962 do_cpt_int_err(xd, "swap", eSwapCoords, list);
963 }
964}
965
966static int do_cpt_footer(XDR *xd, int file_version)
967{
968 bool_t res = 0;
969 int magic;
970
971 if (file_version >= 2)
972 {
973 magic = CPT_MAGIC2171819;
974 res = xdr_int(xd, &magic);
975 if (res == 0)
976 {
977 cp_error();
978 }
979 if (magic != CPT_MAGIC2171819)
980 {
981 return -1;
982 }
983 }
984
985 return 0;
986}
987
988static int do_cpt_state(XDR *xd, gmx_bool bRead,
989 int fflags, t_state *state,
990 FILE *list)
991{
992 int sflags;
993 int i;
994 int ret;
995 int nnht, nnhtp;
996
997 ret = 0;
998
999 nnht = state->nhchainlength*state->ngtc;
1000 nnhtp = state->nhchainlength*state->nnhpres;
1001
1002 if (bRead) /* we need to allocate space for dfhist if we are reading */
1003 {
1004 init_df_history(&state->dfhist, state->dfhist.nlambda);
1005 }
1006
1007 sflags = state->flags;
1008 for (i = 0; (i < estNR && ret == 0); i++)
1009 {
1010 if (fflags & (1<<i))
1011 {
1012 switch (i)
1013 {
1014 case estLAMBDA: ret = do_cpte_reals(xd, cptpEST, i, sflags, efptNR, &(state->lambda), list); break;
1015 case estFEPSTATE: ret = do_cpte_int (xd, cptpEST, i, sflags, &state->fep_state, list); break;
1016 case estBOX: ret = do_cpte_matrix(xd, cptpEST, i, sflags, state->box, list); break;
1017 case estBOX_REL: ret = do_cpte_matrix(xd, cptpEST, i, sflags, state->box_rel, list); break;
1018 case estBOXV: ret = do_cpte_matrix(xd, cptpEST, i, sflags, state->boxv, list); break;
1019 case estPRES_PREV: ret = do_cpte_matrix(xd, cptpEST, i, sflags, state->pres_prev, list); break;
1020 case estSVIR_PREV: ret = do_cpte_matrix(xd, cptpEST, i, sflags, state->svir_prev, list); break;
1021 case estFVIR_PREV: ret = do_cpte_matrix(xd, cptpEST, i, sflags, state->fvir_prev, list); break;
1022 case estNH_XI: ret = do_cpte_doubles(xd, cptpEST, i, sflags, nnht, &state->nosehoover_xi, list); break;
1023 case estNH_VXI: ret = do_cpte_doubles(xd, cptpEST, i, sflags, nnht, &state->nosehoover_vxi, list); break;
1024 case estNHPRES_XI: ret = do_cpte_doubles(xd, cptpEST, i, sflags, nnhtp, &state->nhpres_xi, list); break;
1025 case estNHPRES_VXI: ret = do_cpte_doubles(xd, cptpEST, i, sflags, nnhtp, &state->nhpres_vxi, list); break;
1026 case estTC_INT: ret = do_cpte_doubles(xd, cptpEST, i, sflags, state->ngtc, &state->therm_integral, list); break;
1027 case estVETA: ret = do_cpte_real(xd, cptpEST, i, sflags, &state->veta, list); break;
1028 case estVOL0: ret = do_cpte_real(xd, cptpEST, i, sflags, &state->vol0, list); break;
1029 case estX: ret = do_cpte_rvecs(xd, cptpEST, i, sflags, state->natoms, &state->x, list); break;
1030 case estV: ret = do_cpte_rvecs(xd, cptpEST, i, sflags, state->natoms, &state->v, list); break;
1031 case estSDX: ret = do_cpte_rvecs(xd, cptpEST, i, sflags, state->natoms, &state->sd_X, list); break;
1032 /* The RNG entries are no longer written,
1033 * the next 4 lines are only for reading old files.
1034 */
1035 case estLD_RNG: ret = do_cpte_ints(xd, cptpEST, i, sflags, 0, NULL((void*)0), list); break;
1036 case estLD_RNGI: ret = do_cpte_ints(xd, cptpEST, i, sflags, 0, NULL((void*)0), list); break;
1037 case estMC_RNG: ret = do_cpte_ints(xd, cptpEST, i, sflags, 0, NULL((void*)0), list); break;
1038 case estMC_RNGI: ret = do_cpte_ints(xd, cptpEST, i, sflags, 0, NULL((void*)0), list); break;
1039 case estDISRE_INITF: ret = do_cpte_real (xd, cptpEST, i, sflags, &state->hist.disre_initf, list); break;
1040 case estDISRE_RM3TAV: ret = do_cpte_n_reals(xd, cptpEST, i, sflags, &state->hist.ndisrepairs, &state->hist.disre_rm3tav, list); break;
1041 case estORIRE_INITF: ret = do_cpte_real (xd, cptpEST, i, sflags, &state->hist.orire_initf, list); break;
1042 case estORIRE_DTAV: ret = do_cpte_n_reals(xd, cptpEST, i, sflags, &state->hist.norire_Dtav, &state->hist.orire_Dtav, list); break;
1043 default:
1044 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1044, "Unknown state entry %d\n"
1045 "You are probably reading a new checkpoint file with old code", i);
1046 }
1047 }
1048 }
1049
1050 return ret;
1051}
1052
1053static int do_cpt_ekinstate(XDR *xd, int fflags, ekinstate_t *ekins,
1054 FILE *list)
1055{
1056 int i;
1057 int ret;
1058
1059 ret = 0;
1060
1061 for (i = 0; (i < eeksNR && ret == 0); i++)
1062 {
1063 if (fflags & (1<<i))
1064 {
1065 switch (i)
1066 {
1067
1068 case eeksEKIN_N: ret = do_cpte_int(xd, cptpEEKS, i, fflags, &ekins->ekin_n, list); break;
1069 case eeksEKINH: ret = do_cpte_matrices(xd, cptpEEKS, i, fflags, ekins->ekin_n, &ekins->ekinh, list); break;
1070 case eeksEKINF: ret = do_cpte_matrices(xd, cptpEEKS, i, fflags, ekins->ekin_n, &ekins->ekinf, list); break;
1071 case eeksEKINO: ret = do_cpte_matrices(xd, cptpEEKS, i, fflags, ekins->ekin_n, &ekins->ekinh_old, list); break;
1072 case eeksEKINTOTAL: ret = do_cpte_matrix(xd, cptpEEKS, i, fflags, ekins->ekin_total, list); break;
1073 case eeksEKINSCALEF: ret = do_cpte_doubles(xd, cptpEEKS, i, fflags, ekins->ekin_n, &ekins->ekinscalef_nhc, list); break;
1074 case eeksVSCALE: ret = do_cpte_doubles(xd, 1, cptpEEKS, fflags, ekins->ekin_n, &ekins->vscale_nhc, list); break;
1075 case eeksEKINSCALEH: ret = do_cpte_doubles(xd, 1, cptpEEKS, fflags, ekins->ekin_n, &ekins->ekinscaleh_nhc, list); break;
1076 case eeksDEKINDL: ret = do_cpte_real(xd, 1, cptpEEKS, fflags, &ekins->dekindl, list); break;
1077 case eeksMVCOS: ret = do_cpte_real(xd, 1, cptpEEKS, fflags, &ekins->mvcos, list); break;
1078 default:
1079 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1079, "Unknown ekin data state entry %d\n"
1080 "You are probably reading a new checkpoint file with old code", i);
1081 }
1082 }
1083 }
1084
1085 return ret;
1086}
1087
1088
1089static int do_cpt_swapstate(XDR *xd, gmx_bool bRead, swapstate_t *swapstate, FILE *list)
1090{
1091 int ii, ic, j;
1092 int ret = 0;
1093 int swap_cpt_version = 1;
1094
1095
1096 if (eswapNO == swapstate->eSwapCoords)
1097 {
1098 return ret;
1099 }
1100
1101 swapstate->bFromCpt = bRead;
1102
1103 do_cpt_int_err(xd, "swap checkpoint version", &swap_cpt_version, list);
1104 do_cpt_int_err(xd, "swap coupling steps", &swapstate->nAverage, list);
1105
1106 /* When reading, init_swapcoords has not been called yet,
1107 * so we have to allocate memory first. */
1108
1109 for (ic = 0; ic < eCompNR; ic++)
1110 {
1111 for (ii = 0; ii < eIonNR; ii++)
1112 {
1113 if (bRead)
1114 {
1115 do_cpt_int_err(xd, "swap requested atoms", &swapstate->nat_req[ic][ii], list);
1116 }
1117 else
1118 {
1119 do_cpt_int_err(xd, "swap requested atoms p", swapstate->nat_req_p[ic][ii], list);
1120 }
1121
1122 if (bRead)
1123 {
1124 do_cpt_int_err(xd, "swap influx netto", &swapstate->inflow_netto[ic][ii], list);
1125 }
1126 else
1127 {
1128 do_cpt_int_err(xd, "swap influx netto p", swapstate->inflow_netto_p[ic][ii], list);
1129 }
1130
1131 if (bRead && (NULL((void*)0) == swapstate->nat_past[ic][ii]) )
1132 {
1133 snew(swapstate->nat_past[ic][ii], swapstate->nAverage)(swapstate->nat_past[ic][ii]) = save_calloc("swapstate->nat_past[ic][ii]"
, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1133, (swapstate->nAverage), sizeof(*(swapstate->nat_past
[ic][ii])));
1134 }
1135
1136 for (j = 0; j < swapstate->nAverage; j++)
1137 {
1138 if (bRead)
1139 {
1140 do_cpt_int_err(xd, "swap past atom counts", &swapstate->nat_past[ic][ii][j], list);
1141 }
1142 else
1143 {
1144 do_cpt_int_err(xd, "swap past atom counts p", &swapstate->nat_past_p[ic][ii][j], list);
1145 }
1146 }
1147 }
1148 }
1149
1150 /* Ion flux per channel */
1151 for (ic = 0; ic < eChanNR; ic++)
1152 {
1153 for (ii = 0; ii < eIonNR; ii++)
1154 {
1155 if (bRead)
1156 {
1157 do_cpt_int_err(xd, "channel flux", &swapstate->fluxfromAtoB[ic][ii], list);
1158 }
1159 else
1160 {
1161 do_cpt_int_err(xd, "channel flux p", swapstate->fluxfromAtoB_p[ic][ii], list);
1162 }
1163 }
1164 }
1165
1166 /* Ion flux leakage */
1167 if (bRead)
1168 {
1169 snew(swapstate->fluxleak, 1)(swapstate->fluxleak) = save_calloc("swapstate->fluxleak"
, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1169, (1), sizeof(*(swapstate->fluxleak)));
1170 }
1171 do_cpt_int_err(xd, "flux leakage", swapstate->fluxleak, list);
1172
1173 /* Ion history */
1174 do_cpt_int_err(xd, "number of ions", &swapstate->nions, list);
1175
1176 if (bRead)
1177 {
1178 snew(swapstate->channel_label, swapstate->nions)(swapstate->channel_label) = save_calloc("swapstate->channel_label"
, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1178, (swapstate->nions), sizeof(*(swapstate->channel_label
)));
1179 snew(swapstate->comp_from, swapstate->nions)(swapstate->comp_from) = save_calloc("swapstate->comp_from"
, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1179, (swapstate->nions), sizeof(*(swapstate->comp_from
)));
1180 }
1181
1182 do_cpt_u_chars(xd, "channel history", swapstate->nions, swapstate->channel_label, list);
1183 do_cpt_u_chars(xd, "domain history", swapstate->nions, swapstate->comp_from, list);
1184
1185 /* Save the last known whole positions to checkpoint
1186 * file to be able to also make multimeric channels whole in PBC */
1187 do_cpt_int_err(xd, "Ch0 atoms", &swapstate->nat[eChan0], list);
1188 do_cpt_int_err(xd, "Ch1 atoms", &swapstate->nat[eChan1], list);
1189 if (bRead)
1190 {
1191 snew(swapstate->xc_old_whole[eChan0], swapstate->nat[eChan0])(swapstate->xc_old_whole[eChan0]) = save_calloc("swapstate->xc_old_whole[eChan0]"
, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1191, (swapstate->nat[eChan0]), sizeof(*(swapstate->xc_old_whole
[eChan0])));
1192 snew(swapstate->xc_old_whole[eChan1], swapstate->nat[eChan1])(swapstate->xc_old_whole[eChan1]) = save_calloc("swapstate->xc_old_whole[eChan1]"
, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1192, (swapstate->nat[eChan1]), sizeof(*(swapstate->xc_old_whole
[eChan1])));
1193 do_cpt_n_rvecs_err(xd, "Ch0 whole x", swapstate->nat[eChan0], swapstate->xc_old_whole[eChan0], list);
1194 do_cpt_n_rvecs_err(xd, "Ch1 whole x", swapstate->nat[eChan1], swapstate->xc_old_whole[eChan1], list);
1195 }
1196 else
1197 {
1198 do_cpt_n_rvecs_err(xd, "Ch0 whole x", swapstate->nat[eChan0], *swapstate->xc_old_whole_p[eChan0], list);
1199 do_cpt_n_rvecs_err(xd, "Ch1 whole x", swapstate->nat[eChan1], *swapstate->xc_old_whole_p[eChan1], list);
1200 }
1201
1202 return ret;
1203}
1204
1205
1206static int do_cpt_enerhist(XDR *xd, gmx_bool bRead,
1207 int fflags, energyhistory_t *enerhist,
1208 FILE *list)
1209{
1210 int i;
1211 int j;
1212 int ret;
1213
1214 ret = 0;
1215
1216 if (bRead)
1217 {
1218 enerhist->nsteps = 0;
1219 enerhist->nsum = 0;
1220 enerhist->nsteps_sim = 0;
1221 enerhist->nsum_sim = 0;
1222 enerhist->dht = NULL((void*)0);
1223
1224 if (fflags & (1<< eenhENERGY_DELTA_H_NN) )
1225 {
1226 snew(enerhist->dht, 1)(enerhist->dht) = save_calloc("enerhist->dht", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1226, (1), sizeof(*(enerhist->dht)));
1227 enerhist->dht->ndh = NULL((void*)0);
1228 enerhist->dht->dh = NULL((void*)0);
1229 enerhist->dht->start_lambda_set = FALSE0;
1230 }
1231 }
1232
1233 for (i = 0; (i < eenhNR && ret == 0); i++)
1234 {
1235 if (fflags & (1<<i))
1236 {
1237 switch (i)
1238 {
1239 case eenhENERGY_N: ret = do_cpte_int(xd, cptpEENH, i, fflags, &enerhist->nener, list); break;
1240 case eenhENERGY_AVER: ret = do_cpte_doubles(xd, cptpEENH, i, fflags, enerhist->nener, &enerhist->ener_ave, list); break;
1241 case eenhENERGY_SUM: ret = do_cpte_doubles(xd, cptpEENH, i, fflags, enerhist->nener, &enerhist->ener_sum, list); break;
1242 case eenhENERGY_NSUM: do_cpt_step_err(xd, eenh_names[i], &enerhist->nsum, list); break;
1243 case eenhENERGY_SUM_SIM: ret = do_cpte_doubles(xd, cptpEENH, i, fflags, enerhist->nener, &enerhist->ener_sum_sim, list); break;
1244 case eenhENERGY_NSUM_SIM: do_cpt_step_err(xd, eenh_names[i], &enerhist->nsum_sim, list); break;
1245 case eenhENERGY_NSTEPS: do_cpt_step_err(xd, eenh_names[i], &enerhist->nsteps, list); break;
1246 case eenhENERGY_NSTEPS_SIM: do_cpt_step_err(xd, eenh_names[i], &enerhist->nsteps_sim, list); break;
1247 case eenhENERGY_DELTA_H_NN: do_cpt_int_err(xd, eenh_names[i], &(enerhist->dht->nndh), list);
1248 if (bRead) /* now allocate memory for it */
1249 {
1250 snew(enerhist->dht->dh, enerhist->dht->nndh)(enerhist->dht->dh) = save_calloc("enerhist->dht->dh"
, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1250, (enerhist->dht->nndh), sizeof(*(enerhist->dht
->dh)));
1251 snew(enerhist->dht->ndh, enerhist->dht->nndh)(enerhist->dht->ndh) = save_calloc("enerhist->dht->ndh"
, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1251, (enerhist->dht->nndh), sizeof(*(enerhist->dht
->ndh)));
1252 for (j = 0; j < enerhist->dht->nndh; j++)
1253 {
1254 enerhist->dht->ndh[j] = 0;
1255 enerhist->dht->dh[j] = NULL((void*)0);
1256 }
1257 }
1258 break;
1259 case eenhENERGY_DELTA_H_LIST:
1260 for (j = 0; j < enerhist->dht->nndh; j++)
1261 {
1262 ret = do_cpte_n_reals(xd, cptpEENH, i, fflags, &enerhist->dht->ndh[j], &(enerhist->dht->dh[j]), list);
1263 }
1264 break;
1265 case eenhENERGY_DELTA_H_STARTTIME:
1266 ret = do_cpte_double(xd, cptpEENH, i, fflags, &(enerhist->dht->start_time), list); break;
1267 case eenhENERGY_DELTA_H_STARTLAMBDA:
1268 ret = do_cpte_double(xd, cptpEENH, i, fflags, &(enerhist->dht->start_lambda), list); break;
1269 default:
1270 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1270, "Unknown energy history entry %d\n"
1271 "You are probably reading a new checkpoint file with old code", i);
1272 }
1273 }
1274 }
1275
1276 if ((fflags & (1<<eenhENERGY_SUM)) && !(fflags & (1<<eenhENERGY_SUM_SIM)))
1277 {
1278 /* Assume we have an old file format and copy sum to sum_sim */
1279 srenew(enerhist->ener_sum_sim, enerhist->nener)(enerhist->ener_sum_sim) = save_realloc("enerhist->ener_sum_sim"
, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1279, (enerhist->ener_sum_sim), (enerhist->nener), sizeof
(*(enerhist->ener_sum_sim)));
1280 for (i = 0; i < enerhist->nener; i++)
1281 {
1282 enerhist->ener_sum_sim[i] = enerhist->ener_sum[i];
1283 }
1284 fflags |= (1<<eenhENERGY_SUM_SIM);
1285 }
1286
1287 if ( (fflags & (1<<eenhENERGY_NSUM)) &&
1288 !(fflags & (1<<eenhENERGY_NSTEPS)))
1289 {
1290 /* Assume we have an old file format and copy nsum to nsteps */
1291 enerhist->nsteps = enerhist->nsum;
1292 fflags |= (1<<eenhENERGY_NSTEPS);
1293 }
1294 if ( (fflags & (1<<eenhENERGY_NSUM_SIM)) &&
1295 !(fflags & (1<<eenhENERGY_NSTEPS_SIM)))
1296 {
1297 /* Assume we have an old file format and copy nsum to nsteps */
1298 enerhist->nsteps_sim = enerhist->nsum_sim;
1299 fflags |= (1<<eenhENERGY_NSTEPS_SIM);
1300 }
1301
1302 return ret;
1303}
1304
1305static int do_cpt_df_hist(XDR *xd, int fflags, df_history_t *dfhist, FILE *list)
1306{
1307 int i, nlambda;
1308 int ret;
1309
1310 nlambda = dfhist->nlambda;
1311 ret = 0;
1312
1313 for (i = 0; (i < edfhNR && ret == 0); i++)
1314 {
1315 if (fflags & (1<<i))
1316 {
1317 switch (i)
1318 {
1319 case edfhBEQUIL: ret = do_cpte_int(xd, cptpEDFH, i, fflags, &dfhist->bEquil, list); break;
1320 case edfhNATLAMBDA: ret = do_cpte_ints(xd, cptpEDFH, i, fflags, nlambda, &dfhist->n_at_lam, list); break;
1321 case edfhWLHISTO: ret = do_cpte_reals(xd, cptpEDFH, i, fflags, nlambda, &dfhist->wl_histo, list); break;
1322 case edfhWLDELTA: ret = do_cpte_real(xd, cptpEDFH, i, fflags, &dfhist->wl_delta, list); break;
1323 case edfhSUMWEIGHTS: ret = do_cpte_reals(xd, cptpEDFH, i, fflags, nlambda, &dfhist->sum_weights, list); break;
1324 case edfhSUMDG: ret = do_cpte_reals(xd, cptpEDFH, i, fflags, nlambda, &dfhist->sum_dg, list); break;
1325 case edfhSUMMINVAR: ret = do_cpte_reals(xd, cptpEDFH, i, fflags, nlambda, &dfhist->sum_minvar, list); break;
1326 case edfhSUMVAR: ret = do_cpte_reals(xd, cptpEDFH, i, fflags, nlambda, &dfhist->sum_variance, list); break;
1327 case edfhACCUMP: ret = do_cpte_nmatrix(xd, cptpEDFH, i, fflags, nlambda, dfhist->accum_p, list); break;
1328 case edfhACCUMM: ret = do_cpte_nmatrix(xd, cptpEDFH, i, fflags, nlambda, dfhist->accum_m, list); break;
1329 case edfhACCUMP2: ret = do_cpte_nmatrix(xd, cptpEDFH, i, fflags, nlambda, dfhist->accum_p2, list); break;
1330 case edfhACCUMM2: ret = do_cpte_nmatrix(xd, cptpEDFH, i, fflags, nlambda, dfhist->accum_m2, list); break;
1331 case edfhTIJ: ret = do_cpte_nmatrix(xd, cptpEDFH, i, fflags, nlambda, dfhist->Tij, list); break;
1332 case edfhTIJEMP: ret = do_cpte_nmatrix(xd, cptpEDFH, i, fflags, nlambda, dfhist->Tij_empirical, list); break;
1333
1334 default:
1335 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1335, "Unknown df history entry %d\n"
1336 "You are probably reading a new checkpoint file with old code", i);
1337 }
1338 }
1339 }
1340
1341 return ret;
1342}
1343
1344
1345/* This function stores the last whole configuration of the reference and
1346 * average structure in the .cpt file
1347 */
1348static int do_cpt_EDstate(XDR *xd, gmx_bool bRead,
1349 edsamstate_t *EDstate, FILE *list)
1350{
1351 int i, j;
1352 int ret = 0;
1353 char buf[STRLEN4096];
1354
1355
1356 EDstate->bFromCpt = bRead;
1357
1358 if (EDstate->nED <= 0)
1359 {
1360 return ret;
1361 }
1362
1363 /* When reading, init_edsam has not been called yet,
1364 * so we have to allocate memory first. */
1365 if (bRead)
1366 {
1367 snew(EDstate->nref, EDstate->nED)(EDstate->nref) = save_calloc("EDstate->nref", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1367, (EDstate->nED), sizeof(*(EDstate->nref)));
1368 snew(EDstate->old_sref, EDstate->nED)(EDstate->old_sref) = save_calloc("EDstate->old_sref", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1368, (EDstate->nED), sizeof(*(EDstate->old_sref)));
1369 snew(EDstate->nav, EDstate->nED)(EDstate->nav) = save_calloc("EDstate->nav", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1369, (EDstate->nED), sizeof(*(EDstate->nav)));
1370 snew(EDstate->old_sav, EDstate->nED)(EDstate->old_sav) = save_calloc("EDstate->old_sav", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1370, (EDstate->nED), sizeof(*(EDstate->old_sav)));
1371 }
1372
1373 /* Read/write the last whole conformation of SREF and SAV for each ED dataset (usually only one) */
1374 for (i = 0; i < EDstate->nED; i++)
1375 {
1376 /* Reference structure SREF */
1377 sprintf(buf, "ED%d # of atoms in reference structure", i+1);
1378 do_cpt_int_err(xd, buf, &EDstate->nref[i], list);
1379 sprintf(buf, "ED%d x_ref", i+1);
1380 if (bRead)
1381 {
1382 snew(EDstate->old_sref[i], EDstate->nref[i])(EDstate->old_sref[i]) = save_calloc("EDstate->old_sref[i]"
, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1382, (EDstate->nref[i]), sizeof(*(EDstate->old_sref[
i])));
1383 do_cpt_n_rvecs_err(xd, buf, EDstate->nref[i], EDstate->old_sref[i], list);
1384 }
1385 else
1386 {
1387 do_cpt_n_rvecs_err(xd, buf, EDstate->nref[i], EDstate->old_sref_p[i], list);
1388 }
1389
1390 /* Average structure SAV */
1391 sprintf(buf, "ED%d # of atoms in average structure", i+1);
1392 do_cpt_int_err(xd, buf, &EDstate->nav[i], list);
1393 sprintf(buf, "ED%d x_av", i+1);
1394 if (bRead)
1395 {
1396 snew(EDstate->old_sav[i], EDstate->nav[i])(EDstate->old_sav[i]) = save_calloc("EDstate->old_sav[i]"
, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1396, (EDstate->nav[i]), sizeof(*(EDstate->old_sav[i]
)));
1397 do_cpt_n_rvecs_err(xd, buf, EDstate->nav[i], EDstate->old_sav[i], list);
1398 }
1399 else
1400 {
1401 do_cpt_n_rvecs_err(xd, buf, EDstate->nav[i], EDstate->old_sav_p[i], list);
1402 }
1403 }
1404
1405 return ret;
1406}
1407
1408
1409static int do_cpt_files(XDR *xd, gmx_bool bRead,
1410 gmx_file_position_t **p_outputfiles, int *nfiles,
1411 FILE *list, int file_version)
1412{
1413 int i, j;
1414 gmx_off_t offset;
1415 gmx_off_t mask = 0xFFFFFFFFL;
1416 int offset_high, offset_low;
1417 char *buf;
1418 gmx_file_position_t *outputfiles;
1419
1420 if (do_cpt_int(xd, "number of output files", nfiles, list) != 0)
1421 {
1422 return -1;
1423 }
1424
1425 if (bRead)
1426 {
1427 snew(*p_outputfiles, *nfiles)(*p_outputfiles) = save_calloc("*p_outputfiles", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1427, (*nfiles), sizeof(*(*p_outputfiles)));
1428 }
1429
1430 outputfiles = *p_outputfiles;
1431
1432 for (i = 0; i < *nfiles; i++)
1433 {
1434 /* 64-bit XDR numbers are not portable, so it is stored as separate high/low fractions */
1435 if (bRead)
1436 {
1437 do_cpt_string_err(xd, bRead, "output filename", &buf, list);
1438 strncpy(outputfiles[i].filename, buf, CPTSTRLEN-1)__builtin_strncpy (outputfiles[i].filename, buf, 1024 -1);
1439 if (list == NULL((void*)0))
1440 {
1441 sfree(buf)save_free("buf", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1441, (buf));
1442 }
1443
1444 if (do_cpt_int(xd, "file_offset_high", &offset_high, list) != 0)
1445 {
1446 return -1;
1447 }
1448 if (do_cpt_int(xd, "file_offset_low", &offset_low, list) != 0)
1449 {
1450 return -1;
1451 }
1452 outputfiles[i].offset = ( ((gmx_off_t) offset_high) << 32 ) | ( (gmx_off_t) offset_low & mask );
1453 }
1454 else
1455 {
1456 buf = outputfiles[i].filename;
1457 do_cpt_string_err(xd, bRead, "output filename", &buf, list);
1458 /* writing */
1459 offset = outputfiles[i].offset;
1460 if (offset == -1)
1461 {
1462 offset_low = -1;
1463 offset_high = -1;
1464 }
1465 else
1466 {
1467 offset_low = (int) (offset & mask);
1468 offset_high = (int) ((offset >> 32) & mask);
1469 }
1470 if (do_cpt_int(xd, "file_offset_high", &offset_high, list) != 0)
1471 {
1472 return -1;
1473 }
1474 if (do_cpt_int(xd, "file_offset_low", &offset_low, list) != 0)
1475 {
1476 return -1;
1477 }
1478 }
1479 if (file_version >= 8)
1480 {
1481 if (do_cpt_int(xd, "file_checksum_size", &(outputfiles[i].chksum_size),
1482 list) != 0)
1483 {
1484 return -1;
1485 }
1486 if (do_cpt_u_chars(xd, "file_checksum", 16, outputfiles[i].chksum, list) != 0)
1487 {
1488 return -1;
1489 }
1490 }
1491 else
1492 {
1493 outputfiles[i].chksum_size = -1;
1494 }
1495 }
1496 return 0;
1497}
1498
1499
1500void write_checkpoint(const char *fn, gmx_bool bNumberAndKeep,
1501 FILE *fplog, t_commrec *cr,
1502 int eIntegrator, int simulation_part,
1503 gmx_bool bExpanded, int elamstats,
1504 gmx_int64_t step, double t, t_state *state)
1505{
1506 t_fileio *fp;
1507 int file_version;
1508 char *version;
1509 char *btime;
1510 char *buser;
1511 char *bhost;
1512 int double_prec;
1513 char *fprog;
1514 char *fntemp; /* the temporary checkpoint file name */
1515 time_t now;
1516 char timebuf[STRLEN4096];
1517 int nppnodes, npmenodes, flag_64bit;
1518 char buf[1024], suffix[5+STEPSTRSIZE22], sbuf[STEPSTRSIZE22];
1519 gmx_file_position_t *outputfiles;
1520 int noutputfiles;
1521 char *ftime;
1522 int flags_eks, flags_enh, flags_dfh, i;
1523 t_fileio *ret;
1524
1525 if (DOMAINDECOMP(cr)(((cr)->dd != ((void*)0)) && ((cr)->nnodes >
1)))
1526 {
1527 nppnodes = cr->dd->nnodes;
1528 npmenodes = cr->npmenodes;
1529 }
1530 else
1531 {
1532 nppnodes = 1;
1533 npmenodes = 0;
1534 }
1535
1536#ifndef GMX_NO_RENAME
1537 /* make the new temporary filename */
1538 snew(fntemp, strlen(fn)+5+STEPSTRSIZE)(fntemp) = save_calloc("fntemp", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1538, (strlen(fn)+5+22), sizeof(*(fntemp)));
1539 strcpy(fntemp, fn);
1540 fntemp[strlen(fn) - strlen(ftp2ext(fn2ftp(fn))) - 1] = '\0';
1541 sprintf(suffix, "_%s%s", "step", gmx_step_str(step, sbuf));
1542 strcat(fntemp, suffix);
1543 strcat(fntemp, fn+strlen(fn) - strlen(ftp2ext(fn2ftp(fn))) - 1);
1544#else
1545 /* if we can't rename, we just overwrite the cpt file.
1546 * dangerous if interrupted.
1547 */
1548 snew(fntemp, strlen(fn))(fntemp) = save_calloc("fntemp", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1548, (strlen(fn)), sizeof(*(fntemp)));
1549 strcpy(fntemp, fn);
1550#endif
1551 time(&now);
1552 gmx_ctime_r(&now, timebuf, STRLEN4096);
1553
1554 if (fplog)
1555 {
1556 fprintf(fplog, "Writing checkpoint, step %s at %s\n\n",
1557 gmx_step_str(step, buf), timebuf);
1558 }
1559
1560 /* Get offsets for open files */
1561 gmx_fio_get_output_file_positions(&outputfiles, &noutputfiles);
1562
1563 fp = gmx_fio_open(fntemp, "w");
1564
1565 if (state->ekinstate.bUpToDate)
1566 {
1567 flags_eks =
1568 ((1<<eeksEKIN_N) | (1<<eeksEKINH) | (1<<eeksEKINF) |
1569 (1<<eeksEKINO) | (1<<eeksEKINSCALEF) | (1<<eeksEKINSCALEH) |
1570 (1<<eeksVSCALE) | (1<<eeksDEKINDL) | (1<<eeksMVCOS));
1571 }
1572 else
1573 {
1574 flags_eks = 0;
1575 }
1576
1577 flags_enh = 0;
1578 if (state->enerhist.nsum > 0 || state->enerhist.nsum_sim > 0)
1579 {
1580 flags_enh |= (1<<eenhENERGY_N);
1581 if (state->enerhist.nsum > 0)
1582 {
1583 flags_enh |= ((1<<eenhENERGY_AVER) | (1<<eenhENERGY_SUM) |
1584 (1<<eenhENERGY_NSTEPS) | (1<<eenhENERGY_NSUM));
1585 }
1586 if (state->enerhist.nsum_sim > 0)
1587 {
1588 flags_enh |= ((1<<eenhENERGY_SUM_SIM) | (1<<eenhENERGY_NSTEPS_SIM) |
1589 (1<<eenhENERGY_NSUM_SIM));
1590 }
1591 if (state->enerhist.dht)
1592 {
1593 flags_enh |= ( (1<< eenhENERGY_DELTA_H_NN) |
1594 (1<< eenhENERGY_DELTA_H_LIST) |
1595 (1<< eenhENERGY_DELTA_H_STARTTIME) |
1596 (1<< eenhENERGY_DELTA_H_STARTLAMBDA) );
1597 }
1598 }
1599
1600 if (bExpanded)
1601 {
1602 flags_dfh = ((1<<edfhBEQUIL) | (1<<edfhNATLAMBDA) | (1<<edfhSUMWEIGHTS) | (1<<edfhSUMDG) |
1603 (1<<edfhTIJ) | (1<<edfhTIJEMP));
1604 if (EWL(elamstats)((elamstats) == elamstatsWL || (elamstats) == elamstatsWWL))
1605 {
1606 flags_dfh |= ((1<<edfhWLDELTA) | (1<<edfhWLHISTO));
1607 }
1608 if ((elamstats == elamstatsMINVAR) || (elamstats == elamstatsBARKER) || (elamstats == elamstatsMETROPOLIS))
1609 {
1610 flags_dfh |= ((1<<edfhACCUMP) | (1<<edfhACCUMM) | (1<<edfhACCUMP2) | (1<<edfhACCUMM2)
1611 | (1<<edfhSUMMINVAR) | (1<<edfhSUMVAR));
1612 }
1613 }
1614 else
1615 {
1616 flags_dfh = 0;
1617 }
1618
1619 /* We can check many more things now (CPU, acceleration, etc), but
1620 * it is highly unlikely to have two separate builds with exactly
1621 * the same version, user, time, and build host!
1622 */
1623
1624 version = gmx_strdup(gmx_version());
1625 btime = gmx_strdup(BUILD_TIME"Вс апр 20 15:08:31 MSK 2014");
1626 buser = gmx_strdup(BUILD_USER"alexxy@fermi [CMAKE]");
1627 bhost = gmx_strdup(BUILD_HOST"Linux 3.13.7-gentoo x86_64");
1628
1629 double_prec = GMX_CPT_BUILD_DP0;
1630 fprog = gmx_strdup(Program());
1631
1632 ftime = &(timebuf[0]);
1633
1634 do_cpt_header(gmx_fio_getxdr(fp), FALSE0, &file_version,
1635 &version, &btime, &buser, &bhost, &double_prec, &fprog, &ftime,
1636 &eIntegrator, &simulation_part, &step, &t, &nppnodes,
1637 DOMAINDECOMP(cr)(((cr)->dd != ((void*)0)) && ((cr)->nnodes >
1)) ? cr->dd->nc : NULL((void*)0), &npmenodes,
1638 &state->natoms, &state->ngtc, &state->nnhpres,
1639 &state->nhchainlength, &(state->dfhist.nlambda), &state->flags, &flags_eks, &flags_enh, &flags_dfh,
1640 &state->edsamstate.nED, &state->swapstate.eSwapCoords,
1641 NULL((void*)0));
1642
1643 sfree(version)save_free("version", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1643, (version));
1644 sfree(btime)save_free("btime", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1644, (btime));
1645 sfree(buser)save_free("buser", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1645, (buser));
1646 sfree(bhost)save_free("bhost", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1646, (bhost));
1647 sfree(fprog)save_free("fprog", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1647, (fprog));
1648
1649 if ((do_cpt_state(gmx_fio_getxdr(fp), FALSE0, state->flags, state, NULL((void*)0)) < 0) ||
1650 (do_cpt_ekinstate(gmx_fio_getxdr(fp), flags_eks, &state->ekinstate, NULL((void*)0)) < 0) ||
1651 (do_cpt_enerhist(gmx_fio_getxdr(fp), FALSE0, flags_enh, &state->enerhist, NULL((void*)0)) < 0) ||
1652 (do_cpt_df_hist(gmx_fio_getxdr(fp), flags_dfh, &state->dfhist, NULL((void*)0)) < 0) ||
1653 (do_cpt_EDstate(gmx_fio_getxdr(fp), FALSE0, &state->edsamstate, NULL((void*)0)) < 0) ||
1654 (do_cpt_swapstate(gmx_fio_getxdr(fp), FALSE0, &state->swapstate, NULL((void*)0)) < 0) ||
1655 (do_cpt_files(gmx_fio_getxdr(fp), FALSE0, &outputfiles, &noutputfiles, NULL((void*)0),
1656 file_version) < 0))
1657 {
1658 gmx_file("Cannot read/write checkpoint; corrupt file, or maybe you are out of disk space?")_gmx_error("file", "Cannot read/write checkpoint; corrupt file, or maybe you are out of disk space?"
, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1658);
1659 }
1660
1661 do_cpt_footer(gmx_fio_getxdr(fp), file_version);
1662
1663 /* we really, REALLY, want to make sure to physically write the checkpoint,
1664 and all the files it depends on, out to disk. Because we've
1665 opened the checkpoint with gmx_fio_open(), it's in our list
1666 of open files. */
1667 ret = gmx_fio_all_output_fsync();
1668
1669 if (ret)
1670 {
1671 char buf[STRLEN4096];
1672 sprintf(buf,
1673 "Cannot fsync '%s'; maybe you are out of disk space?",
1674 gmx_fio_getname(ret));
1675
1676 if (getenv(GMX_IGNORE_FSYNC_FAILURE_ENV"GMX_IGNORE_FSYNC_FAILURE") == NULL((void*)0))
1677 {
1678 gmx_file(buf)_gmx_error("file", buf, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1678);
1679 }
1680 else
1681 {
1682 gmx_warning(buf);
1683 }
1684 }
1685
1686 if (gmx_fio_close(fp) != 0)
1687 {
1688 gmx_file("Cannot read/write checkpoint; corrupt file, or maybe you are out of disk space?")_gmx_error("file", "Cannot read/write checkpoint; corrupt file, or maybe you are out of disk space?"
, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1688);
1689 }
1690
1691 /* we don't move the checkpoint if the user specified they didn't want it,
1692 or if the fsyncs failed */
1693#ifndef GMX_NO_RENAME
1694 if (!bNumberAndKeep && !ret)
1695 {
1696 if (gmx_fexist(fn))
1697 {
1698 /* Rename the previous checkpoint file */
1699 strcpy(buf, fn);
1700 buf[strlen(fn) - strlen(ftp2ext(fn2ftp(fn))) - 1] = '\0';
1701 strcat(buf, "_prev");
1702 strcat(buf, fn+strlen(fn) - strlen(ftp2ext(fn2ftp(fn))) - 1);
1703#ifndef GMX_FAHCORE
1704 /* we copy here so that if something goes wrong between now and
1705 * the rename below, there's always a state.cpt.
1706 * If renames are atomic (such as in POSIX systems),
1707 * this copying should be unneccesary.
1708 */
1709 gmx_file_copy(fn, buf, FALSE0);
1710 /* We don't really care if this fails:
1711 * there's already a new checkpoint.
1712 */
1713#else
1714 gmx_file_rename(fn, buf);
1715#endif
1716 }
1717 if (gmx_file_rename(fntemp, fn) != 0)
1718 {
1719 gmx_file("Cannot rename checkpoint file; maybe you are out of disk space?")_gmx_error("file", "Cannot rename checkpoint file; maybe you are out of disk space?"
, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1719);
1720 }
1721 }
1722#endif /* GMX_NO_RENAME */
1723
1724 sfree(outputfiles)save_free("outputfiles", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1724, (outputfiles));
1725 sfree(fntemp)save_free("fntemp", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1725, (fntemp));
1726
1727#ifdef GMX_FAHCORE
1728 /*code for alternate checkpointing scheme. moved from top of loop over
1729 steps */
1730 fcRequestCheckPoint();
1731 if (fcCheckPointParallel( cr->nodeid, NULL((void*)0), 0) == 0)
1732 {
1733 gmx_fatal( 3, __FILE__"/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c", __LINE__1733, "Checkpoint error on step %d\n", step );
1734 }
1735#endif /* end GMX_FAHCORE block */
1736}
1737
1738static void print_flag_mismatch(FILE *fplog, int sflags, int fflags)
1739{
1740 int i;
1741
1742 fprintf(fplog, "\nState entry mismatch between the simulation and the checkpoint file\n");
1743 fprintf(fplog, "Entries which are not present in the checkpoint file will not be updated\n");
1744 fprintf(fplog, " %24s %11s %11s\n", "", "simulation", "checkpoint");
1745 for (i = 0; i < estNR; i++)
1746 {
1747 if ((sflags & (1<<i)) || (fflags & (1<<i)))
1748 {
1749 fprintf(fplog, " %24s %11s %11s\n",
1750 est_names[i],
1751 (sflags & (1<<i)) ? " present " : "not present",
1752 (fflags & (1<<i)) ? " present " : "not present");
1753 }
1754 }
1755}
1756
1757static void check_int(FILE *fplog, const char *type, int p, int f, gmx_bool *mm)
1758{
1759 FILE *fp = fplog ? fplog : stderrstderr;
1760
1761 if (p != f)
1762 {
1763 fprintf(fp, " %s mismatch,\n", type);
1764 fprintf(fp, " current program: %d\n", p);
1765 fprintf(fp, " checkpoint file: %d\n", f);
1766 fprintf(fp, "\n");
1767 *mm = TRUE1;
1768 }
1769}
1770
1771static void check_string(FILE *fplog, const char *type, const char *p,
1772 const char *f, gmx_bool *mm)
1773{
1774 FILE *fp = fplog ? fplog : stderrstderr;
1775
1776 if (strcmp(p, f)__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(p) && __builtin_constant_p (f) && (__s1_len
= strlen (p), __s2_len = strlen (f), (!((size_t)(const void *
)((p) + 1) - (size_t)(const void *)(p) == 1) || __s1_len >=
4) && (!((size_t)(const void *)((f) + 1) - (size_t)(
const void *)(f) == 1) || __s2_len >= 4)) ? __builtin_strcmp
(p, f) : (__builtin_constant_p (p) && ((size_t)(const
void *)((p) + 1) - (size_t)(const void *)(p) == 1) &&
(__s1_len = strlen (p), __s1_len < 4) ? (__builtin_constant_p
(f) && ((size_t)(const void *)((f) + 1) - (size_t)(const
void *)(f) == 1) ? __builtin_strcmp (p, f) : (__extension__ (
{ const unsigned char *__s2 = (const unsigned char *) (const char
*) (f); int __result = (((const unsigned char *) (const char
*) (p))[0] - __s2[0]); if (__s1_len > 0 && __result
== 0) { __result = (((const unsigned char *) (const char *) (
p))[1] - __s2[1]); if (__s1_len > 1 && __result ==
0) { __result = (((const unsigned char *) (const char *) (p)
)[2] - __s2[2]); if (__s1_len > 2 && __result == 0
) __result = (((const unsigned char *) (const char *) (p))[3]
- __s2[3]); } } __result; }))) : (__builtin_constant_p (f) &&
((size_t)(const void *)((f) + 1) - (size_t)(const void *)(f)
== 1) && (__s2_len = strlen (f), __s2_len < 4) ? (
__builtin_constant_p (p) && ((size_t)(const void *)((
p) + 1) - (size_t)(const void *)(p) == 1) ? __builtin_strcmp (
p, f) : (- (__extension__ ({ const unsigned char *__s2 = (const
unsigned char *) (const char *) (p); int __result = (((const
unsigned char *) (const char *) (f))[0] - __s2[0]); if (__s2_len
> 0 && __result == 0) { __result = (((const unsigned
char *) (const char *) (f))[1] - __s2[1]); if (__s2_len >
1 && __result == 0) { __result = (((const unsigned char
*) (const char *) (f))[2] - __s2[2]); if (__s2_len > 2 &&
__result == 0) __result = (((const unsigned char *) (const char
*) (f))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp
(p, f)))); }) != 0)
1777 {
1778 fprintf(fp, " %s mismatch,\n", type);
1779 fprintf(fp, " current program: %s\n", p);
1780 fprintf(fp, " checkpoint file: %s\n", f);
1781 fprintf(fp, "\n");
1782 *mm = TRUE1;
1783 }
1784}
1785
1786static void check_match(FILE *fplog,
1787 char *version,
1788 char *btime, char *buser, char *bhost, int double_prec,
1789 char *fprog,
1790 t_commrec *cr, int npp_f, int npme_f,
1791 ivec dd_nc, ivec dd_nc_f)
1792{
1793 int npp;
1794 gmx_bool mm;
1795
1796 mm = FALSE0;
1797
1798 check_string(fplog, "Version", gmx_version(), version, &mm);
1799 check_string(fplog, "Build time", BUILD_TIME"Вс апр 20 15:08:31 MSK 2014", btime, &mm);
1800 check_string(fplog, "Build user", BUILD_USER"alexxy@fermi [CMAKE]", buser, &mm);
1801 check_string(fplog, "Build host", BUILD_HOST"Linux 3.13.7-gentoo x86_64", bhost, &mm);
1802 check_int (fplog, "Double prec.", GMX_CPT_BUILD_DP0, double_prec, &mm);
1803 check_string(fplog, "Program name", Program(), fprog, &mm);
1804
1805 check_int (fplog, "#nodes", cr->nnodes, npp_f+npme_f, &mm);
1806 if (cr->nnodes > 1)
1807 {
1808 check_int (fplog, "#PME-nodes", cr->npmenodes, npme_f, &mm);
1809
1810 npp = cr->nnodes;
1811 if (cr->npmenodes >= 0)
1812 {
1813 npp -= cr->npmenodes;
1814 }
1815 if (npp == npp_f)
1816 {
1817 check_int (fplog, "#DD-cells[x]", dd_nc[XX0], dd_nc_f[XX0], &mm);
1818 check_int (fplog, "#DD-cells[y]", dd_nc[YY1], dd_nc_f[YY1], &mm);
1819 check_int (fplog, "#DD-cells[z]", dd_nc[ZZ2], dd_nc_f[ZZ2], &mm);
1820 }
1821 }
1822
1823 if (mm)
1824 {
1825 fprintf(stderrstderr,
1826 "Gromacs binary or parallel settings not identical to previous run.\n"
1827 "Continuation is exact, but is not guaranteed to be binary identical%s.\n\n",
1828 fplog ? ",\n see the log file for details" : "");
1829
1830 if (fplog)
1831 {
1832 fprintf(fplog,
1833 "Gromacs binary or parallel settings not identical to previous run.\n"
1834 "Continuation is exact, but is not guaranteed to be binary identical.\n\n");
1835 }
1836 }
1837}
1838
1839static void read_checkpoint(const char *fn, FILE **pfplog,
1840 t_commrec *cr, ivec dd_nc,
1841 int eIntegrator, int *init_fep_state, gmx_int64_t *step, double *t,
1842 t_state *state, gmx_bool *bReadEkin,
1843 int *simulation_part,
1844 gmx_bool bAppendOutputFiles, gmx_bool bForceAppend)
1845{
1846 t_fileio *fp;
1847 int i, j, rc;
1848 int file_version;
1849 char *version, *btime, *buser, *bhost, *fprog, *ftime;
1850 int double_prec;
1851 char filename[STRLEN4096], buf[STEPSTRSIZE22];
1852 int nppnodes, eIntegrator_f, nppnodes_f, npmenodes_f;
1853 ivec dd_nc_f;
1854 int natoms, ngtc, nnhpres, nhchainlength, nlambda, fflags, flags_eks, flags_enh, flags_dfh;
1855 int d;
1856 int ret;
1857 gmx_file_position_t *outputfiles;
1858 int nfiles;
1859 t_fileio *chksum_file;
1860 FILE * fplog = *pfplog;
1861 unsigned char digest[16];
1862#if !defined __native_client__ && !defined GMX_NATIVE_WINDOWS
1863 struct flock fl; /* don't initialize here: the struct order is OS
1864 dependent! */
1865#endif
1866
1867 const char *int_warn =
1868 "WARNING: The checkpoint file was generated with integrator %s,\n"
1869 " while the simulation uses integrator %s\n\n";
1870
1871#if !defined __native_client__ && !defined GMX_NATIVE_WINDOWS
1872 fl.l_type = F_WRLCK1;
1873 fl.l_whence = SEEK_SET0;
1874 fl.l_start = 0;
1875 fl.l_len = 0;
1876 fl.l_pid = 0;
1877#endif
1878
1879 fp = gmx_fio_open(fn, "r");
1880 do_cpt_header(gmx_fio_getxdr(fp), TRUE1, &file_version,
1881 &version, &btime, &buser, &bhost, &double_prec, &fprog, &ftime,
1882 &eIntegrator_f, simulation_part, step, t,
1883 &nppnodes_f, dd_nc_f, &npmenodes_f,
1884 &natoms, &ngtc, &nnhpres, &nhchainlength, &nlambda,
1885 &fflags, &flags_eks, &flags_enh, &flags_dfh,
1886 &state->edsamstate.nED, &state->swapstate.eSwapCoords, NULL((void*)0));
1887
1888 if (bAppendOutputFiles &&
1889 file_version >= 13 && double_prec != GMX_CPT_BUILD_DP0)
1890 {
1891 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1891, "Output file appending requested, but the code and checkpoint file precision (single/double) don't match");
1892 }
1893
1894 if (cr == NULL((void*)0) || MASTER(cr)(((cr)->nodeid == 0) || !((cr)->nnodes > 1)))
1895 {
1896 fprintf(stderrstderr, "\nReading checkpoint file %s generated: %s\n\n",
1897 fn, ftime);
1898 }
1899
1900 /* This will not be written if we do appending, since fplog is still NULL then */
1901 if (fplog)
1902 {
1903 fprintf(fplog, "\n");
1904 fprintf(fplog, "Reading checkpoint file %s\n", fn);
1905 fprintf(fplog, " file generated by: %s\n", fprog);
1906 fprintf(fplog, " file generated at: %s\n", ftime);
1907 fprintf(fplog, " GROMACS build time: %s\n", btime);
1908 fprintf(fplog, " GROMACS build user: %s\n", buser);
1909 fprintf(fplog, " GROMACS build host: %s\n", bhost);
1910 fprintf(fplog, " GROMACS double prec.: %d\n", double_prec);
1911 fprintf(fplog, " simulation part #: %d\n", *simulation_part);
1912 fprintf(fplog, " step: %s\n", gmx_step_str(*step, buf));
1913 fprintf(fplog, " time: %f\n", *t);
1914 fprintf(fplog, "\n");
1915 }
1916
1917 if (natoms != state->natoms)
1918 {
1919 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1919, "Checkpoint file is for a system of %d atoms, while the current system consists of %d atoms", natoms, state->natoms);
1920 }
1921 if (ngtc != state->ngtc)
1922 {
1923 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1923, "Checkpoint file is for a system of %d T-coupling groups, while the current system consists of %d T-coupling groups", ngtc, state->ngtc);
1924 }
1925 if (nnhpres != state->nnhpres)
1926 {
1927 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1927, "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);
1928 }
1929
1930 if (nlambda != state->dfhist.nlambda)
1931 {
1932 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1932, "Checkpoint file is for a system with %d lambda states, while the current system consists of %d lambda states", nlambda, state->dfhist.nlambda);
1933 }
1934
1935 init_gtc_state(state, state->ngtc, state->nnhpres, nhchainlength); /* need to keep this here to keep the tpr format working */
1936 /* write over whatever was read; we use the number of Nose-Hoover chains from the checkpoint */
1937
1938 if (eIntegrator_f != eIntegrator)
1939 {
1940 if (MASTER(cr)(((cr)->nodeid == 0) || !((cr)->nnodes > 1)))
1941 {
1942 fprintf(stderrstderr, int_warn, EI(eIntegrator_f)((((eIntegrator_f) < 0) || ((eIntegrator_f) >= (eiNR)))
? "UNDEFINED" : (ei_names)[eIntegrator_f]), EI(eIntegrator)((((eIntegrator) < 0) || ((eIntegrator) >= (eiNR))) ? "UNDEFINED"
: (ei_names)[eIntegrator]));
1943 }
1944 if (bAppendOutputFiles)
1945 {
1946 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1946,
1947 "Output file appending requested, but input/checkpoint integrators do not match.\n"
1948 "Stopping the run to prevent you from ruining all your data...\n"
1949 "If you _really_ know what you are doing, try with the -noappend option.\n");
1950 }
1951 if (fplog)
1952 {
1953 fprintf(fplog, int_warn, EI(eIntegrator_f)((((eIntegrator_f) < 0) || ((eIntegrator_f) >= (eiNR)))
? "UNDEFINED" : (ei_names)[eIntegrator_f]), EI(eIntegrator)((((eIntegrator) < 0) || ((eIntegrator) >= (eiNR))) ? "UNDEFINED"
: (ei_names)[eIntegrator]));
1954 }
1955 }
1956
1957 if (!PAR(cr)((cr)->nnodes > 1))
1958 {
1959 nppnodes = 1;
Value stored to 'nppnodes' is never read
1960 cr->npmenodes = 0;
1961 }
1962 else if (cr->nnodes == nppnodes_f + npmenodes_f)
1963 {
1964 if (cr->npmenodes < 0)
1965 {
1966 cr->npmenodes = npmenodes_f;
1967 }
1968 nppnodes = cr->nnodes - cr->npmenodes;
1969 if (nppnodes == nppnodes_f)
1970 {
1971 for (d = 0; d < DIM3; d++)
1972 {
1973 if (dd_nc[d] == 0)
1974 {
1975 dd_nc[d] = dd_nc_f[d];
1976 }
1977 }
1978 }
1979 }
1980 else
1981 {
1982 /* The number of PP nodes has not been set yet */
1983 nppnodes = -1;
1984 }
1985
1986 if (fflags != state->flags)
1987 {
1988
1989 if (MASTER(cr)(((cr)->nodeid == 0) || !((cr)->nnodes > 1)))
1990 {
1991 if (bAppendOutputFiles)
1992 {
1993 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 1993,
1994 "Output file appending requested, but input and checkpoint states are not identical.\n"
1995 "Stopping the run to prevent you from ruining all your data...\n"
1996 "You can try with the -noappend option, and get more info in the log file.\n");
1997 }
1998
1999 if (getenv("GMX_ALLOW_CPT_MISMATCH") == NULL((void*)0))
2000 {
2001 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2001, "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");
2002 }
2003 else
2004 {
2005 fprintf(stderrstderr,
2006 "WARNING: The checkpoint state entries do not match the simulation,\n"
2007 " see the log file for details\n\n");
2008 }
2009 }
2010
2011 if (fplog)
2012 {
2013 print_flag_mismatch(fplog, state->flags, fflags);
2014 }
2015 }
2016 else
2017 {
2018 if (MASTER(cr)(((cr)->nodeid == 0) || !((cr)->nnodes > 1)))
2019 {
2020 check_match(fplog, version, btime, buser, bhost, double_prec, fprog,
2021 cr, nppnodes_f, npmenodes_f, dd_nc, dd_nc_f);
2022 }
2023 }
2024 ret = do_cpt_state(gmx_fio_getxdr(fp), TRUE1, fflags, state, NULL((void*)0));
2025 *init_fep_state = state->fep_state; /* there should be a better way to do this than setting it here.
2026 Investigate for 5.0. */
2027 if (ret)
2028 {
2029 cp_error();
2030 }
2031 ret = do_cpt_ekinstate(gmx_fio_getxdr(fp), flags_eks, &state->ekinstate, NULL((void*)0));
2032 if (ret)
2033 {
2034 cp_error();
2035 }
2036 *bReadEkin = ((flags_eks & (1<<eeksEKINH)) || (flags_eks & (1<<eeksEKINF)) || (flags_eks & (1<<eeksEKINO)) ||
2037 ((flags_eks & (1<<eeksEKINSCALEF)) | (flags_eks & (1<<eeksEKINSCALEH)) | (flags_eks & (1<<eeksVSCALE))));
2038
2039 ret = do_cpt_enerhist(gmx_fio_getxdr(fp), TRUE1,
2040 flags_enh, &state->enerhist, NULL((void*)0));
2041 if (ret)
2042 {
2043 cp_error();
2044 }
2045
2046 if (file_version < 6)
2047 {
2048 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.";
2049
2050 fprintf(stderrstderr, "\nWARNING: %s\n\n", warn);
2051 if (fplog)
2052 {
2053 fprintf(fplog, "\nWARNING: %s\n\n", warn);
2054 }
2055 state->enerhist.nsum = *step;
2056 state->enerhist.nsum_sim = *step;
2057 }
2058
2059 ret = do_cpt_df_hist(gmx_fio_getxdr(fp), flags_dfh, &state->dfhist, NULL((void*)0));
2060 if (ret)
2061 {
2062 cp_error();
2063 }
2064
2065 ret = do_cpt_swapstate(gmx_fio_getxdr(fp), TRUE1, &state->swapstate, NULL((void*)0));
2066 if (ret)
2067 {
2068 cp_error();
2069 }
2070
2071 ret = do_cpt_EDstate(gmx_fio_getxdr(fp), TRUE1, &state->edsamstate, NULL((void*)0));
2072 if (ret)
2073 {
2074 cp_error();
2075 }
2076
2077 ret = do_cpt_files(gmx_fio_getxdr(fp), TRUE1, &outputfiles, &nfiles, NULL((void*)0), file_version);
2078 if (ret)
2079 {
2080 cp_error();
2081 }
2082
2083 ret = do_cpt_footer(gmx_fio_getxdr(fp), file_version);
2084 if (ret)
2085 {
2086 cp_error();
2087 }
2088 if (gmx_fio_close(fp) != 0)
2089 {
2090 gmx_file("Cannot read/write checkpoint; corrupt file, or maybe you are out of disk space?")_gmx_error("file", "Cannot read/write checkpoint; corrupt file, or maybe you are out of disk space?"
, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2090);
2091 }
2092
2093 sfree(fprog)save_free("fprog", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2093, (fprog));
2094 sfree(ftime)save_free("ftime", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2094, (ftime));
2095 sfree(btime)save_free("btime", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2095, (btime));
2096 sfree(buser)save_free("buser", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2096, (buser));
2097 sfree(bhost)save_free("bhost", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2097, (bhost));
2098
2099 /* If the user wants to append to output files,
2100 * we use the file pointer positions of the output files stored
2101 * in the checkpoint file and truncate the files such that any frames
2102 * written after the checkpoint time are removed.
2103 * All files are md5sum checked such that we can be sure that
2104 * we do not truncate other (maybe imprortant) files.
2105 */
2106 if (bAppendOutputFiles)
2107 {
2108 if (fn2ftp(outputfiles[0].filename) != efLOG)
2109 {
2110 /* make sure first file is log file so that it is OK to use it for
2111 * locking
2112 */
2113 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2113, "The first output file should always be the log "
2114 "file but instead is: %s. Cannot do appending because of this condition.", outputfiles[0].filename);
2115 }
2116 for (i = 0; i < nfiles; i++)
2117 {
2118 if (outputfiles[i].offset < 0)
2119 {
2120 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2120, "The original run wrote a file called '%s' which "
2121 "is larger than 2 GB, but mdrun did not support large file"
2122 " offsets. Can not append. Run mdrun with -noappend",
2123 outputfiles[i].filename);
2124 }
2125#ifdef GMX_FAHCORE
2126 chksum_file = gmx_fio_open(outputfiles[i].filename, "a");
2127
2128#else
2129 chksum_file = gmx_fio_open(outputfiles[i].filename, "r+");
2130
2131 /* lock log file */
2132 if (i == 0)
2133 {
2134 /* Note that there are systems where the lock operation
2135 * will succeed, but a second process can also lock the file.
2136 * We should probably try to detect this.
2137 */
2138#if defined __native_client__
2139 errno(*__errno_location ()) = ENOSYS38;
2140 if (1)
2141
2142#elif defined GMX_NATIVE_WINDOWS
2143 if (_locking(fileno(gmx_fio_getfp(chksum_file)), _LK_NBLCK, LONG_MAX9223372036854775807L) == -1)
2144#else
2145 if (fcntl(fileno(gmx_fio_getfp(chksum_file)), F_SETLK6, &fl) == -1)
2146#endif
2147 {
2148 if (errno(*__errno_location ()) == ENOSYS38)
2149 {
2150 if (!bForceAppend)
2151 {
2152 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2152, "File locking is not supported on this system. Use -noappend or specify -append explicitly to append anyhow.");
2153 }
2154 else
2155 {
2156 fprintf(stderrstderr, "\nNOTE: File locking is not supported on this system, will not lock %s\n\n", outputfiles[i].filename);
2157 if (fplog)
2158 {
2159 fprintf(fplog, "\nNOTE: File locking not supported on this system, will not lock %s\n\n", outputfiles[i].filename);
2160 }
2161 }
2162 }
2163 else if (errno(*__errno_location ()) == EACCES13 || errno(*__errno_location ()) == EAGAIN11)
2164 {
2165 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2165, "Failed to lock: %s. Already running "
2166 "simulation?", outputfiles[i].filename);
2167 }
2168 else
2169 {
2170 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2170, "Failed to lock: %s. %s.",
2171 outputfiles[i].filename, strerror(errno(*__errno_location ())));
2172 }
2173 }
2174 }
2175
2176 /* compute md5 chksum */
2177 if (outputfiles[i].chksum_size != -1)
2178 {
2179 if (gmx_fio_get_file_md5(chksum_file, outputfiles[i].offset,
2180 digest) != outputfiles[i].chksum_size) /*at the end of the call the file position is at the end of the file*/
2181 {
2182 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2182, "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.",
2183 outputfiles[i].chksum_size,
2184 outputfiles[i].filename);
2185 }
2186 }
2187 if (i == 0) /*log file needs to be seeked in case we need to truncate (other files are truncated below)*/
2188 {
2189 if (gmx_fio_seek(chksum_file, outputfiles[i].offset))
2190 {
2191 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2191, "Seek error! Failed to truncate log-file: %s.", strerror(errno(*__errno_location ())));
2192 }
2193 }
2194#endif
2195
2196 if (i == 0) /*open log file here - so that lock is never lifted
2197 after chksum is calculated */
2198 {
2199 *pfplog = gmx_fio_getfp(chksum_file);
2200 }
2201 else
2202 {
2203 gmx_fio_close(chksum_file);
2204 }
2205#ifndef GMX_FAHCORE
2206 /* compare md5 chksum */
2207 if (outputfiles[i].chksum_size != -1 &&
2208 memcmp(digest, outputfiles[i].chksum, 16) != 0)
2209 {
2210 if (debug)
2211 {
2212 fprintf(debug, "chksum for %s: ", outputfiles[i].filename);
2213 for (j = 0; j < 16; j++)
2214 {
2215 fprintf(debug, "%02x", digest[j]);
2216 }
2217 fprintf(debug, "\n");
2218 }
2219 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2219, "Checksum wrong for '%s'. The file has been replaced or its contents have been modified. Cannot do appending because of this condition.",
2220 outputfiles[i].filename);
2221 }
2222#endif
2223
2224
2225 if (i != 0) /*log file is already seeked to correct position */
2226 {
2227#ifdef GMX_NATIVE_WINDOWS
2228 rc = gmx_wintruncate(outputfiles[i].filename, outputfiles[i].offset);
2229#else
2230 rc = truncate(outputfiles[i].filename, outputfiles[i].offset);
2231#endif
2232 if (rc != 0)
2233 {
2234 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2234, "Truncation of file %s failed. Cannot do appending because of this failure.", outputfiles[i].filename);
2235 }
2236 }
2237 }
2238 }
2239
2240 sfree(outputfiles)save_free("outputfiles", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2240, (outputfiles));
2241}
2242
2243
2244void load_checkpoint(const char *fn, FILE **fplog,
2245 t_commrec *cr, ivec dd_nc,
2246 t_inputrec *ir, t_state *state,
2247 gmx_bool *bReadEkin,
2248 gmx_bool bAppend, gmx_bool bForceAppend)
2249{
2250 gmx_int64_t step;
2251 double t;
2252
2253 if (SIMMASTER(cr)(((((cr)->nodeid == 0) || !((cr)->nnodes > 1)) &&
((cr)->duty & (1<<0))) || !((cr)->nnodes >
1)))
2254 {
2255 /* Read the state from the checkpoint file */
2256 read_checkpoint(fn, fplog,
2257 cr, dd_nc,
2258 ir->eI, &(ir->fepvals->init_fep_state), &step, &t, state, bReadEkin,
2259 &ir->simulation_part, bAppend, bForceAppend);
2260 }
2261 if (PAR(cr)((cr)->nnodes > 1))
2262 {
2263 gmx_bcast(sizeof(cr->npmenodes), &cr->npmenodes, cr);
2264 gmx_bcast(DIM3*sizeof(dd_nc[0]), dd_nc, cr);
2265 gmx_bcast(sizeof(step), &step, cr);
2266 gmx_bcast(sizeof(*bReadEkin), bReadEkin, cr);
2267 }
2268 ir->bContinuation = TRUE1;
2269 if (ir->nsteps >= 0)
2270 {
2271 ir->nsteps += ir->init_step - step;
2272 }
2273 ir->init_step = step;
2274 ir->simulation_part += 1;
2275}
2276
2277static void read_checkpoint_data(t_fileio *fp, int *simulation_part,
2278 gmx_int64_t *step, double *t, t_state *state,
2279 int *nfiles, gmx_file_position_t **outputfiles)
2280{
2281 int file_version;
2282 char *version, *btime, *buser, *bhost, *fprog, *ftime;
2283 int double_prec;
2284 int eIntegrator;
2285 int nppnodes, npme;
2286 ivec dd_nc;
2287 int flags_eks, flags_enh, flags_dfh;
2288 int nfiles_loc;
2289 gmx_file_position_t *files_loc = NULL((void*)0);
2290 int ret;
2291
2292 do_cpt_header(gmx_fio_getxdr(fp), TRUE1, &file_version,
2293 &version, &btime, &buser, &bhost, &double_prec, &fprog, &ftime,
2294 &eIntegrator, simulation_part, step, t, &nppnodes, dd_nc, &npme,
2295 &state->natoms, &state->ngtc, &state->nnhpres, &state->nhchainlength,
2296 &(state->dfhist.nlambda), &state->flags, &flags_eks, &flags_enh, &flags_dfh,
2297 &state->edsamstate.nED, &state->swapstate.eSwapCoords, NULL((void*)0));
2298 ret =
2299 do_cpt_state(gmx_fio_getxdr(fp), TRUE1, state->flags, state, NULL((void*)0));
2300 if (ret)
2301 {
2302 cp_error();
2303 }
2304 ret = do_cpt_ekinstate(gmx_fio_getxdr(fp), flags_eks, &state->ekinstate, NULL((void*)0));
2305 if (ret)
2306 {
2307 cp_error();
2308 }
2309 ret = do_cpt_enerhist(gmx_fio_getxdr(fp), TRUE1,
2310 flags_enh, &state->enerhist, NULL((void*)0));
2311 if (ret)
2312 {
2313 cp_error();
2314 }
2315 ret = do_cpt_df_hist(gmx_fio_getxdr(fp), flags_dfh, &state->dfhist, NULL((void*)0));
2316 if (ret)
2317 {
2318 cp_error();
2319 }
2320
2321 ret = do_cpt_EDstate(gmx_fio_getxdr(fp), TRUE1, &state->edsamstate, NULL((void*)0));
2322 if (ret)
2323 {
2324 cp_error();
2325 }
2326
2327 ret = do_cpt_swapstate(gmx_fio_getxdr(fp), TRUE1, &state->swapstate, NULL((void*)0));
2328 if (ret)
2329 {
2330 cp_error();
2331 }
2332
2333 ret = do_cpt_files(gmx_fio_getxdr(fp), TRUE1,
2334 outputfiles != NULL((void*)0) ? outputfiles : &files_loc,
2335 outputfiles != NULL((void*)0) ? nfiles : &nfiles_loc,
2336 NULL((void*)0), file_version);
2337 if (files_loc != NULL((void*)0))
2338 {
2339 sfree(files_loc)save_free("files_loc", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2339, (files_loc));
2340 }
2341
2342 if (ret)
2343 {
2344 cp_error();
2345 }
2346
2347 ret = do_cpt_footer(gmx_fio_getxdr(fp), file_version);
2348 if (ret)
2349 {
2350 cp_error();
2351 }
2352
2353 sfree(fprog)save_free("fprog", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2353, (fprog));
2354 sfree(ftime)save_free("ftime", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2354, (ftime));
2355 sfree(btime)save_free("btime", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2355, (btime));
2356 sfree(buser)save_free("buser", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2356, (buser));
2357 sfree(bhost)save_free("bhost", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2357, (bhost));
2358}
2359
2360void
2361read_checkpoint_state(const char *fn, int *simulation_part,
2362 gmx_int64_t *step, double *t, t_state *state)
2363{
2364 t_fileio *fp;
2365
2366 fp = gmx_fio_open(fn, "r");
2367 read_checkpoint_data(fp, simulation_part, step, t, state, NULL((void*)0), NULL((void*)0));
2368 if (gmx_fio_close(fp) != 0)
2369 {
2370 gmx_file("Cannot read/write checkpoint; corrupt file, or maybe you are out of disk space?")_gmx_error("file", "Cannot read/write checkpoint; corrupt file, or maybe you are out of disk space?"
, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2370);
2371 }
2372}
2373
2374void read_checkpoint_trxframe(t_fileio *fp, t_trxframe *fr)
2375{
2376 /* This next line is nasty because the sub-structures of t_state
2377 * cannot be assumed to be zeroed (or even initialized in ways the
2378 * rest of the code might assume). Using snew would be better, but
2379 * this will all go away for 5.0. */
2380 t_state state;
2381 int simulation_part;
2382 gmx_int64_t step;
2383 double t;
2384
2385 init_state(&state, 0, 0, 0, 0, 0);
2386
2387 read_checkpoint_data(fp, &simulation_part, &step, &t, &state, NULL((void*)0), NULL((void*)0));
2388
2389 fr->natoms = state.natoms;
2390 fr->bTitle = FALSE0;
2391 fr->bStep = TRUE1;
2392 fr->step = gmx_int64_to_int(step,
2393 "conversion of checkpoint to trajectory");
2394 fr->bTime = TRUE1;
2395 fr->time = t;
2396 fr->bLambda = TRUE1;
2397 fr->lambda = state.lambda[efptFEP];
2398 fr->fep_state = state.fep_state;
2399 fr->bAtoms = FALSE0;
2400 fr->bX = (state.flags & (1<<estX));
2401 if (fr->bX)
2402 {
2403 fr->x = state.x;
2404 state.x = NULL((void*)0);
2405 }
2406 fr->bV = (state.flags & (1<<estV));
2407 if (fr->bV)
2408 {
2409 fr->v = state.v;
2410 state.v = NULL((void*)0);
2411 }
2412 fr->bF = FALSE0;
2413 fr->bBox = (state.flags & (1<<estBOX));
2414 if (fr->bBox)
2415 {
2416 copy_mat(state.box, fr->box);
2417 }
2418 done_state(&state);
2419}
2420
2421void list_checkpoint(const char *fn, FILE *out)
2422{
2423 t_fileio *fp;
2424 int file_version;
2425 char *version, *btime, *buser, *bhost, *fprog, *ftime;
2426 int double_prec;
2427 int eIntegrator, simulation_part, nppnodes, npme;
2428 gmx_int64_t step;
2429 double t;
2430 ivec dd_nc;
2431 t_state state;
2432 int flags_eks, flags_enh, flags_dfh;
2433 int indent;
2434 int i, j;
2435 int ret;
2436 gmx_file_position_t *outputfiles;
2437 int nfiles;
2438
2439 init_state(&state, -1, -1, -1, -1, 0);
2440
2441 fp = gmx_fio_open(fn, "r");
2442 do_cpt_header(gmx_fio_getxdr(fp), TRUE1, &file_version,
2443 &version, &btime, &buser, &bhost, &double_prec, &fprog, &ftime,
2444 &eIntegrator, &simulation_part, &step, &t, &nppnodes, dd_nc, &npme,
2445 &state.natoms, &state.ngtc, &state.nnhpres, &state.nhchainlength,
2446 &(state.dfhist.nlambda), &state.flags,
2447 &flags_eks, &flags_enh, &flags_dfh, &state.edsamstate.nED,
2448 &state.swapstate.eSwapCoords, out);
2449 ret = do_cpt_state(gmx_fio_getxdr(fp), TRUE1, state.flags, &state, out);
2450 if (ret)
2451 {
2452 cp_error();
2453 }
2454 ret = do_cpt_ekinstate(gmx_fio_getxdr(fp), flags_eks, &state.ekinstate, out);
2455 if (ret)
2456 {
2457 cp_error();
2458 }
2459 ret = do_cpt_enerhist(gmx_fio_getxdr(fp), TRUE1,
2460 flags_enh, &state.enerhist, out);
2461
2462 if (ret == 0)
2463 {
2464 ret = do_cpt_df_hist(gmx_fio_getxdr(fp),
2465 flags_dfh, &state.dfhist, out);
2466 }
2467
2468 if (ret == 0)
2469 {
2470 ret = do_cpt_EDstate(gmx_fio_getxdr(fp), TRUE1, &state.edsamstate, out);
2471 }
2472
2473 if (ret == 0)
2474 {
2475 ret = do_cpt_swapstate(gmx_fio_getxdr(fp), TRUE1, &state.swapstate, out);
2476 }
2477
2478 if (ret == 0)
2479 {
2480 do_cpt_files(gmx_fio_getxdr(fp), TRUE1, &outputfiles, &nfiles, out, file_version);
2481 }
2482
2483 if (ret == 0)
2484 {
2485 ret = do_cpt_footer(gmx_fio_getxdr(fp), file_version);
2486 }
2487
2488 if (ret)
2489 {
2490 cp_warning(out);
2491 }
2492 if (gmx_fio_close(fp) != 0)
2493 {
2494 gmx_file("Cannot read/write checkpoint; corrupt file, or maybe you are out of disk space?")_gmx_error("file", "Cannot read/write checkpoint; corrupt file, or maybe you are out of disk space?"
, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2494);
2495 }
2496
2497 done_state(&state);
2498}
2499
2500
2501static gmx_bool exist_output_file(const char *fnm_cp, int nfile, const t_filenm fnm[])
2502{
2503 int i;
2504
2505 /* Check if the output file name stored in the checkpoint file
2506 * is one of the output file names of mdrun.
2507 */
2508 i = 0;
2509 while (i < nfile &&
2510 !(is_output(&fnm[i]) && strcmp(fnm_cp, fnm[i].fns[0])__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p
(fnm_cp) && __builtin_constant_p (fnm[i].fns[0]) &&
(__s1_len = strlen (fnm_cp), __s2_len = strlen (fnm[i].fns[0
]), (!((size_t)(const void *)((fnm_cp) + 1) - (size_t)(const void
*)(fnm_cp) == 1) || __s1_len >= 4) && (!((size_t)
(const void *)((fnm[i].fns[0]) + 1) - (size_t)(const void *)(
fnm[i].fns[0]) == 1) || __s2_len >= 4)) ? __builtin_strcmp
(fnm_cp, fnm[i].fns[0]) : (__builtin_constant_p (fnm_cp) &&
((size_t)(const void *)((fnm_cp) + 1) - (size_t)(const void *
)(fnm_cp) == 1) && (__s1_len = strlen (fnm_cp), __s1_len
< 4) ? (__builtin_constant_p (fnm[i].fns[0]) && (
(size_t)(const void *)((fnm[i].fns[0]) + 1) - (size_t)(const void
*)(fnm[i].fns[0]) == 1) ? __builtin_strcmp (fnm_cp, fnm[i].fns
[0]) : (__extension__ ({ const unsigned char *__s2 = (const unsigned
char *) (const char *) (fnm[i].fns[0]); int __result = (((const
unsigned char *) (const char *) (fnm_cp))[0] - __s2[0]); if (
__s1_len > 0 && __result == 0) { __result = (((const
unsigned char *) (const char *) (fnm_cp))[1] - __s2[1]); if (
__s1_len > 1 && __result == 0) { __result = (((const
unsigned char *) (const char *) (fnm_cp))[2] - __s2[2]); if (
__s1_len > 2 && __result == 0) __result = (((const
unsigned char *) (const char *) (fnm_cp))[3] - __s2[3]); } }
__result; }))) : (__builtin_constant_p (fnm[i].fns[0]) &&
((size_t)(const void *)((fnm[i].fns[0]) + 1) - (size_t)(const
void *)(fnm[i].fns[0]) == 1) && (__s2_len = strlen (
fnm[i].fns[0]), __s2_len < 4) ? (__builtin_constant_p (fnm_cp
) && ((size_t)(const void *)((fnm_cp) + 1) - (size_t)
(const void *)(fnm_cp) == 1) ? __builtin_strcmp (fnm_cp, fnm[
i].fns[0]) : (- (__extension__ ({ const unsigned char *__s2 =
(const unsigned char *) (const char *) (fnm_cp); int __result
= (((const unsigned char *) (const char *) (fnm[i].fns[0]))[
0] - __s2[0]); if (__s2_len > 0 && __result == 0) {
__result = (((const unsigned char *) (const char *) (fnm[i].
fns[0]))[1] - __s2[1]); if (__s2_len > 1 && __result
== 0) { __result = (((const unsigned char *) (const char *) (
fnm[i].fns[0]))[2] - __s2[2]); if (__s2_len > 2 &&
__result == 0) __result = (((const unsigned char *) (const char
*) (fnm[i].fns[0]))[3] - __s2[3]); } } __result; })))) : __builtin_strcmp
(fnm_cp, fnm[i].fns[0])))); }) == 0))
2511 {
2512 i++;
2513 }
2514
2515 return (i < nfile && gmx_fexist(fnm_cp));
2516}
2517
2518/* This routine cannot print tons of data, since it is called before the log file is opened. */
2519gmx_bool read_checkpoint_simulation_part(const char *filename, int *simulation_part,
2520 gmx_int64_t *cpt_step, t_commrec *cr,
2521 gmx_bool bAppendReq,
2522 int nfile, const t_filenm fnm[],
2523 const char *part_suffix, gmx_bool *bAddPart)
2524{
2525 t_fileio *fp;
2526 gmx_int64_t step = 0;
2527 double t;
2528 /* This next line is nasty because the sub-structures of t_state
2529 * cannot be assumed to be zeroed (or even initialized in ways the
2530 * rest of the code might assume). Using snew would be better, but
2531 * this will all go away for 5.0. */
2532 t_state state;
2533 int nfiles;
2534 gmx_file_position_t *outputfiles;
2535 int nexist, f;
2536 gmx_bool bAppend;
2537 char *fn, suf_up[STRLEN4096];
2538
2539 bAppend = FALSE0;
2540
2541 if (SIMMASTER(cr)(((((cr)->nodeid == 0) || !((cr)->nnodes > 1)) &&
((cr)->duty & (1<<0))) || !((cr)->nnodes >
1)))
2542 {
2543 if (!gmx_fexist(filename) || (!(fp = gmx_fio_open(filename, "r")) ))
2544 {
2545 *simulation_part = 0;
2546 }
2547 else
2548 {
2549 init_state(&state, 0, 0, 0, 0, 0);
2550
2551 read_checkpoint_data(fp, simulation_part, &step, &t, &state,
2552 &nfiles, &outputfiles);
2553 if (gmx_fio_close(fp) != 0)
2554 {
2555 gmx_file("Cannot read/write checkpoint; corrupt file, or maybe you are out of disk space?")_gmx_error("file", "Cannot read/write checkpoint; corrupt file, or maybe you are out of disk space?"
, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2555);
2556 }
2557 done_state(&state);
2558
2559 if (bAppendReq)
2560 {
2561 nexist = 0;
2562 for (f = 0; f < nfiles; f++)
2563 {
2564 if (exist_output_file(outputfiles[f].filename, nfile, fnm))
2565 {
2566 nexist++;
2567 }
2568 }
2569 if (nexist == nfiles)
2570 {
2571 bAppend = bAppendReq;
2572 }
2573 else if (nexist > 0)
2574 {
2575 fprintf(stderrstderr,
2576 "Output file appending has been requested,\n"
2577 "but some output files listed in the checkpoint file %s\n"
2578 "are not present or are named differently by the current program:\n",
2579 filename);
2580 fprintf(stderrstderr, "output files present:");
2581 for (f = 0; f < nfiles; f++)
2582 {
2583 if (exist_output_file(outputfiles[f].filename,
2584 nfile, fnm))
2585 {
2586 fprintf(stderrstderr, " %s", outputfiles[f].filename);
2587 }
2588 }
2589 fprintf(stderrstderr, "\n");
2590 fprintf(stderrstderr, "output files not present or named differently:");
2591 for (f = 0; f < nfiles; f++)
2592 {
2593 if (!exist_output_file(outputfiles[f].filename,
2594 nfile, fnm))
2595 {
2596 fprintf(stderrstderr, " %s", outputfiles[f].filename);
2597 }
2598 }
2599 fprintf(stderrstderr, "\n");
2600
2601 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2601, "File appending requested, but only %d of the %d output files are present", nexist, nfiles);
2602 }
2603 }
2604
2605 if (bAppend)
2606 {
2607 if (nfiles == 0)
2608 {
2609 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2609, "File appending requested, but no output file information is stored in the checkpoint file");
2610 }
2611 fn = outputfiles[0].filename;
2612 if (strlen(fn) < 4 ||
2613 gmx_strcasecmp(fn+strlen(fn)-4, ftp2ext(efLOG)) == 0)
2614 {
2615 gmx_fatal(FARGS0, "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2615, "File appending requested, but the log file is not the first file listed in the checkpoint file");
2616 }
2617 /* Set bAddPart to whether the suffix string '.part' is present
2618 * in the log file name.
2619 */
2620 strcpy(suf_up, part_suffix);
2621 upstring(suf_up);
2622 *bAddPart = (strstr(fn, part_suffix) != NULL((void*)0) ||
2623 strstr(fn, suf_up) != NULL((void*)0));
2624 }
2625
2626 sfree(outputfiles)save_free("outputfiles", "/home/alexxy/Develop/gromacs/src/gromacs/gmxlib/checkpoint.c"
, 2626, (outputfiles));
2627 }
2628 }
2629 if (PAR(cr)((cr)->nnodes > 1))
2630 {
2631 gmx_bcast(sizeof(*simulation_part), simulation_part, cr);
2632
2633 if (*simulation_part > 0 && bAppendReq)
2634 {
2635 gmx_bcast(sizeof(bAppend), &bAppend, cr);
2636 gmx_bcast(sizeof(*bAddPart), bAddPart, cr);
2637 }
2638 }
2639 if (NULL((void*)0) != cpt_step)
2640 {
2641 *cpt_step = step;
2642 }
2643
2644 return bAppend;
2645}