?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Removed -skip option from gmx energy
[gromacs.git] / src / gromacs / gmxana / gmx_energy.cpp
blobc756e4e777b7ad14112f995c83bc86cf5d94214f
1 /*
2 * This file is part of the GROMACS molecular simulation package.
3 *
4 * Copyright (c) 1991-2000, University of Groningen, The Netherlands.
5 * Copyright (c) 2001-2004, The GROMACS development team.
6 * Copyright (c) 2013,2014,2015,2016,2017, by the GROMACS development team, led by
7 * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
8 * and including many others, as listed in the AUTHORS file in the
9 * top-level source directory and at http://www.gromacs.org.
10 *
11 * GROMACS is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public License
13 * as published by the Free Software Foundation; either version 2.1
14 * of the License, or (at your option) any later version.
15 *
16 * GROMACS is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with GROMACS; if not, see
23 * http://www.gnu.org/licenses, or write to the Free Software Foundation,
24 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
25 *
26 * If you want to redistribute modifications to GROMACS, please
27 * consider that scientific software is very special. Version
28 * control is crucial - bugs must be traceable. We will be happy to
29 * consider code for inclusion in the official distribution, but
30 * derived work must not be called official GROMACS. Details are found
31 * in the README & COPYING files - if they are missing, get the
32 * official version at http://www.gromacs.org.
33 *
34 * To help us fund GROMACS development, we humbly ask that you cite
35 * the research papers on the package. Check out http://www.gromacs.org.
36 */
37 #include "gmxpre.h"
38
39 #include <cmath>
40 #include <cstdlib>
41 #include <cstring>
42
43 #include <algorithm>
44
45 #include "gromacs/commandline/pargs.h"
46 #include "gromacs/commandline/viewit.h"
47 #include "gromacs/correlationfunctions/autocorr.h"
48 #include "gromacs/fileio/enxio.h"
49 #include "gromacs/fileio/gmxfio.h"
50 #include "gromacs/fileio/tpxio.h"
51 #include "gromacs/fileio/trxio.h"
52 #include "gromacs/fileio/xvgr.h"
53 #include "gromacs/gmxana/gmx_ana.h"
54 #include "gromacs/gmxana/gstat.h"
55 #include "gromacs/math/functions.h"
56 #include "gromacs/math/units.h"
57 #include "gromacs/math/vec.h"
58 #include "gromacs/mdlib/mdebin.h"
59 #include "gromacs/mdtypes/inputrec.h"
60 #include "gromacs/mdtypes/md_enums.h"
61 #include "gromacs/topology/ifunc.h"
62 #include "gromacs/topology/mtop_lookup.h"
63 #include "gromacs/topology/mtop_util.h"
64 #include "gromacs/topology/topology.h"
65 #include "gromacs/utility/arraysize.h"
66 #include "gromacs/utility/cstringutil.h"
67 #include "gromacs/utility/fatalerror.h"
68 #include "gromacs/utility/gmxassert.h"
69 #include "gromacs/utility/pleasecite.h"
70 #include "gromacs/utility/smalloc.h"
71 #include "gromacs/utility/strconvert.h"
72
73 static const int NOTSET = -23451;
74
75 typedef struct {
76 real sum;
77 real sum2;
78 } exactsum_t;
79
80 typedef struct {
81 real *ener;
82 exactsum_t *es;
83 gmx_bool bExactStat;
84 double av;
85 double rmsd;
86 double ee;
87 double slope;
88 } enerdat_t;
89
90 typedef struct {
91 gmx_int64_t nsteps;
92 gmx_int64_t npoints;
93 int nframes;
94 int *step;
95 int *steps;
96 int *points;
97 enerdat_t *s;
98 gmx_bool bHaveSums;
99 } enerdata_t;
100
101 static void done_enerdata_t(int nset, enerdata_t *edat)
102 {
103 sfree(edat->step);
104 sfree(edat->steps);
105 sfree(edat->points);
106 for (int i = 0; i < nset; i++)
107 {
108 sfree(edat->s[i].ener);
109 sfree(edat->s[i].es);
110 }
111 sfree(edat->s);
112 }
113
114 static void chomp(char *buf)
115 {
116 int len = std::strlen(buf);
117
118 while ((len > 0) && (buf[len-1] == '\n'))
119 {
120 buf[len-1] = '\0';
121 len--;
122 }
123 }
124
125 static int *select_by_name(int nre, gmx_enxnm_t *nm, int *nset)
126 {
127 gmx_bool *bE;
128 int k, kk, j, i, nmatch, nind, nss;
129 int *set;
130 gmx_bool bEOF, bVerbose = TRUE, bLong = FALSE;
131 char *ptr, buf[STRLEN];
132 const char *fm4 = "%3d %-14s";
133 const char *fm2 = "%3d %-34s";
134 char **newnm = nullptr;
135
136 if ((getenv("GMX_ENER_VERBOSE")) != nullptr)
137 {
138 bVerbose = FALSE;
139 }
140
141 fprintf(stderr, "\n");
142 fprintf(stderr, "Select the terms you want from the following list by\n");
143 fprintf(stderr, "selecting either (part of) the name or the number or a combination.\n");
144 fprintf(stderr, "End your selection with an empty line or a zero.\n");
145 fprintf(stderr, "-------------------------------------------------------------------\n");
146
147 snew(newnm, nre);
148 j = 0;
149 for (k = 0; k < nre; k++)
150 {
151 newnm[k] = gmx_strdup(nm[k].name);
152 /* Insert dashes in all the names */
153 while ((ptr = std::strchr(newnm[k], ' ')) != nullptr)
154 {
155 *ptr = '-';
156 }
157 if (bVerbose)
158 {
159 if (j == 0)
160 {
161 if (k > 0)
162 {
163 fprintf(stderr, "\n");
164 }
165 bLong = FALSE;
166 for (kk = k; kk < k+4; kk++)
167 {
168 if (kk < nre && std::strlen(nm[kk].name) > 14)
169 {
170 bLong = TRUE;
171 }
172 }
173 }
174 else
175 {
176 fprintf(stderr, " ");
177 }
178 if (!bLong)
179 {
180 fprintf(stderr, fm4, k+1, newnm[k]);
181 j++;
182 if (j == 4)
183 {
184 j = 0;
185 }
186 }
187 else
188 {
189 fprintf(stderr, fm2, k+1, newnm[k]);
190 j++;
191 if (j == 2)
192 {
193 j = 0;
194 }
195 }
196 }
197 }
198 if (bVerbose)
199 {
200 fprintf(stderr, "\n\n");
201 }
202
203 snew(bE, nre);
204
205 bEOF = FALSE;
206 while (!bEOF && (fgets2(buf, STRLEN-1, stdin)))
207 {
208 /* Remove newlines */
209 chomp(buf);
210
211 /* Remove spaces */
212 trim(buf);
213
214 /* Empty line means end of input */
215 bEOF = (std::strlen(buf) == 0);
216 if (!bEOF)
217 {
218 ptr = buf;
219 do
220 {
221 if (!bEOF)
222 {
223 /* First try to read an integer */
224 nss = sscanf(ptr, "%d", &nind);
225 if (nss == 1)
226 {
227 /* Zero means end of input */
228 if (nind == 0)
229 {
230 bEOF = TRUE;
231 }
232 else if ((1 <= nind) && (nind <= nre))
233 {
234 bE[nind-1] = TRUE;
235 }
236 else
237 {
238 fprintf(stderr, "number %d is out of range\n", nind);
239 }
240 }
241 else
242 {
243 /* Now try to read a string */
244 nmatch = 0;
245 for (nind = 0; nind < nre; nind++)
246 {
247 if (gmx_strcasecmp(newnm[nind], ptr) == 0)
248 {
249 bE[nind] = TRUE;
250 nmatch++;
251 }
252 }
253 if (nmatch == 0)
254 {
255 i = std::strlen(ptr);
256 nmatch = 0;
257 for (nind = 0; nind < nre; nind++)
258 {
259 if (gmx_strncasecmp(newnm[nind], ptr, i) == 0)
260 {
261 bE[nind] = TRUE;
262 nmatch++;
263 }
264 }
265 if (nmatch == 0)
266 {
267 fprintf(stderr, "String '%s' does not match anything\n", ptr);
268 }
269 }
270 }
271 }
272 /* Look for the first space, and remove spaces from there */
273 if ((ptr = std::strchr(ptr, ' ')) != nullptr)
274 {
275 trim(ptr);
276 }
277 }
278 while (!bEOF && (ptr && (std::strlen(ptr) > 0)));
279 }
280 }
281
282 snew(set, nre);
283 for (i = (*nset) = 0; (i < nre); i++)
284 {
285 if (bE[i])
286 {
287 set[(*nset)++] = i;
288 }
289 }
290
291 sfree(bE);
292
293 if (*nset == 0)
294 {
295 gmx_fatal(FARGS, "No energy terms selected");
296 }
297
298 for (i = 0; (i < nre); i++)
299 {
300 sfree(newnm[i]);
301 }
302 sfree(newnm);
303
304 return set;
305 }
306
307 static void get_dhdl_parms(const char *topnm, t_inputrec *ir)
308 {
309 gmx_mtop_t mtop;
310 int natoms;
311 matrix box;
312
313 /* all we need is the ir to be able to write the label */
314 read_tpx(topnm, ir, box, &natoms, nullptr, nullptr, &mtop);
315 done_mtop(&mtop);
316 }
317
318 static void einstein_visco(const char *fn, const char *fni, int nsets,
319 int nint, real **eneint,
320 real V, real T, double dt,
321 const gmx_output_env_t *oenv)
322 {
323 FILE *fp0, *fp1;
324 double av[4], avold[4];
325 double fac, di;
326 int i, j, m, nf4;
327
328 nf4 = nint/4 + 1;
329
330 for (i = 0; i <= nsets; i++)
331 {
332 avold[i] = 0;
333 }
334 fp0 = xvgropen(fni, "Shear viscosity integral",
335 "Time (ps)", "(kg m\\S-1\\N s\\S-1\\N ps)", oenv);
336 fp1 = xvgropen(fn, "Shear viscosity using Einstein relation",
337 "Time (ps)", "(kg m\\S-1\\N s\\S-1\\N)", oenv);
338 for (i = 0; i < nf4; i++)
339 {
340 for (m = 0; m <= nsets; m++)
341 {
342 av[m] = 0;
343 }
344 for (j = 0; j < nint - i; j++)
345 {
346 for (m = 0; m < nsets; m++)
347 {
348 di = gmx::square(eneint[m][j+i] - eneint[m][j]);
349
350 av[m] += di;
351 av[nsets] += di/nsets;
352 }
353 }
354 /* Convert to SI for the viscosity */
355 fac = (V*NANO*NANO*NANO*PICO*1e10)/(2*BOLTZMANN*T)/(nint - i);
356 fprintf(fp0, "%10g", i*dt);
357 for (m = 0; (m <= nsets); m++)
358 {
359 av[m] = fac*av[m];
360 fprintf(fp0, " %10g", av[m]);
361 }
362 fprintf(fp0, "\n");
363 fprintf(fp1, "%10g", (i + 0.5)*dt);
364 for (m = 0; (m <= nsets); m++)
365 {
366 fprintf(fp1, " %10g", (av[m]-avold[m])/dt);
367 avold[m] = av[m];
368 }
369 fprintf(fp1, "\n");
370 }
371 xvgrclose(fp0);
372 xvgrclose(fp1);
373 }
374
375 typedef struct {
376 gmx_int64_t np;
377 double sum;
378 double sav;
379 double sav2;
380 } ee_sum_t;
381
382 typedef struct {
383 int b;
384 ee_sum_t sum;
385 gmx_int64_t nst;
386 gmx_int64_t nst_min;
387 } ener_ee_t;
388
389 static void clear_ee_sum(ee_sum_t *ees)
390 {
391 ees->sav = 0;
392 ees->sav2 = 0;
393 ees->np = 0;
394 ees->sum = 0;
395 }
396
397 static void add_ee_sum(ee_sum_t *ees, double sum, int np)
398 {
399 ees->np += np;
400 ees->sum += sum;
401 }
402
403 static void add_ee_av(ee_sum_t *ees)
404 {
405 double av;
406
407 av = ees->sum/ees->np;
408 ees->sav += av;
409 ees->sav2 += av*av;
410 ees->np = 0;
411 ees->sum = 0;
412 }
413
414 static double calc_ee2(int nb, ee_sum_t *ees)
415 {
416 return (ees->sav2/nb - gmx::square(ees->sav/nb))/(nb - 1);
417 }
418
419 static void set_ee_av(ener_ee_t *eee)
420 {
421 if (debug)
422 {
423 char buf[STEPSTRSIZE];
424 fprintf(debug, "Storing average for err.est.: %s steps\n",
425 gmx_step_str(eee->nst, buf));
426 }
427 add_ee_av(&eee->sum);
428 eee->b++;
429 if (eee->b == 1 || eee->nst < eee->nst_min)
430 {
431 eee->nst_min = eee->nst;
432 }
433 eee->nst = 0;
434 }
435
436 static void calc_averages(int nset, enerdata_t *edat, int nbmin, int nbmax)
437 {
438 int nb, i, f, nee;
439 double sum, sum2, sump, see2;
440 gmx_int64_t np, p, bound_nb;
441 enerdat_t *ed;
442 exactsum_t *es;
443 gmx_bool bAllZero;
444 double x, sx, sy, sxx, sxy;
445 ener_ee_t *eee;
446
447 /* Check if we have exact statistics over all points */
448 for (i = 0; i < nset; i++)
449 {
450 ed = &edat->s[i];
451 ed->bExactStat = FALSE;
452 if (edat->bHaveSums)
453 {
454 /* All energy file sum entries 0 signals no exact sums.
455 * But if all energy values are 0, we still have exact sums.
456 */
457 bAllZero = TRUE;
458 for (f = 0; f < edat->nframes && !ed->bExactStat; f++)
459 {
460 if (ed->ener[i] != 0)
461 {
462 bAllZero = FALSE;
463 }
464 ed->bExactStat = (ed->es[f].sum != 0);
465 }
466 if (bAllZero)
467 {
468 ed->bExactStat = TRUE;
469 }
470 }
471 }
472
473 snew(eee, nbmax+1);
474 for (i = 0; i < nset; i++)
475 {
476 ed = &edat->s[i];
477
478 sum = 0;
479 sum2 = 0;
480 np = 0;
481 sx = 0;
482 sy = 0;
483 sxx = 0;
484 sxy = 0;
485 for (nb = nbmin; nb <= nbmax; nb++)
486 {
487 eee[nb].b = 0;
488 clear_ee_sum(&eee[nb].sum);
489 eee[nb].nst = 0;
490 eee[nb].nst_min = 0;
491 }
492 for (f = 0; f < edat->nframes; f++)
493 {
494 es = &ed->es[f];
495
496 if (ed->bExactStat)
497 {
498 /* Add the sum and the sum of variances to the totals. */
499 p = edat->points[f];
500 sump = es->sum;
501 sum2 += es->sum2;
502 if (np > 0)
503 {
504 sum2 += gmx::square(sum/np - (sum + es->sum)/(np + p))
505 *np*(np + p)/p;
506 }
507 }
508 else
509 {
510 /* Add a single value to the sum and sum of squares. */
511 p = 1;
512 sump = ed->ener[f];
513 sum2 += gmx::square(sump);
514 }
515
516 /* sum has to be increased after sum2 */
517 np += p;
518 sum += sump;
519
520 /* For the linear regression use variance 1/p.
521 * Note that sump is the sum, not the average, so we don't need p*.
522 */
523 x = edat->step[f] - 0.5*(edat->steps[f] - 1);
524 sx += p*x;
525 sy += sump;
526 sxx += p*x*x;
527 sxy += x*sump;
528
529 for (nb = nbmin; nb <= nbmax; nb++)
530 {
531 /* Check if the current end step is closer to the desired
532 * block boundary than the next end step.
533 */
534 bound_nb = (edat->step[0]-1)*nb + edat->nsteps*(eee[nb].b+1);
535 if (eee[nb].nst > 0 &&
536 bound_nb - edat->step[f-1]*nb < edat->step[f]*nb - bound_nb)
537 {
538 set_ee_av(&eee[nb]);
539 }
540 if (f == 0)
541 {
542 eee[nb].nst = 1;
543 }
544 else
545 {
546 eee[nb].nst += edat->step[f] - edat->step[f-1];
547 }
548 if (ed->bExactStat)
549 {
550 add_ee_sum(&eee[nb].sum, es->sum, edat->points[f]);
551 }
552 else
553 {
554 add_ee_sum(&eee[nb].sum, edat->s[i].ener[f], 1);
555 }
556 bound_nb = (edat->step[0]-1)*nb + edat->nsteps*(eee[nb].b+1);
557 if (edat->step[f]*nb >= bound_nb)
558 {
559 set_ee_av(&eee[nb]);
560 }
561 }
562 }
563
564 edat->s[i].av = sum/np;
565 if (ed->bExactStat)
566 {
567 edat->s[i].rmsd = std::sqrt(sum2/np);
568 }
569 else
570 {
571 edat->s[i].rmsd = std::sqrt(sum2/np - gmx::square(edat->s[i].av));
572 }
573
574 if (edat->nframes > 1)
575 {
576 edat->s[i].slope = (np*sxy - sx*sy)/(np*sxx - sx*sx);
577 }
578 else
579 {
580 edat->s[i].slope = 0;
581 }
582
583 nee = 0;
584 see2 = 0;
585 for (nb = nbmin; nb <= nbmax; nb++)
586 {
587 /* Check if we actually got nb blocks and if the smallest
588 * block is not shorter than 80% of the average.
589 */
590 if (debug)
591 {
592 char buf1[STEPSTRSIZE], buf2[STEPSTRSIZE];
593 fprintf(debug, "Requested %d blocks, we have %d blocks, min %s nsteps %s\n",
594 nb, eee[nb].b,
595 gmx_step_str(eee[nb].nst_min, buf1),
596 gmx_step_str(edat->nsteps, buf2));
597 }
598 if (eee[nb].b == nb && 5*nb*eee[nb].nst_min >= 4*edat->nsteps)
599 {
600 see2 += calc_ee2(nb, &eee[nb].sum);
601 nee++;
602 }
603 }
604 if (nee > 0)
605 {
606 edat->s[i].ee = std::sqrt(see2/nee);
607 }
608 else
609 {
610 edat->s[i].ee = -1;
611 }
612 }
613 sfree(eee);
614 }
615
616 static enerdata_t *calc_sum(int nset, enerdata_t *edat, int nbmin, int nbmax)
617 {
618 enerdata_t *esum;
619 enerdat_t *s;
620 int f, i;
621 double sum;
622
623 snew(esum, 1);
624 *esum = *edat;
625 snew(esum->s, 1);
626 s = &esum->s[0];
627 snew(s->ener, esum->nframes);
628 snew(s->es, esum->nframes);
629
630 s->bExactStat = TRUE;
631 s->slope = 0;
632 for (i = 0; i < nset; i++)
633 {
634 if (!edat->s[i].bExactStat)
635 {
636 s->bExactStat = FALSE;
637 }
638 s->slope += edat->s[i].slope;
639 }
640
641 for (f = 0; f < edat->nframes; f++)
642 {
643 sum = 0;
644 for (i = 0; i < nset; i++)
645 {
646 sum += edat->s[i].ener[f];
647 }
648 s->ener[f] = sum;
649 sum = 0;
650 for (i = 0; i < nset; i++)
651 {
652 sum += edat->s[i].es[f].sum;
653 }
654 s->es[f].sum = sum;
655 s->es[f].sum2 = 0;
656 }
657
658 calc_averages(1, esum, nbmin, nbmax);
659
660 return esum;
661 }
662
663 static void ee_pr(double ee, int buflen, char *buf)
664 {
665 snprintf(buf, buflen, "%s", "--");
666 if (ee >= 0)
667 {
668 /* Round to two decimals by printing. */
669 char tmp[100];
670 snprintf(tmp, sizeof(tmp), "%.1e", ee);
671 double rnd = gmx::doubleFromString(tmp);
672 snprintf(buf, buflen, "%g", rnd);
673 }
674 }
675
676 static void remove_drift(int nset, int nbmin, int nbmax, real dt, enerdata_t *edat)
677 {
678 /* Remove the drift by performing a fit to y = ax+b.
679 Uses 5 iterations. */
680 int i, j, k;
681 double delta;
682
683 edat->npoints = edat->nframes;
684 edat->nsteps = edat->nframes;
685
686 for (k = 0; (k < 5); k++)
687 {
688 for (i = 0; (i < nset); i++)
689 {
690 delta = edat->s[i].slope*dt;
691
692 if (nullptr != debug)
693 {
694 fprintf(debug, "slope for set %d is %g\n", i, edat->s[i].slope);
695 }
696
697 for (j = 0; (j < edat->nframes); j++)
698 {
699 edat->s[i].ener[j] -= j*delta;
700 edat->s[i].es[j].sum = 0;
701 edat->s[i].es[j].sum2 = 0;
702 }
703 }
704 calc_averages(nset, edat, nbmin, nbmax);
705 }
706 }
707
708 static void calc_fluctuation_props(FILE *fp,
709 gmx_bool bDriftCorr, real dt,
710 int nset, int nmol,
711 char **leg, enerdata_t *edat,
712 int nbmin, int nbmax)
713 {
714 int i, j;
715 double vv, v, h, varv, hh, varh, tt, cv, cp, alpha, kappa, dcp, varet;
716 double NANO3;
717 enum {
718 eVol, eEnth, eTemp, eEtot, eNR
719 };
720 const char *my_ener[] = { "Volume", "Enthalpy", "Temperature", "Total Energy" };
721 int ii[eNR];
722
723 NANO3 = NANO*NANO*NANO;
724 if (!bDriftCorr)
725 {
726 fprintf(fp, "\nYou may want to use the -driftcorr flag in order to correct\n"
727 "for spurious drift in the graphs. Note that this is not\n"
728 "a substitute for proper equilibration and sampling!\n");
729 }
730 else
731 {
732 remove_drift(nset, nbmin, nbmax, dt, edat);
733 }
734 for (i = 0; (i < eNR); i++)
735 {
736 for (ii[i] = 0; (ii[i] < nset &&
737 (gmx_strcasecmp(leg[ii[i]], my_ener[i]) != 0)); ii[i]++)
738 {
739 ;
740 }
741 /* if (ii[i] < nset)
742 fprintf(fp,"Found %s data.\n",my_ener[i]);
743 */ }
744 /* Compute it all! */
745 alpha = kappa = cp = dcp = cv = NOTSET;
746
747 /* Temperature */
748 tt = NOTSET;
749 if (ii[eTemp] < nset)
750 {
751 tt = edat->s[ii[eTemp]].av;
752 }
753 /* Volume */
754 vv = varv = NOTSET;
755 if ((ii[eVol] < nset) && (ii[eTemp] < nset))
756 {
757 vv = edat->s[ii[eVol]].av*NANO3;
758 varv = gmx::square(edat->s[ii[eVol]].rmsd*NANO3);
759 kappa = (varv/vv)/(BOLTZMANN*tt);
760 }
761 /* Enthalpy */
762 hh = varh = NOTSET;
763 if ((ii[eEnth] < nset) && (ii[eTemp] < nset))
764 {
765 hh = KILO*edat->s[ii[eEnth]].av/AVOGADRO;
766 varh = gmx::square(KILO*edat->s[ii[eEnth]].rmsd/AVOGADRO);
767 cp = AVOGADRO*((varh/nmol)/(BOLTZMANN*tt*tt));
768 }
769 /* Total energy */
770 if ((ii[eEtot] < nset) && (hh == NOTSET) && (tt != NOTSET))
771 {
772 /* Only compute cv in constant volume runs, which we can test
773 by checking whether the enthalpy was computed.
774 */
775 varet = gmx::square(edat->s[ii[eEtot]].rmsd);
776 cv = KILO*((varet/nmol)/(BOLTZ*tt*tt));
777 }
778 /* Alpha, dcp */
779 if ((ii[eVol] < nset) && (ii[eEnth] < nset) && (ii[eTemp] < nset))
780 {
781 double v_sum, h_sum, vh_sum, v_aver, h_aver, vh_aver;
782 vh_sum = v_sum = h_sum = 0;
783 for (j = 0; (j < edat->nframes); j++)
784 {
785 v = edat->s[ii[eVol]].ener[j]*NANO3;
786 h = KILO*edat->s[ii[eEnth]].ener[j]/AVOGADRO;
787 v_sum += v;
788 h_sum += h;
789 vh_sum += (v*h);
790 }
791 vh_aver = vh_sum / edat->nframes;
792 v_aver = v_sum / edat->nframes;
793 h_aver = h_sum / edat->nframes;
794 alpha = (vh_aver-v_aver*h_aver)/(v_aver*BOLTZMANN*tt*tt);
795 dcp = (v_aver*AVOGADRO/nmol)*tt*gmx::square(alpha)/(kappa);
796 }
797
798 if (tt != NOTSET)
799 {
800 if (nmol < 2)
801 {
802 fprintf(fp, "\nWARNING: nmol = %d, this may not be what you want.\n",
803 nmol);
804 }
805 fprintf(fp, "\nTemperature dependent fluctuation properties at T = %g.\n", tt);
806 fprintf(fp, "\nHeat capacities obtained from fluctuations do *not* include\n");
807 fprintf(fp, "quantum corrections. If you want to get a more accurate estimate\n");
808 fprintf(fp, "please use the g_dos program.\n\n");
809 fprintf(fp, "WARNING: Please verify that your simulations are converged and perform\n"
810 "a block-averaging error analysis (not implemented in g_energy yet)\n");
811
812 if (debug != nullptr)
813 {
814 if (varv != NOTSET)
815 {
816 fprintf(fp, "varv = %10g (m^6)\n", varv*AVOGADRO/nmol);
817 }
818 }
819 if (vv != NOTSET)
820 {
821 fprintf(fp, "Volume = %10g m^3/mol\n",
822 vv*AVOGADRO/nmol);
823 }
824 if (varh != NOTSET)
825 {
826 fprintf(fp, "Enthalpy = %10g kJ/mol\n",
827 hh*AVOGADRO/(KILO*nmol));
828 }
829 if (alpha != NOTSET)
830 {
831 fprintf(fp, "Coefficient of Thermal Expansion Alpha_P = %10g (1/K)\n",
832 alpha);
833 }
834 if (kappa != NOTSET)
835 {
836 fprintf(fp, "Isothermal Compressibility Kappa = %10g (m^3/J)\n",
837 kappa);
838 fprintf(fp, "Adiabatic bulk modulus = %10g (J/m^3)\n",
839 1.0/kappa);
840 }
841 if (cp != NOTSET)
842 {
843 fprintf(fp, "Heat capacity at constant pressure Cp = %10g J/(mol K)\n",
844 cp);
845 }
846 if (cv != NOTSET)
847 {
848 fprintf(fp, "Heat capacity at constant volume Cv = %10g J/(mol K)\n",
849 cv);
850 }
851 if (dcp != NOTSET)
852 {
853 fprintf(fp, "Cp-Cv = %10g J/(mol K)\n",
854 dcp);
855 }
856 please_cite(fp, "Allen1987a");
857 }
858 else
859 {
860 fprintf(fp, "You should select the temperature in order to obtain fluctuation properties.\n");
861 }
862 }
863
864 static void analyse_ener(gmx_bool bCorr, const char *corrfn,
865 const char *eviscofn, const char *eviscoifn,
866 gmx_bool bFee, gmx_bool bSum, gmx_bool bFluct,
867 gmx_bool bVisco, const char *visfn, int nmol,
868 gmx_int64_t start_step, double start_t,
869 gmx_int64_t step, double t,
870 real reftemp,
871 enerdata_t *edat,
872 int nset, int set[], gmx_bool *bIsEner,
873 char **leg, gmx_enxnm_t *enm,
874 real Vaver, real ezero,
875 int nbmin, int nbmax,
876 const gmx_output_env_t *oenv)
877 {
878 FILE *fp;
879 /* Check out the printed manual for equations! */
880 double Dt, aver, stddev, errest, delta_t, totaldrift;
881 enerdata_t *esum = nullptr;
882 real integral, intBulk, Temp = 0, Pres = 0;
883 real pr_aver, pr_stddev, pr_errest;
884 double beta = 0, expE, expEtot, *fee = nullptr;
885 gmx_int64_t nsteps;
886 int nexact, nnotexact;
887 int i, j, nout;
888 char buf[256], eebuf[100];
889
890 nsteps = step - start_step + 1;
891 if (nsteps < 1)
892 {
893 fprintf(stdout, "Not enough steps (%s) for statistics\n",
894 gmx_step_str(nsteps, buf));
895 }
896 else
897 {
898 /* Calculate the time difference */
899 delta_t = t - start_t;
900
901 fprintf(stdout, "\nStatistics over %s steps [ %.4f through %.4f ps ], %d data sets\n",
902 gmx_step_str(nsteps, buf), start_t, t, nset);
903
904 calc_averages(nset, edat, nbmin, nbmax);
905
906 if (bSum)
907 {
908 esum = calc_sum(nset, edat, nbmin, nbmax);
909 }
910
911 if (!edat->bHaveSums)
912 {
913 nexact = 0;
914 nnotexact = nset;
915 }
916 else
917 {
918 nexact = 0;
919 nnotexact = 0;
920 for (i = 0; (i < nset); i++)
921 {
922 if (edat->s[i].bExactStat)
923 {
924 nexact++;
925 }
926 else
927 {
928 nnotexact++;
929 }
930 }
931 }
932
933 if (nnotexact == 0)
934 {
935 fprintf(stdout, "All statistics are over %s points\n",
936 gmx_step_str(edat->npoints, buf));
937 }
938 else if (nexact == 0 || edat->npoints == edat->nframes)
939 {
940 fprintf(stdout, "All statistics are over %d points (frames)\n",
941 edat->nframes);
942 }
943 else
944 {
945 fprintf(stdout, "The term%s", nnotexact == 1 ? "" : "s");
946 for (i = 0; (i < nset); i++)
947 {
948 if (!edat->s[i].bExactStat)
949 {
950 fprintf(stdout, " '%s'", leg[i]);
951 }
952 }
953 fprintf(stdout, " %s has statistics over %d points (frames)\n",
954 nnotexact == 1 ? "is" : "are", edat->nframes);
955 fprintf(stdout, "All other statistics are over %s points\n",
956 gmx_step_str(edat->npoints, buf));
957 }
958 fprintf(stdout, "\n");
959
960 fprintf(stdout, "%-24s %10s %10s %10s %10s",
961 "Energy", "Average", "Err.Est.", "RMSD", "Tot-Drift");
962 if (bFee)
963 {
964 fprintf(stdout, " %10s\n", "-kT ln<e^(E/kT)>");
965 }
966 else
967 {
968 fprintf(stdout, "\n");
969 }
970 fprintf(stdout, "-------------------------------------------------------------------------------\n");
971
972 /* Initiate locals, only used with -sum */
973 expEtot = 0;
974 if (bFee)
975 {
976 beta = 1.0/(BOLTZ*reftemp);
977 snew(fee, nset);
978 }
979 for (i = 0; (i < nset); i++)
980 {
981 aver = edat->s[i].av;
982 stddev = edat->s[i].rmsd;
983 errest = edat->s[i].ee;
984
985 if (bFee)
986 {
987 expE = 0;
988 for (j = 0; (j < edat->nframes); j++)
989 {
990 expE += std::exp(beta*(edat->s[i].ener[j] - aver)/nmol);
991 }
992 if (bSum)
993 {
994 expEtot += expE/edat->nframes;
995 }
996
997 fee[i] = std::log(expE/edat->nframes)/beta + aver/nmol;
998 }
999 if (std::strstr(leg[i], "empera") != nullptr)
1000 {
1001 Temp = aver;
1002 }
1003 else if (std::strstr(leg[i], "olum") != nullptr)
1004 {
1005 Vaver = aver;
1006 }
1007 else if (std::strstr(leg[i], "essure") != nullptr)
1008 {
1009 Pres = aver;
1010 }
1011 if (bIsEner[i])
1012 {
1013 pr_aver = aver/nmol-ezero;
1014 pr_stddev = stddev/nmol;
1015 pr_errest = errest/nmol;
1016 }
1017 else
1018 {
1019 pr_aver = aver;
1020 pr_stddev = stddev;
1021 pr_errest = errest;
1022 }
1023
1024 /* Multiply the slope in steps with the number of steps taken */
1025 totaldrift = (edat->nsteps - 1)*edat->s[i].slope;
1026 if (bIsEner[i])
1027 {
1028 totaldrift /= nmol;
1029 }
1030
1031 ee_pr(pr_errest, sizeof(eebuf), eebuf);
1032 fprintf(stdout, "%-24s %10g %10s %10g %10g",
1033 leg[i], pr_aver, eebuf, pr_stddev, totaldrift);
1034 if (bFee)
1035 {
1036 fprintf(stdout, " %10g", fee[i]);
1037 }
1038
1039 fprintf(stdout, " (%s)\n", enm[set[i]].unit);
1040
1041 if (bFluct)
1042 {
1043 for (j = 0; (j < edat->nframes); j++)
1044 {
1045 edat->s[i].ener[j] -= aver;
1046 }
1047 }
1048 }
1049 if (bSum)
1050 {
1051 totaldrift = (edat->nsteps - 1)*esum->s[0].slope;
1052 ee_pr(esum->s[0].ee/nmol, sizeof(eebuf), eebuf);
1053 fprintf(stdout, "%-24s %10g %10s %10s %10g (%s)",
1054 "Total", esum->s[0].av/nmol, eebuf,
1055 "--", totaldrift/nmol, enm[set[0]].unit);
1056 /* pr_aver,pr_stddev,a,totaldrift */
1057 if (bFee)
1058 {
1059 fprintf(stdout, " %10g %10g\n",
1060 std::log(expEtot)/beta + esum->s[0].av/nmol, std::log(expEtot)/beta);
1061 }
1062 else
1063 {
1064 fprintf(stdout, "\n");
1065 }
1066 }
1067
1068 /* Do correlation function */
1069 if (edat->nframes > 1)
1070 {
1071 Dt = delta_t/(edat->nframes - 1);
1072 }
1073 else
1074 {
1075 Dt = 0;
1076 }
1077 if (bVisco)
1078 {
1079 const char* leg[] = { "Shear", "Bulk" };
1080 real factor;
1081 real **eneset;
1082 real **eneint;
1083
1084 /* Assume pressure tensor is in Pxx Pxy Pxz Pyx Pyy Pyz Pzx Pzy Pzz */
1085
1086 /* Symmetrise tensor! (and store in first three elements)
1087 * And subtract average pressure!
1088 */
1089 snew(eneset, 12);
1090 for (i = 0; i < 12; i++)
1091 {
1092 snew(eneset[i], edat->nframes);
1093 }
1094 for (i = 0; (i < edat->nframes); i++)
1095 {
1096 eneset[0][i] = 0.5*(edat->s[1].ener[i]+edat->s[3].ener[i]);
1097 eneset[1][i] = 0.5*(edat->s[2].ener[i]+edat->s[6].ener[i]);
1098 eneset[2][i] = 0.5*(edat->s[5].ener[i]+edat->s[7].ener[i]);
1099 for (j = 3; j <= 11; j++)
1100 {
1101 eneset[j][i] = edat->s[j].ener[i];
1102 }
1103 eneset[11][i] -= Pres;
1104 }
1105
1106 /* Determine integrals of the off-diagonal pressure elements */
1107 snew(eneint, 3);
1108 for (i = 0; i < 3; i++)
1109 {
1110 snew(eneint[i], edat->nframes + 1);
1111 }
1112 eneint[0][0] = 0;
1113 eneint[1][0] = 0;
1114 eneint[2][0] = 0;
1115 for (i = 0; i < edat->nframes; i++)
1116 {
1117 eneint[0][i+1] = eneint[0][i] + 0.5*(edat->s[1].es[i].sum + edat->s[3].es[i].sum)*Dt/edat->points[i];
1118 eneint[1][i+1] = eneint[1][i] + 0.5*(edat->s[2].es[i].sum + edat->s[6].es[i].sum)*Dt/edat->points[i];
1119 eneint[2][i+1] = eneint[2][i] + 0.5*(edat->s[5].es[i].sum + edat->s[7].es[i].sum)*Dt/edat->points[i];
1120 }
1121
1122 einstein_visco(eviscofn, eviscoifn,
1123 3, edat->nframes+1, eneint, Vaver, Temp, Dt, oenv);
1124
1125 for (i = 0; i < 3; i++)
1126 {
1127 sfree(eneint[i]);
1128 }
1129 sfree(eneint);
1130
1131 /*do_autocorr(corrfn,buf,nenergy,3,eneset,Dt,eacNormal,TRUE);*/
1132 /* Do it for shear viscosity */
1133 std::strcpy(buf, "Shear Viscosity");
1134 low_do_autocorr(corrfn, oenv, buf, edat->nframes, 3,
1135 (edat->nframes+1)/2, eneset, Dt,
1136 eacNormal, 1, TRUE, FALSE, FALSE, 0.0, 0.0, 0);
1137
1138 /* Now for bulk viscosity */
1139 std::strcpy(buf, "Bulk Viscosity");
1140 low_do_autocorr(corrfn, oenv, buf, edat->nframes, 1,
1141 (edat->nframes+1)/2, &(eneset[11]), Dt,
1142 eacNormal, 1, TRUE, FALSE, FALSE, 0.0, 0.0, 0);
1143
1144 factor = (Vaver*1e-26/(BOLTZMANN*Temp))*Dt;
1145 fp = xvgropen(visfn, buf, "Time (ps)", "\\8h\\4 (cp)", oenv);
1146 xvgr_legend(fp, asize(leg), leg, oenv);
1147
1148 /* Use trapezium rule for integration */
1149 integral = 0;
1150 intBulk = 0;
1151 nout = get_acfnout();
1152 if ((nout < 2) || (nout >= edat->nframes/2))
1153 {
1154 nout = edat->nframes/2;
1155 }
1156 for (i = 1; (i < nout); i++)
1157 {
1158 integral += 0.5*(eneset[0][i-1] + eneset[0][i])*factor;
1159 intBulk += 0.5*(eneset[11][i-1] + eneset[11][i])*factor;
1160 fprintf(fp, "%10g %10g %10g\n", (i*Dt), integral, intBulk);
1161 }
1162 xvgrclose(fp);
1163
1164 for (i = 0; i < 12; i++)
1165 {
1166 sfree(eneset[i]);
1167 }
1168 sfree(eneset);
1169 }
1170 else if (bCorr)
1171 {
1172 if (bFluct)
1173 {
1174 std::strcpy(buf, "Autocorrelation of Energy Fluctuations");
1175 }
1176 else
1177 {
1178 std::strcpy(buf, "Energy Autocorrelation");
1179 }
1180 #if 0
1181 do_autocorr(corrfn, oenv, buf, edat->nframes,
1182 bSum ? 1 : nset,
1183 bSum ? &edat->s[nset-1].ener : eneset,
1184 (delta_t/edat->nframes), eacNormal, FALSE);
1185 #endif
1186 }
1187 }
1188 }
1189
1190 static void print_time(FILE *fp, double t)
1191 {
1192 fprintf(fp, "%12.6f", t);
1193 }
1194
1195 static void print1(FILE *fp, gmx_bool bDp, real e)
1196 {
1197 if (bDp)
1198 {
1199 fprintf(fp, " %16.12f", e);
1200 }
1201 else
1202 {
1203 fprintf(fp, " %10.6f", e);
1204 }
1205 }
1206
1207 static void fec(const char *ene2fn, const char *runavgfn,
1208 real reftemp, int nset, int set[], char *leg[],
1209 enerdata_t *edat, double time[],
1210 const gmx_output_env_t *oenv)
1211 {
1212 const char * ravgleg[] = {
1213 "\\8D\\4E = E\\sB\\N-E\\sA\\N",
1214 "<e\\S-\\8D\\4E/kT\\N>\\s0..t\\N"
1215 };
1216 FILE *fp;
1217 ener_file_t enx;
1218 int timecheck, nenergy, nenergy2, maxenergy;
1219 int i, j;
1220 gmx_bool bCont;
1221 real aver, beta;
1222 real **eneset2;
1223 double dE, sum;
1224 gmx_enxnm_t *enm = nullptr;
1225 t_enxframe *fr;
1226 char buf[22];
1227
1228 /* read second energy file */
1229 snew(fr, 1);
1230 enm = nullptr;
1231 enx = open_enx(ene2fn, "r");
1232 do_enxnms(enx, &(fr->nre), &enm);
1233
1234 snew(eneset2, nset+1);
1235 nenergy2 = 0;
1236 maxenergy = 0;
1237 timecheck = 0;
1238 do
1239 {
1240 /* This loop searches for the first frame (when -b option is given),
1241 * or when this has been found it reads just one energy frame
1242 */
1243 do
1244 {
1245 bCont = do_enx(enx, fr);
1246
1247 if (bCont)
1248 {
1249 timecheck = check_times(fr->t);
1250 }
1251
1252 }
1253 while (bCont && (timecheck < 0));
1254
1255 /* Store energies for analysis afterwards... */
1256 if ((timecheck == 0) && bCont)
1257 {
1258 if (fr->nre > 0)
1259 {
1260 if (nenergy2 >= maxenergy)
1261 {
1262 maxenergy += 1000;
1263 for (i = 0; i <= nset; i++)
1264 {
1265 srenew(eneset2[i], maxenergy);
1266 }
1267 }
1268 GMX_RELEASE_ASSERT(time != nullptr, "trying to dereference NULL time pointer");
1269
1270 if (fr->t != time[nenergy2])
1271 {
1272 fprintf(stderr, "\nWARNING time mismatch %g!=%g at frame %s\n",
1273 fr->t, time[nenergy2], gmx_step_str(fr->step, buf));
1274 }
1275 for (i = 0; i < nset; i++)
1276 {
1277 eneset2[i][nenergy2] = fr->ener[set[i]].e;
1278 }
1279 nenergy2++;
1280 }
1281 }
1282 }
1283 while (bCont && (timecheck == 0));
1284
1285 /* check */
1286 if (edat->nframes != nenergy2)
1287 {
1288 fprintf(stderr, "\nWARNING file length mismatch %d!=%d\n",
1289 edat->nframes, nenergy2);
1290 }
1291 nenergy = std::min(edat->nframes, nenergy2);
1292
1293 /* calculate fe difference dF = -kT ln < exp(-(E_B-E_A)/kT) >_A */
1294 fp = nullptr;
1295 if (runavgfn)
1296 {
1297 fp = xvgropen(runavgfn, "Running average free energy difference",
1298 "Time (" unit_time ")", "\\8D\\4E (" unit_energy ")", oenv);
1299 xvgr_legend(fp, asize(ravgleg), ravgleg, oenv);
1300 }
1301 fprintf(stdout, "\n%-24s %10s\n",
1302 "Energy", "dF = -kT ln < exp(-(EB-EA)/kT) >A");
1303 sum = 0;
1304 beta = 1.0/(BOLTZ*reftemp);
1305 for (i = 0; i < nset; i++)
1306 {
1307 if (gmx_strcasecmp(leg[i], enm[set[i]].name) != 0)
1308 {
1309 fprintf(stderr, "\nWARNING energy set name mismatch %s!=%s\n",
1310 leg[i], enm[set[i]].name);
1311 }
1312 for (j = 0; j < nenergy; j++)
1313 {
1314 dE = eneset2[i][j] - edat->s[i].ener[j];
1315 sum += std::exp(-dE*beta);
1316 if (fp)
1317 {
1318 fprintf(fp, "%10g %10g %10g\n",
1319 time[j], dE, -BOLTZ*reftemp*std::log(sum/(j+1)) );
1320 }
1321 }
1322 aver = -BOLTZ*reftemp*std::log(sum/nenergy);
1323 fprintf(stdout, "%-24s %10g\n", leg[i], aver);
1324 }
1325 if (fp)
1326 {
1327 xvgrclose(fp);
1328 }
1329 sfree(fr);
1330 }
1331
1332
1333 static void do_dhdl(t_enxframe *fr, const t_inputrec *ir, FILE **fp_dhdl,
1334 const char *filename, gmx_bool bDp,
1335 int *blocks, int *hists, int *samples, int *nlambdas,
1336 const gmx_output_env_t *oenv)
1337 {
1338 const char *dhdl = "dH/d\\lambda", *deltag = "\\DeltaH", *lambda = "\\lambda";
1339 char title[STRLEN], label_x[STRLEN], label_y[STRLEN], legend[STRLEN];
1340 char buf[STRLEN];
1341 int nblock_hist = 0, nblock_dh = 0, nblock_dhcoll = 0;
1342 int i, j, k;
1343 /* coll data */
1344 double temp = 0, start_time = 0, delta_time = 0, start_lambda = 0;
1345 static int setnr = 0;
1346 double *native_lambda_vec = nullptr;
1347 const char **lambda_components = nullptr;
1348 int n_lambda_vec = 0;
1349 bool firstPass = true;
1350
1351 /* now count the blocks & handle the global dh data */
1352 for (i = 0; i < fr->nblock; i++)
1353 {
1354 if (fr->block[i].id == enxDHHIST)
1355 {
1356 nblock_hist++;
1357 }
1358 else if (fr->block[i].id == enxDH)
1359 {
1360 nblock_dh++;
1361 }
1362 else if (fr->block[i].id == enxDHCOLL)
1363 {
1364 nblock_dhcoll++;
1365 if ( (fr->block[i].nsub < 1) ||
1366 (fr->block[i].sub[0].type != xdr_datatype_double) ||
1367 (fr->block[i].sub[0].nr < 5))
1368 {
1369 gmx_fatal(FARGS, "Unexpected block data");
1370 }
1371
1372 /* read the data from the DHCOLL block */
1373 temp = fr->block[i].sub[0].dval[0];
1374 start_time = fr->block[i].sub[0].dval[1];
1375 delta_time = fr->block[i].sub[0].dval[2];
1376 start_lambda = fr->block[i].sub[0].dval[3];
1377 if (fr->block[i].nsub > 1)
1378 {
1379 if (firstPass)
1380 {
1381 n_lambda_vec = fr->block[i].sub[1].ival[1];
1382 snew(lambda_components, n_lambda_vec);
1383 snew(native_lambda_vec, n_lambda_vec);
1384 firstPass = false;
1385 }
1386 else
1387 {
1388 if (n_lambda_vec != fr->block[i].sub[1].ival[1])
1389 {
1390 gmx_fatal(FARGS,
1391 "Unexpected change of basis set in lambda");
1392 }
1393 }
1394 for (j = 0; j < n_lambda_vec; j++)
1395 {
1396 native_lambda_vec[j] = fr->block[i].sub[0].dval[5+j];
1397 lambda_components[j] =
1398 efpt_singular_names[fr->block[i].sub[1].ival[2+j]];
1399 }
1400 }
1401 }
1402 }
1403 // Clean up!
1404 sfree(native_lambda_vec);
1405 sfree(lambda_components);
1406 if (nblock_hist == 0 && nblock_dh == 0)
1407 {
1408 /* don't do anything */
1409 return;
1410 }
1411 if (nblock_hist > 0 && nblock_dh > 0)
1412 {
1413 gmx_fatal(FARGS, "This energy file contains both histogram dhdl data and non-histogram dhdl data. Don't know what to do.");
1414 }
1415 if (!*fp_dhdl)
1416 {
1417 if (nblock_dh > 0)
1418 {
1419 /* we have standard, non-histogram data --
1420 call open_dhdl to open the file */
1421 /* TODO this is an ugly hack that needs to be fixed: this will only
1422 work if the order of data is always the same and if we're
1423 only using the g_energy compiled with the mdrun that produced
1424 the ener.edr. */
1425 *fp_dhdl = open_dhdl(filename, ir, oenv);
1426 }
1427 else
1428 {
1429 sprintf(title, "N(%s)", deltag);
1430 sprintf(label_x, "%s (%s)", deltag, unit_energy);
1431 sprintf(label_y, "Samples");
1432 *fp_dhdl = xvgropen_type(filename, title, label_x, label_y, exvggtXNY, oenv);
1433 sprintf(buf, "T = %g (K), %s = %g", temp, lambda, start_lambda);
1434 xvgr_subtitle(*fp_dhdl, buf, oenv);
1435 }
1436 }
1437
1438 (*hists) += nblock_hist;
1439 (*blocks) += nblock_dh;
1440 (*nlambdas) = nblock_hist+nblock_dh;
1441
1442 /* write the data */
1443 if (nblock_hist > 0)
1444 {
1445 gmx_int64_t sum = 0;
1446 /* histograms */
1447 for (i = 0; i < fr->nblock; i++)
1448 {
1449 t_enxblock *blk = &(fr->block[i]);
1450 if (blk->id == enxDHHIST)
1451 {
1452 double foreign_lambda, dx;
1453 gmx_int64_t x0;
1454 int nhist, derivative;
1455
1456 /* check the block types etc. */
1457 if ( (blk->nsub < 2) ||
1458 (blk->sub[0].type != xdr_datatype_double) ||
1459 (blk->sub[1].type != xdr_datatype_int64) ||
1460 (blk->sub[0].nr < 2) ||
1461 (blk->sub[1].nr < 2) )
1462 {
1463 gmx_fatal(FARGS, "Unexpected block data in file");
1464 }
1465 foreign_lambda = blk->sub[0].dval[0];
1466 dx = blk->sub[0].dval[1];
1467 nhist = blk->sub[1].lval[0];
1468 derivative = blk->sub[1].lval[1];
1469 for (j = 0; j < nhist; j++)
1470 {
1471 const char *lg[1];
1472 x0 = blk->sub[1].lval[2+j];
1473
1474 if (!derivative)
1475 {
1476 sprintf(legend, "N(%s(%s=%g) | %s=%g)",
1477 deltag, lambda, foreign_lambda,
1478 lambda, start_lambda);
1479 }
1480 else
1481 {
1482 sprintf(legend, "N(%s | %s=%g)",
1483 dhdl, lambda, start_lambda);
1484 }
1485
1486 lg[0] = legend;
1487 xvgr_new_dataset(*fp_dhdl, setnr, 1, lg, oenv);
1488 setnr++;
1489 for (k = 0; k < blk->sub[j+2].nr; k++)
1490 {
1491 int hist;
1492 double xmin, xmax;
1493
1494 hist = blk->sub[j+2].ival[k];
1495 xmin = (x0+k)*dx;
1496 xmax = (x0+k+1)*dx;
1497 fprintf(*fp_dhdl, "%g %d\n%g %d\n", xmin, hist,
1498 xmax, hist);
1499 sum += hist;
1500 }
1501 /* multiple histogram data blocks in one histogram
1502 mean that the second one is the reverse of the first one:
1503 for dhdl derivatives, it's important to know both the
1504 maximum and minimum values */
1505 dx = -dx;
1506 }
1507 }
1508 }
1509 (*samples) += static_cast<int>(sum/nblock_hist);
1510 }
1511 else
1512 {
1513 /* raw dh */
1514 int len = 0;
1515
1516 for (i = 0; i < fr->nblock; i++)
1517 {
1518 t_enxblock *blk = &(fr->block[i]);
1519 if (blk->id == enxDH)
1520 {
1521 if (len == 0)
1522 {
1523 len = blk->sub[2].nr;
1524 }
1525 else
1526 {
1527 if (len != blk->sub[2].nr)
1528 {
1529 gmx_fatal(FARGS, "Length inconsistency in dhdl data");
1530 }
1531 }
1532 }
1533 }
1534 (*samples) += len;
1535
1536 for (i = 0; i < len; i++)
1537 {
1538 double time = start_time + delta_time*i;
1539
1540 fprintf(*fp_dhdl, "%.4f ", time);
1541
1542 for (j = 0; j < fr->nblock; j++)
1543 {
1544 t_enxblock *blk = &(fr->block[j]);
1545 if (blk->id == enxDH)
1546 {
1547 double value;
1548 if (blk->sub[2].type == xdr_datatype_float)
1549 {
1550 value = blk->sub[2].fval[i];
1551 }
1552 else
1553 {
1554 value = blk->sub[2].dval[i];
1555 }
1556 /* we need to decide which data type it is based on the count*/
1557
1558 if (j == 1 && ir->bExpanded)
1559 {
1560 fprintf(*fp_dhdl, "%4d", static_cast<int>(value)); /* if expanded ensembles and zero, this is a state value, it's an integer. We need a cleaner conditional than if j==1! */
1561 }
1562 else
1563 {
1564 if (bDp)
1565 {
1566 fprintf(*fp_dhdl, " %#.12g", value); /* print normal precision */
1567 }
1568 else
1569 {
1570 fprintf(*fp_dhdl, " %#.8g", value); /* print normal precision */
1571 }
1572 }
1573 }
1574 }
1575 fprintf(*fp_dhdl, "\n");
1576 }
1577 }
1578 }
1579
1580
1581 int gmx_energy(int argc, char *argv[])
1582 {
1583 const char *desc[] = {
1584 "[THISMODULE] extracts energy components",
1585 "from an energy file. The user is prompted to interactively",
1586 "select the desired energy terms.[PAR]",
1587
1588 "Average, RMSD, and drift are calculated with full precision from the",
1589 "simulation (see printed manual). Drift is calculated by performing",
1590 "a least-squares fit of the data to a straight line. The reported total drift",
1591 "is the difference of the fit at the first and last point.",
1592 "An error estimate of the average is given based on a block averages",
1593 "over 5 blocks using the full-precision averages. The error estimate",
1594 "can be performed over multiple block lengths with the options",
1595 "[TT]-nbmin[tt] and [TT]-nbmax[tt].",
1596 "[BB]Note[bb] that in most cases the energy files contains averages over all",
1597 "MD steps, or over many more points than the number of frames in",
1598 "energy file. This makes the [THISMODULE] statistics output more accurate",
1599 "than the [REF].xvg[ref] output. When exact averages are not present in the energy",
1600 "file, the statistics mentioned above are simply over the single, per-frame",
1601 "energy values.[PAR]",
1602
1603 "The term fluctuation gives the RMSD around the least-squares fit.[PAR]",
1604
1605 "Some fluctuation-dependent properties can be calculated provided",
1606 "the correct energy terms are selected, and that the command line option",
1607 "[TT]-fluct_props[tt] is given. The following properties",
1608 "will be computed:",
1609 "",
1610 "=============================== ===================",
1611 "Property Energy terms needed",
1612 "=============================== ===================",
1613 "Heat capacity C[SUB]p[sub] (NPT sims): Enthalpy, Temp",
1614 "Heat capacity C[SUB]v[sub] (NVT sims): Etot, Temp",
1615 "Thermal expansion coeff. (NPT): Enthalpy, Vol, Temp",
1616 "Isothermal compressibility: Vol, Temp",
1617 "Adiabatic bulk modulus: Vol, Temp",
1618 "=============================== ===================",
1619 "",
1620 "You always need to set the number of molecules [TT]-nmol[tt].",
1621 "The C[SUB]p[sub]/C[SUB]v[sub] computations do [BB]not[bb] include any corrections",
1622 "for quantum effects. Use the [gmx-dos] program if you need that (and you do).[PAR]"
1623
1624 "Option [TT]-odh[tt] extracts and plots the free energy data",
1625 "(Hamiltoian differences and/or the Hamiltonian derivative dhdl)",
1626 "from the [TT]ener.edr[tt] file.[PAR]",
1627
1628 "With [TT]-fee[tt] an estimate is calculated for the free-energy",
1629 "difference with an ideal gas state::",
1630 "",
1631 " [GRK]Delta[grk] A = A(N,V,T) - A[SUB]idealgas[sub](N,V,T) = kT [LN][CHEVRON][EXP]U[SUB]pot[sub]/kT[exp][chevron][ln]",
1632 " [GRK]Delta[grk] G = G(N,p,T) - G[SUB]idealgas[sub](N,p,T) = kT [LN][CHEVRON][EXP]U[SUB]pot[sub]/kT[exp][chevron][ln]",
1633 "",
1634 "where k is Boltzmann's constant, T is set by [TT]-fetemp[tt] and",
1635 "the average is over the ensemble (or time in a trajectory).",
1636 "Note that this is in principle",
1637 "only correct when averaging over the whole (Boltzmann) ensemble",
1638 "and using the potential energy. This also allows for an entropy",
1639 "estimate using::",
1640 "",
1641 " [GRK]Delta[grk] S(N,V,T) = S(N,V,T) - S[SUB]idealgas[sub](N,V,T) = ([CHEVRON]U[SUB]pot[sub][chevron] - [GRK]Delta[grk] A)/T",
1642 " [GRK]Delta[grk] S(N,p,T) = S(N,p,T) - S[SUB]idealgas[sub](N,p,T) = ([CHEVRON]U[SUB]pot[sub][chevron] + pV - [GRK]Delta[grk] G)/T",
1643 "",
1644
1645 "When a second energy file is specified ([TT]-f2[tt]), a free energy",
1646 "difference is calculated::",
1647 "",
1648 " dF = -kT [LN][CHEVRON][EXP]-(E[SUB]B[sub]-E[SUB]A[sub])/kT[exp][chevron][SUB]A[sub][ln] ,",
1649 "",
1650 "where E[SUB]A[sub] and E[SUB]B[sub] are the energies from the first and second energy",
1651 "files, and the average is over the ensemble A. The running average",
1652 "of the free energy difference is printed to a file specified by [TT]-ravg[tt].",
1653 "[BB]Note[bb] that the energies must both be calculated from the same trajectory."
1654
1655 };
1656 static gmx_bool bSum = FALSE, bFee = FALSE, bPrAll = FALSE, bFluct = FALSE, bDriftCorr = FALSE;
1657 static gmx_bool bDp = FALSE, bMutot = FALSE, bOrinst = FALSE, bOvec = FALSE, bFluctProps = FALSE;
1658 static int nmol = 1, nbmin = 5, nbmax = 5;
1659 static real reftemp = 300.0, ezero = 0;
1660 t_pargs pa[] = {
1661 { "-fee", FALSE, etBOOL, {&bFee},
1662 "Do a free energy estimate" },
1663 { "-fetemp", FALSE, etREAL, {&reftemp},
1664 "Reference temperature for free energy calculation" },
1665 { "-zero", FALSE, etREAL, {&ezero},
1666 "Subtract a zero-point energy" },
1667 { "-sum", FALSE, etBOOL, {&bSum},
1668 "Sum the energy terms selected rather than display them all" },
1669 { "-dp", FALSE, etBOOL, {&bDp},
1670 "Print energies in high precision" },
1671 { "-nbmin", FALSE, etINT, {&nbmin},
1672 "Minimum number of blocks for error estimate" },
1673 { "-nbmax", FALSE, etINT, {&nbmax},
1674 "Maximum number of blocks for error estimate" },
1675 { "-mutot", FALSE, etBOOL, {&bMutot},
1676 "Compute the total dipole moment from the components" },
1677 { "-aver", FALSE, etBOOL, {&bPrAll},
1678 "Also print the exact average and rmsd stored in the energy frames (only when 1 term is requested)" },
1679 { "-nmol", FALSE, etINT, {&nmol},
1680 "Number of molecules in your sample: the energies are divided by this number" },
1681 { "-fluct_props", FALSE, etBOOL, {&bFluctProps},
1682 "Compute properties based on energy fluctuations, like heat capacity" },
1683 { "-driftcorr", FALSE, etBOOL, {&bDriftCorr},
1684 "Useful only for calculations of fluctuation properties. The drift in the observables will be subtracted before computing the fluctuation properties."},
1685 { "-fluc", FALSE, etBOOL, {&bFluct},
1686 "Calculate autocorrelation of energy fluctuations rather than energy itself" },
1687 { "-orinst", FALSE, etBOOL, {&bOrinst},
1688 "Analyse instantaneous orientation data" },
1689 { "-ovec", FALSE, etBOOL, {&bOvec},
1690 "Also plot the eigenvectors with [TT]-oten[tt]" }
1691 };
1692 static const char *setnm[] = {
1693 "Pres-XX", "Pres-XY", "Pres-XZ", "Pres-YX", "Pres-YY",
1694 "Pres-YZ", "Pres-ZX", "Pres-ZY", "Pres-ZZ", "Temperature",
1695 "Volume", "Pressure"
1696 };
1697
1698 FILE *out = nullptr;
1699 FILE *fp_dhdl = nullptr;
1700 ener_file_t fp;
1701 int timecheck = 0;
1702 enerdata_t edat;
1703 gmx_enxnm_t *enm = nullptr;
1704 t_enxframe *frame, *fr = nullptr;
1705 int cur = 0;
1706 #define NEXT (1-cur)
1707 int nre, nfr;
1708 gmx_int64_t start_step;
1709 real start_t;
1710 gmx_bool bDHDL;
1711 gmx_bool bFoundStart, bCont, bVisco;
1712 double sum, dbl;
1713 double *time = nullptr;
1714 real Vaver;
1715 int *set = nullptr, i, j, nset, sss;
1716 gmx_bool *bIsEner = nullptr;
1717 char **leg = nullptr;
1718 char buf[256];
1719 gmx_output_env_t *oenv;
1720 int dh_blocks = 0, dh_hists = 0, dh_samples = 0, dh_lambdas = 0;
1721
1722 t_filenm fnm[] = {
1723 { efEDR, "-f", nullptr, ffREAD },
1724 { efEDR, "-f2", nullptr, ffOPTRD },
1725 { efTPR, "-s", nullptr, ffOPTRD },
1726 { efXVG, "-o", "energy", ffWRITE },
1727 { efXVG, "-viol", "violaver", ffOPTWR },
1728 { efXVG, "-pairs", "pairs", ffOPTWR },
1729 { efXVG, "-corr", "enecorr", ffOPTWR },
1730 { efXVG, "-vis", "visco", ffOPTWR },
1731 { efXVG, "-evisco", "evisco", ffOPTWR },
1732 { efXVG, "-eviscoi", "eviscoi", ffOPTWR },
1733 { efXVG, "-ravg", "runavgdf", ffOPTWR },
1734 { efXVG, "-odh", "dhdl", ffOPTWR }
1735 };
1736 #define NFILE asize(fnm)
1737 int npargs;
1738 t_pargs *ppa;
1739
1740 npargs = asize(pa);
1741 ppa = add_acf_pargs(&npargs, pa);
1742 if (!parse_common_args(&argc, argv,
1743 PCA_CAN_VIEW | PCA_CAN_BEGIN | PCA_CAN_END,
1744 NFILE, fnm, npargs, ppa, asize(desc), desc, 0, nullptr, &oenv))
1745 {
1746 sfree(ppa);
1747 return 0;
1748 }
1749
1750 bDHDL = opt2bSet("-odh", NFILE, fnm);
1751
1752 nset = 0;
1753
1754 snew(frame, 2);
1755 fp = open_enx(ftp2fn(efEDR, NFILE, fnm), "r");
1756 do_enxnms(fp, &nre, &enm);
1757
1758 Vaver = -1;
1759
1760 bVisco = opt2bSet("-vis", NFILE, fnm);
1761
1762 t_inputrec irInstance;
1763 t_inputrec *ir = &irInstance;
1764
1765 if (!bDHDL)
1766 {
1767 if (bVisco)
1768 {
1769 nset = asize(setnm);
1770 snew(set, nset);
1771 /* This is nasty code... To extract Pres tensor, Volume and Temperature */
1772 for (j = 0; j < nset; j++)
1773 {
1774 for (i = 0; i < nre; i++)
1775 {
1776 if (std::strstr(enm[i].name, setnm[j]))
1777 {
1778 set[j] = i;
1779 break;
1780 }
1781 }
1782 if (i == nre)
1783 {
1784 if (gmx_strcasecmp(setnm[j], "Volume") == 0)
1785 {
1786 printf("Enter the box volume (" unit_volume "): ");
1787 if (1 != scanf("%lf", &dbl))
1788 {
1789 gmx_fatal(FARGS, "Error reading user input");
1790 }
1791 Vaver = dbl;
1792 }
1793 else
1794 {
1795 gmx_fatal(FARGS, "Could not find term %s for viscosity calculation",
1796 setnm[j]);
1797 }
1798 }
1799 }
1800 }
1801 else
1802 {
1803 set = select_by_name(nre, enm, &nset);
1804 }
1805 /* Print all the different units once */
1806 sprintf(buf, "(%s)", enm[set[0]].unit);
1807 for (i = 1; i < nset; i++)
1808 {
1809 for (j = 0; j < i; j++)
1810 {
1811 if (std::strcmp(enm[set[i]].unit, enm[set[j]].unit) == 0)
1812 {
1813 break;
1814 }
1815 }
1816 if (j == i)
1817 {
1818 std::strcat(buf, ", (");
1819 std::strcat(buf, enm[set[i]].unit);
1820 std::strcat(buf, ")");
1821 }
1822 }
1823 out = xvgropen(opt2fn("-o", NFILE, fnm), "GROMACS Energies", "Time (ps)", buf,
1824 oenv);
1825
1826 snew(leg, nset+1);
1827 for (i = 0; (i < nset); i++)
1828 {
1829 leg[i] = enm[set[i]].name;
1830 }
1831 if (bSum)
1832 {
1833 leg[nset] = gmx_strdup("Sum");
1834 xvgr_legend(out, nset+1, (const char**)leg, oenv);
1835 }
1836 else
1837 {
1838 xvgr_legend(out, nset, (const char**)leg, oenv);
1839 }
1840
1841 snew(bIsEner, nset);
1842 for (i = 0; (i < nset); i++)
1843 {
1844 bIsEner[i] = FALSE;
1845 for (j = 0; (j <= F_ETOT); j++)
1846 {
1847 bIsEner[i] = bIsEner[i] ||
1848 (gmx_strcasecmp(interaction_function[j].longname, leg[i]) == 0);
1849 }
1850 }
1851 if (bPrAll && nset > 1)
1852 {
1853 gmx_fatal(FARGS, "Printing averages can only be done when a single set is selected");
1854 }
1855
1856 }
1857 else if (bDHDL)
1858 {
1859 get_dhdl_parms(ftp2fn(efTPR, NFILE, fnm), ir);
1860 }
1861
1862 /* Initiate energies and set them to zero */
1863 edat.nsteps = 0;
1864 edat.npoints = 0;
1865 edat.nframes = 0;
1866 edat.step = nullptr;
1867 edat.steps = nullptr;
1868 edat.points = nullptr;
1869 edat.bHaveSums = TRUE;
1870 snew(edat.s, nset);
1871
1872 /* Initiate counters */
1873 bFoundStart = FALSE;
1874 start_step = 0;
1875 start_t = 0;
1876 do
1877 {
1878 /* This loop searches for the first frame (when -b option is given),
1879 * or when this has been found it reads just one energy frame
1880 */
1881 do
1882 {
1883 bCont = do_enx(fp, &(frame[NEXT]));
1884 if (bCont)
1885 {
1886 timecheck = check_times(frame[NEXT].t);
1887 }
1888 }
1889 while (bCont && (timecheck < 0));
1890
1891 if ((timecheck == 0) && bCont)
1892 {
1893 /* We read a valid frame, so we can use it */
1894 fr = &(frame[NEXT]);
1895
1896 if (fr->nre > 0)
1897 {
1898 /* The frame contains energies, so update cur */
1899 cur = NEXT;
1900
1901 if (edat.nframes % 1000 == 0)
1902 {
1903 srenew(edat.step, edat.nframes+1000);
1904 std::memset(&(edat.step[edat.nframes]), 0, 1000*sizeof(edat.step[0]));
1905 srenew(edat.steps, edat.nframes+1000);
1906 std::memset(&(edat.steps[edat.nframes]), 0, 1000*sizeof(edat.steps[0]));
1907 srenew(edat.points, edat.nframes+1000);
1908 std::memset(&(edat.points[edat.nframes]), 0, 1000*sizeof(edat.points[0]));
1909
1910 for (i = 0; i < nset; i++)
1911 {
1912 srenew(edat.s[i].ener, edat.nframes+1000);
1913 std::memset(&(edat.s[i].ener[edat.nframes]), 0,
1914 1000*sizeof(edat.s[i].ener[0]));
1915 srenew(edat.s[i].es, edat.nframes+1000);
1916 std::memset(&(edat.s[i].es[edat.nframes]), 0,
1917 1000*sizeof(edat.s[i].es[0]));
1918 }
1919 }
1920
1921 nfr = edat.nframes;
1922 edat.step[nfr] = fr->step;
1923
1924 if (!bFoundStart)
1925 {
1926 bFoundStart = TRUE;
1927 /* Initiate the previous step data */
1928 start_step = fr->step;
1929 start_t = fr->t;
1930 /* Initiate the energy sums */
1931 edat.steps[nfr] = 1;
1932 edat.points[nfr] = 1;
1933 for (i = 0; i < nset; i++)
1934 {
1935 sss = set[i];
1936 edat.s[i].es[nfr].sum = fr->ener[sss].e;
1937 edat.s[i].es[nfr].sum2 = 0;
1938 }
1939 edat.nsteps = 1;
1940 edat.npoints = 1;
1941 }
1942 else
1943 {
1944 edat.steps[nfr] = fr->nsteps;
1945
1946 if (fr->nsum <= 1)
1947 {
1948 /* mdrun only calculated the energy at energy output
1949 * steps. We don't need to check step intervals.
1950 */
1951 edat.points[nfr] = 1;
1952 for (i = 0; i < nset; i++)
1953 {
1954 sss = set[i];
1955 edat.s[i].es[nfr].sum = fr->ener[sss].e;
1956 edat.s[i].es[nfr].sum2 = 0;
1957 }
1958 edat.npoints += 1;
1959 edat.bHaveSums = FALSE;
1960 }
1961 else if (fr->step - start_step + 1 == edat.nsteps + fr->nsteps)
1962 {
1963 /* We have statistics to the previous frame */
1964 edat.points[nfr] = fr->nsum;
1965 for (i = 0; i < nset; i++)
1966 {
1967 sss = set[i];
1968 edat.s[i].es[nfr].sum = fr->ener[sss].esum;
1969 edat.s[i].es[nfr].sum2 = fr->ener[sss].eav;
1970 }
1971 edat.npoints += fr->nsum;
1972 }
1973 else
1974 {
1975 /* The interval does not match fr->nsteps:
1976 * can not do exact averages.
1977 */
1978 edat.bHaveSums = FALSE;
1979 }
1980
1981 edat.nsteps = fr->step - start_step + 1;
1982 }
1983 for (i = 0; i < nset; i++)
1984 {
1985 edat.s[i].ener[nfr] = fr->ener[set[i]].e;
1986 }
1987 }
1988 /*
1989 * Store energies for analysis afterwards...
1990 */
1991 if (!bDHDL && (fr->nre > 0))
1992 {
1993 if (edat.nframes % 1000 == 0)
1994 {
1995 srenew(time, edat.nframes+1000);
1996 }
1997 time[edat.nframes] = fr->t;
1998 edat.nframes++;
1999 }
2000 if (bDHDL)
2001 {
2002 do_dhdl(fr, ir, &fp_dhdl, opt2fn("-odh", NFILE, fnm), bDp, &dh_blocks, &dh_hists, &dh_samples, &dh_lambdas, oenv);
2003 }
2004
2005 /*******************************************
2006 * E N E R G I E S
2007 *******************************************/
2008 else
2009 {
2010 if (fr->nre > 0)
2011 {
2012 if (bPrAll)
2013 {
2014 /* We skip frames with single points (usually only the first frame),
2015 * since they would result in an average plot with outliers.
2016 */
2017 if (fr->nsum > 1)
2018 {
2019 print_time(out, fr->t);
2020 print1(out, bDp, fr->ener[set[0]].e);
2021 print1(out, bDp, fr->ener[set[0]].esum/fr->nsum);
2022 print1(out, bDp, std::sqrt(fr->ener[set[0]].eav/fr->nsum));
2023 fprintf(out, "\n");
2024 }
2025 }
2026 else
2027 {
2028 print_time(out, fr->t);
2029 if (bSum)
2030 {
2031 sum = 0;
2032 for (i = 0; i < nset; i++)
2033 {
2034 sum += fr->ener[set[i]].e;
2035 }
2036 print1(out, bDp, sum/nmol-ezero);
2037 }
2038 else
2039 {
2040 for (i = 0; (i < nset); i++)
2041 {
2042 if (bIsEner[i])
2043 {
2044 print1(out, bDp, (fr->ener[set[i]].e)/nmol-ezero);
2045 }
2046 else
2047 {
2048 print1(out, bDp, fr->ener[set[i]].e);
2049 }
2050 }
2051 }
2052 fprintf(out, "\n");
2053 }
2054 }
2055 }
2056 }
2057 }
2058 while (bCont && (timecheck == 0));
2059
2060 fprintf(stderr, "\n");
2061 done_ener_file(fp);
2062 if (out)
2063 {
2064 xvgrclose(out);
2065 }
2066
2067 if (bDHDL)
2068 {
2069 if (fp_dhdl)
2070 {
2071 gmx_fio_fclose(fp_dhdl);
2072 printf("\n\nWrote %d lambda values with %d samples as ",
2073 dh_lambdas, dh_samples);
2074 if (dh_hists > 0)
2075 {
2076 printf("%d dH histograms ", dh_hists);
2077 }
2078 if (dh_blocks > 0)
2079 {
2080 printf("%d dH data blocks ", dh_blocks);
2081 }
2082 printf("to %s\n", opt2fn("-odh", NFILE, fnm));
2083
2084 }
2085 else
2086 {
2087 gmx_fatal(FARGS, "No dH data in %s\n", opt2fn("-f", NFILE, fnm));
2088 }
2089
2090 }
2091 else
2092 {
2093 double dt = (frame[cur].t-start_t)/(edat.nframes-1);
2094 analyse_ener(opt2bSet("-corr", NFILE, fnm), opt2fn("-corr", NFILE, fnm),
2095 opt2fn("-evisco", NFILE, fnm), opt2fn("-eviscoi", NFILE, fnm),
2096 bFee, bSum, bFluct,
2097 bVisco, opt2fn("-vis", NFILE, fnm),
2098 nmol,
2099 start_step, start_t, frame[cur].step, frame[cur].t,
2100 reftemp, &edat,
2101 nset, set, bIsEner, leg, enm, Vaver, ezero, nbmin, nbmax,
2102 oenv);
2103 if (bFluctProps)
2104 {
2105 calc_fluctuation_props(stdout, bDriftCorr, dt, nset, nmol, leg, &edat,
2106 nbmin, nbmax);
2107 }
2108 }
2109 if (opt2bSet("-f2", NFILE, fnm))
2110 {
2111 fec(opt2fn("-f2", NFILE, fnm), opt2fn("-ravg", NFILE, fnm),
2112 reftemp, nset, set, leg, &edat, time, oenv);
2113 }
2114 // Clean up!
2115 done_enerdata_t(nset, &edat);
2116 sfree(time);
2117 free_enxframe(&frame[0]);
2118 free_enxframe(&frame[1]);
2119 sfree(frame);
2120 free_enxnms(nre, enm);
2121 sfree(ppa);
2122 sfree(set);
2123 sfree(leg);
2124 sfree(bIsEner);
2125 {
2126 const char *nxy = "-nxy";
2127
2128 do_view(oenv, opt2fn("-o", NFILE, fnm), nxy);
2129 do_view(oenv, opt2fn_null("-ravg", NFILE, fnm), nxy);
2130 do_view(oenv, opt2fn_null("-odh", NFILE, fnm), nxy);
2131 }
2132 output_env_done(oenv);
2133 done_filenms(NFILE, fnm);
2134
2135 return 0;
2136 }
The ultimate molecular dynamics simulation package