def minimize(self):
"""compute the best estimate for the density of states"""
nreps = self.nrep
nbins = self.nebins
visitsT = (self.visits1d)
#print "min vis", np.min(visitsT)
#print "minlogp", np.min(self.logP)
self.reduced_energy = self.binenergy[np.newaxis, :] / (
self.Tlist[:, np.newaxis] * self.k_B)
self.whampot = WhamPotential(visitsT, self.reduced_energy)
if False:
X = np.random.rand(nreps + nbins)
else:
# estimate an initial guess for the offsets and density of states
# so the minimizer converges more rapidly
offsets_estimate, log_dos_estimate = wham_utils.estimate_dos(
self.visits1d, self.reduced_energy)
X = np.concatenate((offsets_estimate, log_dos_estimate))
E0, grad = self.whampot.getEnergyGradient(X)
rms0 = np.linalg.norm(grad) / np.sqrt(grad.size)
try:
from pele.optimize import lbfgs_cpp as quench
if self.verbose:
print "minimizing with pele lbfgs"
ret = quench(X, self.whampot, tol=1e-3, maxstep=1e4, nsteps=10000)
except ImportError:
from wham_utils import lbfgs_scipy
if self.verbose:
print "minimizing with scipy lbfgs"
ret = lbfgs_scipy(X, self.whampot, tol=1e-3, nsteps=10000)
#print "quench energy", ret.energy
if self.verbose:
print "chi^2 went from %g (rms %g) to %g (rms %g) in %d iterations" % (
E0, rms0, ret.energy, ret.rms, ret.nfev)
X = ret.coords
self.logn_E = X[nreps:]
self.w_i_final = X[:nreps]
def minimize(self):
"""compute the best estimate for the density of states"""
nreps = self.nrep
nbins = self.nebins
visitsT = (self.visits1d)
#print "min vis", np.min(visitsT)
#print "minlogp", np.min(self.logP)
self.reduced_energy = self.binenergy[np.newaxis,:] / (self.Tlist[:,np.newaxis] * self.k_B)
self.whampot = WhamPotential(visitsT, self.reduced_energy)
if False:
X = np.random.rand( nreps + nbins )
else:
# estimate an initial guess for the offsets and density of states
# so the minimizer converges more rapidly
offsets_estimate, log_dos_estimate = wham_utils.estimate_dos(self.visits1d,
self.reduced_energy)
X = np.concatenate((offsets_estimate, log_dos_estimate))
E0, grad = self.whampot.getEnergyGradient(X)
rms0 = np.linalg.norm(grad) / np.sqrt(grad.size)
try:
from pele.optimize import lbfgs_cpp as quench
if self.verbose:
print "minimizing with pele lbfgs"
ret = quench(X, self.whampot, tol=1e-3, maxstep=1e4, nsteps=10000)
except ImportError:
from wham_utils import lbfgs_scipy
if self.verbose:
print "minimizing with scipy lbfgs"
ret = lbfgs_scipy(X, self.whampot, tol=1e-3, nsteps=10000)
#print "quench energy", ret.energy
if self.verbose:
print "chi^2 went from %g (rms %g) to %g (rms %g) in %d iterations" % (
E0, rms0, ret.energy, ret.rms, ret.nfev)
X = ret.coords
self.logn_E = X[nreps:]
self.w_i_final = X[:nreps]
class Wham1d(object):
"""Combine 1d histograms of energy at multiple temperatures into one density of states
Parameters
----------
Tlist : list of floats
list of temperatures
binenergy : list of floats
the lower edges of the energy bins
visits1d : ndarray
two dimensional array where visits1d[r,e] is the histogram value
for replica r at energy bin e.
k_B : float
the Boltzmann constant
"""
def __init__(self, Tlist, binenergy, visits1d, k_B=1., verbose=True):
if visits1d.shape != (len(Tlist), len(binenergy)):
raise ValueError("visits1d has the wrong shape")
#define some parameters
self.k_B = 1.
self.nrep = len(Tlist)
self.nebins = len(binenergy)
self.Tlist = np.asarray(Tlist)
self.binenergy = np.asarray(binenergy)
self.visits1d = np.asarray(visits1d)
self.verbose = verbose
def minimize(self):
"""compute the best estimate for the density of states"""
nreps = self.nrep
nbins = self.nebins
visitsT = (self.visits1d)
#print "min vis", np.min(visitsT)
#print "minlogp", np.min(self.logP)
self.reduced_energy = self.binenergy[np.newaxis,:] / (self.Tlist[:,np.newaxis] * self.k_B)
self.whampot = WhamPotential(visitsT, self.reduced_energy)
if False:
X = np.random.rand( nreps + nbins )
else:
# estimate an initial guess for the offsets and density of states
# so the minimizer converges more rapidly
offsets_estimate, log_dos_estimate = wham_utils.estimate_dos(self.visits1d,
self.reduced_energy)
X = np.concatenate((offsets_estimate, log_dos_estimate))
E0, grad = self.whampot.getEnergyGradient(X)
rms0 = np.linalg.norm(grad) / np.sqrt(grad.size)
try:
from pele.optimize import lbfgs_cpp as quench
if self.verbose:
print "minimizing with pele lbfgs"
ret = quench(X, self.whampot, tol=1e-3, maxstep=1e4, nsteps=10000)
except ImportError:
from wham_utils import lbfgs_scipy
if self.verbose:
print "minimizing with scipy lbfgs"
ret = lbfgs_scipy(X, self.whampot, tol=1e-3, nsteps=10000)
#print "quench energy", ret.energy
if self.verbose:
print "chi^2 went from %g (rms %g) to %g (rms %g) in %d iterations" % (
E0, rms0, ret.energy, ret.rms, ret.nfev)
X = ret.coords
self.logn_E = X[nreps:]
self.w_i_final = X[:nreps]
def calc_Cv(self, ndof, Tlist=None, ntemp=100):
if Tlist is None:
Tlist = np.linspace(self.Tlist[0], self.Tlist[-1], ntemp)
have_data = np.where(self.visits1d.sum(0) > 0)[0]
return wham_utils.calc_Cv(Tlist, self.binenergy, self.logn_E, ndof,
have_data=have_data, k_B=self.k_B)
class Wham1d(object):
"""Combine 1d histograms of energy at multiple temperatures into one density of states
Parameters
----------
Tlist : list of floats
list of temperatures
binenergy : list of floats
the lower edges of the energy bins
visits1d : ndarray
two dimensional array where visits1d[r,e] is the histogram value
for replica r at energy bin e.
k_B : float
the Boltzmann constant
"""
def __init__(self, Tlist, binenergy, visits1d, k_B=1., verbose=True):
if visits1d.shape != (len(Tlist), len(binenergy)):
raise ValueError("visits1d has the wrong shape")
#define some parameters
self.k_B = 1.
self.nrep = len(Tlist)
self.nebins = len(binenergy)
self.Tlist = np.asarray(Tlist)
self.binenergy = np.asarray(binenergy)
self.visits1d = np.asarray(visits1d)
self.verbose = verbose
def minimize(self):
"""compute the best estimate for the density of states"""
nreps = self.nrep
nbins = self.nebins
visitsT = (self.visits1d)
#print "min vis", np.min(visitsT)
#print "minlogp", np.min(self.logP)
self.reduced_energy = self.binenergy[np.newaxis, :] / (
self.Tlist[:, np.newaxis] * self.k_B)
self.whampot = WhamPotential(visitsT, self.reduced_energy)
if False:
X = np.random.rand(nreps + nbins)
else:
# estimate an initial guess for the offsets and density of states
# so the minimizer converges more rapidly
offsets_estimate, log_dos_estimate = wham_utils.estimate_dos(
self.visits1d, self.reduced_energy)
X = np.concatenate((offsets_estimate, log_dos_estimate))
E0, grad = self.whampot.getEnergyGradient(X)
rms0 = np.linalg.norm(grad) / np.sqrt(grad.size)
try:
from pele.optimize import lbfgs_cpp as quench
if self.verbose:
print "minimizing with pele lbfgs"
ret = quench(X, self.whampot, tol=1e-3, maxstep=1e4, nsteps=10000)
except ImportError:
from wham_utils import lbfgs_scipy
if self.verbose:
print "minimizing with scipy lbfgs"
ret = lbfgs_scipy(X, self.whampot, tol=1e-3, nsteps=10000)
#print "quench energy", ret.energy
if self.verbose:
print "chi^2 went from %g (rms %g) to %g (rms %g) in %d iterations" % (
E0, rms0, ret.energy, ret.rms, ret.nfev)
X = ret.coords
self.logn_E = X[nreps:]
self.w_i_final = X[:nreps]
def calc_Cv(self, ndof, Tlist=None, ntemp=100):
if Tlist is None:
Tlist = np.linspace(self.Tlist[0], self.Tlist[-1], ntemp)
have_data = np.where(self.visits1d.sum(0) > 0)[0]
return wham_utils.calc_Cv(Tlist,
self.binenergy,
self.logn_E,
ndof,
have_data=have_data,
k_B=self.k_B)
