def test_mbar_computeExpectations_position_averages():
"""Can MBAR calculate E(x_n)??"""
for system_generator in system_generators:
name, test = system_generator()
x_n, u_kn, N_k_output, s_n = test.sample(N_k, mode='u_kn')
eq(N_k, N_k_output)
mbar = MBAR(u_kn, N_k)
results = mbar.computeExpectations(x_n, return_dict=True)
mu_t, sigma_t = mbar.computeExpectations(x_n, return_dict=False)
mu = results['mu']
sigma = results['sigma']
eq(mu, mu_t)
eq(sigma, sigma_t)
mu0 = test.analytical_observable(observable='position')
z = (mu0 - mu) / sigma
eq(z / z_scale_factor, np.zeros(len(z)), decimal=0)
def test_mbar_computeExpectations_position_differences():
"""Can MBAR calculate E(x_n)??"""
for system_generator in system_generators:
name, test = system_generator()
x_n, u_kn, N_k_output, s_n = test.sample(N_k, mode='u_kn')
eq(N_k, N_k_output)
mbar = MBAR(u_kn, N_k)
mu_ij, sigma_ij = mbar.computeExpectations(x_n, output='differences')
mu0 = test.analytical_observable(observable='position')
z = convert_to_differences(mu_ij, sigma_ij, mu0)
eq(z / z_scale_factor, np.zeros(np.shape(z)), decimal=0)
def test_mbar_computeExpectations_position_averages():
"""Can MBAR calculate E(x_n)??"""
for system_generator in system_generators:
name, test = system_generator()
x_n, u_kn, N_k_output, s_n = test.sample(N_k, mode='u_kn')
eq(N_k, N_k_output)
mbar = MBAR(u_kn, N_k)
mu, sigma = mbar.computeExpectations(x_n)
mu0 = test.analytical_observable(observable='position')
z = (mu0 - mu) / sigma
eq(z / z_scale_factor, np.zeros(len(z)), decimal=0)
def test_mbar_computeExpectations_position_differences():
"""Can MBAR calculate E(x_n)??"""
for system_generator in system_generators:
name, test = system_generator()
x_n, u_kn, N_k_output, s_n = test.sample(N_k, mode='u_kn')
eq(N_k, N_k_output)
mbar = MBAR(u_kn, N_k)
mu_ij, sigma_ij = mbar.computeExpectations(x_n, output = 'differences')
mu0 = test.analytical_observable(observable = 'position')
z = convert_to_differences(mu_ij, sigma_ij, mu0)
eq(z / z_scale_factor, np.zeros(np.shape(z)), decimal=0)
def test_exponential_mbar_xkn_squared():
"""Harmonic Oscillators Test: can MBAR calculate E(x_kn^2)??"""
test = harmonic_oscillators.HarmonicOscillatorsTestCase(O_k, k_k)
x_kn, u_kln, N_k_output = test.sample(N_k)
eq(N_k, N_k_output)
mbar = MBAR(u_kln, N_k)
mu, sigma = mbar.computeExpectations(x_kn ** 2)
mu0 = test.analytical_x_squared()
z = (mu0 - mu) / sigma
eq(z / z_scale_factor, np.zeros(len(z)), decimal=0)
def test_mbar_computeExpectations_position_averages():
"""Can MBAR calculate E(x_n)??"""
for system_generator in system_generators:
name, test = system_generator()
x_n, u_kn, N_k_output, s_n = test.sample(N_k, mode='u_kn')
eq(N_k, N_k_output)
mbar = MBAR(u_kn, N_k)
mu, sigma = mbar.computeExpectations(x_n)
mu0 = test.analytical_observable(observable = 'position')
z = (mu0 - mu) / sigma
eq(z / z_scale_factor, np.zeros(len(z)), decimal=0)
def test_mbar_computeExpectations_potential():
"""Can MBAR calculate E(u_kn)??"""
for system_generator in system_generators:
name, test = system_generator()
x_n, u_kn, N_k_output, s_n = test.sample(N_k, mode='u_kn')
eq(N_k, N_k_output)
mbar = MBAR(u_kn, N_k)
mu, sigma = mbar.computeExpectations(u_kn, state_dependent=True)
mu0 = test.analytical_observable(observable='potential energy')
print(mu)
print(mu0)
z = (mu0 - mu) / sigma
eq(z / z_scale_factor, np.zeros(len(z)), decimal=0)
def test_exponential_mbar_xkn_squared():
"""Exponential Distribution Test: can MBAR calculate E(x_kn^2)"""
test = exponential_distributions.ExponentialTestCase(rates)
x_kn, u_kln, N_k_output = test.sample(N_k)
eq(N_k, N_k_output)
mbar = MBAR(u_kln, N_k)
mu, sigma = mbar.computeExpectations(x_kn ** 2)
mu0 = test.analytical_x_squared()
z = (mu0 - mu) / sigma
eq(z / z_scale_factor, np.zeros(len(z)), decimal=0)
def test_mbar_computeExpectations_potential():
"""Can MBAR calculate E(u_kn)??"""
for system_generator in system_generators:
name, test = system_generator()
x_n, u_kn, N_k_output, s_n = test.sample(N_k, mode='u_kn')
eq(N_k, N_k_output)
mbar = MBAR(u_kn, N_k)
mu, sigma = mbar.computeExpectations(u_kn, state_dependent = True)
mu0 = test.analytical_observable(observable = 'potential energy')
print(mu)
print(mu0)
z = (mu0 - mu) / sigma
eq(z / z_scale_factor, np.zeros(len(z)), decimal=0)
def test_exponential_mbar_xkn_squared():
"""Exponential Distribution Test: can MBAR calculate E(x_kn^2)"""
test = exponential_distributions.ExponentialTestCase(rates)
x_n, u_kn, origin = test.sample(N_k)
u_ijn, N_k_output = convert_ukn_to_uijn(u_kn)
eq(N_k, N_k_output.values)
mbar = MBAR(u_ijn.values, N_k)
x_kn = convert_xn_to_x_kn(x_n) ** 2.0
x_kn = x_kn.values # Convert to numpy for MBAR
x_kn[np.isnan(x_kn)] = 0.0 # Convert nans to 0.0
mu, sigma = mbar.computeExpectations(x_kn)
mu0 = test.analytical_x_squared()
z = (mu0 - mu) / sigma
eq(z / z_scale_factor, np.zeros(len(z)), decimal=0)
def test_exponential_mbar_xkn():
"""Exponential Distribution Test: can MBAR calculate E(x_kn)?"""
test = exponential_distributions.ExponentialTestCase(rates)
x_n, u_kn, origin = test.sample(N_k)
u_ijn, N_k_output = convert_ukn_to_uijn(u_kn)
eq(N_k, N_k_output.values)
mbar = MBAR(u_ijn.values, N_k)
x_kn = convert_xn_to_x_kn(x_n)
x_kn = x_kn.values # Convert to numpy for MBAR
x_kn[np.isnan(x_kn)] = 0.0 # Convert nans to 0.0
mu, sigma = mbar.computeExpectations(x_kn)
mu0 = test.analytical_means()
z = (mu0 - mu) / sigma
eq(z / z_scale_factor, np.zeros(len(z)), decimal=0)
def test_exponential_mbar_xkn_squared():
"""Harmonic Oscillators Test: can MBAR calculate E(x_kn^2)??"""
test = harmonic_oscillators.HarmonicOscillatorsTestCase(O_k, k_k)
x_n, u_kn, origin = test.sample(N_k)
u_ijn, N_k_output = convert_ukn_to_uijn(u_kn)
eq(N_k, N_k_output.values)
mbar = MBAR(u_ijn.values, N_k)
x_kn = convert_xn_to_x_kn(x_n) ** 2.
x_kn = x_kn.values # Convert to numpy for MBAR
x_kn[np.isnan(x_kn)] = 0.0 # Convert nans to 0.0
mu, sigma = mbar.computeExpectations(x_kn)
mu0 = test.analytical_x_squared()
z = (mu0 - mu) / sigma
eq(z / z_scale_factor, np.zeros(len(z)), decimal=0)
def test_exponential_mbar__xkn():
"""Harmonic Oscillators Test: can MBAR calculate E(x_kn)??"""
test = harmonic_oscillators.HarmonicOscillatorsTestCase(O_k, k_k)
x_n, u_kn, origin = test.sample(N_k)
u_ijn, N_k_output = convert_ukn_to_uijn(u_kn)
eq(N_k, N_k_output.values)
mbar = MBAR(u_ijn.values, N_k)
x_kn = convert_xn_to_x_kn(x_n)
x_kn = x_kn.values # Convert to numpy for MBAR
x_kn[np.isnan(x_kn)] = 0.0 # Convert nans to 0.0
mu, sigma = mbar.computeExpectations(x_kn)
mu0 = test.analytical_means()
z = (mu0 - mu) / sigma
eq(z / z_scale_factor, np.zeros(len(z)), decimal=0)
# observable for estimation is the position
elif observe == 'position':
state_dependent = False
A_kn = numpy.zeros([K,N_max], dtype = numpy.float64)
for k in range(0,K):
A_kn[k,0:N_k[k]] = x_kn[k,0:N_k[k]]
# observable for estimation is the position^2
elif observe == 'position^2':
state_dependent = False
A_kn = numpy.zeros([K,N_max], dtype = numpy.float64)
for k in range(0,K):
A_kn[k,0:N_k[k]] = x_kn[k,0:N_k[k]]**2
(A_k_estimated, dA_k_estimated) = mbar.computeExpectations(A_kn, state_dependent = state_dependent)
# need to additionally transform to get the square root
if observe == 'RMS displacement':
A_k_estimated = numpy.sqrt(A_k_estimated)
# Compute error from analytical observable estimate.
dA_k_estimated = dA_k_estimated/(2*A_k_estimated)
As_k_estimated = numpy.zeros([K],numpy.float64)
dAs_k_estimated = numpy.zeros([K],numpy.float64)
# 'standard' expectation averages - not defined if no samples
nonzeros = numpy.arange(K)[Nk_ne_zero]
totaln = 0
for k in nonzeros:
#MRS: 1001 for state 0, 1.00 for state 2, 985 for state 3
# MRS: The observable we are interested in is U, internal energy. The
# question is, WHICH internal energy. We are interested in the
# internal energy generated from the ith potential. So there are
# actually _three_ observables.
# Now, the confusing thing, we can estimate the expectation of the
# three observables in three different states. We can estimate the
# observable of U_0 in states 0, 1 and 2, the observable of U_1 in
# states 0, 1, and 2, etc.
EAk = np.zeros([3, 3])
dEAk = np.zeros([3, 3])
(EAk[:, 0], dEAk[:, 0]) = mbar.computeExpectations(
U_00
) # potential energy of 0, estimated in state 0:2 (sampled from just 0)
(EAk[:, 1], dEAk[:, 1]) = mbar.computeExpectations(
U_01
) # potential energy of 1, estimated in state 0:2 (sampled from just 0)
(EAk[:, 2], dEAk[:, 2]) = mbar.computeExpectations(
U_02
) # potential energy of 2, estimated in state 0:2 (sampled from just 0)
# MRS: Some of these are of no practical importance. We are most
# interested in the observable of U_0 in the 0th state, U_1 in the 1st
# state, and U_2 in the 2nd state, or the diagonal of the matrix EA.
EA = EAk.diagonal()
dEA = dEAk.diagonal()
#RM: Perhaps I am implementing MBAR improperly. Here I have reevaluated the expectation values
# observable for estimation is the position
elif observe == 'position':
state_dependent = False
A_kn = numpy.zeros([K,N_max], dtype = numpy.float64)
for k in range(0,K):
A_kn[k,0:N_k[k]] = x_kn[k,0:N_k[k]]
# observable for estimation is the position^2
elif observe == 'position^2':
state_dependent = False
A_kn = numpy.zeros([K,N_max], dtype = numpy.float64)
for k in range(0,K):
A_kn[k,0:N_k[k]] = x_kn[k,0:N_k[k]]**2
results = mbar.computeExpectations(A_kn, state_dependent = state_dependent)
A_k_estimated = results['mu']
dA_k_estimated = results['sigma']
# need to additionally transform to get the square root
if observe == 'RMS displacement':
A_k_estimated = numpy.sqrt(A_k_estimated)
# Compute error from analytical observable estimate.
dA_k_estimated = dA_k_estimated/(2*A_k_estimated)
As_k_estimated = numpy.zeros([K],numpy.float64)
dAs_k_estimated = numpy.zeros([K],numpy.float64)
# 'standard' expectation averages - not defined if no samples
nonzeros = numpy.arange(K)[Nk_ne_zero]
print "Loading from %s." % path_dir
path_LogL = os.path.join(path_dir, 'LogLikelihood.dat')
path_w = os.path.join(path_dir, 'w_params.dat')
path_v = os.path.join(path_dir, 'v_params.dat')
energies_LogL[k, :] = np.loadtxt(path_LogL)[-N:]
obs_w[k, :] = np.loadtxt(path_w)[-N:, 0]
obs_v[k, :] = np.loadtxt(path_v)[-N:, 0]
print "Preparing data..."
u_kln, N_k = prepare_mbar_input(energies=energies_LogL,
temps=temps[:ntemps],
N_max=N)
print "Running MBAR..."
mbar = MBAR(u_kln,
N_k,
relative_tolerance=2.0e-2,
verbose=True,
method='self-consistent-iteration')
# compute observable expectations
A_k = np.zeros(N * K, np.float64)
index = 0
for i in range(len(obs_w)):
A_k[index:len(obs_w[i])] = obs_w[i]
index = index + len(obs_w[i])
P, dP = mbar.computeExpectations(obs_w, uncertainty_method='approximate')
print "P:"
print P
print "dP"
print dP
# observable for estimation is the position
elif observe == 'position':
state_dependent = False
A_kn = numpy.zeros([K, N_max], dtype=numpy.float64)
for k in range(0, K):
A_kn[k, 0:N_k[k]] = x_kn[k, 0:N_k[k]]
# observable for estimation is the position^2
elif observe == 'position^2':
state_dependent = False
A_kn = numpy.zeros([K, N_max], dtype=numpy.float64)
for k in range(0, K):
A_kn[k, 0:N_k[k]] = x_kn[k, 0:N_k[k]]**2
results = mbar.computeExpectations(A_kn, state_dependent=state_dependent)
A_k_estimated = results['mu']
dA_k_estimated = results['sigma']
# need to additionally transform to get the square root
if observe == 'RMS displacement':
A_k_estimated = numpy.sqrt(A_k_estimated)
# Compute error from analytical observable estimate.
dA_k_estimated = dA_k_estimated / (2 * A_k_estimated)
As_k_estimated = numpy.zeros([K], numpy.float64)
dAs_k_estimated = numpy.zeros([K], numpy.float64)
# 'standard' expectation averages - not defined if no samples
nonzeros = numpy.arange(K)[Nk_ne_zero]
def _reweight_observables(
self,
weights: ObservableArray,
mbar: pymbar.MBAR,
target_reduced_potentials: ObservableArray,
**observables: ObservableArray,
) -> typing.Union[ObservableArray, Observable]:
"""A function which computes the average value of an observable using
weights computed from MBAR and from a set of component observables.
Parameters
----------
weights
The MBAR weights
observables
The component observables which may be combined to yield the final
average observable of interest.
mbar
A pre-computed MBAR object encoded information from the reference states.
This will be used to compute the std error when not bootstrapping.
target_reduced_potentials
The reduced potentials at the target state. This will be used to compute
the std error when not bootstrapping.
Returns
-------
The re-weighted average observable.
"""
observable = observables.pop("observable")
assert len(observables) == 0
return_type = ObservableArray if observable.value.shape[
1] > 1 else Observable
weighted_observable = weights * observable
average_value = weighted_observable.value.sum(axis=0)
average_gradients = [
ParameterGradient(key=gradient.key,
value=gradient.value.sum(axis=0))
for gradient in weighted_observable.gradients
]
if return_type == Observable:
average_value = average_value.item()
average_gradients = [
ParameterGradient(key=gradient.key,
value=gradient.value.item())
for gradient in average_gradients
]
else:
average_value = average_value.reshape(1, -1)
average_gradients = [
ParameterGradient(key=gradient.key,
value=gradient.value.reshape(1, -1))
for gradient in average_gradients
]
if self.bootstrap_uncertainties is False:
# Unfortunately we need to re-compute the average observable for now
# as pymbar does not expose an easier way to compute the average
# uncertainty.
observable_dimensions = observable.value.shape[1]
assert observable_dimensions == 1
results = mbar.computeExpectations(
observable.value.T.magnitude,
target_reduced_potentials.value.T.magnitude,
state_dependent=True,
)
uncertainty = results[1][-1] * observable.value.units
average_value = average_value.plus_minus(uncertainty)
return return_type(value=average_value, gradients=average_gradients)
msmle.solve_uwham(f1)
f1_bs[trial] = msmle.f
f1_bs[trial] -= msmle.f[0]
xbar1_bs[trial] = msmle.compute_expectations(test.x_jn, False)[0]
ferr1_bs = f1_bs.std(axis=0)[1:]
varxbar1_bs = xbar1_bs.var(axis=0)
msmle.revert_sample()
f1 = f1[1:]
if do_pymbar:
try:
mbar = MBAR(test.data, test.data_size)
f2, ferr2, t = mbar.getFreeEnergyDifferences()
f2 = f2[0][1:]
ferr2 = ferr2[0][1:]
xbar2, varxbar2 = mbar.computeExpectations(test.x_jn)
skipmbar = False
except:
print('MBAR choked!')
skipmbar = True
pass
else:
skipmbar = True
def print_float_array(msg, arr):
print('%-16s '%msg + ' '.join(('% 6.4f'%x for x in arr)))
print('samples:', test.data_size)
print_float_array('actual energies', f3)
print_float_array('uwham energies', f1)
u_kn[1,len(u00):] = u11
u_kn[2,:len(u00)] = u20
u_kn[2,len(u00):] = u21
N_kn = np.zeros(len(u00)+len(u11))
N_kn[:len(u00)] = N0
N_kn[len(u00):] = N1
mbar = MBAR(u_kn,N_k)
Deltaf_ij = mbar.getFreeEnergyDifferences(return_theta=False)
print "effective sample numbers"
print (mbar.computeEffectiveSampleNumber())
print('\nWhich is approximately '+str(mbar.computeEffectiveSampleNumber()/N_K*100.)+'%')
NAk, dNAk = mbar.computeExpectations(N_kn) # Average number of molecules
NAk_alt = np.zeros(len(N_k))
for i in range(len(N_k)):
NAk_alt[i] = np.sum(mbar.W_nk[:,i]*N_kn)
print(NAk)
Nscan = np.arange(60,100)
sqdeltaW0 = np.zeros(len(Nscan))
for iN, Ni in enumerate(Nscan):
sumWliq = np.sum(mbar.W_nk[:,0][N_kn>Ni])
sumWvap = np.sum(mbar.W_nk[:,0][N_kn<=Ni])
sqdeltaW0[iN] = (sumWliq - sumWvap)**2
# Save the uncertainty in the free energy uncertainties_for_each_num_states.extend([uncertainty_free_energies]) # Get the dimensionless free energy differences and uncertainties for the uniform sampling approach free_energies,uncertainty_free_energies = mbar_same_total_samples.getFreeEnergyDifferences()[0],mbar_same_total_samples.getFreeEnergyDifferences()[1] # Save the data free_energies_for_each_num_states_same_total_samples.extend([free_energies]) uncertainties_for_each_num_states_same_total_samples.extend([uncertainty_free_energies]) ############# # # 7) Calculate < R_Na-Cl > with MBAR # ############# # Get < R_Na-Cl >, and uncertainty, with MBAR averages, uncertainty = mbar.computeExpectations(distances)[0],mbar.computeExpectations(distances)[1] # Save < R_Na-Cl >, and uncertainty distance_averages_for_each_num_states.extend([averages]) uncertainty_distances_for_each_num_states.extend([uncertainty]) # Get < R_Na-Cl >, and uncertainty, with uniform sampling averages, uncertainty = mbar_same_total_samples.computeExpectations(distances_same_total_samples)[0],mbar_same_total_samples.computeExpectations(distances_same_total_samples)[1] # Save the data distance_averages_for_each_num_states_same_total_samples.extend([averages]) uncertainty_distances_for_each_num_states_same_total_samples.extend([uncertainty]) ############# # # 8) Analyze uncertainty in < R_Na-Cl > with MBAR as a function of ensemble size # #############
def MBAR_analysis(self, debug=False):
"""MBAR analysis for populations and BICePs score"""
# load necessary data first
self.load_data()
# Suppose the energies sampled from each simulation are u_kln, where u_kln[k,l,n] is the reduced potential energy
# of snapshot n \in 1,...,N_k of simulation k \in 1,...,K evaluated at reduced potential for state l.
self.K = self.nlambda # number of thermodynamic ensembles
# N_k[k] will denote the number of correlated snapshots from state k
N_k = np.array(
[len(self.traj[i]['trajectory']) for i in range(self.nlambda)])
nsnaps = N_k.max()
u_kln = np.zeros((self.K, self.K, nsnaps))
nstates = int(self.states)
print('nstates', nstates)
states_kn = np.zeros((self.K, nsnaps, self.nreplicas))
# special treatment for neglogP function
temp_parameters_indices = self.traj[0]['trajectory'][0][4:][0]
#print temp_parameters_indices
original_index = [
] # keep tracking the original index of the parameters
for ind in range(len(temp_parameters_indices)):
for in_ind in temp_parameters_indices[ind]:
original_index.append(ind)
# Get snapshot energies rescored in the different ensembles
"""['step', 'E', 'accept', 'state', [nuisance parameters]]"""
for n in range(nsnaps):
for k in range(self.K):
for l in range(self.K):
if debug:
print('step',
self.traj[k]['trajectory'][n][0],
end=' ')
if k == l:
u_kln[k, k, n] = self.traj[k]['trajectory'][n][1]
state, sigma_index = self.traj[k]['trajectory'][n][3:]
for r in range(self.nreplicas):
states_kn[k, n, r] = state[r]
temp_parameters = []
new_parameters = [
[] for i in range(len(temp_parameters_indices))
]
temp_parameter_indices = np.concatenate(sigma_index)
for ind in range(len(temp_parameter_indices)):
temp_parameters.append(
self.traj[k]['allowed_parameters'][ind][
temp_parameter_indices[ind]])
for m in range(len(original_index)):
new_parameters[original_index[m]].append(
temp_parameters[m])
u_kln[k, l,
n] = self.sampler[l].neglogP(state, new_parameters,
sigma_index)
if debug:
print('E_%d evaluated in model_%d' % (k, l),
u_kln[k, l, n])
# Initialize MBAR with reduced energies u_kln and number of uncorrelated configurations from each state N_k.
# u_kln[k,l,n] is the reduced potential energy beta*U_l(x_kn), where U_l(x) is the potential energy function for state l,
# beta is the inverse temperature, and and x_kn denotes uncorrelated configuration n from state k.
# N_k[k] is the number of configurations from state k stored in u_knm
# Note that this step may take some time, as the relative dimensionless free energies f_k are determined at this point.
mbar = MBAR(u_kln, N_k)
# Extract dimensionless free energy differences and their statistical uncertainties.
# (Deltaf_ij, dDeltaf_ij) = mbar.getFreeEnergyDifferences()
#(Deltaf_ij, dDeltaf_ij, Theta_ij) = mbar.getFreeEnergyDifferences(uncertainty_method='svd-ew')
(Deltaf_ij, dDeltaf_ij, Theta_ij) = mbar.getFreeEnergyDifferences(
uncertainty_method='approximate')
#print 'Deltaf_ij', Deltaf_ij
#print 'dDeltaf_ij', dDeltaf_ij
beta = 1.0 # keep in units kT
#print 'Unit-bearing (units kT) free energy difference f_1K = f_K - f_1: %f +- %f' % ( (1./beta) * Deltaf_ij[0,K-1], (1./beta) * dDeltaf_ij[0,K-1])
self.f_df = np.zeros(
(self.nlambda, 2)
) # first column is Deltaf_ij[0,:], second column is dDeltaf_ij[0,:]
self.f_df[:, 0] = Deltaf_ij[0, :]
self.f_df[:, 1] = dDeltaf_ij[0, :]
# Compute the expectation of some observable A(x) at each state i, and associated uncertainty matrix.
# Here, A_kn[k,n] = A(x_{kn})
#(A_k, dA_k) = mbar.computeExpectations(A_kn)
self.P_dP = np.zeros(
(nstates, 2 * self.K)) # left columns are P, right columns are dP
if debug:
print('state\tP\tdP')
states_kn = np.array(states_kn)
for i in range(nstates):
sampled = np.array([
np.where(states_kn[:, :, r] == i, 1, 0)
for r in range(self.nreplicas)
])
A_kn = sampled.sum(axis=0)
(p_i,
dp_i) = mbar.computeExpectations(A_kn,
uncertainty_method='approximate')
self.P_dP[i, 0:self.K] = p_i
self.P_dP[i, self.K:2 * self.K] = dp_i
pops, dpops = self.P_dP[:, 0:self.K], self.P_dP[:, self.K:2 * self.K]
# save results
self.save_MBAR()
# observable for estimation is the position
elif observe == 'position':
state_dependent = False
A_kn = numpy.zeros([K,N_max], dtype = numpy.float64)
for k in range(0,K):
A_kn[k,0:N_k[k]] = x_kn[k,0:N_k[k]]
# observable for estimation is the position^2
elif observe == 'position^2':
state_dependent = False
A_kn = numpy.zeros([K,N_max], dtype = numpy.float64)
for k in range(0,K):
A_kn[k,0:N_k[k]] = x_kn[k,0:N_k[k]]**2
results = mbar.computeExpectations(A_kn, state_dependent = state_dependent, return_dict=True)
A_k_estimated = results['mu']
dA_k_estimated = results['sigma']
# need to additionally transform to get the square root
if observe == 'RMS displacement':
A_k_estimated = numpy.sqrt(A_k_estimated)
# Compute error from analytical observable estimate.
dA_k_estimated = dA_k_estimated/(2*A_k_estimated)
As_k_estimated = numpy.zeros([K],numpy.float64)
dAs_k_estimated = numpy.zeros([K],numpy.float64)
# 'standard' expectation averages - not defined if no samples
nonzeros = numpy.arange(K)[Nk_ne_zero]
# thermodynamic state
elif observe == 'potential energy':
A_kn = U_kln
# observable for estimation is the position
elif observe == 'position':
A_kn = numpy.zeros([K,N_max], dtype = numpy.float64)
for k in range(0,K):
A_kn[k,0:N_k[k]] = x_kn[k,0:N_k[k]]
elif observe == 'position^2':
A_kn = numpy.zeros([K,N_max], dtype = numpy.float64)
for k in range(0,K):
A_kn[k,0:N_k[k]] = x_kn[k,0:N_k[k]]**2
results = mbar.computeExpectations(A_kn)
A_k_estimated = results['mu']
dA_k_estimated = results['sigma']
As_k_estimated = numpy.zeros([K],numpy.float64)
dAs_k_estimated = numpy.zeros([K],numpy.float64)
# 'standard' expectation averages
ifzero = numpy.array(N_k != 0)
for k in range(K):
if (ifzero[k]):
if (observe == 'position') or (observe == 'position^2'):
As_k_estimated[k] = numpy.average(A_kn[k,0:N_k[k]])
dAs_k_estimated[k] = numpy.sqrt(numpy.var(A_kn[k,0:N_k[k]])/(N_k[k]-1))
elif (observe == 'RMS displacement' ) or (observe == 'potential energy'):
As_k_estimated[k] = numpy.average(A_kn[k,k,0:N_k[k]])
f_df[:,0] = Deltaf_ij[0,:]
f_df[:,1] = dDeltaf_ij[0,:]
print 'Writing %s...'%args.bayesfactorfile
savetxt(args.bayesfactorfile, f_df)
print '...Done.'
# Compute the expectation of some observable A(x) at each state i, and associated uncertainty matrix.
# Here, A_kn[k,n] = A(x_{kn})
#(A_k, dA_k) = mbar.computeExpectations(A_kn)
P_dP = np.zeros( (nstates, 2*K) ) # left columns are P, right columns are dP
if (1):
print 'state\tP\tdP'
for i in range(nstates):
A_kn = np.where(states_kn==i,1,0)
(p_i, dp_i) = mbar.computeExpectations(A_kn, uncertainty_method='approximate')
P_dP[i,0:K] = p_i
P_dP[i,K:2*K] = dp_i
print i,
for p in p_i: print p,
for dp in dp_i: print dp,
print
pops, dpops = P_dP[:,0:K], P_dP[:,K:2*K]
print 'Writing %s...'%args.popsfile
savetxt(args.popsfile, P_dP)
print '...Done.'
# Using just the Model 0 mdrun samples N_k = np.array([len(u_00), 0]) # The number of samples from the two states u_kn = np.array([u_00, u_01]) U_kn = U_00 V_kn = V_00 mbar = MBAR(u_kn, N_k) (Deltaf_ij, dDeltaf_ij, Theta_ij) = mbar.getFreeEnergyDifferences(return_theta=True) # The first observable we are interested in is U, internal energy A_kn = U_kn (EA_k, dEA_k) = mbar.computeExpectations(A_kn) # The second observable we are interested in is V, volume A2_kn = V_kn (EA2_k, dEA2_k) = mbar.computeExpectations(A2_kn) # The third observable we are interested in is density A3_kn = rho_calc(V_kn) A3_kn = A3_kn[:] (EA3_k, dEA3_k) = mbar.computeExpectations(A3_kn) # The averages for the different mdruns and reruns U_00_ave = np.mean(U_00)
def MBAR_analysis(self, debug = False):
"""MBAR analysis for populations and BICePs score"""
# load necessary data first
self.load_data()
# Suppose the energies sampled from each simulation are u_kln, where u_kln[k,l,n] is the reduced potential energy
# of snapshot n \in 1,...,N_k of simulation k \in 1,...,K evaluated at reduced potential for state l.
self.K = self.nlambda # number of thermodynamic ensembles
# N_k[k] will denote the number of correlated snapshots from state k
N_k = np.array( [len(self.traj[i]['trajectory']) for i in range(self.nlambda)] )
nsnaps = N_k.max()
u_kln = np.zeros( (self.K, self.K, nsnaps) )
nstates = int(self.states)
print 'nstates', nstates
states_kn = np.zeros( (self.K, nsnaps) )
# Get snapshot energies rescored in the different ensembles
"""['step', 'E', 'accept', 'state', 'sigma_noe', 'sigma_J', 'sigma_cs', 'sigma_pf''gamma']
[int(step), float(self.E), int(accept), int(self.state), int(self.sigma_noe_index), int(self.sigma_J_index), int(self.sigma_cs_H_index), int(self.sigma_cs_Ha_index), int(self.sigma_cs_N_index), int(self.sigma_cs_Ca_index), int(self.sigma_pf_index), int(self.gamma_index)] """
for n in range(nsnaps):
for k in range(self.K):
for l in range(self.K):
if debug:
print 'step', self.traj[k]['trajectory'][n][0],
if k==l:
print 'E%d evaluated in model %d'%(k,k), self.traj[k]['trajectory'][n][1],
u_kln[k,k,n] = self.traj[k]['trajectory'][n][1]
state, sigma_noe_index, sigma_J_index, sigma_cs_H_index, sigma_cs_Ha_index, sigma_cs_N_index, sigma_cs_Ca_index, sigma_pf_index, gamma_index = self.traj[k]['trajectory'][n][3:] # IMPORTANT: make sure the order of these parameters is the same as the way they are saved in PosteriorSampler
print 'state, sigma_noe_index, sigma_J_index, sigma_cs_H_index, sigma_cs_Ha_index, sigma_cs_N_index, sigma_cs_Ca_index, sigma_pf_index, gamma_index', state, sigma_noe_index, sigma_J_index, sigma_cs_H_index, sigma_cs_Ha_index, sigma_cs_N_index, sigma_cs_Ca_index, sigma_pf_index, gamma_index
states_kn[k,n] = state
sigma_noe = self.traj[k]['allowed_sigma_noe'][sigma_noe_index]
sigma_J = self.traj[k]['allowed_sigma_J'][sigma_J_index]
sigma_cs_H = self.traj[k]['allowed_sigma_cs_H'][sigma_cs_H_index]
sigma_cs_Ha = self.traj[k]['allowed_sigma_cs_Ha'][sigma_cs_Ha_index]
sigma_cs_N = self.traj[k]['allowed_sigma_cs_N'][sigma_cs_N_index]
sigma_cs_Ca = self.traj[k]['allowed_sigma_cs_Ca'][sigma_cs_Ca_index]
sigma_pf = self.traj[k]['allowed_sigma_pf'][sigma_pf_index]
u_kln[k,l,n] = self.sampler[l].neglogP(0, state, sigma_noe, sigma_J, sigma_cs_H, sigma_cs_Ha, sigma_cs_N, sigma_cs_Ca, sigma_pf, gamma_index)
if debug:
print 'E_%d evaluated in model_%d'%(k,l), u_kln[k,l,n]
# Initialize MBAR with reduced energies u_kln and number of uncorrelated configurations from each state N_k.
# u_kln[k,l,n] is the reduced potential energy beta*U_l(x_kn), where U_l(x) is the potential energy function for state l,
# beta is the inverse temperature, and and x_kn denotes uncorrelated configuration n from state k.
# N_k[k] is the number of configurations from state k stored in u_knm
# Note that this step may take some time, as the relative dimensionless free energies f_k are determined at this point.
mbar = MBAR(u_kln, N_k)
# Extract dimensionless free energy differences and their statistical uncertainties.
# (Deltaf_ij, dDeltaf_ij) = mbar.getFreeEnergyDifferences()
#(Deltaf_ij, dDeltaf_ij, Theta_ij) = mbar.getFreeEnergyDifferences(uncertainty_method='svd-ew')
(Deltaf_ij, dDeltaf_ij, Theta_ij) = mbar.getFreeEnergyDifferences(uncertainty_method='approximate')
#print 'Deltaf_ij', Deltaf_ij
#print 'dDeltaf_ij', dDeltaf_ij
beta = 1.0 # keep in units kT
#print 'Unit-bearing (units kT) free energy difference f_1K = f_K - f_1: %f +- %f' % ( (1./beta) * Deltaf_ij[0,K-1], (1./beta) * dDeltaf_ij[0,K-1])
self.f_df = np.zeros( (self.nlambda, 2) ) # first column is Deltaf_ij[0,:], second column is dDeltaf_ij[0,:]
self.f_df[:,0] = Deltaf_ij[0,:]
self.f_df[:,1] = dDeltaf_ij[0,:]
# Compute the expectation of some observable A(x) at each state i, and associated uncertainty matrix.
# Here, A_kn[k,n] = A(x_{kn})
#(A_k, dA_k) = mbar.computeExpectations(A_kn)
self.P_dP = np.zeros( (nstates, 2*self.K) ) # left columns are P, right columns are dP
if debug:
print 'state\tP\tdP'
for i in range(nstates):
A_kn = np.where(states_kn==i,1,0)
(p_i, dp_i) = mbar.computeExpectations(A_kn, uncertainty_method='approximate')
self.P_dP[i,0:self.K] = p_i
self.P_dP[i,self.K:2*self.K] = dp_i
print i
for p in p_i: print p,
for dp in dp_i: print dp,
print
pops, dpops = self.P_dP[:,0:self.K], self.P_dP[:,self.K:2*self.K]
# save results
self.save_MBAR()
def execute(nstates, q_samp_space, epsi_samp_space, sig_samp_space, singlestate=None, singleparms=None, useO=False, crunchset=False, bootstrap=False, bootstrapcount=200):
#Initilize limts
sig3_samp_space = sig_samp_space**3
#These are the limits used to compute the constant matricies
#They should match with LJ 0 and 5, ALWAYS
q_min = -2.0
q_max = +2.0
epsi_min = epsi_samp_space[0]
epsi_max = epsi_samp_space[5]
sig_min = sig_samp_space[0]
sig_max = sig_samp_space[5]
lamto_epsi = lambda lam: (epsi_max - epsi_min)*lam + epsi_min
lamto_sig3 = lambda lam: (sig_max**3 - sig_min**3)*lam + sig
lamto_sig = lambda lam: lamto_sig3(lam)**(1.0/3)
if spacing is logspace:
StartSpace = -5
EndSpace = 0
spacename='log'
PlotStart = 10**StartSpace
PlotEnd = 10**EndSpace
elif spacing is linspace:
sigStartSpace = sig_min
sigEndSpace = sig_max
epsiStartSpace = epsi_min
qStartSpace = q_min
qEndSpace = q_max
if alle:
epsiEndSpace = 3.6 #!!! Manual set
else:
epsiEndSpace = epsi_max
spacename='linear'
sigPlotStart = sigStartSpace**sig_factor
sigPlotEnd = sigEndSpace**sig_factor
epsiPlotStart = epsiStartSpace
epsiPlotEnd = epsiEndSpace
qPlotStart = qStartSpace
qPlotEnd = qEndSpace
#generate sample length
g_en_start = 19 #Row where data starts in g_energy output
g_en_energy = 1 #Column where the energy is located
niterations_max = 30001
#Min and max sigmas:
fC12 = lambda epsi,sig: 4*epsi*sig**12
fC6 = lambda epsi,sig: 4*epsi*sig**6
fsig = lambda C12, C6: (C12/C6)**(1.0/6)
fepsi = lambda C12, C6: C6**2/(4*C12)
C12_delta = fC12(epsi_max, sig_max) - fC12(epsi_min, sig_min)
C6_delta = fC6(epsi_max, sig_max) - fC6(epsi_min, sig_min)
C12_delta_sqrt = fC12(epsi_max, sig_max)**.5 - fC12(epsi_min, sig_min)**.5
C6_delta_sqrt = fC6(epsi_max, sig_max)**.5 - fC6(epsi_min, sig_min)**.5
#Set up lambda calculation equations
flamC6 = lambda epsi, sig: (fC6(epsi, sig) - fC6(epsi_min, sig_min))/C6_delta
flamC12 = lambda epsi, sig: (fC12(epsi, sig) - fC12(epsi_min, sig_min))/C12_delta
flamC6sqrt = lambda epsi, sig: (fC6(epsi, sig)**.5 - fC6(epsi_min, sig_min)**.5)/C6_delta_sqrt
flamC12sqrt = lambda epsi, sig: (fC12(epsi, sig)**.5 - fC12(epsi_min, sig_min)**.5)/C12_delta_sqrt
flamC1 = lambda q: q
lamC12 = flamC12sqrt(epsi_samp_space, sig_samp_space)
lamC6 = flamC6sqrt(epsi_samp_space, sig_samp_space)
lamC1 = flamC1(q_samp_space)
#Try to load u_kln
lam_range = linspace(0,1,nstates)
subsampled = numpy.zeros([nstates],dtype=numpy.bool)
if load_ukln and os.path.isfile('esq_ukln_consts_n%i.npz'%nstates):
energies = consts(nstates, file='esq_ukln_consts_n%i.npz'%nstates)
else:
#Initial u_kln
energies = consts(nstates)
g_t = numpy.zeros([nstates])
#Read in the data
for k in xrange(nstates):
print "Importing LJ = %02i" % k
energy_dic = {'full':{}, 'rep':{}}
#Try to load the subsampled filenames
try:
energy_dic['null'] = open('lj%s/prod/subenergy%s_null.xvg' %(k,k),'r').readlines()[g_en_start:] #Read in the null energies (unaffected) of the K states
for l in xrange(nstates):
energy_dic['full']['%s'%l] = open('lj%s/prod/subenergy%s_%s.xvg' %(k,k,l),'r').readlines()[g_en_start:] #Read in the full energies for each state at KxL
if l == 5 or l == 0:
energy_dic['rep']['%s'%l] = open('lj%s/prod/subenergy%s_%s_rep.xvg' %(k,k,l),'r').readlines()[g_en_start:] #Read in the repulsive energies at 0, nstates-1, and K
energy_dic['q'] = open('lj%s/prod/subenergy%s_q.xvg' %(k,k),'r').readlines()[g_en_start:] #Read in the charge potential energy
energy_dic['q2'] = open('lj%s/prod/subenergy%s_q2.xvg' %(k,k),'r').readlines()[g_en_start:] #Read in the charge potential energy
iter = len(energy_dic['null'])
subsampled[k] = True
# Set the object to iterate over, since we want every frame of the subsampled proces, we just use every frame
frames = xrange(iter)
except: #Load the normal way
energy_dic['null'] = open('lj%s/prod/energy%s_null.xvg' %(k,k),'r').readlines()[g_en_start:] #Read in the null energies (unaffected) of the K states
for l in xrange(nstates):
energy_dic['full']['%s'%l] = open('lj%s/prod/energy%s_%s.xvg' %(k,k,l),'r').readlines()[g_en_start:] #Read in the full energies for each state at KxL
if l == 5 or l == 0:
energy_dic['rep']['%s'%l] = open('lj%s/prod/energy%s_%s_rep.xvg' %(k,k,l),'r').readlines()[g_en_start:] #Read in the repulsive energies at 0, nstates-1, and K
energy_dic['q'] = open('lj%s/prod/energy%s_q.xvg' %(k,k),'r').readlines()[g_en_start:] #Read in the charge potential energy
energy_dic['q2'] = open('lj%s/prod/energy%s_q2.xvg' %(k,k),'r').readlines()[g_en_start:] #Read in the charge potential energy
iter = niterations_max
#Subsample
tempenergy = numpy.zeros(iter)
for frame in xrange(iter):
tempenergy[frame] = float(energy_dic['full']['%s'%k][frame].split()[g_en_energy])
frames, temp_series, g_t[k] = subsample_series(tempenergy, return_g_t=True)
print "State %i has g_t of %i" % (k, g_t[k])
iter = len(frames)
#Update iterations if need be
energies.updateiter(iter)
#Fill in matricies
n = 0
for frame in frames:
#Unaffected state
energies.const_Un_matrix[k,n] = float(energy_dic['null'][frame].split()[g_en_energy])
#Charge only state
VI = float(energy_dic['q'][frame].split()[g_en_energy]) - energies.const_Un_matrix[k,n]
VII = float(energy_dic['q2'][frame].split()[g_en_energy]) - energies.const_Un_matrix[k,n]
q1 = 1
q2 = 0.5
QB = (q1**2*VII - q2**2*VI)/(q1**2*q2 - q2**2*q1)
QA = (VI - q1*QB)/q1**2
energies.const_q_matrix[k,n] = QB
energies.const_q2_matrix[k,n] = QA
#const_q_matrix[k,n] = float(energy_dic['q'][n].split()[g_en_energy]) - const_Un_matrix[k,n]
#Isolate the data
for l in xrange(nstates):
energies.u_kln[k,l,n] = float(energy_dic['full']['%s'%l][frame].split()[g_en_energy]) #extract the kln energy, get the line, split the line, get the energy, convert to float, store
#Repulsive terms:
#R0 = U_rep[k,k,n] + dhdl[k,0,n] - Un[k,n]
energies.const_R0_matrix[k,n] = float(energy_dic['rep']['%s'%(0)][frame].split()[g_en_energy]) - energies.const_Un_matrix[k,n]
#R1 = U_rep[k,k,n] + dhdl[k,-1,n] - Un[k,n]
energies.const_R1_matrix[k,n] = float(energy_dic['rep']['%s'%(5)][frame].split()[g_en_energy]) - energies.const_Un_matrix[k,n]
energies.const_R_matrix[k,n] = energies.const_R1_matrix[k,n] - energies.const_R0_matrix[k,n]
#Finish the total unaffected term
#Total unaffected = const_Un + U0 = const_Un + (U_full[k,0,n] - const_Un) = U_full[k,0,n]
energies.const_unaffected_matrix[k,n] = energies.u_kln[k,0,n]
#Fill in the q matrix
#Attractive term
#u_A = U_full[k,n] - constR[k,n] - const_unaffected[k,n]
energies.const_A0_matrix[k,n] = energies.u_kln[k,0,n] - energies.const_R0_matrix[k,n] - energies.const_Un_matrix[k,n]
energies.const_A1_matrix[k,n] = energies.u_kln[k,5,n] - energies.const_R1_matrix[k,n] - energies.const_Un_matrix[k,n]
energies.const_A_matrix[k,n] = energies.const_A1_matrix[k,n] - energies.const_A0_matrix[k,n]
n += 1
energies.determine_all_N_k()
#write_g_t(g_t)
constname = 'esq_ukln_consts_n%i.npz'%nstates
if load_ukln and not os.path.isfile(constname):
energies.save_consts(constname)
#Sanity check
sanity_kln = numpy.zeros(energies.u_kln.shape)
#Round q to the the GROMACS precision, otherwise there is drift in q which can cause false positives
lamC1r = numpy.around(lamC1, decimals=4)
for l in xrange(nstates):
#sanity_kln[:,l,:] = lamC12[l]*energies.const_R_matrix + lamC6[l]*energies.const_A_matrix + lamC1[l]*energies.const_q_matrix + lamC1[l]**2*energies.const_q2_matrix + energies.const_unaffected_matrix
sanity_kln[:,l,:] = lamC12[l]*energies.const_R_matrix + lamC6[l]*energies.const_A_matrix + lamC1r[l]*energies.const_q_matrix + lamC1r[l]**2*energies.const_q2_matrix + energies.const_unaffected_matrix
del_kln = numpy.abs(energies.u_kln - sanity_kln)
del_tol = 1 #in kJ per mol
print "Max Delta: %f" % numpy.nanmax(del_kln)
if numpy.nanmax(del_kln) > 1: #Check for numeric error
#Double check to see if the weight is non-zero.
#Most common occurance is when small particle is tested in large particle properties
#Results in energies > 60,000 kj/mol, which carry 0 weight to machine precision
nonzero_weights = numpy.count_nonzero(numpy.exp(-energies.u_kln[numpy.where(del_kln > .2)] * kjpermolTokT))
if nonzero_weights != 0:
print "and there are %d nonzero weights! Stopping execution" % nonzero_weights
pdb.set_trace()
else:
print "but these carry no weight and so numeric error does not change the answer"
##################################################
############### END DATA INPUT ###################
##################################################
#Convert to dimless
energies.dimless()
#Set up regular grid
sig_range = (spacing(sigStartSpace**3,sigEndSpace**3,Nparm))**(1.0/3)
epsi_range = spacing(epsiStartSpace,epsiEndSpace,Nparm)
q_range = spacing(qStartSpace,qEndSpace,Nparm)
epsi_plot_range = spacing(epsiStartSpace,epsi_max,Nparm)
#Load subsequent f_ki
f_ki_loaded = False
state_counter = nstates
while not f_ki_loaded and state_counter != 0:
#Load the largest f_ki you can
try:
f_ki_load = numpy.load('esq_f_k_{myint:{width}}.npy'.format(myint=state_counter, width=len(str(state_counter))))
f_ki_loaded = True
f_ki_n = state_counter
except:
pass
state_counter -= 1
try:
if nstates >= f_ki_n:
draw_ki = f_ki_n
else:
draw_ki = nstates
#Copy the loaded data
f_ki = numpy.zeros(nstates)
f_ki[:draw_ki] = f_ki_load[:draw_ki]
mbar = MBAR(energies.u_kln, energies.N_k, verbose = True, initial_f_k=f_ki, subsampling_protocol=[{'method':'L-BFGS-B','options':{'disp':True}}], subsampling=1)
except:
mbar = MBAR(energies.u_kln, energies.N_k, verbose = True, subsampling_protocol=[{'method':'L-BFGS-B','options':{'disp':True}}], subsampling=1)
if not f_ki_loaded or f_ki_n != nstates:
try:
numpy.save_compressed('esq_f_k_{myint:{width}}.npy'.format(myint=nstates, width=len(str(nstates))), mbar.f_k)
except:
numpy.save('esq_f_k_{myint:{width}}.npy'.format(myint=nstates, width=len(str(nstates))), mbar.f_k)
######## Begin Computing RDF's #########
basebins = genrdf.defbin
plotx = linspace(genrdf.distmin, genrdf.distmax, basebins)/10.0 #put in nm
#Generate blank
rdfs = numpy.zeros([basebins, nstates, energies.itermax], dtype=numpy.float64)
if useO:
pathstr = 'lj%s/prod/rdfOhist%s.npz'
else:
pathstr = 'lj%s/prod/rdfhist%s.npz'
for k in xrange(nstates):
try: #Try to load in
if useO:
rdfk = numpy.load(pathstr%(k,k))['rdf']
else:
rdfk = numpy.load(pathstr%(k,k))['rdf']
except:
rdfk = genrdf.buildrdf(k, useO=useO)
nkbin, nkiter = rdfk.shape
rdfs[:,k,:nkiter] = rdfk
if singleparms is not None:
Npert = 1
pertq = numpy.array([singleparms[0]])
pertepsi = numpy.array([singleparms[1]])
pertsig = numpy.array([singleparms[2]])
pertrdfs = None
if useO:
filestring = 'pertrdfs/pertrdfOn%s' % nstates
else:
filestring = 'pertrdfs/pertrdfn%s' % nstates
filestring += 'q%fe%fs%f.npz'
fileobjs = [singleparms[0],singleparms[1],singleparms[2]] #Even though 0 and 1 get +l, the l =0 in this instance so its fine
elif singlestate is not None:
Npert = 1
pertq = numpy.array([q_samp_space[singlestate]])
pertepsi = numpy.array([epsi_samp_space[singlestate]])
pertsig = numpy.array( [sig_samp_space[singlestate]])
try:
pertrdf = numpy.load(pathstr%(singlestate,singlestate))['rdf']
except:
pertrdf = genrdf.buildrdf(singlestate, useO=useO)
pertbin, pertnk = pertrdf.shape
quickrdf = numpy.zeros([pertbin,1,pertnk]) #Initilze the matrix I will pass into the graphing routine
quickrdf[:,0,:] = pertrdf
pertrdf = quickrdf
del quickrdf #Cleanup a bit
if useO:
filestring = 'lj%s/rdfO%sfromn%s.npz'
else:
filestring = 'lj%s/rdf%sfromn%s.npz'
fileobjs = [singlestate,singlestate,nstates]
elif crunchset is True:
#Joung/Cheatham params:
pertname = ['Li+', 'Na+', 'K+', 'Rb+', 'Cs+', 'F-', 'Cl-', 'Br-', 'I-']
pertq = numpy.array([1, 1, 1, 1, 1, -1, -1, -1, -1])
pertepsi = numpy.array([0.11709719, 0.365846031, 0.810369254, 1.37160683, 1.70096085, 0.014074976, 0.148912744, 0.245414194, 0.224603814])
pertsig = numpy.array([0.196549675, 0.24794308, 0.30389715, 0.323090391, 0.353170773, 0.417552588, 0.461739606, 0.482458908, 0.539622469])
#pertname = ['Br-']
#pertq = numpy.array([-1])
#pertepsi = numpy.array([0.245414194])
#pertsig = numpy.array([0.482458908])
Npert = len(pertq)
if useO:
filestring = 'pertrdfs/pertrdfOn%s%s.npz'
else:
filestring = 'pertrdfs/pertrdfn%s%s.npz'
else:
#For now, just use the back 5 of the qes set
Npert = 5
pertq = q_samp_space[-Npert:]
pertepsi = epsi_samp_space[-Npert:]
pertsig = sig_samp_space[-Npert:]
pertNk = energies.N_k[-Npert:]
pertrdfs = rdfs[:,-Npert:,:]
if useO:
filestring = 'lj%s/rdfO%sfromn%s.npz'
else:
filestring = 'lj%s/rdf%sfromn%s.npz'
fileobjs = [nstates-Npert,nstates-Npert,nstates]
#pertq = numpy.array([q_samp_space[1]])+0.25
#pertepsi = numpy.array([epsi_samp_space[1]])
#pertepsi *= 2
#pertsig = numpy.array([sig_samp_space[1]])
#pertsig *= 1.5
#pertNk = numpy.array([energies.N_k[1]])
#pertrdfs = rdfs[:,1,:]
#Begin computing expectations
Erdfs = numpy.zeros([Npert, basebins])
dErdfs = numpy.zeros([Npert, basebins])
eff_u_kln = numpy.zeros([energies.nstates, energies.nstates + Npert, energies.itermax])
eff_u_kln[:energies.nstates, :energies.nstates, :] = energies.u_kln
for l in xrange(Npert):
#if not savedata or not os.path.isfile('lj%s/rdf%sfromn%s.npz'%(nstates-Npert+l, nstates-Npert+l, nstates)):
if crunchset:
filecheck = filestring % (nstates, pertname[l])
else:
filecheck = filestring % (fileobjs[0]+l, fileobjs[1]+l, fileobjs[2])
if not savedata or not os.path.isfile(filecheck) or effnum:
print "Working on state %d/%d" %(l+1, Npert)
q = pertq[l]
epsi = pertepsi[l]
sig = pertsig[l]
#u_kn_P = numpy.zeros([nstates,energies.itermax])
u_kn_P = flamC12sqrt(epsi,sig)*energies.const_R_matrix + flamC6sqrt(epsi,sig)*energies.const_A_matrix + flamC1(q)*energies.const_q_matrix + flamC1(q)**2*energies.const_q2_matrix + energies.const_unaffected_matrix
if effnum:
eff_u_kln[:,energies.nstates+l,:] = u_kn_P
else:
for bin in xrange(basebins):
stdout.flush()
stdout.write('\rWorking on bin %d/%d'%(bin,basebins-1))
#Erdfs[l, bin], dErdfs[l, bin] = mbar.computePerturbedExpectation(u_kn_P, rdfs[bin,:,:])
Erdfs[l, bin], dErdfs[l, bin] = mbar.computeExpectations(rdfs[bin,:,:], u_kn=u_kn_P, compute_uncertainty=False)
stdout.write('\n')
if savedata:
#savez('lj%s/rdf%sfromn%s.npz'%(nstates-Npert+l, nstates-Npert+l, nstates), Erdfs=Erdfs[l,:], dErdfs=dErdfs[l,:])
if crunchset:
savez(filestring % (nstates, pertname[l]), Erdfs=Erdfs[l,:], dErdfs=dErdfs[l,:])
else:
savez(filestring % (fileobjs[0]+l, fileobjs[1]+l, fileobjs[2]), Erdfs=Erdfs[l,:], dErdfs=dErdfs[l,:])
else:
#rdfdata = numpy.load('lj%s/rdf%sfromn%s.npz'%(nstates-Npert+l, nstates-Npert+l, nstates))
if crunchset:
rdfdata = numpy.load(filestring % (nstates, pertname[l]))
else:
rdfdata = numpy.load(filestring % (fileobjs[0]+l, fileobjs[1]+l, fileobjs[2]))
Erdfs[l,:] = rdfdata['Erdfs']
dErdfs[l,:] = rdfdata['dErdfs']
#Effective number of samples
if effnum:
N_k = numpy.zeros(energies.nstates+Npert, dtype=numpy.int32)
f_k = numpy.zeros(energies.nstates+Npert)
N_k[:energies.nstates] = energies.N_k
f_k[:mbar.K] = mbar.f_k
eff_mbar = MBAR(eff_u_kln, N_k, verbose = True, initial_f_k=f_k, subsampling_protocol=[{'method':'L-BFGS-B','options':{'disp':True}}], subsampling=1)
for l in xrange(Npert):
w = numpy.exp(eff_mbar.Log_W_nk[:,mbar.K+l])
neff = 1.0/numpy.sum(w**2)
print "Effective number of samples for {0:s}: {1:f}".format(pertname[l], neff)
pdb.set_trace()
if bootstrap: #I spun this off into its own section, although it probably could have been folded into the previous
from numpy.random import random_integers
Nboot = bootstrapcount
ErdfsB = numpy.zeros([Nboot, Npert, basebins])
run_start_time = time.time()
number_of_iterations = Npert*Nboot
iteration = 0
for l in xrange(Npert): #Go through each bootstrap
print "Bootstraping on state %d/%d" %(l+1, Npert)
q = pertq[l]
epsi = pertepsi[l]
sig = pertsig[l]
#u_kn_P = numpy.zeros([nstates,energies.itermax])
u_kn_P = flamC12sqrt(epsi,sig)*energies.const_R_matrix + flamC6sqrt(epsi,sig)*energies.const_A_matrix + flamC1(q)*energies.const_q_matrix + flamC1(q)**2*energies.const_q2_matrix + energies.const_unaffected_matrix
for Nb in xrange(Nboot): #Bootstrap
initial_time=time.time()
iteration += 1
u_kn_B = numpy.zeros(u_kn_P.shape)
rdfsB = numpy.zeros(rdfs.shape)
for k in xrange(nstates): #Roll random numbers
N_k = energies.N_k[k]
samplepool = random_integers(0,N_k-1,N_k)
for i in xrange(len(samplepool)):
u_kn_B[k,i] = u_kn_P[k,samplepool[i]] #Have to do this since slicing the first index alone reverses the return order for the last 2 indicies
rdfsB[:,k,i] = rdfs[:,k,samplepool[i]]
#for bin in xrange(basebins):
for bin in xrange(60): #Cut down for time
stdout.flush()
#stdout.write('\rWorking on bootstrap %d/%d and bin %d/%d'%(Nb,Nboot-1,bin,basebins-1))
stdout.write('\rWorking on bootstrap %d/%d and bin %d/%d'%(Nb,Nboot-1,bin,60-1))
ErdfsB[Nb, l, bin] = mbar.computePerturbedExpectation(u_kn_B, rdfsB[bin,:,:], compute_uncertainty=False)[0] #Dont compute error for speed
laptime = time.clock()
# Show timing statistics. copied from Repex.py, copywrite John Chodera
final_time = time.time()
elapsed_time = final_time - initial_time
estimated_time_remaining = (final_time - run_start_time) / (iteration) * (number_of_iterations - iteration)
estimated_total_time = (final_time - run_start_time) / (iteration) * (number_of_iterations)
estimated_finish_time = final_time + estimated_time_remaining
print "Iteration took %.3f s." % elapsed_time
print "Estimated completion in %s, at %s (consuming total wall clock time %s)." % (str(datetime.timedelta(seconds=estimated_time_remaining)), time.ctime(estimated_finish_time), str(datetime.timedelta(seconds=estimated_total_time)))
savez('BootstrapedIonRDF.npz', Erdfs = ErdfsB)
if singleparms is None and not crunchset:
f,a = plt.subplots(Npert, 2)
for l in xrange(Npert):
Nl = pertNk[l]
rdftraj = pertrdfs[:,l,:Nl]
if Npert == 1:
a[0].plot(plotx, Erdfs[l,:], '-k')
#a[0].plot(plotx, Erdfs[l,:] + dErdfs[l,:], '--k')
#a[0].plot(plotx, Erdfs[l,:] - dErdfs[l,:], '--k')
a[1].plot(plotx, rdftraj.sum(axis=1)/float(Nl), '-k')
alims0 = a[0].get_ylim()
alims1 = a[1].get_ylim()
a[0].set_ylim(0, numpy.amax(numpy.array([alims0[1], alims1[1]])))
a[1].set_ylim(0, numpy.amax(numpy.array([alims0[1], alims1[1]])))
else:
a[l,0].plot(plotx, Erdfs[l,:], '-k')
#a[l,0].plot(plotx, Erdfs[l,:] + dErdfs[l,:], '--k')
#a[l,0].plot(plotx, Erdfs[l,:] - dErdfs[l,:], '--k')
a[l,1].plot(plotx, rdftraj.sum(axis=1)/float(Nl), '-k')
alims0 = a[l,0].get_ylim()
alims1 = a[l,1].get_ylim()
a[l,0].set_ylim(0, numpy.amax(numpy.array([alims0[1], alims1[1]])))
a[l,1].set_ylim(0, numpy.amax(numpy.array([alims0[1], alims1[1]])))
elif crunchset:
f,a = plt.subplots(Npert)
for l in xrange(Npert):
a[l].plot(plotx, Erdfs[l,:], '-k')
a[l].set_ylim([0,a[l].get_ylim()[1]])
print "Peak for %s at %f" % (pertname[l], plotx[numpy.argmax(Erdfs[l,:])])
else:
f,a=plt.subplots(1,1)
a.plot(plotx, Erdfs[0,:], '-k')
plt.show()
pdb.set_trace()
# thermodynamic state
elif observe == 'potential energy':
A_kn = U_kln
# observable for estimation is the position
elif observe == 'position':
A_kn = numpy.zeros([K,N_max], dtype = numpy.float64)
for k in range(0,K):
A_kn[k,0:N_k[k]] = x_kn[k,0:N_k[k]]
elif observe == 'position^2':
A_kn = numpy.zeros([K,N_max], dtype = numpy.float64)
for k in range(0,K):
A_kn[k,0:N_k[k]] = x_kn[k,0:N_k[k]]**2
(A_k_estimated, dA_k_estimated) = mbar.computeExpectations(A_kn)
As_k_estimated = numpy.zeros([K],numpy.float64)
dAs_k_estimated = numpy.zeros([K],numpy.float64)
# 'standard' expectation averages
ifzero = numpy.array(N_k != 0)
for k in range(K):
if (ifzero[k]):
if (observe == 'position') or (observe == 'position^2'):
As_k_estimated[k] = numpy.average(A_kn[k,0:N_k[k]])
dAs_k_estimated[k] = numpy.sqrt(numpy.var(A_kn[k,0:N_k[k]])/(N_k[k]-1))
elif (observe == 'RMS displacement' ) or (observe == 'potential energy'):
As_k_estimated[k] = numpy.average(A_kn[k,k,0:N_k[k]])
# observable for estimation is the position
elif observe == 'position':
state_dependent = False
A_kn = numpy.zeros([K,N_max], dtype = numpy.float64)
for k in range(0,K):
A_kn[k,0:N_k[k]] = x_kn[k,0:N_k[k]]
# observable for estimation is the position^2
elif observe == 'position^2':
state_dependent = False
A_kn = numpy.zeros([K,N_max], dtype = numpy.float64)
for k in range(0,K):
A_kn[k,0:N_k[k]] = x_kn[k,0:N_k[k]]**2
(A_k_estimated, dA_k_estimated) = mbar.computeExpectations(A_kn, state_dependent = state_dependent)
# need to additionally transform to get the square root
if observe == 'RMS displacement':
A_k_estimated = numpy.sqrt(A_k_estimated)
# Compute error from analytical observable estimate.
dA_k_estimated = dA_k_estimated/(2*A_k_estimated)
As_k_estimated = numpy.zeros([K],numpy.float64)
dAs_k_estimated = numpy.zeros([K],numpy.float64)
# 'standard' expectation averages - not defined if no samples
nonzeros = numpy.arange(K)[Nk_ne_zero]
totaln = 0
for k in nonzeros:
