def run_EMUS(self):
# Load data
psis, cv_trajs, neighbors = uu.data_from_meta(self.meta_file_name,
self.dim,
T=self.T,
k_B=self.k_B,
period=None)
# Calculate the partition function for each window
z, F = emus.calculate_zs(psis, neighbors=neighbors)
# Calculate error in each z value from the first iteration.
zerr, zcontribs, ztaus = avar.calc_partition_functions(
psis, z, F, iat_method='acor')
# Calculate the PMF from EMUS
domain = ((-0.5, 6)) # Range of dihedral angle values
pmf, edges = emus.calculate_pmf(cv_trajs,
psis,
domain,
z,
nbins=self.num_bins,
kT=self.kT,
use_iter=False) # Calculate the pmf
# Calculate z using the MBAR iteration.
z_iter_1, F_iter_1 = emus.calculate_zs(psis, n_iter=1)
z_iter_2, F_iter_2 = emus.calculate_zs(psis, n_iter=2)
z_iter_5, F_iter_5 = emus.calculate_zs(psis, n_iter=5)
z_iter_1k, F_iter_1k = emus.calculate_zs(psis, n_iter=1000)
# Calculate new PMF
iterpmf, edges = emus.calculate_pmf(cv_trajs,
psis,
domain,
nbins=self.num_bins,
z=z_iter_1k,
kT=self.kT)
# Get the asymptotic error of each histogram bin.
pmf_av_mns, pmf_avars = avar.calc_pmf(cv_trajs,
psis,
domain,
z,
F,
nbins=self.num_bins,
kT=self.kT,
iat_method=np.average(ztaus,
axis=0))
### Data Output Section ###
# Plot the EMUS, Iterative EMUS pmfs.
pmf_centers = (edges[0][1:] + edges[0][:-1]) / 2.
self.x = pmf_centers
self.y = pmf_av_mns / self.tau
self.err = 1 / self.tau * np.sqrt(pmf_avars)
self.y_iter = iterpmf / self.tau
z, F = emus.calculate_zs(psis, neighbors=neighbors)
# Calculate error in each z value from the first iteration.
zerr, zcontribs, ztaus = avar.calc_partition_functions(psis,
z,
F,
iat_method='acor')
#zerr, zcontribs, ztaus = avar.calc_partition_functions(psis,z,F,neighbors,iat_method='acor')
# Calculate the PMF from EMUS
#domain = ((-180.0,180.)) # Range of dihedral angle values
domain = ((3.0, 25.0)) # Range of length values
pmf, edges = emus.calculate_pmf(cv_trajs,
psis,
domain,
z,
nbins=nbins,
kT=kT,
use_iter=False) # Calculate the pmf
# Calculate z using the MBAR iteration.
z_iter_1, F_iter_1 = emus.calculate_zs(psis, n_iter=1)
z_iter_2, F_iter_2 = emus.calculate_zs(psis, n_iter=2)
z_iter_5, F_iter_5 = emus.calculate_zs(psis, n_iter=5)
z_iter_1k, F_iter_1k = emus.calculate_zs(psis, n_iter=1000)
#z_iter_1, F_iter_1 = emus.calculate_zs(psis,neighbors=neighbors,n_iter=1)
#z_iter_2, F_iter_2 = emus.calculate_zs(psis,neighbors=neighbors,n_iter=2)
#z_iter_5, F_iter_5 = emus.calculate_zs(psis,neighbors=neighbors,n_iter=5)
#z_iter_1k, F_iter_1k = emus.calculate_zs(psis,neighbors=neighbors,n_iter=1000)
# Calculate new PMF
def main():
a = _parse_args() # Get Dictionary of Arguments
kT = a['k_B'] * a['T']
domain = np.reshape(a['domain'], (-1, 2))
# Load data
psis, cv_trajs, neighbors = uu.data_from_meta(a['meta_file'],
a['n_dim'],
T=a['T'],
k_B=a['k_B'],
period=a['period'],
nsig=a['sigma'])
if a['fxn_file'] is not None:
fdata = uu.fxn_data_from_meta(a['fxn_file'])
else:
fdata = None
# Calculate the partition function for each window
z, F = emus.calculate_zs(psis, neighbors=neighbors, n_iter=a['n_iter'])
# Calculate the PMF
pmf, edges = emus.calculate_pmf(cv_trajs,
psis,
domain,
z,
neighbors=neighbors,
nbins=a['nbins'],
kT=kT)
# Calculate any averages of functions.
if fdata is not None:
favgs = []
for n, fdata_i in enumerate(fdata):
favgs.append(
emus.calculate_obs(psis, z, fdata_i, neighbors=neighbors))
# Perform Error analysis if requested.
if a['error'] is not None:
zEMUS, FEMUS = emus.calculate_zs(psis, neighbors=neighbors, n_iter=0)
zvars, z_contribs, z_iats = avar.calc_partition_functions(
psis, zEMUS, FEMUS, neighbors=neighbors, iat_method=a['error'])
z_avg_taus = np.average(z_iats, axis=0)
pmf_EMUS, pmf_EMUS_avar = avar.calc_pmf(cv_trajs,
psis,
domain,
zEMUS,
FEMUS,
neighbors=neighbors,
nbins=a['nbins'],
kT=kT,
iat_method=z_avg_taus)
# Perform analysis on any provided functions.
if fdata is not None:
favgs_EM = []
ferrs = []
fcontribs = []
for fdata_i in fdata:
iat, mean, variances = avar.calc_avg_ratio(
psis,
zEMUS,
FEMUS,
fdata_i,
neighbors=neighbors,
iat_method=a['error'])
favgs_EM.append(mean)
fcontribs.append(variances)
ferrs.append(np.sum(variances))
# Save Data
f = h5py.File(a['output'] + '_out.hdf5', "w")
# Save PMF
pmf_grp = f.create_group("PMF")
pmf_dset = pmf_grp.create_dataset("pmf", pmf.shape, dtype='f')
dmn_dset = pmf_grp.create_dataset("domain",
np.array(domain).shape,
dtype='f')
pmf_dset[...] = pmf
dmn_dset[...] = np.array(domain)
for ie, edg in enumerate(edges):
edg_dset = pmf_grp.create_dataset("edge_%d" % ie, edg.shape, dtype='f')
edg_dset[...] = edg
if a['error'] is not None:
pmf_EMUS_dset = pmf_grp.create_dataset("pmf_no_iter",
pmf_EMUS.shape,
dtype='f')
pmf_EMUS_dset[...] = pmf_EMUS
pmf_EMUS_avar_dset = pmf_grp.create_dataset("pmf_no_iter_avars",
pmf_EMUS_avar.shape,
dtype='f')
pmf_EMUS_avar_dset[...] = pmf_EMUS_avar
# Save partition functions
z_grp = f.create_group("partition_function")
z_dset = z_grp.create_dataset("z", z.shape, dtype='f')
z_dset[...] = z
F_dset = z_grp.create_dataset("F", F.shape, dtype='f')
F_dset[...] = F
if a['error'] is not None:
zerr_dset = z_grp.create_dataset("z_avars",
np.array(zvars).shape,
dtype='f')
zerr_dset[...] = np.array(zvars)
zEMUS_dset = z_grp.create_dataset("z_no_iter", zEMUS.shape, dtype='f')
zEMUS_dset[...] = zEMUS
FEMUS_dset = z_grp.create_dataset("F_no_iter", FEMUS.shape, dtype='f')
FEMUS_dset[...] = FEMUS
# Save function data.
if fdata is not None:
f_grp = f.create_group('function_averages')
f_dset = f_grp.create_dataset("f", np.shape(favgs), dtype='f')
f_dset[...] = np.array(favgs)
if a['error'] is not None:
fvar_dset = f_grp.create_dataset("f_avars",
np.shape(ferrs),
dtype='f')
fvar_dset[...] = ferrs
f.close()
period=period)
# Calculate the partition function for each window
z_iter, F_iter = emus.calculate_zs(psis, neighbors=neighbors, n_iter=5)
plt.plot(np.arange(len(z_iter)), -np.log(z_iter), label='Window Free Energies')
plt.xlabel(r'Window Index')
plt.ylabel('Window FE Unitless')
plt.legend()
plt.show()
domain = ((-180.0, 180.)) # Range of dihedral angle values
# Calculate new PMF
iterpmf, edges = emus.calculate_pmf(cv_trajs,
psis,
domain,
nbins=nbins,
z=z_iter,
kT=kT)
fdata = [((traj > 25) & (traj < 100)).flatten() for traj in cv_trajs]
prob_C7ax_iter = emus.calculate_obs(
psis, z_iter, fdata, use_iter=True) # Just calculate the probability
fe_C7ax = -np.log(prob_C7ax_iter)
fe_C7ax_err, fe_C7ax_contribs, fe_C7ax_taus = iter_avar.calc_log_avg_ratio(
psis, z_iter, fdata, neighbors=neighbors)
avg_pmf, edges = emus.calculate_avg_on_pmf(cv_trajs,
psis, (-180, 180),
z_iter,
fdata,
meta_file = 'wham_meta.txt' # Path to Meta File
dim = 1 # 1 Dimensional CV space.
period = 360 # Dihedral Angles periodicity
# Load data
psis, cv_trajs, neighbors = uu.data_from_WHAMmeta('wham_meta.txt',dim,T=T,k_B=k_B,period=period)
# Calculate the partition function for each window
z, F = emus.calculate_zs(psis,neighbors=neighbors,)
# Calculate error in each z value from the first iteration.
zerr, zcontribs, ztaus = avar.partition_functions(psis,z,F,iat_method='acor')
# Calculate the PMF
domain = ((-180.0,180.)) # Range of dihedral angle values
pmf = emus.calculate_pmf(cv_trajs,psis,domain,z,nbins=60,kT=kT) # Calculate the pmf
# Calculate z using the MBAR iteration.
z_MBAR_1, F_MBAR_1 = emus.calculate_zs(psis,nMBAR=1)
z_MBAR_2, F_MBAR_2 = emus.calculate_zs(psis,nMBAR=2)
z_MBAR_5, F_MBAR_5 = emus.calculate_zs(psis,nMBAR=5)
z_MBAR_1k, F_MBAR_1k = emus.calculate_zs(psis,nMBAR=1000)
# Calculate new PMF
MBARpmf = emus.calculate_pmf(cv_trajs,psis,domain,nbins=60,z=z_MBAR_1k,kT=kT)
# Estimate probability of being in C7 ax basin
fdata = [(traj>25) & (traj<100) for traj in cv_trajs]
# Calculate the probability and perform error analysis.
iat, probC7ax, probC7ax_contribs = avar.average_ratio(psis,z,F,fdata,iat_method='acor')
probC7ax_std = np.sqrt(np.sum(probC7ax_contribs))
# This command just calculates the probability, without error analysis.
def main():
a = _parse_args() # Get Dictionary of Arguments
kT = a['k_B'] * a['T']
# Load data
psis, cv_trajs, neighbors = uu.data_from_WHAMmeta(a['meta_file'],a['ndim'],T=a['T'], k_B=a['k_B'],period=a['period'],nsig=a['sigma'])
if a['fxn_file'] is not None:
fdata = uu.data_from_fxnmeta(a['fxn_file'])
else:
fdata = None
# Calculate the partition function for each window
z, F= emus.calculate_zs(psis,neighbors=neighbors,nMBAR=a['nMBAR'])
# Calculate the PMF
pmf = emus.calculate_pmf(cv_trajs,psis,a['domain'],z,nbins=a['nbins'],kT=kT)
# Calculate any averages of functions.
if fdata is not None:
favgs = []
for n, fdata_i in enumerate(fdata):
favgs.append(emus.calculate_obs(psis,z,fdata_i))
# Perform Error analysis if requested.
if a['error'] is not None:
zEMUS, FEMUS= emus.calculate_zs(psis,neighbors=neighbors,nMBAR=0)
zvars, z_contribs, z_iats = avar.partition_functions(psis,zEMUS,FEMUS,neighbors=neighbors,iat_method=a['error'])
# Perform analysis on any provided functions.
if fdata is not None:
favgs_EM = []
ferrs = []
fcontribs = []
nfxns = len(fdata[0][0])
for n in xrange(nfxns):
fdata_i = [fi[:,n] for fi in fdata]
iat, mean, variances = avar.average_ratio(psis,zEMUS,FEMUS,fdata_i,neighbors=neighbors,iat_method=a['error'])
favgs_EM.append(mean)
fcontribs.append(variances)
ferrs.append(np.sum(variances))
# Save Data
if a['ext'] == 'txt':
np.savetxt(a['output']+'_pmf.txt',pmf)
np.savetxt(a['output']+'_z.txt',z)
np.savetxt(a['output']+'_F.txt',F)
if fdata is not None:
np.savetxt(a['output']+'_f.txt',favgs)
if a['error'] is not None:
np.savetxt(a['output']+'_zvars.txt',zvars)
if fdata is not None:
np.savetxt(a['output']+'_fvars.txt',ferrs)
elif a['ext'] == 'hdf5':
import h5py
f = h5py.File(a['output']+'_out.hdf5',"w")
# Save PMF
pmf_grp = f.create_group("PMF")
pmf_dset = pmf_grp.create_dataset("pmf",pmf.shape,dtype='f')
dmn_dset = pmf_grp.create_dataset("domain",np.array(a['domain']).shape,dtype='f')
pmf_dset[...] = pmf
dmn_dset[...] = np.array(a['domain'])
# Save partition functions
z_grp = f.create_group("partition_function")
z_dset = z_grp.create_dataset("z",z.shape,dtype='f')
z_dset[...] = z
F_dset = z_grp.create_dataset("F",F.shape,dtype='f')
F_dset[...] = F
if a['error'] is not None:
zerr_dset = z_grp.create_dataset("z_vars",np.array(zvars).shape,dtype='f')
zerr_dset[...] = np.array(zvars)
if fdata is not None:
f_grp = f.create_group('function_averages')
f_dset = f_grp.create_dataset("f",np.shape(favgs),dtype='f')
f_dset[...] = np.array(favgs)
if a['error'] is not None:
fvar_dset = f_grp.create_dataset("f_variances",np.shape(fvars),dtype='f')
fvar_dset[...] = ferrs
f.close()
else:
raise Warning('No valid output method detected.')
