src/gromacs/mdlib/expanded.c

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 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 #ifdef HAVE_CONFIG_H
  36 #include <config.h>
  37 #endif
  38
  39 #include <stdio.h>
  40 #include <math.h>
  41 #include "typedefs.h"
  42 #include "gromacs/utility/smalloc.h"
  43 #include "names.h"
  44 #include "gromacs/fileio/confio.h"
  45 #include "txtdump.h"
  46 #include "pbc.h"
  47 #include "chargegroup.h"
  48 #include "vec.h"
  49 #include "nrnb.h"
  50 #include "mshift.h"
  51 #include "mdrun.h"
  52 #include "update.h"
  53 #include "physics.h"
  54 #include "main.h"
  55 #include "mdatoms.h"
  56 #include "force.h"
  57 #include "bondf.h"
  58 #include "pme.h"
  59 #include "disre.h"
  60 #include "orires.h"
  61 #include "network.h"
  62 #include "calcmu.h"
  63 #include "constr.h"
  64 #include "xvgr.h"
  65 #include "gromacs/random/random.h"
  66 #include "domdec.h"
  67 #include "macros.h"
  68
  69 #include "gromacs/fileio/confio.h"
  70 #include "gromacs/fileio/gmxfio.h"
  71 #include "gromacs/fileio/trnio.h"
  72 #include "gromacs/fileio/xtcio.h"
  73 #include "gromacs/timing/wallcycle.h"
  74 #include "gmx_fatal.h"
  75 #include "gromacs/utility/gmxmpi.h"
  76
  77 static void init_df_history_weights(df_history_t *dfhist, t_expanded *expand, int nlim)
  78 {
  79     int i;
  80     dfhist->wl_delta = expand->init_wl_delta;
  81     for (i = 0; i < nlim; i++)
  82     {
  83         dfhist->sum_weights[i] = expand->init_lambda_weights[i];
  84         dfhist->sum_dg[i]      = expand->init_lambda_weights[i];
  85     }
  86 }
  87
  88 /* Eventually should contain all the functions needed to initialize expanded ensemble
  89    before the md loop starts */
  90 extern void init_expanded_ensemble(gmx_bool bStateFromCP, t_inputrec *ir, df_history_t *dfhist)
  91 {
  92     if (!bStateFromCP)
  93     {
  94         init_df_history_weights(dfhist, ir->expandedvals, ir->fepvals->n_lambda);
  95     }
  96 }
  97
  98 static void GenerateGibbsProbabilities(real *ene, double *p_k, double *pks, int minfep, int maxfep)
  99 {
 100
 101     int  i;
 102     real maxene;
 103
 104     *pks   = 0.0;
 105     maxene = ene[minfep];
 106     /* find the maximum value */
 107     for (i = minfep; i <= maxfep; i++)
 108     {
 109         if (ene[i] > maxene)
 110         {
 111             maxene = ene[i];
 112         }
 113     }
 114     /* find the denominator */
 115     for (i = minfep; i <= maxfep; i++)
 116     {
 117         *pks += exp(ene[i]-maxene);
 118     }
 119     /*numerators*/
 120     for (i = minfep; i <= maxfep; i++)
 121     {
 122         p_k[i] = exp(ene[i]-maxene) / *pks;
 123     }
 124 }
 125
 126 static void GenerateWeightedGibbsProbabilities(real *ene, double *p_k, double *pks, int nlim, real *nvals, real delta)
 127 {
 128
 129     int   i;
 130     real  maxene;
 131     real *nene;
 132     *pks = 0.0;
 133
 134     snew(nene, nlim);
 135     for (i = 0; i < nlim; i++)
 136     {
 137         if (nvals[i] == 0)
 138         {
 139             /* add the delta, since we need to make sure it's greater than zero, and
 140                we need a non-arbitrary number? */
 141             nene[i] = ene[i] + log(nvals[i]+delta);
 142         }
 143         else
 144         {
 145             nene[i] = ene[i] + log(nvals[i]);
 146         }
 147     }
 148
 149     /* find the maximum value */
 150     maxene = nene[0];
 151     for (i = 0; i < nlim; i++)
 152     {
 153         if (nene[i] > maxene)
 154         {
 155             maxene = nene[i];
 156         }
 157     }
 158
 159     /* subtract off the maximum, avoiding overflow */
 160     for (i = 0; i < nlim; i++)
 161     {
 162         nene[i] -= maxene;
 163     }
 164
 165     /* find the denominator */
 166     for (i = 0; i < nlim; i++)
 167     {
 168         *pks += exp(nene[i]);
 169     }
 170
 171     /*numerators*/
 172     for (i = 0; i < nlim; i++)
 173     {
 174         p_k[i] = exp(nene[i]) / *pks;
 175     }
 176     sfree(nene);
 177 }
 178
 179 real do_logsum(int N, real *a_n)
 180 {
 181
 182     /*     RETURN VALUE */
 183     /* log(\sum_{i=0}^(N-1) exp[a_n]) */
 184     real maxarg;
 185     real sum;
 186     int  i;
 187     real logsum;
 188     /*     compute maximum argument to exp(.) */
 189
 190     maxarg = a_n[0];
 191     for (i = 1; i < N; i++)
 192     {
 193         maxarg = max(maxarg, a_n[i]);
 194     }
 195
 196     /* compute sum of exp(a_n - maxarg) */
 197     sum = 0.0;
 198     for (i = 0; i < N; i++)
 199     {
 200         sum = sum + exp(a_n[i] - maxarg);
 201     }
 202
 203     /*     compute log sum */
 204     logsum = log(sum) + maxarg;
 205     return logsum;
 206 }
 207
 208 int FindMinimum(real *min_metric, int N)
 209 {
 210
 211     real min_val;
 212     int  min_nval, nval;
 213
 214     min_nval = 0;
 215     min_val  = min_metric[0];
 216
 217     for (nval = 0; nval < N; nval++)
 218     {
 219         if (min_metric[nval] < min_val)
 220         {
 221             min_val  = min_metric[nval];
 222             min_nval = nval;
 223         }
 224     }
 225     return min_nval;
 226 }
 227
 228 static gmx_bool CheckHistogramRatios(int nhisto, real *histo, real ratio)
 229 {
 230
 231     int      i;
 232     real     nmean;
 233     gmx_bool bIfFlat;
 234
 235     nmean = 0;
 236     for (i = 0; i < nhisto; i++)
 237     {
 238         nmean += histo[i];
 239     }
 240
 241     if (nmean == 0)
 242     {
 243         /* no samples! is bad!*/
 244         bIfFlat = FALSE;
 245         return bIfFlat;
 246     }
 247     nmean /= (real)nhisto;
 248
 249     bIfFlat = TRUE;
 250     for (i = 0; i < nhisto; i++)
 251     {
 252         /* make sure that all points are in the ratio < x <  1/ratio range  */
 253         if (!((histo[i]/nmean < 1.0/ratio) && (histo[i]/nmean > ratio)))
 254         {
 255             bIfFlat = FALSE;
 256             break;
 257         }
 258     }
 259     return bIfFlat;
 260 }
 261
 262 static gmx_bool CheckIfDoneEquilibrating(int nlim, t_expanded *expand, df_history_t *dfhist, gmx_int64_t step)
 263 {
 264
 265     int      i, totalsamples;
 266     gmx_bool bDoneEquilibrating = TRUE;
 267     gmx_bool bIfFlat;
 268
 269     /* assume we have equilibrated the weights, then check to see if any of the conditions are not met */
 270
 271     /* calculate the total number of samples */
 272     switch (expand->elmceq)
 273     {
 274         case elmceqNO:
 275             /* We have not equilibrated, and won't, ever. */
 276             return FALSE;
 277         case elmceqYES:
 278             /* we have equilibrated -- we're done */
 279             return TRUE;
 280         case elmceqSTEPS:
 281             /* first, check if we are equilibrating by steps, if we're still under */
 282             if (step < expand->equil_steps)
 283             {
 284                 bDoneEquilibrating = FALSE;
 285             }
 286             break;
 287         case elmceqSAMPLES:
 288             totalsamples = 0;
 289             for (i = 0; i < nlim; i++)
 290             {
 291                 totalsamples += dfhist->n_at_lam[i];
 292             }
 293             if (totalsamples < expand->equil_samples)
 294             {
 295                 bDoneEquilibrating = FALSE;
 296             }
 297             break;
 298         case elmceqNUMATLAM:
 299             for (i = 0; i < nlim; i++)
 300             {
 301                 if (dfhist->n_at_lam[i] < expand->equil_n_at_lam) /* we are still doing the initial sweep, so we're definitely not
 302                                                                      done equilibrating*/
 303                 {
 304                     bDoneEquilibrating  = FALSE;
 305                     break;
 306                 }
 307             }
 308             break;
 309         case elmceqWLDELTA:
 310             if (EWL(expand->elamstats)) /* This check is in readir as well, but
 311                                            just to be sure */
 312             {
 313                 if (dfhist->wl_delta > expand->equil_wl_delta)
 314                 {
 315                     bDoneEquilibrating = FALSE;
 316                 }
 317             }
 318             break;
 319         case elmceqRATIO:
 320             /* we can use the flatness as a judge of good weights, as long as
 321                we're not doing minvar, or Wang-Landau.
 322                But turn off for now until we figure out exactly how we do this.
 323              */
 324
 325             if (!(EWL(expand->elamstats) || expand->elamstats == elamstatsMINVAR))
 326             {
 327                 /* we want to use flatness -avoiding- the forced-through samples.  Plus, we need to convert to
 328                    floats for this histogram function. */
 329
 330                 real *modhisto;
 331                 snew(modhisto, nlim);
 332                 for (i = 0; i < nlim; i++)
 333                 {
 334                     modhisto[i] = 1.0*(dfhist->n_at_lam[i]-expand->lmc_forced_nstart);
 335                 }
 336                 bIfFlat = CheckHistogramRatios(nlim, modhisto, expand->equil_ratio);
 337                 sfree(modhisto);
 338                 if (!bIfFlat)
 339                 {
 340                     bDoneEquilibrating = FALSE;
 341                 }
 342             }
 343         default:
 344             bDoneEquilibrating = TRUE;
 345     }
 346     /* one last case to go though, if we are doing slow growth to get initial values, we haven't finished equilibrating */
 347
 348     if (expand->lmc_forced_nstart > 0)
 349     {
 350         for (i = 0; i < nlim; i++)
 351         {
 352             if (dfhist->n_at_lam[i] < expand->lmc_forced_nstart) /* we are still doing the initial sweep, so we're definitely not
 353                                                                     done equilibrating*/
 354             {
 355                 bDoneEquilibrating = FALSE;
 356                 break;
 357             }
 358         }
 359     }
 360     return bDoneEquilibrating;
 361 }
 362
 363 static gmx_bool UpdateWeights(int nlim, t_expanded *expand, df_history_t *dfhist,
 364                               int fep_state, real *scaled_lamee, real *weighted_lamee, gmx_int64_t step)
 365 {
 366     real     maxdiff = 0.000000001;
 367     gmx_bool bSufficientSamples;
 368     int      i, k, n, nz, indexi, indexk, min_n, max_n, totali;
 369     int      n0, np1, nm1, nval, min_nvalm, min_nvalp, maxc;
 370     real     omega_m1_0, omega_p1_m1, omega_m1_p1, omega_p1_0, clam_osum;
 371     real     de, de_function, dr, denom, maxdr;
 372     real     min_val, cnval, zero_sum_weights;
 373     real    *omegam_array, *weightsm_array, *omegap_array, *weightsp_array, *varm_array, *varp_array, *dwp_array, *dwm_array;
 374     real     clam_varm, clam_varp, clam_weightsm, clam_weightsp, clam_minvar;
 375     real    *lam_weights, *lam_minvar_corr, *lam_variance, *lam_dg;
 376     double  *p_k;
 377     double   pks = 0;
 378     real    *numweighted_lamee, *logfrac;
 379     int     *nonzero;
 380     real     chi_m1_0, chi_p1_0, chi_m2_0, chi_p2_0, chi_p1_m1, chi_p2_m1, chi_m1_p1, chi_m2_p1;
 381
 382     /* if we have equilibrated the weights, exit now */
 383     if (dfhist->bEquil)
 384     {
 385         return FALSE;
 386     }
 387
 388     if (CheckIfDoneEquilibrating(nlim, expand, dfhist, step))
 389     {
 390         dfhist->bEquil = TRUE;
 391         /* zero out the visited states so we know how many equilibrated states we have
 392            from here on out.*/
 393         for (i = 0; i < nlim; i++)
 394         {
 395             dfhist->n_at_lam[i] = 0;
 396         }
 397         return TRUE;
 398     }
 399
 400     /* If we reached this far, we have not equilibrated yet, keep on
 401        going resetting the weights */
 402
 403     if (EWL(expand->elamstats))
 404     {
 405         if (expand->elamstats == elamstatsWL)  /* Standard Wang-Landau */
 406         {
 407             dfhist->sum_weights[fep_state] -= dfhist->wl_delta;
 408             dfhist->wl_histo[fep_state]    += 1.0;
 409         }
 410         else if (expand->elamstats == elamstatsWWL) /* Weighted Wang-Landau */
 411         {
 412             snew(p_k, nlim);
 413
 414             /* first increment count */
 415             GenerateGibbsProbabilities(weighted_lamee, p_k, &pks, 0, nlim-1);
 416             for (i = 0; i < nlim; i++)
 417             {
 418                 dfhist->wl_histo[i] += (real)p_k[i];
 419             }
 420
 421             /* then increment weights (uses count) */
 422             pks = 0.0;
 423             GenerateWeightedGibbsProbabilities(weighted_lamee, p_k, &pks, nlim, dfhist->wl_histo, dfhist->wl_delta);
 424
 425             for (i = 0; i < nlim; i++)
 426             {
 427                 dfhist->sum_weights[i] -= dfhist->wl_delta*(real)p_k[i];
 428             }
 429             /* Alternate definition, using logarithms. Shouldn't make very much difference! */
 430             /*
 431                real di;
 432                for (i=0;i<nlim;i++)
 433                {
 434                 di = (real)1.0 + dfhist->wl_delta*(real)p_k[i];
 435                 dfhist->sum_weights[i] -= log(di);
 436                }
 437              */
 438             sfree(p_k);
 439         }
 440
 441         zero_sum_weights =  dfhist->sum_weights[0];
 442         for (i = 0; i < nlim; i++)
 443         {
 444             dfhist->sum_weights[i] -= zero_sum_weights;
 445         }
 446     }
 447
 448     if (expand->elamstats == elamstatsBARKER || expand->elamstats == elamstatsMETROPOLIS || expand->elamstats == elamstatsMINVAR)
 449     {
 450
 451         de_function = 0;  /* to get rid of warnings, but this value will not be used because of the logic */
 452         maxc        = 2*expand->c_range+1;
 453
 454         snew(lam_dg, nlim);
 455         snew(lam_variance, nlim);
 456
 457         snew(omegap_array, maxc);
 458         snew(weightsp_array, maxc);
 459         snew(varp_array, maxc);
 460         snew(dwp_array, maxc);
 461
 462         snew(omegam_array, maxc);
 463         snew(weightsm_array, maxc);
 464         snew(varm_array, maxc);
 465         snew(dwm_array, maxc);
 466
 467         /* unpack the current lambdas -- we will only update 2 of these */
 468
 469         for (i = 0; i < nlim-1; i++)
 470         {   /* only through the second to last */
 471             lam_dg[i]       = dfhist->sum_dg[i+1] - dfhist->sum_dg[i];
 472             lam_variance[i] = pow(dfhist->sum_variance[i+1], 2) - pow(dfhist->sum_variance[i], 2);
 473         }
 474
 475         /* accumulate running averages */
 476         for (nval = 0; nval < maxc; nval++)
 477         {
 478             /* constants for later use */
 479             cnval = (real)(nval-expand->c_range);
 480             /* actually, should be able to rewrite it w/o exponential, for better numerical stability */
 481             if (fep_state > 0)
 482             {
 483                 de = exp(cnval - (scaled_lamee[fep_state]-scaled_lamee[fep_state-1]));
 484                 if (expand->elamstats == elamstatsBARKER || expand->elamstats == elamstatsMINVAR)
 485                 {
 486                     de_function = 1.0/(1.0+de);
 487                 }
 488                 else if (expand->elamstats == elamstatsMETROPOLIS)
 489                 {
 490                     if (de < 1.0)
 491                     {
 492                         de_function = 1.0;
 493                     }
 494                     else
 495                     {
 496                         de_function = 1.0/de;
 497                     }
 498                 }
 499                 dfhist->accum_m[fep_state][nval]  += de_function;
 500                 dfhist->accum_m2[fep_state][nval] += de_function*de_function;
 501             }
 502
 503             if (fep_state < nlim-1)
 504             {
 505                 de = exp(-cnval + (scaled_lamee[fep_state+1]-scaled_lamee[fep_state]));
 506                 if (expand->elamstats == elamstatsBARKER || expand->elamstats == elamstatsMINVAR)
 507                 {
 508                     de_function = 1.0/(1.0+de);
 509                 }
 510                 else if (expand->elamstats == elamstatsMETROPOLIS)
 511                 {
 512                     if (de < 1.0)
 513                     {
 514                         de_function = 1.0;
 515                     }
 516                     else
 517                     {
 518                         de_function = 1.0/de;
 519                     }
 520                 }
 521                 dfhist->accum_p[fep_state][nval]  += de_function;
 522                 dfhist->accum_p2[fep_state][nval] += de_function*de_function;
 523             }
 524
 525             /* Metropolis transition and Barker transition (unoptimized Bennett) acceptance weight determination */
 526
 527             n0  = dfhist->n_at_lam[fep_state];
 528             if (fep_state > 0)
 529             {
 530                 nm1 = dfhist->n_at_lam[fep_state-1];
 531             }
 532             else
 533             {
 534                 nm1 = 0;
 535             }
 536             if (fep_state < nlim-1)
 537             {
 538                 np1 = dfhist->n_at_lam[fep_state+1];
 539             }
 540             else
 541             {
 542                 np1 = 0;
 543             }
 544
 545             /* logic SHOULD keep these all set correctly whatever the logic, but apparently it can't figure it out. */
 546             chi_m1_0 = chi_p1_0 = chi_m2_0 = chi_p2_0 = chi_p1_m1 = chi_p2_m1 = chi_m1_p1 = chi_m2_p1 = 0;
 547
 548             if (n0 > 0)
 549             {
 550                 chi_m1_0 = dfhist->accum_m[fep_state][nval]/n0;
 551                 chi_p1_0 = dfhist->accum_p[fep_state][nval]/n0;
 552                 chi_m2_0 = dfhist->accum_m2[fep_state][nval]/n0;
 553                 chi_p2_0 = dfhist->accum_p2[fep_state][nval]/n0;
 554             }
 555
 556             if ((fep_state > 0 ) && (nm1 > 0))
 557             {
 558                 chi_p1_m1 = dfhist->accum_p[fep_state-1][nval]/nm1;
 559                 chi_p2_m1 = dfhist->accum_p2[fep_state-1][nval]/nm1;
 560             }
 561
 562             if ((fep_state < nlim-1) && (np1 > 0))
 563             {
 564                 chi_m1_p1 = dfhist->accum_m[fep_state+1][nval]/np1;
 565                 chi_m2_p1 = dfhist->accum_m2[fep_state+1][nval]/np1;
 566             }
 567
 568             omega_m1_0    = 0;
 569             omega_p1_0    = 0;
 570             clam_weightsm = 0;
 571             clam_weightsp = 0;
 572             clam_varm     = 0;
 573             clam_varp     = 0;
 574
 575             if (fep_state > 0)
 576             {
 577                 if (n0 > 0)
 578                 {
 579                     omega_m1_0 = chi_m2_0/(chi_m1_0*chi_m1_0) - 1.0;
 580                 }
 581                 if (nm1 > 0)
 582                 {
 583                     omega_p1_m1 = chi_p2_m1/(chi_p1_m1*chi_p1_m1) - 1.0;
 584                 }
 585                 if ((n0 > 0) && (nm1 > 0))
 586                 {
 587                     clam_weightsm = (log(chi_m1_0) - log(chi_p1_m1)) + cnval;
 588                     clam_varm     = (1.0/n0)*(omega_m1_0) + (1.0/nm1)*(omega_p1_m1);
 589                 }
 590             }
 591
 592             if (fep_state < nlim-1)
 593             {
 594                 if (n0 > 0)
 595                 {
 596                     omega_p1_0 = chi_p2_0/(chi_p1_0*chi_p1_0) - 1.0;
 597                 }
 598                 if (np1 > 0)
 599                 {
 600                     omega_m1_p1 = chi_m2_p1/(chi_m1_p1*chi_m1_p1) - 1.0;
 601                 }
 602                 if ((n0 > 0) && (np1 > 0))
 603                 {
 604                     clam_weightsp = (log(chi_m1_p1) - log(chi_p1_0)) + cnval;
 605                     clam_varp     = (1.0/np1)*(omega_m1_p1) + (1.0/n0)*(omega_p1_0);
 606                 }
 607             }
 608
 609             if (n0 > 0)
 610             {
 611                 omegam_array[nval]             = omega_m1_0;
 612             }
 613             else
 614             {
 615                 omegam_array[nval]             = 0;
 616             }
 617             weightsm_array[nval]           = clam_weightsm;
 618             varm_array[nval]               = clam_varm;
 619             if (nm1 > 0)
 620             {
 621                 dwm_array[nval]  = fabs( (cnval + log((1.0*n0)/nm1)) - lam_dg[fep_state-1] );
 622             }
 623             else
 624             {
 625                 dwm_array[nval]  = fabs( cnval - lam_dg[fep_state-1] );
 626             }
 627
 628             if (n0 > 0)
 629             {
 630                 omegap_array[nval]             = omega_p1_0;
 631             }
 632             else
 633             {
 634                 omegap_array[nval]             = 0;
 635             }
 636             weightsp_array[nval]           = clam_weightsp;
 637             varp_array[nval]               = clam_varp;
 638             if ((np1 > 0) && (n0 > 0))
 639             {
 640                 dwp_array[nval]  = fabs( (cnval + log((1.0*np1)/n0)) - lam_dg[fep_state] );
 641             }
 642             else
 643             {
 644                 dwp_array[nval]  = fabs( cnval - lam_dg[fep_state] );
 645             }
 646
 647         }
 648
 649         /* find the C's closest to the old weights value */
 650
 651         min_nvalm     = FindMinimum(dwm_array, maxc);
 652         omega_m1_0    = omegam_array[min_nvalm];
 653         clam_weightsm = weightsm_array[min_nvalm];
 654         clam_varm     = varm_array[min_nvalm];
 655
 656         min_nvalp     = FindMinimum(dwp_array, maxc);
 657         omega_p1_0    = omegap_array[min_nvalp];
 658         clam_weightsp = weightsp_array[min_nvalp];
 659         clam_varp     = varp_array[min_nvalp];
 660
 661         clam_osum   = omega_m1_0 + omega_p1_0;
 662         clam_minvar = 0;
 663         if (clam_osum > 0)
 664         {
 665             clam_minvar = 0.5*log(clam_osum);
 666         }
 667
 668         if (fep_state > 0)
 669         {
 670             lam_dg[fep_state-1]       = clam_weightsm;
 671             lam_variance[fep_state-1] = clam_varm;
 672         }
 673
 674         if (fep_state < nlim-1)
 675         {
 676             lam_dg[fep_state]       = clam_weightsp;
 677             lam_variance[fep_state] = clam_varp;
 678         }
 679
 680         if (expand->elamstats == elamstatsMINVAR)
 681         {
 682             bSufficientSamples = TRUE;
 683             /* make sure they are all past a threshold */
 684             for (i = 0; i < nlim; i++)
 685             {
 686                 if (dfhist->n_at_lam[i] < expand->minvarmin)
 687                 {
 688                     bSufficientSamples = FALSE;
 689                 }
 690             }
 691             if (bSufficientSamples)
 692             {
 693                 dfhist->sum_minvar[fep_state] = clam_minvar;
 694                 if (fep_state == 0)
 695                 {
 696                     for (i = 0; i < nlim; i++)
 697                     {
 698                         dfhist->sum_minvar[i] += (expand->minvar_const-clam_minvar);
 699                     }
 700                     expand->minvar_const          = clam_minvar;
 701                     dfhist->sum_minvar[fep_state] = 0.0;
 702                 }
 703                 else
 704                 {
 705                     dfhist->sum_minvar[fep_state] -= expand->minvar_const;
 706                 }
 707             }
 708         }
 709
 710         /* we need to rezero minvar now, since it could change at fep_state = 0 */
 711         dfhist->sum_dg[0]       = 0.0;
 712         dfhist->sum_variance[0] = 0.0;
 713         dfhist->sum_weights[0]  = dfhist->sum_dg[0] + dfhist->sum_minvar[0]; /* should be zero */
 714
 715         for (i = 1; i < nlim; i++)
 716         {
 717             dfhist->sum_dg[i]       = lam_dg[i-1] + dfhist->sum_dg[i-1];
 718             dfhist->sum_variance[i] = sqrt(lam_variance[i-1] + pow(dfhist->sum_variance[i-1], 2));
 719             dfhist->sum_weights[i]  = dfhist->sum_dg[i] + dfhist->sum_minvar[i];
 720         }
 721
 722         sfree(lam_dg);
 723         sfree(lam_variance);
 724
 725         sfree(omegam_array);
 726         sfree(weightsm_array);
 727         sfree(varm_array);
 728         sfree(dwm_array);
 729
 730         sfree(omegap_array);
 731         sfree(weightsp_array);
 732         sfree(varp_array);
 733         sfree(dwp_array);
 734     }
 735     return FALSE;
 736 }
 737
 738 static int ChooseNewLambda(int nlim, t_expanded *expand, df_history_t *dfhist, int fep_state, real *weighted_lamee, double *p_k,
 739                            gmx_int64_t seed, gmx_int64_t step)
 740 {
 741     /* Choose new lambda value, and update transition matrix */
 742
 743     int      i, ifep, jfep, minfep, maxfep, lamnew, lamtrial, starting_fep_state;
 744     real     r1, r2, de_old, de_new, de, trialprob, tprob = 0;
 745     real   **Tij;
 746     double  *propose, *accept, *remainder;
 747     double   pks;
 748     real     sum, pnorm;
 749     gmx_bool bRestricted;
 750
 751     starting_fep_state = fep_state;
 752     lamnew             = fep_state; /* so that there is a default setting -- stays the same */
 753
 754     if (!EWL(expand->elamstats))    /* ignore equilibrating the weights if using WL */
 755     {
 756         if ((expand->lmc_forced_nstart > 0) && (dfhist->n_at_lam[nlim-1] <= expand->lmc_forced_nstart))
 757         {
 758             /* Use a marching method to run through the lambdas and get preliminary free energy data,
 759                before starting 'free' sampling.  We start free sampling when we have enough at each lambda */
 760
 761             /* if we have enough at this lambda, move on to the next one */
 762
 763             if (dfhist->n_at_lam[fep_state] == expand->lmc_forced_nstart)
 764             {
 765                 lamnew = fep_state+1;
 766                 if (lamnew == nlim)  /* whoops, stepped too far! */
 767                 {
 768                     lamnew -= 1;
 769                 }
 770             }
 771             else
 772             {
 773                 lamnew = fep_state;
 774             }
 775             return lamnew;
 776         }
 777     }
 778
 779     snew(propose, nlim);
 780     snew(accept, nlim);
 781     snew(remainder, nlim);
 782
 783     for (i = 0; i < expand->lmc_repeats; i++)
 784     {
 785         double rnd[2];
 786
 787         gmx_rng_cycle_2uniform(step, i, seed, RND_SEED_EXPANDED, rnd);
 788
 789         for (ifep = 0; ifep < nlim; ifep++)
 790         {
 791             propose[ifep] = 0;
 792             accept[ifep]  = 0;
 793         }
 794
 795         if ((expand->elmcmove == elmcmoveGIBBS) || (expand->elmcmove == elmcmoveMETGIBBS))
 796         {
 797             bRestricted = TRUE;
 798             /* use the Gibbs sampler, with restricted range */
 799             if (expand->gibbsdeltalam < 0)
 800             {
 801                 minfep      = 0;
 802                 maxfep      = nlim-1;
 803                 bRestricted = FALSE;
 804             }
 805             else
 806             {
 807                 minfep = fep_state - expand->gibbsdeltalam;
 808                 maxfep = fep_state + expand->gibbsdeltalam;
 809                 if (minfep < 0)
 810                 {
 811                     minfep = 0;
 812                 }
 813                 if (maxfep > nlim-1)
 814                 {
 815                     maxfep = nlim-1;
 816                 }
 817             }
 818
 819             GenerateGibbsProbabilities(weighted_lamee, p_k, &pks, minfep, maxfep);
 820
 821             if (expand->elmcmove == elmcmoveGIBBS)
 822             {
 823                 for (ifep = minfep; ifep <= maxfep; ifep++)
 824                 {
 825                     propose[ifep] = p_k[ifep];
 826                     accept[ifep]  = 1.0;
 827                 }
 828                 /* Gibbs sampling */
 829                 r1 = rnd[0];
 830                 for (lamnew = minfep; lamnew <= maxfep; lamnew++)
 831                 {
 832                     if (r1 <= p_k[lamnew])
 833                     {
 834                         break;
 835                     }
 836                     r1 -= p_k[lamnew];
 837                 }
 838             }
 839             else if (expand->elmcmove == elmcmoveMETGIBBS)
 840             {
 841
 842                 /* Metropolized Gibbs sampling */
 843                 for (ifep = minfep; ifep <= maxfep; ifep++)
 844                 {
 845                     remainder[ifep] = 1 - p_k[ifep];
 846                 }
 847
 848                 /* find the proposal probabilities */
 849
 850                 if (remainder[fep_state] == 0)
 851                 {
 852                     /* only the current state has any probability */
 853                     /* we have to stay at the current state */
 854                     lamnew = fep_state;
 855                 }
 856                 else
 857                 {
 858                     for (ifep = minfep; ifep <= maxfep; ifep++)
 859                     {
 860                         if (ifep != fep_state)
 861                         {
 862                             propose[ifep] = p_k[ifep]/remainder[fep_state];
 863                         }
 864                         else
 865                         {
 866                             propose[ifep] = 0;
 867                         }
 868                     }
 869
 870                     r1 = rnd[0];
 871                     for (lamtrial = minfep; lamtrial <= maxfep; lamtrial++)
 872                     {
 873                         pnorm = p_k[lamtrial]/remainder[fep_state];
 874                         if (lamtrial != fep_state)
 875                         {
 876                             if (r1 <= pnorm)
 877                             {
 878                                 break;
 879                             }
 880                             r1 -= pnorm;
 881                         }
 882                     }
 883
 884                     /* we have now selected lamtrial according to p(lamtrial)/1-p(fep_state) */
 885                     tprob = 1.0;
 886                     /* trial probability is min{1,\frac{1 - p(old)}{1-p(new)} MRS 1/8/2008 */
 887                     trialprob = (remainder[fep_state])/(remainder[lamtrial]);
 888                     if (trialprob < tprob)
 889                     {
 890                         tprob = trialprob;
 891                     }
 892                     r2 = rnd[1];
 893                     if (r2 < tprob)
 894                     {
 895                         lamnew = lamtrial;
 896                     }
 897                     else
 898                     {
 899                         lamnew = fep_state;
 900                     }
 901                 }
 902
 903                 /* now figure out the acceptance probability for each */
 904                 for (ifep = minfep; ifep <= maxfep; ifep++)
 905                 {
 906                     tprob = 1.0;
 907                     if (remainder[ifep] != 0)
 908                     {
 909                         trialprob = (remainder[fep_state])/(remainder[ifep]);
 910                     }
 911                     else
 912                     {
 913                         trialprob = 1.0; /* this state is the only choice! */
 914                     }
 915                     if (trialprob < tprob)
 916                     {
 917                         tprob = trialprob;
 918                     }
 919                     /* probability for fep_state=0, but that's fine, it's never proposed! */
 920                     accept[ifep] = tprob;
 921                 }
 922             }
 923
 924             if (lamnew > maxfep)
 925             {
 926                 /* it's possible some rounding is failing */
 927                 if (gmx_within_tol(remainder[fep_state], 0, 50*GMX_DOUBLE_EPS))
 928                 {
 929                     /* numerical rounding error -- no state other than the original has weight */
 930                     lamnew = fep_state;
 931                 }
 932                 else
 933                 {
 934                     /* probably not a numerical issue */
 935                     int   loc    = 0;
 936                     int   nerror = 200+(maxfep-minfep+1)*60;
 937                     char *errorstr;
 938                     snew(errorstr, nerror);
 939                     /* if its greater than maxfep, then something went wrong -- probably underflow in the calculation
 940                        of sum weights. Generated detailed info for failure */
 941                     loc += sprintf(errorstr, "Something wrong in choosing new lambda state with a Gibbs move -- probably underflow in weight determination.\nDenominator is: %3d%17.10e\n  i                dE        numerator          weights\n", 0, pks);
 942                     for (ifep = minfep; ifep <= maxfep; ifep++)
 943                     {
 944                         loc += sprintf(&errorstr[loc], "%3d %17.10e%17.10e%17.10e\n", ifep, weighted_lamee[ifep], p_k[ifep], dfhist->sum_weights[ifep]);
 945                     }
 946                     gmx_fatal(FARGS, errorstr);
 947                 }
 948             }
 949         }
 950         else if ((expand->elmcmove == elmcmoveMETROPOLIS) || (expand->elmcmove == elmcmoveBARKER))
 951         {
 952             /* use the metropolis sampler with trial +/- 1 */
 953             r1 = rnd[0];
 954             if (r1 < 0.5)
 955             {
 956                 if (fep_state == 0)
 957                 {
 958                     lamtrial = fep_state;
 959                 }
 960                 else
 961                 {
 962                     lamtrial = fep_state-1;
 963                 }
 964             }
 965             else
 966             {
 967                 if (fep_state == nlim-1)
 968                 {
 969                     lamtrial = fep_state;
 970                 }
 971                 else
 972                 {
 973                     lamtrial = fep_state+1;
 974                 }
 975             }
 976
 977             de = weighted_lamee[lamtrial] - weighted_lamee[fep_state];
 978             if (expand->elmcmove == elmcmoveMETROPOLIS)
 979             {
 980                 tprob     = 1.0;
 981                 trialprob = exp(de);
 982                 if (trialprob < tprob)
 983                 {
 984                     tprob = trialprob;
 985                 }
 986                 propose[fep_state] = 0;
 987                 propose[lamtrial]  = 1.0; /* note that this overwrites the above line if fep_state = ntrial, which only occurs at the ends */
 988                 accept[fep_state]  = 1.0; /* doesn't actually matter, never proposed unless fep_state = ntrial, in which case it's 1.0 anyway */
 989                 accept[lamtrial]   = tprob;
 990
 991             }
 992             else if (expand->elmcmove == elmcmoveBARKER)
 993             {
 994                 tprob = 1.0/(1.0+exp(-de));
 995
 996                 propose[fep_state] = (1-tprob);
 997                 propose[lamtrial] += tprob; /* we add, to account for the fact that at the end, they might be the same point */
 998                 accept[fep_state]  = 1.0;
 999                 accept[lamtrial]   = 1.0;
1000             }
1001
1002             r2 = rnd[1];
1003             if (r2 < tprob)
1004             {
1005                 lamnew = lamtrial;
1006             }
1007             else
1008             {
1009                 lamnew = fep_state;
1010             }
1011         }
1012
1013         for (ifep = 0; ifep < nlim; ifep++)
1014         {
1015             dfhist->Tij[fep_state][ifep]      += propose[ifep]*accept[ifep];
1016             dfhist->Tij[fep_state][fep_state] += propose[ifep]*(1.0-accept[ifep]);
1017         }
1018         fep_state = lamnew;
1019     }
1020
1021     dfhist->Tij_empirical[starting_fep_state][lamnew] += 1.0;
1022
1023     sfree(propose);
1024     sfree(accept);
1025     sfree(remainder);
1026
1027     return lamnew;
1028 }
1029
1030 /* print out the weights to the log, along with current state */
1031 extern void PrintFreeEnergyInfoToFile(FILE *outfile, t_lambda *fep, t_expanded *expand, t_simtemp *simtemp, df_history_t *dfhist,
1032                                       int fep_state, int frequency, gmx_int64_t step)
1033 {
1034     int         nlim, i, ifep, jfep;
1035     real        dw, dg, dv, dm, Tprint;
1036     real       *temps;
1037     const char *print_names[efptNR] = {" FEPL", "MassL", "CoulL", " VdwL", "BondL", "RestT", "Temp.(K)"};
1038     gmx_bool    bSimTemp            = FALSE;
1039
1040     nlim = fep->n_lambda;
1041     if (simtemp != NULL)
1042     {
1043         bSimTemp = TRUE;
1044     }
1045
1046     if (mod(step, frequency) == 0)
1047     {
1048         fprintf(outfile, "             MC-lambda information\n");
1049         if (EWL(expand->elamstats) && (!(dfhist->bEquil)))
1050         {
1051             fprintf(outfile, "  Wang-Landau incrementor is: %11.5g\n", dfhist->wl_delta);
1052         }
1053         fprintf(outfile, "  N");
1054         for (i = 0; i < efptNR; i++)
1055         {
1056             if (fep->separate_dvdl[i])
1057             {
1058                 fprintf(outfile, "%7s", print_names[i]);
1059             }
1060             else if ((i == efptTEMPERATURE) && bSimTemp)
1061             {
1062                 fprintf(outfile, "%10s", print_names[i]); /* more space for temperature formats */
1063             }
1064         }
1065         fprintf(outfile, "    Count   ");
1066         if (expand->elamstats == elamstatsMINVAR)
1067         {
1068             fprintf(outfile, "W(in kT)   G(in kT)  dG(in kT)  dV(in kT)\n");
1069         }
1070         else
1071         {
1072             fprintf(outfile, "G(in kT)  dG(in kT)\n");
1073         }
1074         for (ifep = 0; ifep < nlim; ifep++)
1075         {
1076             if (ifep == nlim-1)
1077             {
1078                 dw = 0.0;
1079                 dg = 0.0;
1080                 dv = 0.0;
1081                 dm = 0.0;
1082             }
1083             else
1084             {
1085                 dw = dfhist->sum_weights[ifep+1] - dfhist->sum_weights[ifep];
1086                 dg = dfhist->sum_dg[ifep+1] - dfhist->sum_dg[ifep];
1087                 dv = sqrt(pow(dfhist->sum_variance[ifep+1], 2) - pow(dfhist->sum_variance[ifep], 2));
1088                 dm = dfhist->sum_minvar[ifep+1] - dfhist->sum_minvar[ifep];
1089
1090             }
1091             fprintf(outfile, "%3d", (ifep+1));
1092             for (i = 0; i < efptNR; i++)
1093             {
1094                 if (fep->separate_dvdl[i])
1095                 {
1096                     fprintf(outfile, "%7.3f", fep->all_lambda[i][ifep]);
1097                 }
1098                 else if (i == efptTEMPERATURE && bSimTemp)
1099                 {
1100                     fprintf(outfile, "%9.3f", simtemp->temperatures[ifep]);
1101                 }
1102             }
1103             if (EWL(expand->elamstats) && (!(dfhist->bEquil)))  /* if performing WL and still haven't equilibrated */
1104             {
1105                 if (expand->elamstats == elamstatsWL)
1106                 {
1107                     fprintf(outfile, " %8d", (int)dfhist->wl_histo[ifep]);
1108                 }
1109                 else
1110                 {
1111                     fprintf(outfile, " %8.3f", dfhist->wl_histo[ifep]);
1112                 }
1113             }
1114             else   /* we have equilibrated weights */
1115             {
1116                 fprintf(outfile, " %8d", dfhist->n_at_lam[ifep]);
1117             }
1118             if (expand->elamstats == elamstatsMINVAR)
1119             {
1120                 fprintf(outfile, " %10.5f %10.5f %10.5f %10.5f", dfhist->sum_weights[ifep], dfhist->sum_dg[ifep], dg, dv);
1121             }
1122             else
1123             {
1124                 fprintf(outfile, " %10.5f %10.5f", dfhist->sum_weights[ifep], dw);
1125             }
1126             if (ifep == fep_state)
1127             {
1128                 fprintf(outfile, " <<\n");
1129             }
1130             else
1131             {
1132                 fprintf(outfile, "   \n");
1133             }
1134         }
1135         fprintf(outfile, "\n");
1136
1137         if ((mod(step, expand->nstTij) == 0) && (expand->nstTij > 0) && (step > 0))
1138         {
1139             fprintf(outfile, "                     Transition Matrix\n");
1140             for (ifep = 0; ifep < nlim; ifep++)
1141             {
1142                 fprintf(outfile, "%12d", (ifep+1));
1143             }
1144             fprintf(outfile, "\n");
1145             for (ifep = 0; ifep < nlim; ifep++)
1146             {
1147                 for (jfep = 0; jfep < nlim; jfep++)
1148                 {
1149                     if (dfhist->n_at_lam[ifep] > 0)
1150                     {
1151                         if (expand->bSymmetrizedTMatrix)
1152                         {
1153                             Tprint = (dfhist->Tij[ifep][jfep]+dfhist->Tij[jfep][ifep])/(dfhist->n_at_lam[ifep]+dfhist->n_at_lam[jfep]);
1154                         }
1155                         else
1156                         {
1157                             Tprint = (dfhist->Tij[ifep][jfep])/(dfhist->n_at_lam[ifep]);
1158                         }
1159                     }
1160                     else
1161                     {
1162                         Tprint = 0.0;
1163                     }
1164                     fprintf(outfile, "%12.8f", Tprint);
1165                 }
1166                 fprintf(outfile, "%3d\n", (ifep+1));
1167             }
1168
1169             fprintf(outfile, "                  Empirical Transition Matrix\n");
1170             for (ifep = 0; ifep < nlim; ifep++)
1171             {
1172                 fprintf(outfile, "%12d", (ifep+1));
1173             }
1174             fprintf(outfile, "\n");
1175             for (ifep = 0; ifep < nlim; ifep++)
1176             {
1177                 for (jfep = 0; jfep < nlim; jfep++)
1178                 {
1179                     if (dfhist->n_at_lam[ifep] > 0)
1180                     {
1181                         if (expand->bSymmetrizedTMatrix)
1182                         {
1183                             Tprint = (dfhist->Tij_empirical[ifep][jfep]+dfhist->Tij_empirical[jfep][ifep])/(dfhist->n_at_lam[ifep]+dfhist->n_at_lam[jfep]);
1184                         }
1185                         else
1186                         {
1187                             Tprint = dfhist->Tij_empirical[ifep][jfep]/(dfhist->n_at_lam[ifep]);
1188                         }
1189                     }
1190                     else
1191                     {
1192                         Tprint = 0.0;
1193                     }
1194                     fprintf(outfile, "%12.8f", Tprint);
1195                 }
1196                 fprintf(outfile, "%3d\n", (ifep+1));
1197             }
1198         }
1199     }
1200 }
1201
1202 extern int ExpandedEnsembleDynamics(FILE *log, t_inputrec *ir, gmx_enerdata_t *enerd,
1203                                     t_state *state, t_extmass *MassQ, int fep_state, df_history_t *dfhist,
1204                                     gmx_int64_t step,
1205                                     rvec *v, t_mdatoms *mdatoms)
1206 /* Note that the state variable is only needed for simulated tempering, not
1207    Hamiltonian expanded ensemble.  May be able to remove it after integrator refactoring. */
1208 {
1209     real       *pfep_lamee, *scaled_lamee, *weighted_lamee;
1210     double     *p_k;
1211     int         i, nlim, lamnew, totalsamples;
1212     real        oneovert, maxscaled = 0, maxweighted = 0;
1213     t_expanded *expand;
1214     t_simtemp  *simtemp;
1215     double     *temperature_lambdas;
1216     gmx_bool    bIfReset, bSwitchtoOneOverT, bDoneEquilibrating = FALSE;
1217
1218     expand  = ir->expandedvals;
1219     simtemp = ir->simtempvals;
1220     nlim    = ir->fepvals->n_lambda;
1221
1222     snew(scaled_lamee, nlim);
1223     snew(weighted_lamee, nlim);
1224     snew(pfep_lamee, nlim);
1225     snew(p_k, nlim);
1226
1227     /* update the count at the current lambda*/
1228     dfhist->n_at_lam[fep_state]++;
1229
1230     /* need to calculate the PV term somewhere, but not needed here? Not until there's a lambda state that's
1231        pressure controlled.*/
1232     /*
1233        pVTerm = 0;
1234        where does this PV term go?
1235        for (i=0;i<nlim;i++)
1236        {
1237        fep_lamee[i] += pVTerm;
1238        }
1239      */
1240
1241     /* determine the minimum value to avoid overflow.  Probably a better way to do this */
1242     /* we don't need to include the pressure term, since the volume is the same between the two.
1243        is there some term we are neglecting, however? */
1244
1245     if (ir->efep != efepNO)
1246     {
1247         for (i = 0; i < nlim; i++)
1248         {
1249             if (ir->bSimTemp)
1250             {
1251                 /* Note -- this assumes no mass changes, since kinetic energy is not added  . . . */
1252                 scaled_lamee[i] = (enerd->enerpart_lambda[i+1]-enerd->enerpart_lambda[0])/(simtemp->temperatures[i]*BOLTZ)
1253                     + enerd->term[F_EPOT]*(1.0/(simtemp->temperatures[i])- 1.0/(simtemp->temperatures[fep_state]))/BOLTZ;
1254             }
1255             else
1256             {
1257                 scaled_lamee[i] = (enerd->enerpart_lambda[i+1]-enerd->enerpart_lambda[0])/(expand->mc_temp*BOLTZ);
1258                 /* mc_temp is currently set to the system reft unless otherwise defined */
1259             }
1260
1261             /* save these energies for printing, so they don't get overwritten by the next step */
1262             /* they aren't overwritten in the non-free energy case, but we always print with these
1263                for simplicity */
1264         }
1265     }
1266     else
1267     {
1268         if (ir->bSimTemp)
1269         {
1270             for (i = 0; i < nlim; i++)
1271             {
1272                 scaled_lamee[i] = enerd->term[F_EPOT]*(1.0/simtemp->temperatures[i] - 1.0/simtemp->temperatures[fep_state])/BOLTZ;
1273             }
1274         }
1275     }
1276
1277     for (i = 0; i < nlim; i++)
1278     {
1279         pfep_lamee[i] = scaled_lamee[i];
1280
1281         weighted_lamee[i] = dfhist->sum_weights[i] - scaled_lamee[i];
1282         if (i == 0)
1283         {
1284             maxscaled   = scaled_lamee[i];
1285             maxweighted = weighted_lamee[i];
1286         }
1287         else
1288         {
1289             if (scaled_lamee[i] > maxscaled)
1290             {
1291                 maxscaled = scaled_lamee[i];
1292             }
1293             if (weighted_lamee[i] > maxweighted)
1294             {
1295                 maxweighted = weighted_lamee[i];
1296             }
1297         }
1298     }
1299
1300     for (i = 0; i < nlim; i++)
1301     {
1302         scaled_lamee[i]   -= maxscaled;
1303         weighted_lamee[i] -= maxweighted;
1304     }
1305
1306     /* update weights - we decide whether or not to actually do this inside */
1307
1308     bDoneEquilibrating = UpdateWeights(nlim, expand, dfhist, fep_state, scaled_lamee, weighted_lamee, step);
1309     if (bDoneEquilibrating)
1310     {
1311         if (log)
1312         {
1313             fprintf(log, "\nStep %d: Weights have equilibrated, using criteria: %s\n", (int)step, elmceq_names[expand->elmceq]);
1314         }
1315     }
1316
1317     lamnew = ChooseNewLambda(nlim, expand, dfhist, fep_state, weighted_lamee, p_k,
1318                              ir->expandedvals->lmc_seed, step);
1319     /* if using simulated tempering, we need to adjust the temperatures */
1320     if (ir->bSimTemp && (lamnew != fep_state)) /* only need to change the temperatures if we change the state */
1321     {
1322         int   i, j, n, d;
1323         real *buf_ngtc;
1324         real  told;
1325         int   nstart, nend, gt;
1326
1327         snew(buf_ngtc, ir->opts.ngtc);
1328
1329         for (i = 0; i < ir->opts.ngtc; i++)
1330         {
1331             if (ir->opts.ref_t[i] > 0)
1332             {
1333                 told              = ir->opts.ref_t[i];
1334                 ir->opts.ref_t[i] =  simtemp->temperatures[lamnew];
1335                 buf_ngtc[i]       = sqrt(ir->opts.ref_t[i]/told); /* using the buffer as temperature scaling */
1336             }
1337         }
1338
1339         /* we don't need to manipulate the ekind information, as it isn't due to be reset until the next step anyway */
1340
1341         nstart = 0;
1342         nend   = mdatoms->homenr;
1343         for (n = nstart; n < nend; n++)
1344         {
1345             gt = 0;
1346             if (mdatoms->cTC)
1347             {
1348                 gt = mdatoms->cTC[n];
1349             }
1350             for (d = 0; d < DIM; d++)
1351             {
1352                 v[n][d] *= buf_ngtc[gt];
1353             }
1354         }
1355
1356         if (IR_NPT_TROTTER(ir) || IR_NPH_TROTTER(ir) || IR_NVT_TROTTER(ir))
1357         {
1358             /* we need to recalculate the masses if the temperature has changed */
1359             init_npt_masses(ir, state, MassQ, FALSE);
1360             for (i = 0; i < state->nnhpres; i++)
1361             {
1362                 for (j = 0; j < ir->opts.nhchainlength; j++)
1363                 {
1364                     state->nhpres_vxi[i+j] *= buf_ngtc[i];
1365                 }
1366             }
1367             for (i = 0; i < ir->opts.ngtc; i++)
1368             {
1369                 for (j = 0; j < ir->opts.nhchainlength; j++)
1370                 {
1371                     state->nosehoover_vxi[i+j] *= buf_ngtc[i];
1372                 }
1373             }
1374         }
1375         sfree(buf_ngtc);
1376     }
1377
1378     /* now check on the Wang-Landau updating critera */
1379
1380     if (EWL(expand->elamstats))
1381     {
1382         bSwitchtoOneOverT = FALSE;
1383         if (expand->bWLoneovert)
1384         {
1385             totalsamples = 0;
1386             for (i = 0; i < nlim; i++)
1387             {
1388                 totalsamples += dfhist->n_at_lam[i];
1389             }
1390             oneovert = (1.0*nlim)/totalsamples;
1391             /* oneovert has decreasd by a bit since last time, so we actually make sure its within one of this number */
1392             /* switch to 1/t incrementing when wl_delta has decreased at least once, and wl_delta is now less than 1/t */
1393             if ((dfhist->wl_delta <= ((totalsamples)/(totalsamples-1.00001))*oneovert) &&
1394                 (dfhist->wl_delta < expand->init_wl_delta))
1395             {
1396                 bSwitchtoOneOverT = TRUE;
1397             }
1398         }
1399         if (bSwitchtoOneOverT)
1400         {
1401             dfhist->wl_delta = oneovert; /* now we reduce by this each time, instead of only at flatness */
1402         }
1403         else
1404         {
1405             bIfReset = CheckHistogramRatios(nlim, dfhist->wl_histo, expand->wl_ratio);
1406             if (bIfReset)
1407             {
1408                 for (i = 0; i < nlim; i++)
1409                 {
1410                     dfhist->wl_histo[i] = 0;
1411                 }
1412                 dfhist->wl_delta *= expand->wl_scale;
1413                 if (log)
1414                 {
1415                     fprintf(log, "\nStep %d: weights are now:", (int)step);
1416                     for (i = 0; i < nlim; i++)
1417                     {
1418                         fprintf(log, " %.5f", dfhist->sum_weights[i]);
1419                     }
1420                     fprintf(log, "\n");
1421                 }
1422             }
1423         }
1424     }
1425     sfree(pfep_lamee);
1426     sfree(scaled_lamee);
1427     sfree(weighted_lamee);
1428     sfree(p_k);
1429
1430     return lamnew;
1431 }