src/gromacs/mdlib/ebin.cpp

   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) 2012,2014,2015, 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 /* This file is completely threadsafe - keep it that way! */
  38 #include "gmxpre.h"
  39
  40 #include "gromacs/legacyheaders/ebin.h"
  41
  42 #include <math.h>
  43 #include <string.h>
  44
  45 #include "gromacs/legacyheaders/typedefs.h"
  46 #include "gromacs/legacyheaders/types/ifunc.h"
  47 #include "gromacs/math/units.h"
  48 #include "gromacs/math/utilities.h"
  49 #include "gromacs/math/vec.h"
  50 #include "gromacs/utility/cstringutil.h"
  51 #include "gromacs/utility/fatalerror.h"
  52 #include "gromacs/utility/smalloc.h"
  53
  54 t_ebin *mk_ebin(void)
  55 {
  56     t_ebin *eb;
  57
  58     snew(eb, 1);
  59
  60     return eb;
  61 }
  62
  63 int get_ebin_space(t_ebin *eb, int nener, const char *enm[], const char *unit)
  64 {
  65     int         index;
  66     int         i, f;
  67     const char *u;
  68
  69     index      = eb->nener;
  70     eb->nener += nener;
  71     srenew(eb->e, eb->nener);
  72     srenew(eb->e_sim, eb->nener);
  73     srenew(eb->enm, eb->nener);
  74     for (i = index; (i < eb->nener); i++)
  75     {
  76         eb->e[i].e        = 0;
  77         eb->e[i].eav      = 0;
  78         eb->e[i].esum     = 0;
  79         eb->e_sim[i].e    = 0;
  80         eb->e_sim[i].eav  = 0;
  81         eb->e_sim[i].esum = 0;
  82         eb->enm[i].name   = gmx_strdup(enm[i-index]);
  83         if (unit != NULL)
  84         {
  85             eb->enm[i].unit = gmx_strdup(unit);
  86         }
  87         else
  88         {
  89             /* Determine the unit from the longname.
  90              * These units should have been defined in ifunc.c
  91              * But even better would be if all interactions functions
  92              * return energies and all non-interaction function
  93              * entries would be removed from the ifunc array.
  94              */
  95             u = unit_energy;
  96             for (f = 0; f < F_NRE; f++)
  97             {
  98                 if (strcmp(eb->enm[i].name,
  99                            interaction_function[f].longname) == 0)
 100                 {
 101                     /* Only the terms in this list are not energies */
 102                     switch (f)
 103                     {
 104                         case F_DISRESVIOL: u = unit_length;   break;
 105                         case F_ORIRESDEV:  u = "obs";         break;
 106                         case F_TEMP:       u = unit_temp_K;   break;
 107                         case F_PDISPCORR:
 108                         case F_PRES:       u = unit_pres_bar; break;
 109                     }
 110                 }
 111             }
 112             eb->enm[i].unit = gmx_strdup(u);
 113         }
 114     }
 115
 116     return index;
 117 }
 118
 119 void add_ebin(t_ebin *eb, int index, int nener, real ener[], gmx_bool bSum)
 120 {
 121     int       i, m;
 122     double    e, invmm, diff;
 123     t_energy *eg, *egs;
 124
 125     if ((index+nener > eb->nener) || (index < 0))
 126     {
 127         gmx_fatal(FARGS, "%s-%d: Energies out of range: index=%d nener=%d maxener=%d",
 128                   __FILE__, __LINE__, index, nener, eb->nener);
 129     }
 130
 131     eg = &(eb->e[index]);
 132
 133     for (i = 0; (i < nener); i++)
 134     {
 135         eg[i].e      = ener[i];
 136     }
 137
 138     if (bSum)
 139     {
 140         egs = &(eb->e_sim[index]);
 141
 142         m = eb->nsum;
 143
 144         if (m == 0)
 145         {
 146             for (i = 0; (i < nener); i++)
 147             {
 148                 eg[i].eav    = 0;
 149                 eg[i].esum   = ener[i];
 150                 egs[i].esum += ener[i];
 151             }
 152         }
 153         else
 154         {
 155             invmm = (1.0/(double)m)/((double)m+1.0);
 156
 157             for (i = 0; (i < nener); i++)
 158             {
 159                 /* Value for this component */
 160                 e = ener[i];
 161
 162                 /* first update sigma, then sum */
 163                 diff         = eg[i].esum - m*e;
 164                 eg[i].eav   += diff*diff*invmm;
 165                 eg[i].esum  += e;
 166                 egs[i].esum += e;
 167             }
 168         }
 169     }
 170 }
 171
 172 void ebin_increase_count(t_ebin *eb, gmx_bool bSum)
 173 {
 174     eb->nsteps++;
 175     eb->nsteps_sim++;
 176
 177     if (bSum)
 178     {
 179         eb->nsum++;
 180         eb->nsum_sim++;
 181     }
 182 }
 183
 184 void reset_ebin_sums(t_ebin *eb)
 185 {
 186     eb->nsteps = 0;
 187     eb->nsum   = 0;
 188     /* The actual sums are cleared when the next frame is stored */
 189 }
 190
 191 void pr_ebin(FILE *fp, t_ebin *eb, int index, int nener, int nperline,
 192              int prmode, gmx_bool bPrHead)
 193 {
 194     int  i, j, i0;
 195     real ee = 0;
 196     int  rc;
 197     char buf[30];
 198
 199     rc = 0;
 200
 201     if (index < 0)
 202     {
 203         gmx_fatal(FARGS, "Invalid index in pr_ebin: %d", index);
 204     }
 205     if (nener == -1)
 206     {
 207         nener = eb->nener;
 208     }
 209     else
 210     {
 211         nener = index + nener;
 212     }
 213     for (i = index; (i < nener) && rc >= 0; )
 214     {
 215         if (bPrHead)
 216         {
 217             i0 = i;
 218             for (j = 0; (j < nperline) && (i < nener) && rc >= 0; j++, i++)
 219             {
 220                 if (strncmp(eb->enm[i].name, "Pres", 4) == 0)
 221                 {
 222                     /* Print the pressure unit to avoid confusion */
 223                     sprintf(buf, "%s (%s)", eb->enm[i].name, unit_pres_bar);
 224                     rc = fprintf(fp, "%15s", buf);
 225                 }
 226                 else
 227                 {
 228                     rc = fprintf(fp, "%15s", eb->enm[i].name);
 229                 }
 230             }
 231
 232             if (rc >= 0)
 233             {
 234                 rc = fprintf(fp, "\n");
 235             }
 236
 237             i = i0;
 238         }
 239         for (j = 0; (j < nperline) && (i < nener) && rc >= 0; j++, i++)
 240         {
 241             switch (prmode)
 242             {
 243                 case eprNORMAL: ee = eb->e[i].e; break;
 244                 case eprAVER:   ee = eb->e_sim[i].esum/eb->nsum_sim; break;
 245                 default: gmx_fatal(FARGS, "Invalid print mode %d in pr_ebin",
 246                                    prmode);
 247             }
 248
 249             rc = fprintf(fp, "   %12.5e", ee);
 250         }
 251         if (rc >= 0)
 252         {
 253             rc = fprintf(fp, "\n");
 254         }
 255     }
 256     if (rc < 0)
 257     {
 258         gmx_fatal(FARGS, "Cannot write to logfile; maybe you are out of disk space?");
 259     }
 260 }
 261
 262 #ifdef DEBUGEBIN
 263 int main(int argc, char *argv[])
 264 {
 265 #define NE 12
 266 #define NT 7
 267 #define NS 5
 268
 269     t_ebin *eb;
 270     int     i;
 271     char    buf[25];
 272     char   *ce[NE], *ct[NT], *cs[NS];
 273     real    e[NE], t[NT], s[NS];
 274     int     ie, it, is;
 275
 276     eb = mk_ebin();
 277     for (i = 0; (i < NE); i++)
 278     {
 279         e[i] = i;
 280         sprintf(buf, "e%d", i);
 281         ce[i] = gmx_strdup(buf);
 282     }
 283     ie = get_ebin_space(eb, NE, ce);
 284     add_ebin(eb, ie, NE, e, 0);
 285     for (i = 0; (i < NS); i++)
 286     {
 287         s[i] = i;
 288         sprintf(buf, "s%d", i);
 289         cs[i] = gmx_strdup(buf);
 290     }
 291     is = get_ebin_space(eb, NS, cs);
 292     add_ebin(eb, is, NS, s, 0);
 293     for (i = 0; (i < NT); i++)
 294     {
 295         t[i] = i;
 296         sprintf(buf, "t%d", i);
 297         ct[i] = gmx_strdup(buf);
 298     }
 299     it = get_ebin_space(eb, NT, ct);
 300     add_ebin(eb, it, NT, t, 0);
 301
 302     printf("Normal:\n");
 303     pr_ebin(stdout, eb, 0, -1, 5, eprNORMAL, 1);
 304
 305     printf("Average:\n");
 306     pr_ebin(stdout, eb, ie, NE, 5, eprAVER, 1);
 307     pr_ebin(stdout, eb, is, NS, 3, eprAVER, 1);
 308     pr_ebin(stdout, eb, it, NT, 4, eprAVER, 1);
 309 }
 310 #endif