def Run(self):
""" Call the appropriate optimizer. This is the method we might want to call from an executable. """
xk = self.OptTab[self.jobtype]()
## Sometimes the optimizer doesn't return anything (i.e. in the case of a single point calculation)
## In these situations, don't do anything
if xk == None: return
## Check derivatives by finite difference after the optimization is over (for good measure)
check_after = False
if check_after:
self.mvals0 = xk.copy()
self.FDCheckG()
## Print out final answer
final_print = True
if final_print:
bar = printcool("Final optimization parameters:\n Paste to input file to restart",bold=True,color=4)
logger.info("read_mvals\n")
self.FF.print_map(xk)
logger.info("/read_mvals\n")
bar = printcool("Final physical parameters:",bold=True,color=4)
self.FF.print_map(self.FF.create_pvals(xk))
logger.info(bar)
self.FF.make(xk,False,'result')
logger.info("\nThe final force field has been printed to the 'result' directory.\n")
#bar = printcool("\x1b[1;45;93mCongratulations, ForceBalance has finished\x1b[0m\n\x1b[1;45;93mGive yourself a pat on the back!\x1b[0m")
bar = printcool("Congratulations, ForceBalance has finished\nGive yourself a pat on the back!",ansi="1;44;93")
## Write out stuff to checkpoint file
self.writechk()
return xk
def submit_liq_gas(self, mvals, AGrad=True):
"""
Set up and submit/run sampling simulations in the liquid and gas phases.
"""
# This routine called by Objective.stage() will run before "get".
# It submits the jobs to the Work Queue and the stage() function will wait for jobs to complete.
printcool("Target: %s - launching %i MD simulations\nTime steps (liq):"
"%i (eq) + %i (md)\nTime steps (g): %i (eq) + %i (md)" %
(self.name, 2 * len(self.IDs), self.liquid_eq_steps,
self.liquid_md_steps, self.gas_eq_steps, self.gas_md_steps),
color=0)
# If self.save_traj == 1, delete the trajectory files from a previous good optimization step.
if self.evaluated and self.goodstep and self.save_traj < 2:
for fn in self.last_traj:
if os.path.exists(fn):
os.remove(fn)
self.last_traj = []
# Set up and run the NPT simulations.
# Less fully featured than liquid simulation; NOT INCLUDED are
# 1) Temperature and pressure
# 2) Multiple initial conditions
for label in self.IDs:
if not os.path.exists(label):
os.makedirs(label)
os.chdir(label)
# Run liquid and gas phase simulations.
self.run_simulation(label, 0, AGrad)
self.run_simulation(label, 1, AGrad)
os.chdir('..')
def submit_liq_gas(self, mvals, AGrad=True):
"""
Set up and submit/run sampling simulations in the liquid and gas phases.
"""
# This routine called by Objective.stage() will run before "get".
# It submits the jobs to the Work Queue and the stage() function will wait for jobs to complete.
printcool("Target: %s - launching %i MD simulations\nTime steps (liq):"
"%i (eq) + %i (md)\nTime steps (g): %i (eq) + %i (md)" %
(self.name, 2*len(self.IDs), self.liquid_eq_steps, self.liquid_md_steps,
self.gas_eq_steps, self.gas_md_steps), color=0)
# If self.save_traj == 1, delete the trajectory files from a previous good optimization step.
if self.evaluated and self.goodstep and self.save_traj < 2:
for fn in self.last_traj:
if os.path.exists(fn):
os.remove(fn)
self.last_traj = []
# Set up and run the NPT simulations.
# Less fully featured than liquid simulation; NOT INCLUDED are
# 1) Temperature and pressure
# 2) Multiple initial conditions
for label in self.IDs:
if not os.path.exists(label):
os.makedirs(label)
os.chdir(label)
# Run liquid and gas phase simulations.
self.run_simulation(label, 0, AGrad)
self.run_simulation(label, 1, AGrad)
os.chdir('..')
def minCentroids(self):
"""
MM optimize cluster centroids, final output is a separate directory for each structure.
"""
printcool("Centroid Minimization")
cwd = os.getcwd()
for k in self.unique_res:
os.chdir("{}/Cluster/{}".format(self.base_tmp, k))
scr = os.path.join(self.root, self.unique_res[k][0].tempdir)
centroids = Molecule("centroids.gro")
self.unique_res[k][0].engine.mol = centroids
for struct in range(len(self.unique_res[k][0].engine.mol)):
if not os.path.isdir("{}".format(struct)):
os.makedirs("{}".format(struct))
os.chdir("{}".format(struct))
if not os.path.isfile("{}".format(self.min_file_name)):
for f in os.listdir("."):
os.remove(f)
engine_files = os.listdir("{}".format(scr))
[
os.symlink("{}/{}".format(scr, z), z)
for z in engine_files
if not os.path.isdir("{}/{}".format(scr, z))
]
os.symlink(
os.path.join(self.root, self.options['ffdir'],
self.options['forcefield'][0]),
"{}".format(self.options['forcefield'][0]))
energy, rmsd, geom = self.unique_res[k][0].engine.optimize(
struct)
geom.write("{}".format(self.min_file_name))
os.chdir("{}".format(
os.path.join(self.root, self.base_tmp, 'Cluster', k)))
os.chdir(cwd)
def Cluster(self):
"""
Cluster structures for each residue using hierarchial clustering in scipy. Follows previous MDTraj procedure.
http://mdtraj.org/1.4.2/examples/clustering.html
"""
printcool("Clustering")
cwd = os.getcwd()
self.cluster_defs = {}
for k in self.unique_res:
os.chdir("{}/Cluster/{}".format(self.base_tmp, k))
if not os.path.isfile("centroids.gro"):
mm_opt = Molecule("mm_opt.gro")
elems = mm_opt.elem
if self.cluster_inds == "heavy":
self.indices = [
i for i in range(len(elems)) if elems[i] != "H"
]
elif self.cluster_inds == "all":
self.indices = [i for i in range(len(elems))]
else:
raise Exception(
"{} is an invalid option for default_cluster_indices.".
format(self.default_cluster_indices))
distances = mm_opt.all_pairwise_rmsd(atom_inds=self.indices)
reduced_distances = squareform(distances, checks=False)
link = hierarchy.linkage(reduced_distances, method="centroid")
clusters = hierarchy.fcluster(link,
t=self.clust_dist,
criterion="distance")
self.cluster_defs = {}
for i in clusters:
self.cluster_defs[i] = []
for i in range(len(clusters)):
self.cluster_defs[clusters[i]].append(i)
centroids = []
for i in self.cluster_defs.keys():
clust_list = self.cluster_defs[i]
dist_clust = distances[clust_list, :][:, clust_list]
ind = getCentroid(dist_clust)
centroids.append(clust_list[ind])
centroids_mmopt = mm_opt[centroids]
centroids_mmopt.write("centroids.gro")
os.chdir(cwd)
def minGrids(self):
"""
For each unique residue, loop through the engine.mol object of each target and minimize all structures.
Then gather all the files for each target into one file that is placed in the "Cluster" directory.
"""
printcool("Initial MM Minimization")
cwd = os.getcwd()
if not os.path.isdir("{}/Cluster".format(self.base_tmp)):
os.makedirs("{}/Cluster".format(self.base_tmp))
for k in self.unique_res:
collect = None
for i in range(len(self.unique_res[k])):
os.chdir(self.unique_res[k][i].tempdir)
scr = os.path.join(self.root, self.unique_res[k][i].tempdir)
if not os.path.isdir("{}".format(self.opt_name)):
os.makedirs("{}".format(self.opt_name))
os.chdir("{}".format(self.opt_name))
for struct in range(len(self.unique_res[k][i].engine.mol)):
if not os.path.isdir("{}".format(struct)):
os.makedirs("{}".format(struct))
os.chdir("{}".format(struct))
engine_files = os.listdir("{}".format(scr))
[
os.symlink("{}/{}".format(scr, z), z)
for z in engine_files
if not os.path.isdir("{}/{}".format(scr, z))
]
os.symlink(
os.path.join(self.root, self.options['ffdir'],
self.options['forcefield'][0]),
"{}".format(self.options['forcefield'][0]))
energy, rmsd, geom = self.unique_res[k][i].engine.optimize(
struct)
geom.write("{}".format(self.min_file_name))
os.chdir(os.path.join(scr, self.opt_name))
_exec('find . -name {} | sort | xargs cat > mm_opt.gro'.format(
self.min_file_name))
mol = Molecule("mm_opt.gro")
if collect is None: collect = mol
else: collect.append(mol)
os.chdir(cwd)
os.chdir("{}/Cluster".format(self.base_tmp))
if not os.path.isdir(k): os.makedirs(k)
os.chdir(k)
collect.write("mm_opt.gro")
os.chdir(cwd)
def parseFBInput(self):
"""
This reads through the provided ForceBalance input file using the
standard FB parse_inputs. It removes any non-AbInitio targets and
removes any AbInitio targets that are previously MMOpt targets.
This forms a dictionary (self.unique_res) containing targets belonging
to the same residue based off of the target prefix.
"""
printcool("Reading Grids")
#Parse FB input file
self.options, self.tgt_opts = parse_inputs(self.fbinput)
#Get force field in FB result directory
ff_path = os.path.join("result",
os.path.splitext(self.options["input_file"])[0])
self.options["ffdir"] = ff_path
self.ff = FF(self.options)
#Retain AbInitio targets that are not mmopt targets
self.tgt_opts = [
l for l in self.tgt_opts
if "ABINITIO" in l.get("type") and "mmopt" not in l.get("name")
]
self.root = self.options["root"]
self.options["input_file"] = "reopt"
#Assemble targets from ImplementedTargets dictionary
self.targets = []
for opts in self.tgt_opts:
Tgt = Implemented_Targets[opts["type"]](self.options, opts,
self.ff)
self.targets.append(Tgt)
#Combine targets that belong to one residue, splits on - or _ in target name (may not be completely sufficient...)
self.unique_res = {}
for i in range(len(self.tgt_opts)):
name = re.split(r"_|-", self.tgt_opts[i]["name"])[0]
if name in self.unique_res:
self.unique_res[name].append(self.targets[i])
else:
self.unique_res[name] = []
self.unique_res[name].append(self.targets[i])
def FDCheckH(self):
""" Finite-difference checker for the objective function Hessian.
For each element in the Hessian, use a five-point stencil in both
parameter indices to compute a finite-difference derivative, and
compare it to the analytic result.
This is meant to be a foolproof checker, so it is pretty slow. We
could write a faster checker if we assumed we had accurate first
derivatives, but it's better to not make that assumption.
The second derivative is computed by double-wrapping the objective
function via the 'wrap2' function.
"""
Adata = self.Objective.Full(self.mvals0,Order=2)['H']
Fdata = np.zeros((self.FF.np,self.FF.np),dtype=float)
printcool("Checking second derivatives by finite difference!\n%-8s%-20s%-20s%13s%13s%13s%13s" \
% ("Index", "Parameter1 ID", "Parameter2 ID", "Analytic","Numerical","Difference","Fractional"),bold=1,color=5)
# Whee, our double-wrapped finite difference second derivative!
def wrap2(mvals0,pidxi,pidxj):
def func1(arg):
mvals = list(mvals0)
mvals[pidxj] += arg
return f1d5p(fdwrap(self.Objective.Full,mvals,pidxi,'X',Order=0),self.h)
return func1
for i in range(self.FF.np):
for j in range(i,self.FF.np):
Fdata[i,j] = f1d5p(wrap2(self.mvals0,i,j),self.h)
Denom = max(abs(Adata[i,j]),abs(Fdata[i,j]))
Denom = Denom > 1e-8 and Denom or 1e-8
D = Adata[i,j] - Fdata[i,j]
Q = (Adata[i,j] - Fdata[i,j])/Denom
cD = abs(D) > 0.5 and "\x1b[1;91m" or (abs(D) > 1e-2 and "\x1b[91m" or (abs(D) > 1e-5 and "\x1b[93m" or "\x1b[92m"))
cQ = abs(Q) > 0.5 and "\x1b[1;91m" or (abs(Q) > 1e-2 and "\x1b[91m" or (abs(Q) > 1e-5 and "\x1b[93m" or "\x1b[92m"))
logger.info("\r %-8i%-20s%-20s% 13.4e% 13.4e%s% 13.4e%s% 13.4e\x1b[0m\n" \
% (i, self.FF.plist[i][:20], self.FF.plist[j][:20], Adata[i,j], Fdata[i,j], cD, D, cQ, Q))
def FDCheckG(self):
""" Finite-difference checker for the objective function gradient.
For each element in the gradient, use a five-point finite difference
stencil to compute a finite-difference derivative, and compare it to
the analytic result.
"""
Adata = self.Objective.Full(self.mvals0,Order=1)['G']
Fdata = np.zeros(self.FF.np,dtype=float)
printcool("Checking first derivatives by finite difference!\n%-8s%-20s%13s%13s%13s%13s" \
% ("Index", "Parameter ID","Analytic","Numerical","Difference","Fractional"),bold=1,color=5)
for i in range(self.FF.np):
Fdata[i] = f1d7p(fdwrap(self.Objective.Full,self.mvals0,i,'X',Order=0),self.h)
Denom = max(abs(Adata[i]),abs(Fdata[i]))
Denom = Denom > 1e-8 and Denom or 1e-8
D = Adata[i] - Fdata[i]
Q = (Adata[i] - Fdata[i])/Denom
cD = abs(D) > 0.5 and "\x1b[1;91m" or (abs(D) > 1e-2 and "\x1b[91m" or (abs(D) > 1e-5 and "\x1b[93m" or "\x1b[92m"))
cQ = abs(Q) > 0.5 and "\x1b[1;91m" or (abs(Q) > 1e-2 and "\x1b[91m" or (abs(Q) > 1e-5 and "\x1b[93m" or "\x1b[92m"))
logger.info("\r %-8i%-20s% 13.4e% 13.4e%s% 13.4e%s% 13.4e\x1b[0m\n" \
% (i, self.FF.plist[i][:20], Adata[i], Fdata[i], cD, D, cQ, Q))
def print_item(key, physunit):
if self.Xp[key] > 0:
the_title = ("%s %s (%s)\n" % (self.name, key.capitalize(), physunit) +
"No. Temperature Pressure Reference " +
"Calculated +- Stddev " +
" Delta Weight Term ")
printcool_dictionary(self.Pp[key], title=the_title, bold=True,
color=4, keywidth=15)
bar = printcool(("%s objective function: % .3f%s" %
(key.capitalize(), self.Xp[key],
", Derivative:" if AGrad else "")))
if AGrad:
self.FF.print_map(vals=self.Gp[key])
logger.info(bar)
PrintDict[key] = (("% 10.5f % 8.3f % 14.5e" %
(self.Xp[key], self.Wp[key],
self.Xp[key]*self.Wp[key])))
def main():
"""Usage:
(gmxprefix.sh) md_chain.py <list of quantities>
--engine <gromacs>
--length <n>
--name <name>
--temperature <T>
--pressure <p>
--nequil <nequil>
--nsteps <nsteps>
This program is meant to be called automatically by ForceBalance.
"""
printcool("ForceBalance simulation using engine: %s" % engname.upper(),
color=4, bold=True)
#----
# Load the ForceBalance pickle file which contains:
#----
# - Force field object
# - Optimization parameters
# - Options from the Target object that launched this simulation
# - Switch for whether to evaluate analytic derivatives.
FF, mvals, TgtOptions, AGrad = lp_load('forcebalance.p')
FF.ffdir = '.'
# Write the force field file.
FF.make(mvals)
#----
# Load the options that are set in the ForceBalance input file.
#----
# Finite difference step size
h = TgtOptions['h']
pgrad = TgtOptions['pgrad']
engines = []
## Setup and carry out simulations in chain
for i in range(args.length):
# Simulation files
if engname == "gromacs":
ndx_flag = False
coords = args.name + str(i+1) + ".gro"
top_file = args.name + str(i+1) + ".top"
mdp_file = args.name + str(i+1) + ".mdp"
ndx_file = args.name + str(i+1) + ".ndx"
if os.path.exists(ndx_file):
ndx_flag = True
mol = Molecule(coords)
#----
# Set coordinates and molecule for engine
#----
EngOpts = OrderedDict([("FF", FF),
("pbc", True),
("coords", coords),
("mol", mol)])
if engname == "gromacs":
# Gromacs-specific options
EngOpts["gmx_top"] = top_file
EngOpts["gmx_mdp"] = mdp_file
if ndx_flag:
EngOpts["gmx_ndx"] = ndx_file
printcool_dictionary(EngOpts)
# Create engine objects and store them for subsequent analysis.
s = Engine(name=args.name+str(i+1), **EngOpts)
#=====================#
# Run the simulation. #
#=====================#
MDOpts = OrderedDict([("nsteps", args.nsteps),
("nequil", args.nequil)])
printcool("Molecular dynamics simulation", color=4, bold=True)
s.md(verbose=True, **MDOpts)
engines.append(s)
#======================================================================#
# Extract the quantities of interest from the MD simulations and dump #
# the results to file. #
# =====================================================================#
results = OrderedDict()
for q in args.quantities:
logger.info("Extracting %s...\n" % q)
# Initialize quantity
objstr = "Quantity_" + q.capitalize()
dm = il.import_module('..quantity',
package='forcebalance.quantity')
Quantity = getattr(dm, objstr)(engname, args.temperature, args.pressure)
Q, Qerr, Qgrad = Quantity.extract(engines, FF, mvals, h, pgrad, AGrad)
results.setdefault("values", []).append(Q)
results.setdefault("errors", []).append(Qerr)
results.setdefault("grads", []).append(Qgrad)
logger.info("Finished!\n")
# Print out results for the quantity and its derivative.
Sep = printcool(("%s: % .4f +- % .4f \nAnalytic Derivative:"
% (q.capitalize(), Q, Qerr)))
FF.print_map(vals=Qgrad)
# Dump results to file
logger.info("Writing final force field.\n")
pvals = FF.make(mvals)
logger.info("Writing all simulation data to disk.\n")
lp_dump((np.asarray(results["values"]),
np.asarray(results["errors"]),
np.asarray(results["grads"])), 'md_result.p')
def _initialize(self):
"""Initializes the evaluator target from an input json file.
1. Reads the user specified input file.
2. Creates a `evaluator` client object.
3. Loads in a reference experimental data set.
4. Assigns and normalises weights for each property.
"""
# Load in the options from a user provided JSON file.
print(os.path.join(self.tgtdir, self.evaluator_input))
options_file_path = os.path.join(self.tgtdir, self.evaluator_input)
self._options = self.OptionsFile.from_json(options_file_path)
for property_type, denominator in self._options.denominators.items():
self._default_units[property_type] = denominator.units
# Attempt to create an evaluator client object using the specified
# connection options.
self._client = EvaluatorClient(self._options.connection_options)
# Load in the experimental data set.
data_set_path = os.path.join(self.tgtdir, self._options.data_set_path)
self._reference_data_set = PhysicalPropertyDataSet.from_json(data_set_path)
if len(self._reference_data_set) == 0:
raise ValueError(
"The physical property data set to optimise against is empty."
)
# Print the reference data, and count the number of instances of
# each property type.
printcool("Loaded experimental data.")
property_types = self._reference_data_set.property_types
number_of_properties = {
x: sum(1 for y in self._reference_data_set.properties_by_type(x))
for x in property_types
}
for substance in self._reference_data_set.substances:
dict_for_print = {}
for physical_property in self._reference_data_set.properties_by_substance(
substance
):
property_type = physical_property.__class__.__name__
value = physical_property.value.to(self._default_units[property_type])
uncertainty = np.nan
if physical_property.uncertainty != UNDEFINED:
uncertainty = physical_property.uncertainty.to(
self._default_units[property_type]
)
tuple_key = (
property_type,
physical_property.thermodynamic_state.temperature,
physical_property.thermodynamic_state.pressure,
)
dict_for_print["%s %s-%s" % tuple_key] = "%s+/-%s" % (
value,
uncertainty,
)
printcool_dictionary(
dict_for_print, title="Reference %s data" % substance.identifier,
)
# Assign and normalize weights for each phase point (average for now)
self._normalised_weights = {}
for property_type in self._reference_data_set.property_types:
self._normalised_weights[property_type] = (
self._options.weights[property_type]
/ number_of_properties[property_type]
)
import forcebalance
from forcebalance.PT import PeriodicTable
from forcebalance.nifty import isint, printcool
import getopt
opts,args = getopt.getopt(argv[1:],'h')
AutoH = False
for o,a in opts:
argv.remove(o)
if o == "-h":
AutoH = True
Alphabet = list(map(chr, range(65, 91)))
printcool(" Welcome to Lee-Ping's Force Field Generator --- ")
print " This script attempts to generate an OPLS force field "
print " from any Gaussian input file. Here's how it works. "
print " 1. Define your atom types. "
print " 2. Define corresponding OPLS atom types. "
print " If there is no corresponding OPLS type, then you "
print " must define your own."
print " 3. Select or input bonding parameters. "
print " If you selected OPLS atom types, then the program"
print " will attempt to recommend parameters for you. "
print " 4. Finished: GRO and ITP files will be generated. "
"""
gauss2gro-OPLS.py is an automatic force field maker, which builds a
force field from a molecular topology (in Gaussian .com format) and
fills in parameters automatically from OPLS-AA. This is probably the
def main():
"""
Usage: (runcuda.sh) nvt.py <openmm|gromacs|tinker> <liquid_nsteps> <liquid_timestep (fs)> <liquid_intvl (ps> <temperature>
This program is meant to be called automatically by ForceBalance on
a GPU cluster (specifically, subroutines in openmmio.py). It is
not easy to use manually. This is because the force field is read
in from a ForceBalance 'FF' class.
"""
printcool("ForceBalance condensed phase NVT simulation using engine: %s" % engname.upper(), color=4, bold=True)
#----
# Load the ForceBalance pickle file which contains:
#----
# - Force field object
# - Optimization parameters
# - Options from the Target object that launched this simulation
# - Switch for whether to evaluate analytic derivatives.
FF,mvals,TgtOptions,AGrad = lp_load('forcebalance.p')
FF.ffdir = '.'
# Write the force field file.
FF.make(mvals)
#----
# Load the options that are set in the ForceBalance input file.
#----
# Finite difference step size
h = TgtOptions['h']
pgrad = TgtOptions['pgrad']
# MD options; time step (fs), production steps, equilibration steps, interval for saving data (ps)
nvt_timestep = TgtOptions['nvt_timestep']
nvt_md_steps = TgtOptions['nvt_md_steps']
nvt_eq_steps = TgtOptions['nvt_eq_steps']
nvt_interval = TgtOptions['nvt_interval']
liquid_fnm = TgtOptions['nvt_coords']
# Number of threads, multiple timestep integrator, anisotropic box etc.
threads = TgtOptions.get('md_threads', 1)
mts = TgtOptions.get('mts_integrator', 0)
rpmd_beads = TgtOptions.get('rpmd_beads', 0)
force_cuda = TgtOptions.get('force_cuda', 0)
nbarostat = TgtOptions.get('n_mcbarostat', 25)
anisotropic = TgtOptions.get('anisotropic_box', 0)
minimize = TgtOptions.get('minimize_energy', 1)
# Print all options.
printcool_dictionary(TgtOptions, title="Options from ForceBalance")
nvt_snapshots = (nvt_timestep * nvt_md_steps / 1000) / nvt_interval
nvt_iframes = 1000 * nvt_interval / nvt_timestep
logger.info("For the condensed phase system, I will collect %i snapshots spaced apart by %i x %.3f fs time steps\n" \
% (nvt_snapshots, nvt_iframes, nvt_timestep))
if nvt_snapshots < 2:
raise Exception('Please set the number of liquid time steps so that you collect at least two snapshots (minimum %i)' \
% (2000 * (nvt_interval/nvt_timestep)))
#----
# Loading coordinates
#----
ML = Molecule(liquid_fnm, toppbc=True)
# Determine the number of molecules in the condensed phase coordinate file.
NMol = len(ML.molecules)
TgtOptions['n_molecules'] = NMol
logger.info("There are %i molecules in the liquid\n" % (NMol))
#----
# Setting up MD simulations
#----
EngOpts = OrderedDict()
EngOpts["liquid"] = OrderedDict([("coords", liquid_fnm), ("mol", ML), ("pbc", True)])
if "nonbonded_cutoff" in TgtOptions:
EngOpts["liquid"]["nonbonded_cutoff"] = TgtOptions["nonbonded_cutoff"]
else:
largest_available_cutoff = min(ML.boxes[0][:3]) / 2 - 0.1
EngOpts["liquid"]["nonbonded_cutoff"] = largest_available_cutoff
logger.info("nonbonded_cutoff is by default set to the largest available value: %g Angstrom" %largest_available_cutoff)
if "vdw_cutoff" in TgtOptions:
EngOpts["liquid"]["vdw_cutoff"] = TgtOptions["vdw_cutoff"]
# Hard Code nonbonded_cutoff to 13A for test
#EngOpts["liquid"]["nonbonded_cutoff"] = EngOpts["liquid"]["vdw_cutoff"] = 13.0
GenOpts = OrderedDict([('FF', FF)])
if engname == "openmm":
# OpenMM-specific options
EngOpts["liquid"]["platname"] = TgtOptions.get("platname", 'CUDA')
if force_cuda:
try: Platform.getPlatformByName('CUDA')
except: raise RuntimeError('Forcing failure because CUDA platform unavailable')
EngOpts["liquid"]["platname"] = 'CUDA'
if threads > 1: logger.warn("Setting the number of threads will have no effect on OpenMM engine.\n")
EngOpts["liquid"].update(GenOpts)
for i in EngOpts:
printcool_dictionary(EngOpts[i], "Engine options for %s" % i)
# Set up MD options
MDOpts = OrderedDict()
MDOpts["liquid"] = OrderedDict([("nsteps", nvt_md_steps), ("timestep", nvt_timestep),
("temperature", temperature),
("nequil", nvt_eq_steps), ("minimize", minimize),
("nsave", int(1000 * nvt_interval / nvt_timestep)),
("verbose", True),
('save_traj', TgtOptions['save_traj']),
("threads", threads),
("mts", mts), ("rpmd_beads", rpmd_beads), ("faststep", faststep)])
# Energy components analysis disabled for OpenMM MTS because it uses force groups
if (engname == "openmm" and mts): logger.warn("OpenMM with MTS integrator; energy components analysis will be disabled.\n")
# Create instances of the MD Engine objects.
Liquid = Engine(name="liquid", **EngOpts["liquid"])
#=================================================================#
# Run the simulation for the full system and analyze the results. #
#=================================================================#
printcool("Condensed phase NVT molecular dynamics", color=4, bold=True)
click()
prop_return = Liquid.molecular_dynamics(**MDOpts["liquid"])
logger.info("Liquid phase MD simulation took %.3f seconds\n" % click())
Potentials = prop_return['Potentials']
#============================================#
# Compute the potential energy derivatives. #
#============================================#
if AGrad:
logger.info("Calculating potential energy derivatives with finite difference step size: %f\n" % h)
# Switch for whether to compute the derivatives two different ways for consistency.
FDCheck = False
printcool("Condensed phase energy and dipole derivatives\nInitializing array to length %i" % len(Potentials), color=4, bold=True)
click()
G, GDx, GDy, GDz = energy_derivatives(Liquid, FF, mvals, h, pgrad, len(Potentials), AGrad, dipole=False)
logger.info("Condensed phase energy derivatives took %.3f seconds\n" % click())
#==============================================#
# Condensed phase properties and derivatives. #
#==============================================#
# Physical constants
kB = 0.008314472471220214
T = temperature
kT = kB * T # Unit: kJ/mol
#--- Surface Tension ----
logger.info("Start Computing surface tension.\n")
perturb_proportion = 0.0005
box_vectors = np.array(Liquid.xyz_omms[0][1]/nanometer) # obtain original box vectors from first frame
delta_S = np.sqrt(np.sum(np.cross(box_vectors[0], box_vectors[1])**2)) * perturb_proportion * 2 # unit: nm^2. *2 for 2 surfaces
# perturb xy area +
click()
scale_x = scale_y = np.sqrt(1 + perturb_proportion)
scale_z = 1.0 / (1+perturb_proportion) # keep the box volumn while changing the area of xy plane
Liquid.scale_box(scale_x, scale_y, scale_z)
logger.info("scale_box+ took %.3f seconds\n" %click())
# Obtain energies and gradients
Potentials_plus = Liquid.energy()
logger.info("Calculation of energies for perturbed box+ took %.3f seconds\n" %click())
if AGrad:
G_plus, _, _, _ = energy_derivatives(Liquid, FF, mvals, h, pgrad, len(Potentials), AGrad, dipole=False)
logger.info("Calculation of energy gradients for perturbed box+ took %.3f seconds\n" %click())
# perturb xy area - ( Note: also need to cancel the previous scaling)
scale_x = scale_y = np.sqrt(1 - perturb_proportion) * (1.0/scale_x)
scale_z = 1.0 / (1-perturb_proportion) * (1.0/scale_z)
Liquid.scale_box(scale_x, scale_y, scale_z)
logger.info("scale_box- took %.3f seconds\n" %click())
# Obtain energies and gradients
Potentials_minus = Liquid.energy()
logger.info("Calculation of energies for perturbed box- took %.3f seconds\n" %click())
if AGrad:
G_minus, _, _, _ = energy_derivatives(Liquid, FF, mvals, h, pgrad, len(Potentials), AGrad, dipole=False)
logger.info("Calculation of energy gradients for perturbed box- took %.3f seconds\n" %click())
# Compute surface tension
dE_plus = Potentials_plus - Potentials # Unit: kJ/mol
dE_minus = Potentials_minus - Potentials # Unit: kJ/mol
prefactor = -0.5 * kT / delta_S / 6.0221409e-1 # Unit mJ m^-2
# Following equation: γ = -kT/(2ΔS) * [ ln<exp(-ΔE+/kT)> - ln<exp(-ΔE-/kT)> ]
#plus_avg, plus_err = mean_stderr(np.exp(-dE_plus/kT))
#minus_avg, minus_err = mean_stderr(np.exp(-dE_minus/kT))
#surf_ten = -0.5 * kT / delta_S * ( np.log(plus_avg) - np.log(minus_avg) ) / 6.0221409e-1 # convert to mJ m^-2
#surf_ten_err = 0.5 * kT / delta_S * ( np.log(plus_avg+plus_err) - np.log(plus_avg-plus_err) + np.log(minus_avg+minus_err) - np.log(minus_avg-minus_err) ) / 6.0221409e-1
exp_dE_plus = np.exp(-dE_plus/kT)
exp_dE_minus = np.exp(-dE_minus/kT)
surf_ten = prefactor * ( np.log(np.mean(exp_dE_plus)) - np.log(np.mean(exp_dE_minus)) )
# Use bootstrap method to estimate the error
num_frames = len(exp_dE_plus)
numboots = 1000
surf_ten_boots = np.zeros(numboots)
for i in xrange(numboots):
boots_ordering = np.random.randint(num_frames, size=num_frames)
boots_exp_dE_plus = np.take(exp_dE_plus, boots_ordering)
boots_exp_dE_minus = np.take(exp_dE_minus, boots_ordering)
surf_ten_boots[i] = prefactor * ( np.log(np.mean(boots_exp_dE_plus)) - np.log(np.mean(boots_exp_dE_minus)) )
surf_ten_err = np.std(surf_ten_boots) * np.sqrt(np.mean([statisticalInefficiency(exp_dE_plus), statisticalInefficiency(exp_dE_minus)]))
printcool("Surface Tension: % .4f +- %.4f mJ m^-2" % (surf_ten, surf_ten_err))
# Analytic Gradient of surface tension
# Formula: β = 1/kT
# ∂γ/∂α = -kT/(2ΔS) * { 1/<exp(-βΔE+)> * [<-β ∂E+/∂α exp(-βΔE+)> - <-β ∂E/∂α><exp(-βΔE+)>]
# -1/<exp(-βΔE-)> * [<-β ∂E-/∂α exp(-βΔE-)> - <-β ∂E/∂α><exp(-βΔE-)>] }
n_params = len(mvals)
G_surf_ten = np.zeros(n_params)
if AGrad:
beta = 1.0 / kT
plus_denom = np.mean(np.exp(-beta*dE_plus))
minus_denom = np.mean(np.exp(-beta*dE_minus))
for param_i in xrange(n_params):
plus_left = np.mean(-beta * G_plus[param_i] * np.exp(-beta*dE_plus))
plus_right = np.mean(-beta * G[param_i]) * plus_denom
minus_left = np.mean(-beta * G_minus[param_i] * np.exp(-beta*dE_minus))
minus_right = np.mean(-beta * G[param_i]) * minus_denom
G_surf_ten[param_i] = prefactor * (1.0/plus_denom*(plus_left-plus_right) - 1.0/minus_denom*(minus_left-minus_right))
printcool("Analytic Derivatives:")
FF.print_map(vals=G_surf_ten)
logger.info("Writing final force field.\n")
pvals = FF.make(mvals)
logger.info("Writing all results to disk.\n")
result_dict = {'surf_ten': surf_ten, 'surf_ten_err': surf_ten_err, 'G_surf_ten': G_surf_ten}
lp_dump(result_dict, 'nvt_result.p')
def main():
printcool("Welcome to ForceBalance version 1.1! =D\nForce Field Optimization System\nAuthor: Lee-Ping Wang", ansi="1", bold=True, minwidth=64)
logostr = """
,'+++
,++++++. .:,,.
:+++++'` `; `,:::::.`
'+++++' `'++++ `,::::,,`
`;+++++: ,+++++'. `.:::::,`
`++++++, :+++++'` .,::::,`
.+++++'. ;+++++' `,,:::,`
:+++++'` `;+++++: `,::::,.`
++++;` `++++++: `.:+@@###@' `,,::::.`
: ,++++++. ,;'+###############. .,::,
:++++++` +################':` .
+++;` `.,,...####+.
,##### +##. +++ +++
,,,, ##### ###### +++ +++
,::, ###' ####' :#####' +++ +++
,::, :####@ ####. ,####' +++ +++
,::, ###### #### +###+ +++ +++
,::, ##### #### ###; +++ +++
,::, :## #### ++` +++ +++
,::, ####``..:;+##############+` +++ +++
,::, .,:;;'++##################################` +++ +++
,::, `############################++++''';;;;;;;;;;;''; +++ +++
,::, ,########':,.`` #### +++ +++
,::, #### +++ +++
,::, #### +++ +++
,::, #### +++ +++
,::, #### +++ +++
,::, #### +++ +++
,::, #### +++ +++
,,,, #### +++ +++
;++, ####
`'+++++: ####
` '+++++; #### `.,:.
++++, :+++++'` #### `,:::::.
.'+++++, :++++++. ### `,::::,.`
`'+++++; .++++++, +` .,::::,`
;+++++'` `++++++: .,:::,,`
:+++++'. `;+++++;` `.:::::,`
,++++++` '++++++ `,::::,,`
.'+++++: ,+; `,:::::.
`'+++++: ,::,,.
;++++. ,`
,`
"""
b = 'blue'
g = 'gold'
k = 'black'
colorlist = [[],[b],[b,g],[b,b,g],[b,b,g],[b,b,g],[b,b,g],[b,b,g],
[b,b,g],[b,b,k,g],[b,b,k,g],[b,k,g],[b,k],[k,k,b,b],
[g,k,k,b,b],[g,k,k,k,b,b],[g,k,k,k,b,b],[g,k,k,k,b,b],
[g,k,k,k,b,b],[g,k,k,k,b,b],[g,k,b,b],[g,k,b,b],[g,k,b,b],
[g,k,k,b,b],[g,k,b,b],[g,k,b,b],[g,k,b,b],[g,k,b,b],[g,k,b,b],
[g,k,b,b],[g,k,b,b],[b,k],[b,k],[b,b,k,g],[b,b,k,g],[b,b,k,g],
[b,b,k,g],[b,b,g],[b,b,g],[b,b,g],[b,b,g],[b,g],[b,g],[b],[]]
words = [l.split() for l in logostr.split('\n')]
for ln, line in enumerate(logostr.split('\n')):
# Reconstruct the line.
words = line.split()
whites = re.findall('[ ]+',line)
newline = ''
i = 0
if len(line) > 0 and line[0] == ' ':
while i < max(len(words), len(whites)):
try:
newline += whites[i]
except: pass
try:
newline += process(words[i], colorlist[ln][i])
except: pass
i += 1
elif len(line) > 0:
while i < max(len(words), len(whites)):
try:
newline += process(words[i], colorlist[ln][i])
except: pass
try:
newline += whites[i]
except: pass
i += 1
print newline
if len(sys.argv) != 2:
print "Please call this program with only one argument - the name of the input file."
sys.exit(1)
Run_ForceBalance(sys.argv[1])
def main():
"""
Usage: (runcuda.sh) npt.py <openmm|gromacs|tinker> <liquid_nsteps> <liquid_timestep (fs)> <liquid_intvl (ps> <temperature> <pressure>
This program is meant to be called automatically by ForceBalance on
a GPU cluster (specifically, subroutines in openmmio.py). It is
not easy to use manually. This is because the force field is read
in from a ForceBalance 'FF' class.
I wrote this program because automatic fitting of the density (or
other equilibrium properties) is computationally intensive, and the
calculations need to be distributed to the queue. The main instance
of ForceBalance (running on my workstation) queues up a bunch of these
jobs (using Work Queue). Then, I submit a bunch of workers to GPU
clusters (e.g. Certainty, Keeneland). The worker scripts connect to.
the main instance and receives one of these jobs.
This script can also be executed locally, if you want to (e.g. for
debugging). Just make sure you have the pickled 'forcebalance.p'
file.
"""
printcool("ForceBalance condensed phase simulation using engine: %s" % engname.upper(), color=4, bold=True)
#----
# Load the ForceBalance pickle file which contains:
#----
# - Force field object
# - Optimization parameters
# - Options from the Target object that launched this simulation
# - Switch for whether to evaluate analytic derivatives.
FF,mvals,TgtOptions,AGrad = lp_load(open('forcebalance.p'))
FF.ffdir = '.'
# Write the force field file.
FF.make(mvals)
#----
# Load the options that are set in the ForceBalance input file.
#----
# Finite difference step size
h = TgtOptions['h']
pgrad = TgtOptions['pgrad']
# MD options; time step (fs), production steps, equilibration steps, interval for saving data (ps)
liquid_timestep = TgtOptions['liquid_timestep']
liquid_nsteps = TgtOptions['liquid_md_steps']
liquid_nequil = TgtOptions['liquid_eq_steps']
liquid_intvl = TgtOptions['liquid_interval']
liquid_fnm = TgtOptions['liquid_coords']
gas_timestep = TgtOptions['gas_timestep']
gas_nsteps = TgtOptions['gas_md_steps']
gas_nequil = TgtOptions['gas_eq_steps']
gas_intvl = TgtOptions['gas_interval']
gas_fnm = TgtOptions['gas_coords']
# Number of threads, multiple timestep integrator, anisotropic box etc.
threads = TgtOptions.get('md_threads', 1)
mts = TgtOptions.get('mts_integrator', 0)
rpmd_beads = TgtOptions.get('rpmd_beads', 0)
force_cuda = TgtOptions.get('force_cuda', 0)
anisotropic = TgtOptions.get('anisotropic_box', 0)
minimize = TgtOptions.get('minimize_energy', 1)
# Print all options.
printcool_dictionary(TgtOptions, title="Options from ForceBalance")
liquid_snapshots = (liquid_nsteps * liquid_timestep / 1000) / liquid_intvl
liquid_iframes = 1000 * liquid_intvl / liquid_timestep
gas_snapshots = (gas_nsteps * gas_timestep / 1000) / gas_intvl
gas_iframes = 1000 * gas_intvl / gas_timestep
logger.info("For the condensed phase system, I will collect %i snapshots spaced apart by %i x %.3f fs time steps\n" \
% (liquid_snapshots, liquid_iframes, liquid_timestep))
if liquid_snapshots < 2:
raise Exception('Please set the number of liquid time steps so that you collect at least two snapshots (minimum %i)' \
% (2000 * (liquid_intvl/liquid_timestep)))
logger.info("For the gas phase system, I will collect %i snapshots spaced apart by %i x %.3f fs time steps\n" \
% (gas_snapshots, gas_iframes, gas_timestep))
if gas_snapshots < 2:
raise Exception('Please set the number of gas time steps so that you collect at least two snapshots (minimum %i)' \
% (2000 * (gas_intvl/gas_timestep)))
#----
# Loading coordinates
#----
ML = Molecule(liquid_fnm)
MG = Molecule(gas_fnm)
# Determine the number of molecules in the condensed phase coordinate file.
NMol = len(ML.molecules)
#----
# Setting up MD simulations
#----
EngOpts = OrderedDict()
EngOpts["liquid"] = OrderedDict([("coords", liquid_fnm), ("mol", ML), ("pbc", True)])
EngOpts["gas"] = OrderedDict([("coords", gas_fnm), ("mol", MG), ("pbc", False)])
GenOpts = OrderedDict([('FF', FF)])
if engname == "openmm":
# OpenMM-specific options
EngOpts["liquid"]["platname"] = 'CUDA'
EngOpts["gas"]["platname"] = 'Reference'
if force_cuda:
try: Platform.getPlatformByName('CUDA')
except: raise RuntimeError('Forcing failure because CUDA platform unavailable')
if threads > 1: logger.warn("Setting the number of threads will have no effect on OpenMM engine.\n")
elif engname == "gromacs":
# Gromacs-specific options
GenOpts["gmxpath"] = TgtOptions["gmxpath"]
GenOpts["gmxsuffix"] = TgtOptions["gmxsuffix"]
EngOpts["liquid"]["gmx_top"] = os.path.splitext(liquid_fnm)[0] + ".top"
EngOpts["liquid"]["gmx_mdp"] = os.path.splitext(liquid_fnm)[0] + ".mdp"
EngOpts["gas"]["gmx_top"] = os.path.splitext(gas_fnm)[0] + ".top"
EngOpts["gas"]["gmx_mdp"] = os.path.splitext(gas_fnm)[0] + ".mdp"
if force_cuda: logger.warn("force_cuda option has no effect on Gromacs engine.")
if rpmd_beads > 0: raise RuntimeError("Gromacs cannot handle RPMD.")
if mts: logger.warn("Gromacs not configured for multiple timestep integrator.")
if anisotropic: logger.warn("Gromacs not configured for anisotropic box scaling.")
elif engname == "tinker":
# Tinker-specific options
GenOpts["tinkerpath"] = TgtOptions["tinkerpath"]
EngOpts["liquid"]["tinker_key"] = os.path.splitext(liquid_fnm)[0] + ".key"
EngOpts["gas"]["tinker_key"] = os.path.splitext(gas_fnm)[0] + ".key"
if force_cuda: logger.warn("force_cuda option has no effect on Tinker engine.")
if rpmd_beads > 0: raise RuntimeError("TINKER cannot handle RPMD.")
if mts: logger.warn("Tinker not configured for multiple timestep integrator.")
EngOpts["liquid"].update(GenOpts)
EngOpts["gas"].update(GenOpts)
for i in EngOpts:
printcool_dictionary(EngOpts[i], "Engine options for %s" % i)
# Set up MD options
MDOpts = OrderedDict()
MDOpts["liquid"] = OrderedDict([("nsteps", liquid_nsteps), ("timestep", liquid_timestep),
("temperature", temperature), ("pressure", pressure),
("nequil", liquid_nequil), ("minimize", minimize),
("nsave", int(1000 * liquid_intvl / liquid_timestep)),
("verbose", True), ('save_traj', TgtOptions['save_traj']),
("threads", threads), ("anisotropic", anisotropic), ("nbarostat", 10),
("mts", mts), ("rpmd_beads", rpmd_beads), ("faststep", faststep)])
MDOpts["gas"] = OrderedDict([("nsteps", gas_nsteps), ("timestep", gas_timestep),
("temperature", temperature), ("nsave", int(1000 * gas_intvl / gas_timestep)),
("nequil", gas_nequil), ("minimize", minimize), ("threads", 1), ("mts", mts),
("rpmd_beads", rpmd_beads), ("faststep", faststep)])
# Energy components analysis disabled for OpenMM MTS because it uses force groups
if (engname == "openmm" and mts): logger.warn("OpenMM with MTS integrator; energy components analysis will be disabled.\n")
# Create instances of the MD Engine objects.
Liquid = Engine(name="liquid", **EngOpts["liquid"])
Gas = Engine(name="gas", **EngOpts["gas"])
#=================================================================#
# Run the simulation for the full system and analyze the results. #
#=================================================================#
printcool("Condensed phase molecular dynamics", color=4, bold=True)
# This line runs the condensed phase simulation.
prop_return = Liquid.molecular_dynamics(**MDOpts["liquid"])
Rhos = prop_return['Rhos']
Potentials = prop_return['Potentials']
Kinetics = prop_return['Kinetics']
Volumes = prop_return['Volumes']
Dips = prop_return['Dips']
EDA = prop_return['Ecomps']
# Create a bunch of physical constants.
# Energies are in kJ/mol
# Lengths are in nanometers.
L = len(Rhos)
kB = 0.008314472471220214
T = temperature
kT = kB * T
mBeta = -1.0 / kT
Beta = 1.0 / kT
atm_unit = 0.061019351687175
bar_unit = 0.060221417930000
# This is how I calculated the prefactor for the dielectric constant.
# eps0 = 8.854187817620e-12 * coulomb**2 / newton / meter**2
# epsunit = 1.0*(debye**2) / nanometer**3 / BOLTZMANN_CONSTANT_kB / kelvin
# prefactor = epsunit/eps0/3
prefactor = 30.348705333964077
# Gather some physical variables.
Energies = Potentials + Kinetics
Ene_avg, Ene_err = mean_stderr(Energies)
pV = atm_unit * pressure * Volumes
pV_avg, pV_err = mean_stderr(pV)
Rho_avg, Rho_err = mean_stderr(Rhos)
PrintEDA(EDA, NMol)
#==============================================#
# Now run the simulation for just the monomer. #
#==============================================#
# Run the OpenMM simulation, gather information.
printcool("Gas phase molecular dynamics", color=4, bold=True)
mprop_return = Gas.molecular_dynamics(**MDOpts["gas"])
mPotentials = mprop_return['Potentials']
mKinetics = mprop_return['Kinetics']
mEDA = mprop_return['Ecomps']
mEnergies = mPotentials + mKinetics
mEne_avg, mEne_err = mean_stderr(mEnergies)
PrintEDA(mEDA, 1)
#============================================#
# Compute the potential energy derivatives. #
#============================================#
logger.info("Calculating potential energy derivatives with finite difference step size: %f\n" % h)
# Switch for whether to compute the derivatives two different ways for consistency.
FDCheck = False
# Create a double-precision simulation object if desired (seems unnecessary).
DoublePrecisionDerivatives = False
if engname == "openmm" and DoublePrecisionDerivatives and AGrad:
logger.info("Creating Double Precision Simulation for parameter derivatives\n")
Liquid = Engine(name="liquid", openmm_precision="double", **EngOpts["liquid"])
Gas = Engine(name="gas", openmm_precision="double", **EngOpts["gas"])
# Compute the energy and dipole derivatives.
printcool("Condensed phase energy and dipole derivatives\nInitializing array to length %i" % len(Energies), color=4, bold=True)
G, GDx, GDy, GDz = energy_derivatives(Liquid, FF, mvals, h, pgrad, len(Energies), AGrad, dipole=True)
printcool("Gas phase energy derivatives", color=4, bold=True)
mG, _, __, ___ = energy_derivatives(Gas, FF, mvals, h, pgrad, len(mEnergies), AGrad, dipole=False)
#==============================================#
# Condensed phase properties and derivatives. #
#==============================================#
#----
# Density
#----
# Build the first density derivative.
GRho = mBeta * (flat(np.mat(G) * col(Rhos)) / L - np.mean(Rhos) * np.mean(G, axis=1))
# Print out the density and its derivative.
Sep = printcool("Density: % .4f +- % .4f kg/m^3\nAnalytic Derivative:" % (Rho_avg, Rho_err))
FF.print_map(vals=GRho)
logger.info(Sep)
def calc_rho(b = None, **kwargs):
if b == None: b = np.ones(L,dtype=float)
if 'r_' in kwargs:
r_ = kwargs['r_']
return bzavg(r_,b)
# No need to calculate error using bootstrap, but here it is anyway
# Rhoboot = []
# for i in range(numboots):
# boot = np.random.randint(N,size=N)
# Rhoboot.append(calc_rho(None,**{'r_':Rhos[boot]}))
# Rhoboot = np.array(Rhoboot)
# Rho_err = np.std(Rhoboot)
if FDCheck:
Sep = printcool("Numerical Derivative:")
GRho1 = property_derivatives(Liquid, FF, mvals, h, pgrad, kT, calc_rho, {'r_':Rhos})
FF.print_map(vals=GRho1)
Sep = printcool("Difference (Absolute, Fractional):")
absfrac = ["% .4e % .4e" % (i-j, (i-j)/j) for i,j in zip(GRho, GRho1)]
FF.print_map(vals=absfrac)
#----
# Enthalpy of vaporization
#----
H = Energies + pV
V = np.array(Volumes)
# Print out the liquid enthalpy.
logger.info("Liquid enthalpy: % .4f kJ/mol, stdev % .4f ; (% .4f from energy, % .4f from pV)\n" %
(np.mean(H), np.std(H), np.mean(Energies), np.mean(pV)))
numboots = 1000
# The enthalpy of vaporization in kJ/mol.
Hvap_avg = mEne_avg - Ene_avg / NMol + kT - np.mean(pV) / NMol
Hvap_err = np.sqrt(Ene_err**2 / NMol**2 + mEne_err**2 + pV_err**2/NMol**2)
# Build the first Hvap derivative.
GHvap = np.mean(G,axis=1)
GHvap += mBeta * (flat(np.mat(G) * col(Energies)) / L - Ene_avg * np.mean(G, axis=1))
GHvap /= NMol
GHvap -= np.mean(mG,axis=1)
GHvap -= mBeta * (flat(np.mat(mG) * col(mEnergies)) / L - mEne_avg * np.mean(mG, axis=1))
GHvap *= -1
GHvap -= mBeta * (flat(np.mat(G) * col(pV)) / L - np.mean(pV) * np.mean(G, axis=1)) / NMol
Sep = printcool("Enthalpy of Vaporization: % .4f +- %.4f kJ/mol\nAnalytic Derivative:" % (Hvap_avg, Hvap_err))
FF.print_map(vals=GHvap)
# Define some things to make the analytic derivatives easier.
Gbar = np.mean(G,axis=1)
def deprod(vec):
return flat(np.mat(G)*col(vec))/L
def covde(vec):
return flat(np.mat(G)*col(vec))/L - Gbar*np.mean(vec)
def avg(vec):
return np.mean(vec)
#----
# Thermal expansion coefficient
#----
def calc_alpha(b = None, **kwargs):
if b == None: b = np.ones(L,dtype=float)
if 'h_' in kwargs:
h_ = kwargs['h_']
if 'v_' in kwargs:
v_ = kwargs['v_']
return 1/(kT*T) * (bzavg(h_*v_,b)-bzavg(h_,b)*bzavg(v_,b))/bzavg(v_,b)
Alpha = calc_alpha(None, **{'h_':H, 'v_':V})
Alphaboot = []
for i in range(numboots):
boot = np.random.randint(L,size=L)
Alphaboot.append(calc_alpha(None, **{'h_':H[boot], 'v_':V[boot]}))
Alphaboot = np.array(Alphaboot)
Alpha_err = np.std(Alphaboot) * max([np.sqrt(statisticalInefficiency(V)),np.sqrt(statisticalInefficiency(H))])
# Thermal expansion coefficient analytic derivative
GAlpha1 = -1 * Beta * deprod(H*V) * avg(V) / avg(V)**2
GAlpha2 = +1 * Beta * avg(H*V) * deprod(V) / avg(V)**2
GAlpha3 = deprod(V)/avg(V) - Gbar
GAlpha4 = Beta * covde(H)
GAlpha = (GAlpha1 + GAlpha2 + GAlpha3 + GAlpha4)/(kT*T)
Sep = printcool("Thermal expansion coefficient: % .4e +- %.4e K^-1\nAnalytic Derivative:" % (Alpha, Alpha_err))
FF.print_map(vals=GAlpha)
if FDCheck:
GAlpha_fd = property_derivatives(Liquid, FF, mvals, h, pgrad, kT, calc_alpha, {'h_':H,'v_':V})
Sep = printcool("Numerical Derivative:")
FF.print_map(vals=GAlpha_fd)
Sep = printcool("Difference (Absolute, Fractional):")
absfrac = ["% .4e % .4e" % (i-j, (i-j)/j) for i,j in zip(GAlpha, GAlpha_fd)]
FF.print_map(vals=absfrac)
#----
# Isothermal compressibility
#----
def calc_kappa(b=None, **kwargs):
if b == None: b = np.ones(L,dtype=float)
if 'v_' in kwargs:
v_ = kwargs['v_']
return bar_unit / kT * (bzavg(v_**2,b)-bzavg(v_,b)**2)/bzavg(v_,b)
Kappa = calc_kappa(None,**{'v_':V})
Kappaboot = []
for i in range(numboots):
boot = np.random.randint(L,size=L)
Kappaboot.append(calc_kappa(None,**{'v_':V[boot]}))
Kappaboot = np.array(Kappaboot)
Kappa_err = np.std(Kappaboot) * np.sqrt(statisticalInefficiency(V))
# Isothermal compressibility analytic derivative
Sep = printcool("Isothermal compressibility: % .4e +- %.4e bar^-1\nAnalytic Derivative:" % (Kappa, Kappa_err))
GKappa1 = +1 * Beta**2 * avg(V**2) * deprod(V) / avg(V)**2
GKappa2 = -1 * Beta**2 * avg(V) * deprod(V**2) / avg(V)**2
GKappa3 = +1 * Beta**2 * covde(V)
GKappa = bar_unit*(GKappa1 + GKappa2 + GKappa3)
FF.print_map(vals=GKappa)
if FDCheck:
GKappa_fd = property_derivatives(Liquid, FF, mvals, h, pgrad, kT, calc_kappa, {'v_':V})
Sep = printcool("Numerical Derivative:")
FF.print_map(vals=GKappa_fd)
Sep = printcool("Difference (Absolute, Fractional):")
absfrac = ["% .4e % .4e" % (i-j, (i-j)/j) for i,j in zip(GKappa, GKappa_fd)]
FF.print_map(vals=absfrac)
#----
# Isobaric heat capacity
#----
def calc_cp(b=None, **kwargs):
if b == None: b = np.ones(L,dtype=float)
if 'h_' in kwargs:
h_ = kwargs['h_']
Cp_ = 1/(NMol*kT*T) * (bzavg(h_**2,b) - bzavg(h_,b)**2)
Cp_ *= 1000 / 4.184
return Cp_
Cp = calc_cp(None,**{'h_':H})
Cpboot = []
for i in range(numboots):
boot = np.random.randint(L,size=L)
Cpboot.append(calc_cp(None,**{'h_':H[boot]}))
Cpboot = np.array(Cpboot)
Cp_err = np.std(Cpboot) * np.sqrt(statisticalInefficiency(H))
# Isobaric heat capacity analytic derivative
GCp1 = 2*covde(H) * 1000 / 4.184 / (NMol*kT*T)
GCp2 = mBeta*covde(H**2) * 1000 / 4.184 / (NMol*kT*T)
GCp3 = 2*Beta*avg(H)*covde(H) * 1000 / 4.184 / (NMol*kT*T)
GCp = GCp1 + GCp2 + GCp3
Sep = printcool("Isobaric heat capacity: % .4e +- %.4e cal mol-1 K-1\nAnalytic Derivative:" % (Cp, Cp_err))
FF.print_map(vals=GCp)
if FDCheck:
GCp_fd = property_derivatives(Liquid, FF, mvals, h, pgrad, kT, calc_cp, {'h_':H})
Sep = printcool("Numerical Derivative:")
FF.print_map(vals=GCp_fd)
Sep = printcool("Difference (Absolute, Fractional):")
absfrac = ["% .4e % .4e" % (i-j, (i-j)/j) for i,j in zip(GCp,GCp_fd)]
FF.print_map(vals=absfrac)
#----
# Dielectric constant
#----
def calc_eps0(b=None, **kwargs):
if b == None: b = np.ones(L,dtype=float)
if 'd_' in kwargs: # Dipole moment vector.
d_ = kwargs['d_']
if 'v_' in kwargs: # Volume.
v_ = kwargs['v_']
b0 = np.ones(L,dtype=float)
dx = d_[:,0]
dy = d_[:,1]
dz = d_[:,2]
D2 = bzavg(dx**2,b)-bzavg(dx,b)**2
D2 += bzavg(dy**2,b)-bzavg(dy,b)**2
D2 += bzavg(dz**2,b)-bzavg(dz,b)**2
return prefactor*D2/bzavg(v_,b)/T
Eps0 = calc_eps0(None,**{'d_':Dips, 'v_':V})
Eps0boot = []
for i in range(numboots):
boot = np.random.randint(L,size=L)
Eps0boot.append(calc_eps0(None,**{'d_':Dips[boot], 'v_':V[boot]}))
Eps0boot = np.array(Eps0boot)
Eps0_err = np.std(Eps0boot)*np.sqrt(np.mean([statisticalInefficiency(Dips[:,0]),statisticalInefficiency(Dips[:,1]),statisticalInefficiency(Dips[:,2])]))
# Dielectric constant analytic derivative
Dx = Dips[:,0]
Dy = Dips[:,1]
Dz = Dips[:,2]
D2 = avg(Dx**2)+avg(Dy**2)+avg(Dz**2)-avg(Dx)**2-avg(Dy)**2-avg(Dz)**2
GD2 = 2*(flat(np.mat(GDx)*col(Dx))/L - avg(Dx)*(np.mean(GDx,axis=1))) - Beta*(covde(Dx**2) - 2*avg(Dx)*covde(Dx))
GD2 += 2*(flat(np.mat(GDy)*col(Dy))/L - avg(Dy)*(np.mean(GDy,axis=1))) - Beta*(covde(Dy**2) - 2*avg(Dy)*covde(Dy))
GD2 += 2*(flat(np.mat(GDz)*col(Dz))/L - avg(Dz)*(np.mean(GDz,axis=1))) - Beta*(covde(Dz**2) - 2*avg(Dz)*covde(Dz))
GEps0 = prefactor*(GD2/avg(V) - mBeta*covde(V)*D2/avg(V)**2)/T
Sep = printcool("Dielectric constant: % .4e +- %.4e\nAnalytic Derivative:" % (Eps0, Eps0_err))
FF.print_map(vals=GEps0)
if FDCheck:
GEps0_fd = property_derivatives(Liquid, FF, mvals, h, pgrad, kT, calc_eps0, {'d_':Dips,'v_':V})
Sep = printcool("Numerical Derivative:")
FF.print_map(vals=GEps0_fd)
Sep = printcool("Difference (Absolute, Fractional):")
absfrac = ["% .4e % .4e" % (i-j, (i-j)/j) for i,j in zip(GEps0,GEps0_fd)]
FF.print_map(vals=absfrac)
logger.info("Writing final force field.\n")
pvals = FF.make(mvals)
logger.info("Writing all simulation data to disk.\n")
with wopen(os.path.join('npt_result.p')) as f: lp_dump((Rhos, Volumes, Potentials, Energies, Dips, G, [GDx, GDy, GDz], mPotentials, mEnergies, mG, Rho_err, Hvap_err, Alpha_err, Kappa_err, Cp_err, Eps0_err, NMol),f)
import forcebalance
from forcebalance.PT import PeriodicTable
from forcebalance.nifty import isint, printcool
import getopt
opts, args = getopt.getopt(argv[1:], 'h')
AutoH = False
for o, a in opts:
argv.remove(o)
if o == "-h":
AutoH = True
Alphabet = list(map(chr, range(65, 91)))
printcool(" Welcome to Lee-Ping's Force Field Generator --- ")
print(" This script attempts to generate an OPLS force field ")
print(" from any Gaussian input file. Here's how it works. ")
print(" 1. Define your atom types. ")
print(" 2. Define corresponding OPLS atom types. ")
print(" If there is no corresponding OPLS type, then you ")
print(" must define your own.")
print(" 3. Select or input bonding parameters. ")
print(" If you selected OPLS atom types, then the program")
print(" will attempt to recommend parameters for you. ")
print(" 4. Finished: GRO and ITP files will be generated. ")
"""
gauss2gro-OPLS.py is an automatic force field maker, which builds a
force field from a molecular topology (in Gaussian .com format) and
fills in parameters automatically from OPLS-AA. This is probably the
most complicated script I've written next to ForceBalance. To avoid
def extract(self, engines, FF, mvals, h, pgrad, AGrad=True):
#==========================================#
# Physical constants and local variables. #
#==========================================#
# Energies in kJ/mol and lengths in nanometers.
kB = 0.008314472471220214
kT = kB*self.temperature
Beta = 1.0/kT
mBeta = -Beta
#======================================================#
# Get simulation properties depending on the engines. #
#======================================================#
if self.engname == "gromacs":
# Default name
deffnm = os.path.basename(os.path.splitext(engines[0].mdene)[0])
# What energy terms are there and what is their order
energyterms = engines[0].energy_termnames(edrfile="%s.%s" % (deffnm, "edr"))
# Grab energy terms to print and keep track of energy term order.
ekeep = ['Total-Energy', 'Potential', 'Kinetic-En.', 'Temperature']
ekeep += ['Volume', 'Density']
ekeep_order = [key for (key, value) in
sorted(energyterms.items(), key=lambda (k, v) : v)
if key in ekeep]
# Perform energy component analysis and return properties.
engines[0].callgmx(("g_energy " +
"-f %s.%s " % (deffnm, "edr") +
"-o %s-energy.xvg " % deffnm +
"-xvg no"),
stdin="\n".join(ekeep))
# Read data and store properties by grabbing columns in right order.
data = np.loadtxt("%s-energy.xvg" % deffnm)
Energy = data[:, ekeep_order.index("Total-Energy") + 1]
Potential = data[:, ekeep_order.index("Potential") + 1]
Kinetic = data[:, ekeep_order.index("Kinetic-En.") + 1]
Volume = data[:, ekeep_order.index("Volume") + 1]
Temperature = data[:, ekeep_order.index("Temperature") + 1]
Density = data[:, ekeep_order.index("Density") + 1]
#============================================#
# Compute the potential energy derivatives. #
#============================================#
logger.info(("Calculating potential energy derivatives " +
"with finite difference step size: %f\n" % h))
printcool("Initializing array to length %i" % len(Energy),
color=4, bold=True)
G = energy_derivatives(engines[0], FF, mvals, h, pgrad, len(Energy), AGrad)
#=======================================#
# Quantity properties and derivatives. #
#=======================================#
# Average and error.
Rho_avg, Rho_err = mean_stderr(Density)
# Analytic first derivative.
Rho_grad = mBeta * (flat(np.mat(G) * col(Density)) / len(Density) \
- np.mean(Density) * np.mean(G, axis=1))
return Rho_avg, Rho_err, Rho_grad
def main():
"""Usage:
(prefix.sh) md_one.py -T, --temperature <temperature in kelvin>
-P, --pressure <pressure in atm>
-g, --grad (if gradients of output timeseries are desired)
-eq, --nequil <number of equilibration MD steps>
-md, --nsteps <number of production MD steps>
-dt, --timestep <number of production MD steps>
-sp, --sample <number of production MD steps>
-nt, --threads <number of CPU threads to use>
-min, --minimize <minimize the energy>
This program is meant to be called automatically by ForceBalance because
force field options are loaded from the 'forcefield.p' file, and
simulation options are loaded from the 'simulation.p' file.
The files are separated because the same force field file
may be used for many simulations.
"""
# Write the force field file.
FF.make(mvals)
# Read the command line options (they may override the options from file.)
AGrad = args['gradient']
for i in ['temperature', 'pressure', 'nequil', 'nsteps', 'timestep', 'sample', 'threads', 'minimize']:
if i in args:
MDOpts[i] = args[i]
MDOpts['nsave'] = int(1000.0*MDOpts['sample']/MDOpts['timestep'])
if 'save_traj' in TgtOpts:
MDOpts['save_traj'] = TgtOpts['save_traj']
#----
# Print some options.
# At this point, engine and MD options should be SET!
#----
printcool("ForceBalance simulation using engine: %s" % engname.upper(),
color=4, bold=True)
printcool_dictionary(args, title="Options from command line")
printcool_dictionary(EngOpts, title="Engine options")
printcool_dictionary(MDOpts, title="Molecular dynamics options")
#----
# For convenience, assign some local variables.
#----
# Finite difference step size
h = TgtOpts['h']
# Active parameters to differentiate
pgrad = TgtOpts['pgrad']
# Create instances of the MD Engine objects.
Engine = EngineClass(**EngOpts)
click() # Start timer.
# This line runs the condensed phase simulation.
#----
# The molecular dynamics simulation returns a dictionary of properties
# In the future, the properties will be stored as data inside the object
Results = Engine.molecular_dynamics(**MDOpts)
if AGrad:
Results['Potential_Derivatives'] = energy_derivatives(Engine, FF, mvals, h, pgrad, dipole=False)['potential']
# Set up engine and calculate the potential in the other phase.
EngOpts_ = deepcopy(EngOpts)
EngOpts_['implicit_solvent'] = not EngOpts['implicit_solvent']
Engine_ = EngineClass(**EngOpts_)
Engine_.xyz_omms = Engine.xyz_omms
Energy_ = Engine_.energy()
Results_ = {'Potentials' : Energy_}
if AGrad:
Derivs_ = energy_derivatives(Engine_, FF, mvals, h, pgrad, dipole=False)['potential']
Results_['Potential_Derivatives'] = Derivs_
# Calculate the hydration energy of each snapshot and its parametric derivatives.
if EngOpts['implicit_solvent']:
Energy_liq = Results['Potentials']
Energy_gas = Results_['Potentials']
if AGrad:
Derivs_liq = Results['Potential_Derivatives']
Derivs_gas = Results_['Potential_Derivatives']
else:
Energy_gas = Results['Potentials']
Energy_liq = Results_['Potentials']
if AGrad:
Derivs_gas = Results['Potential_Derivatives']
Derivs_liq = Results_['Potential_Derivatives']
Results['Hydration'] = Energy_liq - Energy_gas
if AGrad:
Results['Hydration_Derivatives'] = Derivs_liq - Derivs_gas
# Code of the future!
# Don't know how to use it yet though.
# Engine.molecular_dynamics(**MDOpts)
# logger.info("MD simulation took %.3f seconds\n" % click())
# # Extract properties.
# Results = Engine.md_extract(OrderedDict([(i, {}) for i in Tgt.timeseries.keys()]))
# potential = properties['Potential']
# Calculate energy and dipole derivatives if needed.
# if AGrad:
# Results['derivatives'] = energy_derivatives(Engine, FF, mvals, h, pgrad, dipole='dipole' in Tgt.timeseries.keys())
# Dump results to file
logger.info("Writing final force field.\n")
pvals = FF.make(mvals)
logger.info("Writing all simulation data to disk.\n")
lp_dump(Results, 'md_result.p')
def main():
"""
Usage: (runcuda.sh) npt.py <openmm|gromacs|tinker|amber> <liquid_nsteps> <liquid_timestep (fs)> <liquid_intvl (ps> <temperature> <pressure>
This program is meant to be called automatically by ForceBalance on
a GPU cluster (specifically, subroutines in openmmio.py). It is
not easy to use manually. This is because the force field is read
in from a ForceBalance 'FF' class.
I wrote this program because automatic fitting of the density (or
other equilibrium properties) is computationally intensive, and the
calculations need to be distributed to the queue. The main instance
of ForceBalance (running on my workstation) queues up a bunch of these
jobs (using Work Queue). Then, I submit a bunch of workers to GPU
clusters (e.g. Certainty, Keeneland). The worker scripts connect to.
the main instance and receives one of these jobs.
This script can also be executed locally, if you want to (e.g. for
debugging). Just make sure you have the pickled 'forcebalance.p'
file.
"""
printcool("ForceBalance condensed phase simulation using engine: %s" % engname.upper(), color=4, bold=True)
#----
# Load the ForceBalance pickle file which contains:
#----
# - Force field object
# - Optimization parameters
# - Options from the Target object that launched this simulation
# - Switch for whether to evaluate analytic derivatives.
FF,mvals,TgtOptions,AGrad = lp_load('forcebalance.p')
FF.ffdir = '.'
# Write the force field file.
FF.make(mvals)
#----
# Load the options that are set in the ForceBalance input file.
#----
# Finite difference step size
h = TgtOptions['h']
pgrad = TgtOptions['pgrad']
# MD options; time step (fs), production steps, equilibration steps, interval for saving data (ps)
liquid_timestep = TgtOptions['liquid_timestep']
liquid_nsteps = TgtOptions['liquid_md_steps']
liquid_nequil = TgtOptions['liquid_eq_steps']
liquid_intvl = TgtOptions['liquid_interval']
liquid_fnm = TgtOptions['liquid_coords']
gas_timestep = TgtOptions['gas_timestep']
gas_nsteps = TgtOptions['gas_md_steps']
gas_nequil = TgtOptions['gas_eq_steps']
gas_intvl = TgtOptions['gas_interval']
gas_fnm = TgtOptions['gas_coords']
# Number of threads, multiple timestep integrator, anisotropic box etc.
threads = TgtOptions.get('md_threads', 1)
mts = TgtOptions.get('mts_integrator', 0)
rpmd_beads = TgtOptions.get('rpmd_beads', 0)
force_cuda = TgtOptions.get('force_cuda', 0)
nbarostat = TgtOptions.get('n_mcbarostat', 25)
anisotropic = TgtOptions.get('anisotropic_box', 0)
minimize = TgtOptions.get('minimize_energy', 1)
# Print all options.
printcool_dictionary(TgtOptions, title="Options from ForceBalance")
liquid_snapshots = int((liquid_nsteps * liquid_timestep / 1000) / liquid_intvl)
liquid_iframes = int(1000 * liquid_intvl / liquid_timestep)
gas_snapshots = int((gas_nsteps * gas_timestep / 1000) / gas_intvl)
gas_iframes = int(1000 * gas_intvl / gas_timestep)
logger.info("For the condensed phase system, I will collect %i snapshots spaced apart by %i x %.3f fs time steps\n" \
% (liquid_snapshots, liquid_iframes, liquid_timestep))
if liquid_snapshots < 2:
raise Exception('Please set the number of liquid time steps so that you collect at least two snapshots (minimum %i)' \
% (2000 * int(liquid_intvl/liquid_timestep)))
logger.info("For the gas phase system, I will collect %i snapshots spaced apart by %i x %.3f fs time steps\n" \
% (gas_snapshots, gas_iframes, gas_timestep))
if gas_snapshots < 2:
raise Exception('Please set the number of gas time steps so that you collect at least two snapshots (minimum %i)' \
% (2000 * int(gas_intvl/gas_timestep)))
#----
# Loading coordinates
#----
ML = Molecule(liquid_fnm, toppbc=True)
MG = Molecule(gas_fnm)
# Determine the number of molecules in the condensed phase coordinate file.
NMol = TgtOptions['n_molecules']
logger.info("There are %i molecules in the liquid\n" % (NMol))
#----
# Setting up MD simulations
#----
EngOpts = OrderedDict()
EngOpts["liquid"] = OrderedDict([("coords", liquid_fnm), ("mol", ML), ("pbc", True)])
if "nonbonded_cutoff" in TgtOptions:
EngOpts["liquid"]["nonbonded_cutoff"] = TgtOptions["nonbonded_cutoff"]
if "vdw_cutoff" in TgtOptions:
EngOpts["liquid"]["vdw_cutoff"] = TgtOptions["vdw_cutoff"]
EngOpts["gas"] = OrderedDict([("coords", gas_fnm), ("mol", MG), ("pbc", False)])
GenOpts = OrderedDict([('FF', FF)])
if engname in ["openmm", "smirnoff"]:
# OpenMM-specific options
EngOpts["liquid"]["platname"] = TgtOptions.get("platname", 'CUDA')
# For now, always run gas phase calculations on the reference platform
EngOpts["gas"]["platname"] = 'Reference'
if force_cuda:
try: Platform.getPlatformByName('CUDA')
except: raise RuntimeError('Forcing failure because CUDA platform unavailable')
EngOpts["liquid"]["platname"] = 'CUDA'
if threads > 1: logger.warn("Setting the number of threads will have no effect on OpenMM engine.\n")
if engname == "smirnoff":
if not TgtOptions['liquid_coords'].endswith('.pdb'):
logger.error("With SMIRNOFF engine, please pass a .pdb file to liquid_coords.")
raise RuntimeError
EngOpts["liquid"]["pdb"] = TgtOptions['liquid_coords']
EngOpts["liquid"]["mol2"] = TgtOptions["mol2"]
if not TgtOptions['gas_coords'].endswith('.pdb'):
logger.error("With SMIRNOFF engine, please pass a .pdb file to gas_coords.")
raise RuntimeError
EngOpts["gas"]["pdb"] = TgtOptions['gas_coords']
EngOpts["gas"]["mol2"] = TgtOptions["mol2"]
elif engname == "gromacs":
# Gromacs-specific options
GenOpts["gmxpath"] = TgtOptions["gmxpath"]
GenOpts["gmxsuffix"] = TgtOptions["gmxsuffix"]
EngOpts["liquid"]["gmx_top"] = os.path.splitext(liquid_fnm)[0] + ".top"
EngOpts["liquid"]["gmx_mdp"] = os.path.splitext(liquid_fnm)[0] + ".mdp"
EngOpts["liquid"]["gmx_eq_barostat"] = TgtOptions["gmx_eq_barostat"]
EngOpts["gas"]["gmx_top"] = os.path.splitext(gas_fnm)[0] + ".top"
EngOpts["gas"]["gmx_mdp"] = os.path.splitext(gas_fnm)[0] + ".mdp"
if force_cuda: logger.warn("force_cuda option has no effect on Gromacs engine.")
if rpmd_beads > 0: raise RuntimeError("Gromacs cannot handle RPMD.")
if mts: logger.warn("Gromacs not configured for multiple timestep integrator.")
if anisotropic: logger.warn("Gromacs not configured for anisotropic box scaling.")
elif engname == "tinker":
# Tinker-specific options
GenOpts["tinkerpath"] = TgtOptions["tinkerpath"]
EngOpts["liquid"]["tinker_key"] = os.path.splitext(liquid_fnm)[0] + ".key"
EngOpts["gas"]["tinker_key"] = os.path.splitext(gas_fnm)[0] + ".key"
if force_cuda: logger.warn("force_cuda option has no effect on Tinker engine.")
if rpmd_beads > 0: raise RuntimeError("TINKER cannot handle RPMD.")
if mts: logger.warn("Tinker not configured for multiple timestep integrator.")
elif engname == "amber":
# AMBER-specific options
GenOpts["amberhome"] = TgtOptions["amberhome"]
if os.path.exists(os.path.splitext(liquid_fnm)[0] + ".mdin"):
EngOpts["liquid"]["mdin"] = os.path.splitext(liquid_fnm)[0] + ".mdin"
if os.path.exists(os.path.splitext(gas_fnm)[0] + ".mdin"):
EngOpts["gas"]["mdin"] = os.path.splitext(gas_fnm)[0] + ".mdin"
EngOpts["liquid"]["leapcmd"] = os.path.splitext(liquid_fnm)[0] + ".leap"
EngOpts["gas"]["leapcmd"] = os.path.splitext(gas_fnm)[0] + ".leap"
EngOpts["liquid"]["pdb"] = liquid_fnm
EngOpts["gas"]["pdb"] = gas_fnm
if force_cuda: logger.warn("force_cuda option has no effect on Amber engine.")
if rpmd_beads > 0: raise RuntimeError("AMBER cannot handle RPMD.")
if mts: logger.warn("Amber not configured for multiple timestep integrator.")
EngOpts["liquid"].update(GenOpts)
EngOpts["gas"].update(GenOpts)
for i in EngOpts:
printcool_dictionary(EngOpts[i], "Engine options for %s" % i)
# Set up MD options
MDOpts = OrderedDict()
MDOpts["liquid"] = OrderedDict([("nsteps", liquid_nsteps), ("timestep", liquid_timestep),
("temperature", temperature), ("pressure", pressure),
("nequil", liquid_nequil), ("minimize", minimize),
("nsave", int(1000 * liquid_intvl / liquid_timestep)),
("verbose", True), ('save_traj', TgtOptions['save_traj']),
("threads", threads), ("anisotropic", anisotropic), ("nbarostat", nbarostat),
("mts", mts), ("rpmd_beads", rpmd_beads), ("faststep", faststep)])
MDOpts["gas"] = OrderedDict([("nsteps", gas_nsteps), ("timestep", gas_timestep),
("temperature", temperature), ("nsave", int(1000 * gas_intvl / gas_timestep)),
("nequil", gas_nequil), ("minimize", minimize), ("threads", 1), ("mts", mts),
("rpmd_beads", rpmd_beads), ("faststep", faststep)])
# Energy components analysis disabled for OpenMM MTS because it uses force groups
if (engname == "openmm" and mts): logger.warn("OpenMM with MTS integrator; energy components analysis will be disabled.\n")
# Create instances of the MD Engine objects.
Liquid = Engine(name="liquid", **EngOpts["liquid"])
Gas = Engine(name="gas", **EngOpts["gas"])
#=================================================================#
# Run the simulation for the full system and analyze the results. #
#=================================================================#
printcool("Condensed phase molecular dynamics", color=4, bold=True)
# This line runs the condensed phase simulation.
click()
prop_return = Liquid.molecular_dynamics(**MDOpts["liquid"])
if hasattr(Liquid, 'freeze_atoms'):
logger.info("Warning: freeze_atoms may result in incorrect system mass and incorrect density calculation\n")
logger.info("Liquid phase MD simulation took %.3f seconds\n" % click())
Rhos = prop_return['Rhos']
Potentials = prop_return['Potentials']
Kinetics = prop_return['Kinetics']
Volumes = prop_return['Volumes']
Dips = prop_return['Dips']
EDA = prop_return['Ecomps']
# Create a bunch of physical constants.
# Energies are in kJ/mol
# Lengths are in nanometers.
L = len(Rhos)
kB = 0.008314472471220214
T = temperature
kT = kB * T
mBeta = -1.0 / kT
Beta = 1.0 / kT
atm_unit = 0.061019351687175
bar_unit = 0.060221417930000
# This is how I calculated the prefactor for the dielectric constant.
# eps0 = 8.854187817620e-12 * coulomb**2 / newton / meter**2
# epsunit = 1.0*(debye**2) / nanometer**3 / BOLTZMANN_CONSTANT_kB / kelvin
# prefactor = epsunit/eps0/3
prefactor = 30.348705333964077
# Gather some physical variables.
Energies = Potentials + Kinetics
Ene_avg, Ene_err = mean_stderr(Energies)
pV = atm_unit * pressure * Volumes
pV_avg, pV_err = mean_stderr(pV)
Rho_avg, Rho_err = mean_stderr(Rhos)
PrintEDA(EDA, NMol)
#==============================================#
# Now run the simulation for just the monomer. #
#==============================================#
# Run the OpenMM simulation, gather information.
printcool("Gas phase molecular dynamics", color=4, bold=True)
click()
mprop_return = Gas.molecular_dynamics(**MDOpts["gas"])
logger.info("Gas phase MD simulation took %.3f seconds\n" % click())
mPotentials = mprop_return['Potentials']
mKinetics = mprop_return['Kinetics']
mEDA = mprop_return['Ecomps']
mEnergies = mPotentials + mKinetics
mEne_avg, mEne_err = mean_stderr(mEnergies)
PrintEDA(mEDA, 1)
#============================================#
# Compute the potential energy derivatives. #
#============================================#
logger.info("Calculating potential energy derivatives with finite difference step size: %f\n" % h)
# Switch for whether to compute the derivatives two different ways for consistency.
FDCheck = False
# Create a double-precision simulation object if desired (seems unnecessary).
DoublePrecisionDerivatives = False
if engname == "openmm" and DoublePrecisionDerivatives and AGrad:
logger.info("Creating Double Precision Simulation for parameter derivatives\n")
Liquid = Engine(name="liquid", openmm_precision="double", **EngOpts["liquid"])
Gas = Engine(name="gas", openmm_precision="double", **EngOpts["gas"])
# Compute the energy and dipole derivatives.
printcool("Condensed phase energy and dipole derivatives\nInitializing array to length %i" % len(Energies), color=4, bold=True)
click()
G, GDx, GDy, GDz = energy_derivatives(Liquid, FF, mvals, h, pgrad, len(Energies), AGrad, dipole=True)
logger.info("Condensed phase energy derivatives took %.3f seconds\n" % click())
click()
printcool("Gas phase energy derivatives", color=4, bold=True)
mG, _, __, ___ = energy_derivatives(Gas, FF, mvals, h, pgrad, len(mEnergies), AGrad, dipole=False)
logger.info("Gas phase energy derivatives took %.3f seconds\n" % click())
#==============================================#
# Condensed phase properties and derivatives. #
#==============================================#
#----
# Density
#----
# Build the first density derivative.
GRho = mBeta * (flat(np.dot(G, col(Rhos))) / L - np.mean(Rhos) * np.mean(G, axis=1))
# Print out the density and its derivative.
Sep = printcool("Density: % .4f +- % .4f kg/m^3\nAnalytic Derivative:" % (Rho_avg, Rho_err))
FF.print_map(vals=GRho)
logger.info(Sep)
def calc_rho(b = None, **kwargs):
if b is None: b = np.ones(L,dtype=float)
if 'r_' in kwargs:
r_ = kwargs['r_']
return bzavg(r_,b)
# No need to calculate error using bootstrap, but here it is anyway
# Rhoboot = []
# for i in range(numboots):
# boot = np.random.randint(N,size=N)
# Rhoboot.append(calc_rho(None,**{'r_':Rhos[boot]}))
# Rhoboot = np.array(Rhoboot)
# Rho_err = np.std(Rhoboot)
if FDCheck:
Sep = printcool("Numerical Derivative:")
GRho1 = property_derivatives(Liquid, FF, mvals, h, pgrad, kT, calc_rho, {'r_':Rhos})
FF.print_map(vals=GRho1)
Sep = printcool("Difference (Absolute, Fractional):")
absfrac = ["% .4e % .4e" % (i-j, (i-j)/j) for i,j in zip(GRho, GRho1)]
FF.print_map(vals=absfrac)
#----
# Enthalpy of vaporization
#----
H = Energies + pV
V = np.array(Volumes)
# Print out the liquid enthalpy.
logger.info("Liquid enthalpy: % .4f kJ/mol, stdev % .4f ; (% .4f from energy, % .4f from pV)\n" %
(np.mean(H), np.std(H), np.mean(Energies), np.mean(pV)))
numboots = 1000
# The enthalpy of vaporization in kJ/mol.
Hvap_avg = mEne_avg - Ene_avg / NMol + kT - np.mean(pV) / NMol
Hvap_err = np.sqrt(Ene_err**2 / NMol**2 + mEne_err**2 + pV_err**2/NMol**2)
# Build the first Hvap derivative.
GHvap = np.mean(G,axis=1)
GHvap += mBeta * (flat(np.dot(G, col(Energies))) / L - Ene_avg * np.mean(G, axis=1))
GHvap /= NMol
GHvap -= np.mean(mG,axis=1)
GHvap -= mBeta * (flat(np.dot(mG, col(mEnergies))) / L - mEne_avg * np.mean(mG, axis=1))
GHvap *= -1
GHvap -= mBeta * (flat(np.dot(G, col(pV))) / L - np.mean(pV) * np.mean(G, axis=1)) / NMol
Sep = printcool("Enthalpy of Vaporization: % .4f +- %.4f kJ/mol\nAnalytic Derivative:" % (Hvap_avg, Hvap_err))
FF.print_map(vals=GHvap)
# Define some things to make the analytic derivatives easier.
Gbar = np.mean(G,axis=1)
def deprod(vec):
return flat(np.dot(G,col(vec)))/L
def covde(vec):
return flat(np.dot(G,col(vec)))/L - Gbar*np.mean(vec)
def avg(vec):
return np.mean(vec)
#----
# Thermal expansion coefficient
#----
def calc_alpha(b = None, **kwargs):
if b is None: b = np.ones(L,dtype=float)
if 'h_' in kwargs:
h_ = kwargs['h_']
if 'v_' in kwargs:
v_ = kwargs['v_']
return 1/(kT*T) * (bzavg(h_*v_,b)-bzavg(h_,b)*bzavg(v_,b))/bzavg(v_,b)
Alpha = calc_alpha(None, **{'h_':H, 'v_':V})
Alphaboot = []
for i in range(numboots):
boot = np.random.randint(L,size=L)
Alphaboot.append(calc_alpha(None, **{'h_':H[boot], 'v_':V[boot]}))
Alphaboot = np.array(Alphaboot)
Alpha_err = np.std(Alphaboot) * max([np.sqrt(statisticalInefficiency(V)),np.sqrt(statisticalInefficiency(H))])
# Thermal expansion coefficient analytic derivative
GAlpha1 = -1 * Beta * deprod(H*V) * avg(V) / avg(V)**2
GAlpha2 = +1 * Beta * avg(H*V) * deprod(V) / avg(V)**2
GAlpha3 = deprod(V)/avg(V) - Gbar
GAlpha4 = Beta * covde(H)
GAlpha = (GAlpha1 + GAlpha2 + GAlpha3 + GAlpha4)/(kT*T)
Sep = printcool("Thermal expansion coefficient: % .4e +- %.4e K^-1\nAnalytic Derivative:" % (Alpha, Alpha_err))
FF.print_map(vals=GAlpha)
if FDCheck:
GAlpha_fd = property_derivatives(Liquid, FF, mvals, h, pgrad, kT, calc_alpha, {'h_':H,'v_':V})
Sep = printcool("Numerical Derivative:")
FF.print_map(vals=GAlpha_fd)
Sep = printcool("Difference (Absolute, Fractional):")
absfrac = ["% .4e % .4e" % (i-j, (i-j)/j) for i,j in zip(GAlpha, GAlpha_fd)]
FF.print_map(vals=absfrac)
#----
# Isothermal compressibility
#----
def calc_kappa(b=None, **kwargs):
if b is None: b = np.ones(L,dtype=float)
if 'v_' in kwargs:
v_ = kwargs['v_']
return bar_unit / kT * (bzavg(v_**2,b)-bzavg(v_,b)**2)/bzavg(v_,b)
Kappa = calc_kappa(None,**{'v_':V})
Kappaboot = []
for i in range(numboots):
boot = np.random.randint(L,size=L)
Kappaboot.append(calc_kappa(None,**{'v_':V[boot]}))
Kappaboot = np.array(Kappaboot)
Kappa_err = np.std(Kappaboot) * np.sqrt(statisticalInefficiency(V))
# Isothermal compressibility analytic derivative
Sep = printcool("Isothermal compressibility: % .4e +- %.4e bar^-1\nAnalytic Derivative:" % (Kappa, Kappa_err))
GKappa1 = +1 * Beta**2 * avg(V**2) * deprod(V) / avg(V)**2
GKappa2 = -1 * Beta**2 * avg(V) * deprod(V**2) / avg(V)**2
GKappa3 = +1 * Beta**2 * covde(V)
GKappa = bar_unit*(GKappa1 + GKappa2 + GKappa3)
FF.print_map(vals=GKappa)
if FDCheck:
GKappa_fd = property_derivatives(Liquid, FF, mvals, h, pgrad, kT, calc_kappa, {'v_':V})
Sep = printcool("Numerical Derivative:")
FF.print_map(vals=GKappa_fd)
Sep = printcool("Difference (Absolute, Fractional):")
absfrac = ["% .4e % .4e" % (i-j, (i-j)/j) for i,j in zip(GKappa, GKappa_fd)]
FF.print_map(vals=absfrac)
#----
# Isobaric heat capacity
#----
def calc_cp(b=None, **kwargs):
if b is None: b = np.ones(L,dtype=float)
if 'h_' in kwargs:
h_ = kwargs['h_']
Cp_ = 1/(NMol*kT*T) * (bzavg(h_**2,b) - bzavg(h_,b)**2)
Cp_ *= 1000 / 4.184
return Cp_
Cp = calc_cp(None,**{'h_':H})
Cpboot = []
for i in range(numboots):
boot = np.random.randint(L,size=L)
Cpboot.append(calc_cp(None,**{'h_':H[boot]}))
Cpboot = np.array(Cpboot)
Cp_err = np.std(Cpboot) * np.sqrt(statisticalInefficiency(H))
# Isobaric heat capacity analytic derivative
GCp1 = 2*covde(H) * 1000 / 4.184 / (NMol*kT*T)
GCp2 = mBeta*covde(H**2) * 1000 / 4.184 / (NMol*kT*T)
GCp3 = 2*Beta*avg(H)*covde(H) * 1000 / 4.184 / (NMol*kT*T)
GCp = GCp1 + GCp2 + GCp3
Sep = printcool("Isobaric heat capacity: % .4e +- %.4e cal mol-1 K-1\nAnalytic Derivative:" % (Cp, Cp_err))
FF.print_map(vals=GCp)
if FDCheck:
GCp_fd = property_derivatives(Liquid, FF, mvals, h, pgrad, kT, calc_cp, {'h_':H})
Sep = printcool("Numerical Derivative:")
FF.print_map(vals=GCp_fd)
Sep = printcool("Difference (Absolute, Fractional):")
absfrac = ["% .4e % .4e" % (i-j, (i-j)/j) for i,j in zip(GCp,GCp_fd)]
FF.print_map(vals=absfrac)
#----
# Dielectric constant
#----
def calc_eps0(b=None, **kwargs):
if b is None: b = np.ones(L,dtype=float)
if 'd_' in kwargs: # Dipole moment vector.
d_ = kwargs['d_']
if 'v_' in kwargs: # Volume.
v_ = kwargs['v_']
b0 = np.ones(L,dtype=float)
dx = d_[:,0]
dy = d_[:,1]
dz = d_[:,2]
D2 = bzavg(dx**2,b)-bzavg(dx,b)**2
D2 += bzavg(dy**2,b)-bzavg(dy,b)**2
D2 += bzavg(dz**2,b)-bzavg(dz,b)**2
return prefactor*D2/bzavg(v_,b)/T
Eps0 = calc_eps0(None,**{'d_':Dips, 'v_':V})
Eps0boot = []
for i in range(numboots):
boot = np.random.randint(L,size=L)
Eps0boot.append(calc_eps0(None,**{'d_':Dips[boot], 'v_':V[boot]}))
Eps0boot = np.array(Eps0boot)
Eps0_err = np.std(Eps0boot)*np.sqrt(np.mean([statisticalInefficiency(Dips[:,0]),statisticalInefficiency(Dips[:,1]),statisticalInefficiency(Dips[:,2])]))
# Dielectric constant analytic derivative
Dx = Dips[:,0]
Dy = Dips[:,1]
Dz = Dips[:,2]
D2 = avg(Dx**2)+avg(Dy**2)+avg(Dz**2)-avg(Dx)**2-avg(Dy)**2-avg(Dz)**2
GD2 = 2*(flat(np.dot(GDx,col(Dx)))/L - avg(Dx)*(np.mean(GDx,axis=1))) - Beta*(covde(Dx**2) - 2*avg(Dx)*covde(Dx))
GD2 += 2*(flat(np.dot(GDy,col(Dy)))/L - avg(Dy)*(np.mean(GDy,axis=1))) - Beta*(covde(Dy**2) - 2*avg(Dy)*covde(Dy))
GD2 += 2*(flat(np.dot(GDz,col(Dz)))/L - avg(Dz)*(np.mean(GDz,axis=1))) - Beta*(covde(Dz**2) - 2*avg(Dz)*covde(Dz))
GEps0 = prefactor*(GD2/avg(V) - mBeta*covde(V)*D2/avg(V)**2)/T
Sep = printcool("Dielectric constant: % .4e +- %.4e\nAnalytic Derivative:" % (Eps0, Eps0_err))
FF.print_map(vals=GEps0)
if FDCheck:
GEps0_fd = property_derivatives(Liquid, FF, mvals, h, pgrad, kT, calc_eps0, {'d_':Dips,'v_':V})
Sep = printcool("Numerical Derivative:")
FF.print_map(vals=GEps0_fd)
Sep = printcool("Difference (Absolute, Fractional):")
absfrac = ["% .4e % .4e" % (i-j, (i-j)/j) for i,j in zip(GEps0,GEps0_fd)]
FF.print_map(vals=absfrac)
logger.info("Writing final force field.\n")
pvals = FF.make(mvals)
logger.info("Writing all simulation data to disk.\n")
lp_dump((Rhos, Volumes, Potentials, Energies, Dips, G, [GDx, GDy, GDz], mPotentials, mEnergies, mG, Rho_err, Hvap_err, Alpha_err, Kappa_err, Cp_err, Eps0_err, NMol),'npt_result.p')
def ScipyOptimizer(self,Algorithm="None"):
""" Driver for SciPy optimizations.
Using any of the SciPy optimizers requires that SciPy is installed.
This method first defines several wrappers around the objective function that the SciPy
optimizers can use. Then it calls the algorith mitself.
@param[in] Algorithm The optimization algorithm to use, for example 'powell', 'simplex' or 'anneal'
"""
from scipy import optimize
def xwrap(func,verbose=True):
def my_func(mvals):
if verbose: logger.info('\n')
Answer = func(mvals,Order=0,verbose=verbose)['X']
dx = (my_func.x_best - Answer) if my_func.x_best != None else 0.0
if Answer < my_func.x_best or my_func.x_best == None:
color = "\x1b[92m"
my_func.x_best = Answer
else:
color = "\x1b[91m"
if verbose:
if self.print_vals:
logger.info("k=" + ' '.join(["% .4f" % i for i in mvals]) + '\n')
logger.info("X2= %s%12.3e\x1b[0m d(X2)= %12.3e\n" % (color,Answer,dx))
if Answer != Answer:
return 1e10
else:
return Answer
my_func.x_best = None
return my_func
def gwrap(func,verbose=True):
def my_gfunc(mvals):
if verbose: logger.info('\n')
Output = func(mvals,Order=1,verbose=verbose)
Answer = Output['G']
Objective = Output['X']
dx = (my_gfunc.x_best - Objective) if my_gfunc.x_best != None else 0.0
if Objective < my_gfunc.x_best or my_gfunc.x_best == None:
color = "\x1b[92m"
my_gfunc.x_best = Objective
else:
color = "\x1b[91m"
if verbose:
if self.print_vals:
logger.info("k=" + ' '.join(["% .4f" % i for i in mvals]) + '\n')
logger.info("|Grad|= %12.3e X2= %s%12.3e\x1b[0m d(X2)= %12.3e\n\n" % (norm(Answer),color,Objective,dx))
return Answer
my_gfunc.x_best = None
return my_gfunc
if Algorithm == "powell":
printcool("Minimizing Objective Function using Powell's Method" , ansi=1, bold=1)
return optimize.fmin_powell(xwrap(self.Objective.Full),self.mvals0,ftol=self.conv_obj,xtol=self.conv_stp,maxiter=self.maxstep)
elif Algorithm == "simplex":
printcool("Minimizing Objective Function using Simplex Method" , ansi=1, bold=1)
return optimize.fmin(xwrap(self.Objective.Full),self.mvals0,ftol=self.conv_obj,xtol=self.conv_stp,maxiter=self.maxstep,maxfun=self.maxstep*10)
elif Algorithm == "anneal":
printcool("Minimizing Objective Function using Simulated Annealing" , ansi=1, bold=1)
return optimize.anneal(xwrap(self.Objective.Full),self.mvals0,lower=-1*self.trust0*np.ones(self.np),upper=self.trust0*np.ones(self.np),schedule='boltzmann')
elif Algorithm == "cg":
printcool("Minimizing Objective Function using Conjugate Gradient" , ansi=1, bold=1)
return optimize.fmin_cg(xwrap(self.Objective.Full,verbose=False),self.mvals0,fprime=gwrap(self.Objective.Full),gtol=self.conv_grd)
def MainOptimizer(self,b_BFGS=0):
""" The main ForceBalance adaptive trust-radius pseudo-Newton optimizer. Tried and true in many situations. :)
Usually this function is called with the BFGS or NewtonRaphson
method. The NewtonRaphson method is consistently the best
method I have, because I always provide at least an
approximate Hessian to the objective function. The BFGS
method is vestigial and currently does not work.
BFGS is a pseudo-Newton method in the sense that it builds an
approximate Hessian matrix from the gradient information in previous
steps; Newton-Raphson requires the actual Hessian matrix.
However, the algorithms are similar in that they both compute the
step by inverting the Hessian and multiplying by the gradient.
The method adaptively changes the step size. If the step is
sufficiently good (i.e. the objective function goes down by a
large fraction of the predicted decrease), then the step size
is increased; if the step is bad, then it rejects the step and
tries again.
The optimization is terminated after either a function value or
step size tolerance is reached.
@param[in] b_BFGS Switch to use BFGS (True) or Newton-Raphson (False)
"""
if any(['liquid' in tgt.name.lower() for tgt in self.Objective.Targets]) and self.conv_obj < 1e-3:
warn_press_key("Condensed phase targets detected - may not converge with current choice of convergence_objective (%.e)\nRecommended range is 1e-2 - 1e-1 for this option." % self.conv_obj)
# Parameters for the adaptive trust radius
a = self.adapt_fac # Default value is 0.5, decrease to make more conservative. Zero to turn off all adaptive.
b = self.adapt_damp # Default value is 0.5, increase to make more conservative
printcool( "Main Optimizer\n%s Mode%s" % ("BFGS" if b_BFGS else "Newton-Raphson", " (Static Radius)" if a == 0.0 else " (Adaptive Radius)"), ansi=1, bold=1)
# First, set a bunch of starting values
Ord = 1 if b_BFGS else 2
#Ord = 2
global ITERATION_NUMBER
ITERATION_NUMBER = 0
global GOODSTEP
Best_Step = 1
if all(i in self.chk for i in ['xk','X','G','H','ehist','x_best','xk_prev','trust']):
logger.info("Reading initial objective, gradient, Hessian from checkpoint file\n")
xk, X, G, H, ehist = self.chk['xk'], self.chk['X'], self.chk['G'], self.chk['H'], self.chk['ehist']
X_best, xk_prev, trust = self.chk['x_best'], self.chk['xk_prev'], self.chk['trust']
else:
xk = self.mvals0.copy()
logger.info('\n')
data = self.Objective.Full(xk,Ord,verbose=True)
X, G, H = data['X'], data['G'], data['H']
ehist = np.array([X])
xk_prev = xk.copy()
trust = abs(self.trust0)
X_best = X
X_prev = X
G_prev = G.copy()
H_stor = H.copy()
ndx = 0.0
color = "\x1b[1m"
nxk = norm(xk)
ngr = norm(G)
Quality = 0.0
restep = False
GOODSTEP = 1
Ord = 1 if b_BFGS else 2
while 1: # Loop until convergence is reached.
## Put data into the checkpoint file
self.chk = {'xk': xk, 'X' : X, 'G' : G, 'H': H, 'ehist': ehist,
'x_best': X_best,'xk_prev': xk_prev, 'trust': trust}
if self.wchk_step:
self.writechk()
stdfront = len(ehist) > self.hist and np.std(np.sort(ehist)[:self.hist]) or (len(ehist) > 0 and np.std(ehist) or 0.0)
stdfront *= 2
logger.info("%6s%12s%12s%12s%14s%12s%12s\n" % ("Step", " |k| "," |dk| "," |grad| "," -=X2=- ","Delta(X2)", "StepQual"))
logger.info("%6i%12.3e%12.3e%12.3e%s%14.5e\x1b[0m%12.3e% 11.3f\n\n" % (ITERATION_NUMBER, nxk, ndx, ngr, color, X, stdfront, Quality))
# Check the convergence criteria
if ngr < self.conv_grd:
logger.info("Convergence criterion reached for gradient norm (%.2e)\n" % self.conv_grd)
break
if ITERATION_NUMBER == self.maxstep:
logger.info("Maximum number of optimization steps reached (%i)\n" % ITERATION_NUMBER)
break
if ndx < self.conv_stp and ITERATION_NUMBER > 0 and not restep:
logger.info("Convergence criterion reached in step size (%.2e)\n" % self.conv_stp)
break
if stdfront < self.conv_obj and len(ehist) > self.hist and not restep: # Factor of two is so [0,1] stdev is normalized to 1
logger.info("Convergence criterion reached for objective function (%.2e)\n" % self.conv_obj)
break
if self.print_grad:
bar = printcool("Total Gradient",color=4)
self.FF.print_map(vals=G,precision=8)
logger.info(bar)
if self.print_hess:
bar = printcool("Total Hessian",color=4)
pmat2d(H,precision=8)
logger.info(bar)
for key, val in self.Objective.ObjDict.items():
if Best_Step:
self.Objective.ObjDict_Last[key] = val
restep = False
dx, dX_expect, bump = self.step(xk, data, trust)
old_pk = self.FF.create_pvals(xk)
old_xk = xk.copy()
# Increment the iteration counter.
ITERATION_NUMBER += 1
# Take a step in the parameter space.
xk += dx
if self.print_vals:
pk = self.FF.create_pvals(xk)
dp = pk - old_pk
bar = printcool("Mathematical Parameters (Current + Step = Next)",color=5)
self.FF.print_map(vals=["% .4e %s %.4e = % .4e" % (old_xk[i], '+' if dx[i] >= 0 else '-', abs(dx[i]), xk[i]) for i in range(len(xk))])
logger.info(bar)
bar = printcool("Physical Parameters (Current + Step = Next)",color=5)
self.FF.print_map(vals=["% .4e %s %.4e = % .4e" % (old_pk[i], '+' if dp[i] >= 0 else '-', abs(dp[i]), pk[i]) for i in range(len(pk))])
logger.info(bar)
# Evaluate the objective function and its derivatives.
data = self.Objective.Full(xk,Ord,verbose=True)
X, G, H = data['X'], data['G'], data['H']
ndx = norm(dx)
nxk = norm(xk)
ngr = norm(G)
drc = abs(flat(dx)).argmax()
dX_actual = X - X_prev
try:
Quality = dX_actual / dX_expect
except:
logger.warning("Warning: Step size of zero detected (i.e. wrong direction). Try reducing the finite_difference_h parameter\n")
Quality = 1.0 # This is a step length of zero.
if Quality <= 0.25 and X < (X_prev + self.err_tol) and self.trust0 > 0:
# If the step quality is bad, then we should decrease the trust radius.
trust = max(ndx*(1./(1+a)), self.mintrust)
logger.info("Low quality step, reducing trust radius to % .4e\n" % trust)
if Quality >= 0.75 and bump and self.trust0 > 0:
# If the step quality is good, then we should increase the trust radius.
# The 'a' factor is how much we should grow or shrink the trust radius each step
# and the 'b' factor determines how closely we are tied down to the original value.
# Recommend values 0.5 and 0.5
trust += a*trust*np.exp(-b*(trust/self.trust0 - 1))
if X > (X_prev + self.err_tol):
Best_Step = 0
# Toggle switch for rejection (experimenting with no rejection)
Rejects = True
GOODSTEP = 0
Reevaluate = True
trust = max(ndx*(1./(1+a)), self.mintrust)
logger.info("Rejecting step and reducing trust radius to % .4e\n" % trust)
if Rejects:
xk = xk_prev.copy()
if Reevaluate:
restep = True
color = "\x1b[91m"
logger.info("%6s%12s%12s%12s%14s%12s%12s\n" % ("Step", " |k| "," |dk| "," |grad| "," -=X2=- ","Delta(X2)", "StepQual"))
logger.info("%6i%12.3e%12.3e%12.3e%s%14.5e\x1b[0m%12.3e% 11.3f\n\n" % (ITERATION_NUMBER, nxk, ndx, ngr, color, X, stdfront, Quality))
printcool("Objective function rises!\nRe-evaluating at the previous point..",color=1)
ITERATION_NUMBER += 1
data = self.Objective.Full(xk,Ord,verbose=True)
GOODSTEP = 1
X, G, H = data['X'], data['G'], data['H']
X_prev = X
dx *= 0
ndx = norm(dx)
nxk = norm(xk)
ngr = norm(G)
Quality = 0.0
color = "\x1b[0m"
else:
color = "\x1b[91m"
G = G_prev.copy()
H = H_stor.copy()
data = deepcopy(datastor)
continue
else:
GOODSTEP = 1
if X > X_best:
Best_Step = 0
color = "\x1b[95m"
else:
Best_Step = 1
color = "\x1b[92m"
X_best = X
ehist = np.append(ehist, X)
# Hessian update for BFGS.
if b_BFGS:
Hnew = H_stor.copy()
Dx = col(xk - xk_prev)
Dy = col(G - G_prev)
Mat1 = (Dy*Dy.T)/(Dy.T*Dx)[0,0]
Mat2 = ((Hnew*Dx)*(Hnew*Dx).T)/(Dx.T*Hnew*Dx)[0,0]
Hnew += Mat1-Mat2
H = Hnew.copy()
data['H'] = H.copy()
datastor= deepcopy(data)
G_prev = G.copy()
H_stor = H.copy()
xk_prev = xk.copy()
X_prev = X
if len(self.FF.parmdestroy_this) > 0:
self.FF.parmdestroy_save.append(self.FF.parmdestroy_this)
self.FF.linedestroy_save.append(self.FF.linedestroy_this)
bar = printcool("Final objective function value\nFull: % .6e Un-penalized: % .6e" % (data['X'],data['X0']), '@', bold=True, color=2)
return xk
def extract(self, engines, FF, mvals, h, pgrad, AGrad=True):
#==========================================#
# Physical constants and local variables. #
#==========================================#
# Energies in kJ/mol and lengths in nanometers.
kB = 0.008314472471220214
kT = kB * self.temperature
Beta = 1.0 / kT
mBeta = -Beta
#======================================================#
# Get simulation properties depending on the engines. #
#======================================================#
if self.engname == "gromacs":
# Default name
deffnm = os.path.basename(os.path.splitext(engines[0].mdene)[0])
# What energy terms are there and what is their order
energyterms = engines[0].energy_termnames(edrfile="%s.%s" %
(deffnm, "edr"))
# Grab energy terms to print and keep track of energy term order.
ekeep = ['Total-Energy', 'Potential', 'Kinetic-En.', 'Temperature']
ekeep += ['Volume', 'Density']
ekeep_order = [
key for (
key,
value) in sorted(energyterms.items(), key=lambda (k, v): v)
if key in ekeep
]
# Perform energy component analysis and return properties.
engines[0].callgmx(
("g_energy " + "-f %s.%s " %
(deffnm, "edr") + "-o %s-energy.xvg " % deffnm + "-xvg no"),
stdin="\n".join(ekeep))
# Read data and store properties by grabbing columns in right order.
data = np.loadtxt("%s-energy.xvg" % deffnm)
Energy = data[:, ekeep_order.index("Total-Energy") + 1]
Potential = data[:, ekeep_order.index("Potential") + 1]
Kinetic = data[:, ekeep_order.index("Kinetic-En.") + 1]
Volume = data[:, ekeep_order.index("Volume") + 1]
Temperature = data[:, ekeep_order.index("Temperature") + 1]
Density = data[:, ekeep_order.index("Density") + 1]
#============================================#
# Compute the potential energy derivatives. #
#============================================#
logger.info(("Calculating potential energy derivatives " +
"with finite difference step size: %f\n" % h))
printcool("Initializing array to length %i" % len(Energy),
color=4,
bold=True)
G = energy_derivatives(engines[0], FF, mvals, h, pgrad, len(Energy),
AGrad)
#=======================================#
# Quantity properties and derivatives. #
#=======================================#
# Average and error.
Rho_avg, Rho_err = mean_stderr(Density)
# Analytic first derivative.
Rho_grad = mBeta * (flat(np.mat(G) * col(Density)) / len(Density) \
- np.mean(Density) * np.mean(G, axis=1))
return Rho_avg, Rho_err, Rho_grad
def main():
printcool("Welcome to ForceBalance version 1.2! =D\nForce Field Optimization System\n\nAuthors:\nLee-Ping Wang\nArthur Vigil\nKeri McKiernan\nErik Brandt", ansi="1", bold=True, minwidth=64)
logostr = """
,'+++
,++++++. .:,,.
:+++++'` `; `,:::::.`
'+++++' `'++++ `,::::,,`
`;+++++: ,+++++'. `.:::::,`
`++++++, :+++++'` .,::::,`
.+++++'. ;+++++' `,,:::,`
:+++++'` `;+++++: `,::::,.`
++++;` `++++++: `.:+@@###@' `,,::::.`
: ,++++++. ,;'+###############. .,::,
:++++++` +################':` .
+++;` `.,,...####+.
,##### +##. +++ +++
,,,, ##### ###### +++ +++
,::, ###' ####' :#####' +++ +++
,::, :####@ ####. ,####' +++ +++
,::, ###### #### +###+ +++ +++
,::, ##### #### ###; +++ +++
,::, :## #### ++` +++ +++
,::, ####``..:;+##############+` +++ +++
,::, .,:;;'++##################################` +++ +++
,::, `############################++++''';;;;;;;;;;;''; +++ +++
,::, ,########':,.`` #### +++ +++
,::, #### +++ +++
,::, #### +++ +++
,::, #### +++ +++
,::, #### +++ +++
,::, #### +++ +++
,::, #### +++ +++
,,,, #### +++ +++
;++, ####
`'+++++: ####
` '+++++; #### `.,:.
++++, :+++++'` #### `,:::::.
.'+++++, :++++++. ### `,::::,.`
`'+++++; .++++++, +` .,::::,`
;+++++'` `++++++: .,:::,,`
:+++++'. `;+++++;` `.:::::,`
,++++++` '++++++ `,::::,,`
.'+++++: ,+; `,:::::.
`'+++++: ,::,,.
;++++. ,`
,`
"""
b = 'blue'
g = 'gold'
k = 'black'
colorlist = [[],[b],[b,g],[b,b,g],[b,b,g],[b,b,g],[b,b,g],[b,b,g],
[b,b,g],[b,b,k,g],[b,b,k,g],[b,k,g],[b,k],[k,k,b,b],
[g,k,k,b,b],[g,k,k,k,b,b],[g,k,k,k,b,b],[g,k,k,k,b,b],
[g,k,k,k,b,b],[g,k,k,k,b,b],[g,k,b,b],[g,k,b,b],[g,k,b,b],
[g,k,k,b,b],[g,k,b,b],[g,k,b,b],[g,k,b,b],[g,k,b,b],[g,k,b,b],
[g,k,b,b],[g,k,b,b],[b,k],[b,k],[b,b,k,g],[b,b,k,g],[b,b,k,g],
[b,b,k,g],[b,b,g],[b,b,g],[b,b,g],[b,b,g],[b,g],[b,g],[b],[]]
words = [l.split() for l in logostr.split('\n')]
for ln, line in enumerate(logostr.split('\n')):
# Reconstruct the line.
words = line.split()
whites = re.findall('[ ]+',line)
newline = ''
i = 0
if len(line) > 0 and line[0] == ' ':
while i < max(len(words), len(whites)):
try:
newline += whites[i]
except: pass
try:
newline += process(words[i], colorlist[ln][i])
except: pass
i += 1
elif len(line) > 0:
while i < max(len(words), len(whites)):
try:
newline += process(words[i], colorlist[ln][i])
except: pass
try:
newline += whites[i]
except: pass
i += 1
print newline
parser = argparse.ArgumentParser(description="Force Field Optimization System")
parser.add_argument("-c", "--continue", action="store_true", help="Continue from a previous run")
parser.add_argument("-d", "--debug", action="store_true", help="Run interactive debugger on program crash")
parser.add_argument("input", help="Forcebalance input file")
args = parser.parse_args()
continue_ = getattr(args, 'continue')
Run_ForceBalance(args.input, debug=args.debug, continue_=continue_)
def extract(self, engines, FF, mvals, h, pgrad, AGrad=True):
#==========================================#
# Physical constants and local variables. #
#==========================================#
# Energies in kJ/mol and lengths in nanometers.
kB = 0.008314472471220214
kT = kB*self.temperature
Beta = 1.0/kT
mBeta = -Beta
# Conversion factor between 1 kJ/mol -> bar nm^3
pconv = 16.6054
# Number of molecules in the liquid phase.
mol = Molecule(os.path.basename(os.path.splitext(engines[0].mdtraj)[0]) +
".gro")
nmol = len(mol.molecules)
#======================================================#
# Get simulation properties depending on the engines. #
#======================================================#
if self.engname == "gromacs":
# Default names
deffnm1 = os.path.basename(os.path.splitext(engines[0].mdene)[0])
deffnm2 = os.path.basename(os.path.splitext(engines[1].mdene)[0])
# Figure out which energy terms and present and their order.
energyterms1 = engines[0].energy_termnames(edrfile="%s.%s" % (deffnm1, "edr"))
energyterms2 = engines[1].energy_termnames(edrfile="%s.%s" % (deffnm2, "edr"))
# Grab energy terms to print and keep track of energy term order.
ekeep1 = ['Total-Energy', 'Potential', 'Kinetic-En.', 'Temperature', 'Volume']
ekeep2 = ['Total-Energy', 'Potential', 'Kinetic-En.', 'Temperature']
ekeep_order1 = [key for (key, value)
in sorted(energyterms1.items(), key=lambda (k, v) : v)
if key in ekeep1]
ekeep_order2 = [key for (key, value)
in sorted(energyterms2.items(), key=lambda (k, v) : v)
if key in ekeep2]
# Perform energy component analysis and return properties.
engines[0].callgmx(("g_energy " +
"-f %s.%s " % (deffnm1, "edr") +
"-o %s-energy.xvg " % deffnm1 +
"-xvg no"),
stdin="\n".join(ekeep1))
engines[1].callgmx(("g_energy " +
"-f %s.%s " % (deffnm2, "edr") +
"-o %s-energy.xvg " % deffnm2 +
"-xvg no"),
stdin="\n".join(ekeep2))
# Read data and store properties by grabbing columns in right order.
data1 = np.loadtxt("%s-energy.xvg" % deffnm1)
data2 = np.loadtxt("%s-energy.xvg" % deffnm2)
Energy = data1[:, ekeep_order1.index("Total-Energy") + 1]
Potential = data1[:, ekeep_order1.index("Potential") + 1]
Kinetic = data1[:, ekeep_order1.index("Kinetic-En.") + 1]
Temperature = data1[:, ekeep_order1.index("Temperature") + 1]
Volume = data1[:, ekeep_order1.index("Volume") + 1]
mEnergy = data2[:, ekeep_order2.index("Total-Energy") + 1]
mPotential = data2[:, ekeep_order2.index("Potential") + 1]
mKinetic = data2[:, ekeep_order2.index("Kinetic-En.") + 1]
#============================================#
# Compute the potential energy derivatives. #
#============================================#
logger.info(("Calculating potential energy derivatives " +
"with finite difference step size: %f\n" % h))
printcool("Initializing arrays to lengths %d" % len(Energy),
color=4, bold=True)
G = energy_derivatives(engines[0], FF, mvals, h, pgrad, len(Energy), AGrad)
Gm = energy_derivatives(engines[1], FF, mvals, h, pgrad, len(mEnergy), AGrad)
#=======================================#
# Quantity properties and derivatives. #
#=======================================#
# Average and error.
E_avg, E_err = mean_stderr(Energy)
Em_avg, Em_err = mean_stderr(mEnergy)
Vol_avg, Vol_err = mean_stderr(Volume)
Hvap_avg = Em_avg - E_avg/nmol - self.pressure*Vol_avg/nmol/pconv + kT
Hvap_err = np.sqrt((E_err/nmol)**2 + Em_err**2
+ (self.pressure**2) * (Vol_err**2)/(float(nmol)**2)/(pconv**2))
# Analytic first derivative.
Hvap_grad = np.mean(Gm, axis=1)
Hvap_grad += mBeta * (flat(np.mat(Gm) * col(mEnergy)) / len(mEnergy) \
- np.mean(mEnergy) * np.mean(Gm, axis=1))
Hvap_grad -= np.mean(G, axis=1)/nmol
Hvap_grad += Beta * (flat(np.mat(G) * col(Energy)) / len(Energy) \
- np.mean(Energy) * np.mean(G, axis=1))/nmol
Hvap_grad += (Beta*self.pressure/nmol/pconv) * \
(flat(np.mat(G) * col(Volume)) / len(Volume) \
- np.mean(Volume) * np.mean(G, axis=1))
return Hvap_avg, Hvap_err, Hvap_grad
def main():
"""Usage:
(gmxprefix.sh) md_chain.py <list of quantities>
--engine <gromacs>
--length <n>
--name <name>
--temperature <T>
--pressure <p>
--nequil <nequil>
--nsteps <nsteps>
This program is meant to be called automatically by ForceBalance.
"""
printcool("ForceBalance simulation using engine: %s" % engname.upper(),
color=4,
bold=True)
#----
# Load the ForceBalance pickle file which contains:
#----
# - Force field object
# - Optimization parameters
# - Options from the Target object that launched this simulation
# - Switch for whether to evaluate analytic derivatives.
FF, mvals, TgtOptions, AGrad = lp_load('forcebalance.p')
FF.ffdir = '.'
# Write the force field file.
FF.make(mvals)
#----
# Load the options that are set in the ForceBalance input file.
#----
# Finite difference step size
h = TgtOptions['h']
pgrad = TgtOptions['pgrad']
engines = []
## Setup and carry out simulations in chain
for i in range(args.length):
# Simulation files
if engname == "gromacs":
ndx_flag = False
coords = args.name + str(i + 1) + ".gro"
top_file = args.name + str(i + 1) + ".top"
mdp_file = args.name + str(i + 1) + ".mdp"
ndx_file = args.name + str(i + 1) + ".ndx"
if os.path.exists(ndx_file):
ndx_flag = True
mol = Molecule(coords)
#----
# Set coordinates and molecule for engine
#----
EngOpts = OrderedDict([("FF", FF), ("pbc", True), ("coords", coords),
("mol", mol)])
if engname == "gromacs":
# Gromacs-specific options
EngOpts["gmx_top"] = top_file
EngOpts["gmx_mdp"] = mdp_file
if ndx_flag:
EngOpts["gmx_ndx"] = ndx_file
printcool_dictionary(EngOpts)
# Create engine objects and store them for subsequent analysis.
s = Engine(name=args.name + str(i + 1), **EngOpts)
#=====================#
# Run the simulation. #
#=====================#
MDOpts = OrderedDict([("nsteps", args.nsteps),
("nequil", args.nequil)])
printcool("Molecular dynamics simulation", color=4, bold=True)
s.md(verbose=True, **MDOpts)
engines.append(s)
#======================================================================#
# Extract the quantities of interest from the MD simulations and dump #
# the results to file. #
# =====================================================================#
results = OrderedDict()
for q in args.quantities:
logger.info("Extracting %s...\n" % q)
# Initialize quantity
objstr = "Quantity_" + q.capitalize()
dm = il.import_module('..quantity', package='forcebalance.quantity')
Quantity = getattr(dm, objstr)(engname, args.temperature,
args.pressure)
Q, Qerr, Qgrad = Quantity.extract(engines, FF, mvals, h, pgrad, AGrad)
results.setdefault("values", []).append(Q)
results.setdefault("errors", []).append(Qerr)
results.setdefault("grads", []).append(Qgrad)
logger.info("Finished!\n")
# Print out results for the quantity and its derivative.
Sep = printcool(("%s: % .4f +- % .4f \nAnalytic Derivative:" %
(q.capitalize(), Q, Qerr)))
FF.print_map(vals=Qgrad)
# Dump results to file
logger.info("Writing final force field.\n")
pvals = FF.make(mvals)
logger.info("Writing all simulation data to disk.\n")
lp_dump((np.asarray(results["values"]), np.asarray(
results["errors"]), np.asarray(results["grads"])), 'md_result.p')
def main():
"""
Run the script with -h for help
Usage: python npt_tinker.py input.xyz [-k input.key] liquid_production_steps liquid_timestep liquid_interval temperature(K) pressure(atm)
"""
if not os.path.exists(args.liquid_xyzfile):
warn_press_key("Warning: %s does not exist, script cannot continue" % args.liquid_xyzfile)
# Set up some conversion factors
# All units are in kJ/mol
N = niterations
# Conversion factor for kT derived from:
# In [6]: 1.0 / ((1.0 * kelvin * BOLTZMANN_CONSTANT_kB * AVOGADRO_CONSTANT_NA) / kilojoule_per_mole)
# Out[6]: 120.27221251395186
T = temperature
mBeta = -120.27221251395186 / temperature
Beta = 120.27221251395186 / temperature
kT = 0.0083144724712202 * temperature
# Conversion factor for pV derived from:
# In [14]: 1.0 * atmosphere * nanometer ** 3 * AVOGADRO_CONSTANT_NA / kilojoule_per_mole
# Out[14]: 0.061019351687175
pcon = 0.061019351687175
# Load the force field in from the ForceBalance pickle.
FF,mvals,h,AGrad = lp_load(open('forcebalance.p'))
# Create the force field XML files.
FF.make(mvals)
#=================================================================#
# Get the number of molecules from the liquid xyz file. #
#=================================================================#
xin = "%s" % args.liquid_xyzfile + ("" if args.liquid_keyfile == None else " -k %s" % args.liquid_keyfile)
cmdstr = "./analyze %s" % xin
oanl = _exec(cmdstr,stdin="G",print_command=True,print_to_screen=True)
molflag = False
for line in oanl:
if 'Number of Molecules' in line:
if not molflag:
NMol = int(line.split()[-1])
molflag = True
else:
raise Exception("TINKER output contained more than one line with the words 'Number of Molecules'")
if molflag:
print "Detected %i Molecules" % NMol
if not molflag:
raise Exception("Failed to detect the number of molecules")
#=================================================================#
# Run the simulation for the full system and analyze the results. #
#=================================================================#
Rhos, Potentials, Kinetics, Volumes, Dips = run_simulation(args.liquid_xyzfile,args.liquid_keyfile,tstep=timestep,nstep=nsteps,neq=nequiliterations,npr=niterations,verbose=True)
Energies = Potentials + Kinetics
V = Volumes
pV = pressure * Volumes
H = Energies + pV
# Get the energy and dipole gradients.
print "Post-processing the liquid simulation snapshots."
G, GDx, GDy, GDz = energy_dipole_derivatives(mvals,h,FF,args.liquid_xyzfile,args.liquid_keyfile,AGrad)
print
#==============================================#
# Now run the simulation for just the monomer. #
#==============================================#
_a, mPotentials, mKinetics, _b, _c = run_simulation(args.gas_xyzfile,args.gas_keyfile,tstep=m_timestep,nstep=m_nsteps,neq=m_nequiliterations,npr=m_niterations,pbc=False)
mEnergies = mPotentials + mKinetics
mN = len(mEnergies)
print "Post-processing the gas simulation snapshots."
mG = energy_derivatives(mvals,h,FF,args.gas_xyzfile,args.gas_keyfile,AGrad)
print
numboots = 1000
def bootstats(func,inputs):
# Calculate error using bootstats method
dboot = []
for i in range(numboots):
newins = {k : v[np.random.randint(len(v),size=len(v))] for k,v in inputs.items()}
dboot.append(np.mean(func(**newins)))
return func(**inputs),np.std(np.array(dboot))
def calc_arr(b = None, **kwargs):
# This tomfoolery is required because of Python syntax;
# default arguments must come after nondefault arguments
# and kwargs must come at the end. This function is used
# in bootstrap error calcs and also in derivative calcs.
if 'arr' in kwargs:
arr = kwargs['arr']
if b == None: b = np.ones(len(arr),dtype=float)
return bzavg(arr,b)
# The density in kg/m^3.
# Note: Not really necessary to use bootstrap here, but good to
# demonstrate the principle.
Rho_avg, Rho_err = bootstats(calc_arr,{'arr':Rhos})
Rho_err *= np.sqrt(statisticalInefficiency(Rhos))
print "The finite difference step size is:",h
# The first density derivative
GRho = mBeta * (flat(np.mat(G) * col(Rhos)) / N - np.mean(Rhos) * np.mean(G, axis=1))
FDCheck = False
Sep = printcool("Density: % .4f +- % .4f kg/m^3, Analytic Derivative" % (Rho_avg, Rho_err))
FF.print_map(vals=GRho)
print Sep
if FDCheck:
Sep = printcool("Numerical Derivative:")
GRho1 = property_derivatives(mvals, h, FF, args.liquid_xyzfile, args.liquid_keyfile, kT, calc_arr, {'arr':Rhos})
FF.print_map(vals=GRho1)
Sep = printcool("Difference (Absolute, Fractional):")
absfrac = ["% .4e % .4e" % (i-j, (i-j)/j) for i,j in zip(GRho, GRho1)]
FF.print_map(vals=absfrac)
# The enthalpy of vaporization in kJ/mol.
Ene_avg, Ene_err = bootstats(calc_arr,{'arr':Energies})
mEne_avg, mEne_err = bootstats(calc_arr,{'arr':mEnergies})
pV_avg, pV_err = bootstats(calc_arr,{'arr':pV})
Ene_err *= np.sqrt(statisticalInefficiency(Energies))
mEne_err *= np.sqrt(statisticalInefficiency(mEnergies))
pV_err *= np.sqrt(statisticalInefficiency(pV))
Hvap_avg = mEne_avg - Ene_avg / NMol + kT - np.mean(pV) / NMol
Hvap_err = np.sqrt(Ene_err**2 / NMol**2 + mEne_err**2 + pV_err**2/NMol**2)
# Build the first Hvap derivative.
GHvap = np.mean(G,axis=1)
GHvap += mBeta * (flat(np.mat(G) * col(Energies)) / N - Ene_avg * np.mean(G, axis=1))
GHvap /= NMol
GHvap -= np.mean(mG,axis=1)
GHvap -= mBeta * (flat(np.mat(mG) * col(mEnergies)) / N - mEne_avg * np.mean(mG, axis=1))
GHvap *= -1
GHvap -= mBeta * (flat(np.mat(G) * col(pV)) / N - np.mean(pV) * np.mean(G, axis=1)) / NMol
print "Box total energy:", np.mean(Energies)
print "Monomer total energy:", np.mean(mEnergies)
Sep = printcool("Enthalpy of Vaporization: % .4f +- %.4f kJ/mol, Derivatives below" % (Hvap_avg, Hvap_err))
FF.print_map(vals=GHvap)
print Sep
# Define some things to make the analytic derivatives easier.
Gbar = np.mean(G,axis=1)
def covde(vec):
return flat(np.mat(G)*col(vec))/N - Gbar*np.mean(vec)
def avg(vec):
return np.mean(vec)
## Thermal expansion coefficient and bootstrap error estimation
def calc_alpha(b = None, **kwargs):
if 'h_' in kwargs:
h_ = kwargs['h_']
if 'v_' in kwargs:
v_ = kwargs['v_']
if b == None: b = np.ones(len(v_),dtype=float)
return 1/(kT*T) * (bzavg(h_*v_,b)-bzavg(h_,b)*bzavg(v_,b))/bzavg(v_,b)
Alpha, Alpha_err = bootstats(calc_alpha,{'h_':H, 'v_':V})
Alpha_err *= np.sqrt(max(statisticalInefficiency(V),statisticalInefficiency(H)))
## Thermal expansion coefficient analytic derivative
GAlpha1 = mBeta * covde(H*V) / avg(V)
GAlpha2 = Beta * avg(H*V) * covde(V) / avg(V)**2
GAlpha3 = flat(np.mat(G)*col(V))/N/avg(V) - Gbar
GAlpha4 = Beta * covde(H)
GAlpha = (GAlpha1 + GAlpha2 + GAlpha3 + GAlpha4)/(kT*T)
Sep = printcool("Thermal expansion coefficient: % .4e +- %.4e K^-1\nAnalytic Derivative:" % (Alpha, Alpha_err))
FF.print_map(vals=GAlpha)
if FDCheck:
GAlpha_fd = property_derivatives(mvals, h, FF, args.liquid_xyzfile, args.liquid_keyfile, kT, calc_alpha, {'h_':H,'v_':V})
Sep = printcool("Numerical Derivative:")
FF.print_map(vals=GAlpha_fd)
Sep = printcool("Difference (Absolute, Fractional):")
absfrac = ["% .4e % .4e" % (i-j, (i-j)/j) for i,j in zip(GAlpha, GAlpha_fd)]
FF.print_map(vals=absfrac)
## Isothermal compressibility
# In [15]: 1.0*bar*nanometer**3/kilojoules_per_mole/item
# Out[15]: 0.06022141792999999
bar_unit = 0.06022141793
def calc_kappa(b=None, **kwargs):
if 'v_' in kwargs:
v_ = kwargs['v_']
if b == None: b = np.ones(len(v_),dtype=float)
return bar_unit / kT * (bzavg(v_**2,b)-bzavg(v_,b)**2)/bzavg(v_,b)
Kappa, Kappa_err = bootstats(calc_kappa,{'v_':V})
Kappa_err *= np.sqrt(statisticalInefficiency(V))
## Isothermal compressibility analytic derivative
Sep = printcool("Isothermal compressibility: % .4e +- %.4e bar^-1\nAnalytic Derivative:" % (Kappa, Kappa_err))
GKappa1 = -1 * Beta**2 * avg(V) * covde(V**2) / avg(V)**2
GKappa2 = +1 * Beta**2 * avg(V**2) * covde(V) / avg(V)**2
GKappa3 = +1 * Beta**2 * covde(V)
GKappa = bar_unit*(GKappa1 + GKappa2 + GKappa3)
FF.print_map(vals=GKappa)
if FDCheck:
GKappa_fd = property_derivatives(mvals, h, FF, args.liquid_xyzfile, args.liquid_keyfile, kT, calc_kappa, {'v_':V})
Sep = printcool("Numerical Derivative:")
FF.print_map(vals=GKappa_fd)
Sep = printcool("Difference (Absolute, Fractional):")
absfrac = ["% .4e % .4e" % (i-j, (i-j)/j) for i,j in zip(GKappa, GKappa_fd)]
FF.print_map(vals=absfrac)
## Isobaric heat capacity
def calc_cp(b=None, **kwargs):
if 'h_' in kwargs:
h_ = kwargs['h_']
if b == None: b = np.ones(len(h_),dtype=float)
Cp_ = 1/(NMol*kT*T) * (bzavg(h_**2,b) - bzavg(h_,b)**2)
Cp_ *= 1000 / 4.184
return Cp_
Cp, Cp_err = bootstats(calc_cp, {'h_':H})
Cp_err *= np.sqrt(statisticalInefficiency(H))
## Isobaric heat capacity analytic derivative
GCp1 = 2*covde(H) * 1000 / 4.184 / (NMol*kT*T)
GCp2 = mBeta*covde(H**2) * 1000 / 4.184 / (NMol*kT*T)
GCp3 = 2*Beta*avg(H)*covde(H) * 1000 / 4.184 / (NMol*kT*T)
GCp = GCp1 + GCp2 + GCp3
Sep = printcool("Isobaric heat capacity: % .4e +- %.4e cal mol-1 K-1\nAnalytic Derivative:" % (Cp, Cp_err))
FF.print_map(vals=GCp)
if FDCheck:
GCp_fd = property_derivatives(mvals, h, FF, args.liquid_xyzfile, args.liquid_keyfile, kT, calc_cp, {'h_':H})
Sep = printcool("Numerical Derivative:")
FF.print_map(vals=GCp_fd)
Sep = printcool("Difference (Absolute, Fractional):")
absfrac = ["% .4e % .4e" % (i-j, (i-j)/j) for i,j in zip(GCp,GCp_fd)]
FF.print_map(vals=absfrac)
## Dielectric constant
# eps0 = 8.854187817620e-12 * coulomb**2 / newton / meter**2
# epsunit = 1.0*(debye**2) / nanometer**3 / BOLTZMANN_CONSTANT_kB / kelvin
# prefactor = epsunit/eps0/3
prefactor = 30.348705333964077
def calc_eps0(b=None, **kwargs):
if 'd_' in kwargs: # Dipole moment vector.
d_ = kwargs['d_']
if 'v_' in kwargs: # Volume.
v_ = kwargs['v_']
if b == None: b = np.ones(len(v_),dtype=float)
dx = d_[:,0]
dy = d_[:,1]
dz = d_[:,2]
D2 = bzavg(dx**2,b)-bzavg(dx,b)**2
D2 += bzavg(dy**2,b)-bzavg(dy,b)**2
D2 += bzavg(dz**2,b)-bzavg(dz,b)**2
return prefactor*D2/bzavg(v_,b)/T
Eps0, Eps0_err = bootstats(calc_eps0,{'d_':Dips, 'v_':V})
Eps0 += 1.0
Eps0_err *= np.sqrt(np.mean([statisticalInefficiency(Dips[:,0]),statisticalInefficiency(Dips[:,1]),statisticalInefficiency(Dips[:,2])]))
## Dielectric constant analytic derivative
Dx = Dips[:,0]
Dy = Dips[:,1]
Dz = Dips[:,2]
D2 = avg(Dx**2)+avg(Dy**2)+avg(Dz**2)-avg(Dx)**2-avg(Dy)**2-avg(Dz)**2
GD2 = 2*(flat(np.mat(GDx)*col(Dx))/N - avg(Dx)*(np.mean(GDx,axis=1))) - Beta*(covde(Dx**2) - 2*avg(Dx)*covde(Dx))
GD2 += 2*(flat(np.mat(GDy)*col(Dy))/N - avg(Dy)*(np.mean(GDy,axis=1))) - Beta*(covde(Dy**2) - 2*avg(Dy)*covde(Dy))
GD2 += 2*(flat(np.mat(GDz)*col(Dz))/N - avg(Dz)*(np.mean(GDz,axis=1))) - Beta*(covde(Dz**2) - 2*avg(Dz)*covde(Dz))
GEps0 = prefactor*(GD2/avg(V) - mBeta*covde(V)*D2/avg(V)**2)/T
Sep = printcool("Dielectric constant: % .4e +- %.4e\nAnalytic Derivative:" % (Eps0, Eps0_err))
FF.print_map(vals=GEps0)
if FDCheck:
GEps0_fd = property_derivatives(mvals, h, FF, args.liquid_xyzfile, args.liquid_keyfile, kT, calc_eps0, {'d_':Dips,'v_':V})
Sep = printcool("Numerical Derivative:")
FF.print_map(vals=GEps0_fd)
Sep = printcool("Difference (Absolute, Fractional):")
absfrac = ["% .4e % .4e" % (i-j, (i-j)/j) for i,j in zip(GEps0,GEps0_fd)]
FF.print_map(vals=absfrac)
## Print the final force field.
pvals = FF.make(mvals)
with open(os.path.join('npt_result.p'),'w') as f: lp_dump((Rhos, Volumes, Potentials, Energies, Dips, G, [GDx, GDy, GDz], mPotentials, mEnergies, mG, Rho_err, Hvap_err, Alpha_err, Kappa_err, Cp_err, Eps0_err, NMol),f)
def main():
"""
Usage: (runcuda.sh) nvt.py <openmm|gromacs|tinker> <liquid_nsteps> <liquid_timestep (fs)> <liquid_intvl (ps> <temperature>
This program is meant to be called automatically by ForceBalance on
a GPU cluster (specifically, subroutines in openmmio.py). It is
not easy to use manually. This is because the force field is read
in from a ForceBalance 'FF' class.
"""
printcool("ForceBalance condensed phase NVT simulation using engine: %s" %
engname.upper(),
color=4,
bold=True)
#----
# Load the ForceBalance pickle file which contains:
#----
# - Force field object
# - Optimization parameters
# - Options from the Target object that launched this simulation
# - Switch for whether to evaluate analytic derivatives.
FF, mvals, TgtOptions, AGrad = lp_load('forcebalance.p')
FF.ffdir = '.'
# Write the force field file.
FF.make(mvals)
#----
# Load the options that are set in the ForceBalance input file.
#----
# Finite difference step size
h = TgtOptions['h']
pgrad = TgtOptions['pgrad']
# MD options; time step (fs), production steps, equilibration steps, interval for saving data (ps)
nvt_timestep = TgtOptions['nvt_timestep']
nvt_md_steps = TgtOptions['nvt_md_steps']
nvt_eq_steps = TgtOptions['nvt_eq_steps']
nvt_interval = TgtOptions['nvt_interval']
liquid_fnm = TgtOptions['nvt_coords']
# Number of threads, multiple timestep integrator, anisotropic box etc.
threads = TgtOptions.get('md_threads', 1)
mts = TgtOptions.get('mts_integrator', 0)
rpmd_beads = TgtOptions.get('rpmd_beads', 0)
force_cuda = TgtOptions.get('force_cuda', 0)
nbarostat = TgtOptions.get('n_mcbarostat', 25)
anisotropic = TgtOptions.get('anisotropic_box', 0)
minimize = TgtOptions.get('minimize_energy', 1)
# Print all options.
printcool_dictionary(TgtOptions, title="Options from ForceBalance")
nvt_snapshots = int((nvt_timestep * nvt_md_steps / 1000) / nvt_interval)
nvt_iframes = int(1000 * nvt_interval / nvt_timestep)
logger.info("For the condensed phase system, I will collect %i snapshots spaced apart by %i x %.3f fs time steps\n" \
% (nvt_snapshots, nvt_iframes, nvt_timestep))
if nvt_snapshots < 2:
raise Exception('Please set the number of liquid time steps so that you collect at least two snapshots (minimum %i)' \
% (2000 * int(nvt_interval,nvt_timestep)))
#----
# Loading coordinates
#----
ML = Molecule(liquid_fnm, toppbc=True)
# Determine the number of molecules in the condensed phase coordinate file.
NMol = len(ML.molecules)
TgtOptions['n_molecules'] = NMol
logger.info("There are %i molecules in the liquid\n" % (NMol))
#----
# Setting up MD simulations
#----
EngOpts = OrderedDict()
EngOpts["liquid"] = OrderedDict([("coords", liquid_fnm), ("mol", ML),
("pbc", True)])
if "nonbonded_cutoff" in TgtOptions:
EngOpts["liquid"]["nonbonded_cutoff"] = TgtOptions["nonbonded_cutoff"]
else:
largest_available_cutoff = min(ML.boxes[0][:3]) / 2 - 0.1
EngOpts["liquid"]["nonbonded_cutoff"] = largest_available_cutoff
logger.info(
"nonbonded_cutoff is by default set to the largest available value: %g Angstrom"
% largest_available_cutoff)
if "vdw_cutoff" in TgtOptions:
EngOpts["liquid"]["vdw_cutoff"] = TgtOptions["vdw_cutoff"]
# Hard Code nonbonded_cutoff to 13A for test
#EngOpts["liquid"]["nonbonded_cutoff"] = EngOpts["liquid"]["vdw_cutoff"] = 13.0
GenOpts = OrderedDict([('FF', FF)])
if engname == "openmm":
# OpenMM-specific options
EngOpts["liquid"]["platname"] = TgtOptions.get("platname", 'CUDA')
if force_cuda:
try:
Platform.getPlatformByName('CUDA')
except:
raise RuntimeError(
'Forcing failure because CUDA platform unavailable')
EngOpts["liquid"]["platname"] = 'CUDA'
if threads > 1:
logger.warn(
"Setting the number of threads will have no effect on OpenMM engine.\n"
)
EngOpts["liquid"].update(GenOpts)
for i in EngOpts:
printcool_dictionary(EngOpts[i], "Engine options for %s" % i)
# Set up MD options
MDOpts = OrderedDict()
MDOpts["liquid"] = OrderedDict([("nsteps", nvt_md_steps),
("timestep", nvt_timestep),
("temperature", temperature),
("nequil", nvt_eq_steps),
("minimize", minimize),
("nsave",
int(1000 * nvt_interval / nvt_timestep)),
("verbose", True),
('save_traj', TgtOptions['save_traj']),
("threads", threads), ("mts", mts),
("rpmd_beads", rpmd_beads),
("faststep", faststep)])
# Energy components analysis disabled for OpenMM MTS because it uses force groups
if (engname == "openmm" and mts):
logger.warn(
"OpenMM with MTS integrator; energy components analysis will be disabled.\n"
)
# Create instances of the MD Engine objects.
Liquid = Engine(name="liquid", **EngOpts["liquid"])
#=================================================================#
# Run the simulation for the full system and analyze the results. #
#=================================================================#
printcool("Condensed phase NVT molecular dynamics", color=4, bold=True)
click()
prop_return = Liquid.molecular_dynamics(**MDOpts["liquid"])
logger.info("Liquid phase MD simulation took %.3f seconds\n" % click())
Potentials = prop_return['Potentials']
#============================================#
# Compute the potential energy derivatives. #
#============================================#
if AGrad:
logger.info(
"Calculating potential energy derivatives with finite difference step size: %f\n"
% h)
# Switch for whether to compute the derivatives two different ways for consistency.
FDCheck = False
printcool(
"Condensed phase energy and dipole derivatives\nInitializing array to length %i"
% len(Potentials),
color=4,
bold=True)
click()
G, GDx, GDy, GDz = energy_derivatives(Liquid,
FF,
mvals,
h,
pgrad,
len(Potentials),
AGrad,
dipole=False)
logger.info("Condensed phase energy derivatives took %.3f seconds\n" %
click())
#==============================================#
# Condensed phase properties and derivatives. #
#==============================================#
# Physical constants
kB = 0.008314472471220214
T = temperature
kT = kB * T # Unit: kJ/mol
#--- Surface Tension ----
logger.info("Start Computing surface tension.\n")
perturb_proportion = 0.0005
box_vectors = np.array(
Liquid.xyz_omms[0][1] /
nanometer) # obtain original box vectors from first frame
delta_S = np.sqrt(
np.sum(np.cross(box_vectors[0], box_vectors[1])**
2)) * perturb_proportion * 2 # unit: nm^2. *2 for 2 surfaces
# perturb xy area +
click()
scale_x = scale_y = np.sqrt(1 + perturb_proportion)
scale_z = 1.0 / (
1 + perturb_proportion
) # keep the box volumn while changing the area of xy plane
Liquid.scale_box(scale_x, scale_y, scale_z)
logger.info("scale_box+ took %.3f seconds\n" % click())
# Obtain energies and gradients
Potentials_plus = Liquid.energy()
logger.info(
"Calculation of energies for perturbed box+ took %.3f seconds\n" %
click())
if AGrad:
G_plus, _, _, _ = energy_derivatives(Liquid,
FF,
mvals,
h,
pgrad,
len(Potentials),
AGrad,
dipole=False)
logger.info(
"Calculation of energy gradients for perturbed box+ took %.3f seconds\n"
% click())
# perturb xy area - ( Note: also need to cancel the previous scaling)
scale_x = scale_y = np.sqrt(1 - perturb_proportion) * (1.0 / scale_x)
scale_z = 1.0 / (1 - perturb_proportion) * (1.0 / scale_z)
Liquid.scale_box(scale_x, scale_y, scale_z)
logger.info("scale_box- took %.3f seconds\n" % click())
# Obtain energies and gradients
Potentials_minus = Liquid.energy()
logger.info(
"Calculation of energies for perturbed box- took %.3f seconds\n" %
click())
if AGrad:
G_minus, _, _, _ = energy_derivatives(Liquid,
FF,
mvals,
h,
pgrad,
len(Potentials),
AGrad,
dipole=False)
logger.info(
"Calculation of energy gradients for perturbed box- took %.3f seconds\n"
% click())
# Compute surface tension
dE_plus = Potentials_plus - Potentials # Unit: kJ/mol
dE_minus = Potentials_minus - Potentials # Unit: kJ/mol
prefactor = -0.5 * kT / delta_S / 6.0221409e-1 # Unit mJ m^-2
# Following equation: γ = -kT/(2ΔS) * [ ln<exp(-ΔE+/kT)> - ln<exp(-ΔE-/kT)> ]
#plus_avg, plus_err = mean_stderr(np.exp(-dE_plus/kT))
#minus_avg, minus_err = mean_stderr(np.exp(-dE_minus/kT))
#surf_ten = -0.5 * kT / delta_S * ( np.log(plus_avg) - np.log(minus_avg) ) / 6.0221409e-1 # convert to mJ m^-2
#surf_ten_err = 0.5 * kT / delta_S * ( np.log(plus_avg+plus_err) - np.log(plus_avg-plus_err) + np.log(minus_avg+minus_err) - np.log(minus_avg-minus_err) ) / 6.0221409e-1
exp_dE_plus = np.exp(-dE_plus / kT)
exp_dE_minus = np.exp(-dE_minus / kT)
surf_ten = prefactor * (np.log(np.mean(exp_dE_plus)) -
np.log(np.mean(exp_dE_minus)))
# Use bootstrap method to estimate the error
num_frames = len(exp_dE_plus)
numboots = 1000
surf_ten_boots = np.zeros(numboots)
for i in range(numboots):
boots_ordering = np.random.randint(num_frames, size=num_frames)
boots_exp_dE_plus = np.take(exp_dE_plus, boots_ordering)
boots_exp_dE_minus = np.take(exp_dE_minus, boots_ordering)
surf_ten_boots[i] = prefactor * (np.log(np.mean(boots_exp_dE_plus)) -
np.log(np.mean(boots_exp_dE_minus)))
surf_ten_err = np.std(surf_ten_boots) * np.sqrt(
np.mean([
statisticalInefficiency(exp_dE_plus),
statisticalInefficiency(exp_dE_minus)
]))
printcool("Surface Tension: % .4f +- %.4f mJ m^-2" %
(surf_ten, surf_ten_err))
# Analytic Gradient of surface tension
# Formula: β = 1/kT
# ∂γ/∂α = -kT/(2ΔS) * { 1/<exp(-βΔE+)> * [<-β ∂E+/∂α exp(-βΔE+)> - <-β ∂E/∂α><exp(-βΔE+)>]
# -1/<exp(-βΔE-)> * [<-β ∂E-/∂α exp(-βΔE-)> - <-β ∂E/∂α><exp(-βΔE-)>] }
n_params = len(mvals)
G_surf_ten = np.zeros(n_params)
if AGrad:
beta = 1.0 / kT
plus_denom = np.mean(np.exp(-beta * dE_plus))
minus_denom = np.mean(np.exp(-beta * dE_minus))
for param_i in range(n_params):
plus_left = np.mean(-beta * G_plus[param_i] *
np.exp(-beta * dE_plus))
plus_right = np.mean(-beta * G[param_i]) * plus_denom
minus_left = np.mean(-beta * G_minus[param_i] *
np.exp(-beta * dE_minus))
minus_right = np.mean(-beta * G[param_i]) * minus_denom
G_surf_ten[param_i] = prefactor * (1.0 / plus_denom *
(plus_left - plus_right) -
1.0 / minus_denom *
(minus_left - minus_right))
printcool("Analytic Derivatives:")
FF.print_map(vals=G_surf_ten)
logger.info("Writing final force field.\n")
pvals = FF.make(mvals)
logger.info("Writing all results to disk.\n")
result_dict = {
'surf_ten': surf_ten,
'surf_ten_err': surf_ten_err,
'G_surf_ten': G_surf_ten
}
lp_dump(result_dict, 'nvt_result.p')
def main():
"""
Usage: (runcuda.sh) npt.py <openmm|gromacs|tinker> <lipid_nsteps> <lipid_timestep (fs)> <lipid_intvl (ps> <temperature> <pressure>
This program is meant to be called automatically by ForceBalance on
a GPU cluster (specifically, subroutines in openmmio.py). It is
not easy to use manually. This is because the force field is read
in from a ForceBalance 'FF' class.
I wrote this program because automatic fitting of the density (or
other equilibrium properties) is computationally intensive, and the
calculations need to be distributed to the queue. The main instance
of ForceBalance (running on my workstation) queues up a bunch of these
jobs (using Work Queue). Then, I submit a bunch of workers to GPU
clusters (e.g. Certainty, Keeneland). The worker scripts connect to.
the main instance and receives one of these jobs.
This script can also be executed locally, if you want to (e.g. for
debugging). Just make sure you have the pickled 'forcebalance.p'
file.
"""
printcool("ForceBalance condensed phase simulation using engine: %s" %
engname.upper(),
color=4,
bold=True)
#----
# Load the ForceBalance pickle file which contains:
#----
# - Force field object
# - Optimization parameters
# - Options from the Target object that launched this simulation
# - Switch for whether to evaluate analytic derivatives.
FF, mvals, TgtOptions, AGrad = lp_load('forcebalance.p')
FF.ffdir = '.'
# Write the force field file.
FF.make(mvals)
#----
# Load the options that are set in the ForceBalance input file.
#----
# Finite difference step size
h = TgtOptions['h']
pgrad = TgtOptions['pgrad']
# MD options; time step (fs), production steps, equilibration steps, interval for saving data (ps)
lipid_timestep = TgtOptions['lipid_timestep']
lipid_nsteps = TgtOptions['lipid_md_steps']
lipid_nequil = TgtOptions['lipid_eq_steps']
lipid_intvl = TgtOptions['lipid_interval']
lipid_fnm = TgtOptions['lipid_coords']
# Number of threads, multiple timestep integrator, anisotropic box etc.
threads = TgtOptions.get('md_threads', 1)
mts = TgtOptions.get('mts_integrator', 0)
force_cuda = TgtOptions.get('force_cuda', 0)
anisotropic = TgtOptions.get('anisotropic_box', 0)
minimize = TgtOptions.get('minimize_energy', 1)
# Print all options.
printcool_dictionary(TgtOptions, title="Options from ForceBalance")
lipid_snapshots = int((lipid_nsteps * lipid_timestep / 1000) / lipid_intvl)
lipid_iframes = int(1000 * lipid_intvl / lipid_timestep)
logger.info("For the condensed phase system, I will collect %i snapshots spaced apart by %i x %.3f fs time steps\n" \
% (lipid_snapshots, lipid_iframes, lipid_timestep))
if lipid_snapshots < 2:
raise Exception('Please set the number of lipid time steps so that you collect at least two snapshots (minimum %i)' \
% (2000 * int(lipid_intvl/lipid_timestep)))
#----
# Loading coordinates
#----
ML = Molecule(lipid_fnm, toppbc=True)
# Determine the number of molecules in the condensed phase coordinate file.
NMol = len(ML.molecules)
#----
# Setting up MD simulations
#----
EngOpts = OrderedDict()
EngOpts["lipid"] = OrderedDict([("coords", lipid_fnm), ("mol", ML),
("pbc", True)])
if "nonbonded_cutoff" in TgtOptions:
EngOpts["lipid"]["nonbonded_cutoff"] = TgtOptions["nonbonded_cutoff"]
if "vdw_cutoff" in TgtOptions:
EngOpts["lipid"]["vdw_cutoff"] = TgtOptions["vdw_cutoff"]
GenOpts = OrderedDict([('FF', FF)])
if engname == "openmm":
# OpenMM-specific options
EngOpts["liquid"]["platname"] = TgtOptions.get("platname", 'CUDA')
# For now, always run gas phase calculations on the reference platform
EngOpts["gas"]["platname"] = 'Reference'
if force_cuda:
try:
Platform.getPlatformByName('CUDA')
except:
raise RuntimeError(
'Forcing failure because CUDA platform unavailable')
EngOpts["liquid"]["platname"] = 'CUDA'
if threads > 1:
logger.warn(
"Setting the number of threads will have no effect on OpenMM engine.\n"
)
elif engname == "gromacs":
# Gromacs-specific options
GenOpts["gmxpath"] = TgtOptions["gmxpath"]
GenOpts["gmxsuffix"] = TgtOptions["gmxsuffix"]
EngOpts["lipid"]["gmx_top"] = os.path.splitext(lipid_fnm)[0] + ".top"
EngOpts["lipid"]["gmx_mdp"] = os.path.splitext(lipid_fnm)[0] + ".mdp"
EngOpts["lipid"]["gmx_eq_barostat"] = TgtOptions["gmx_eq_barostat"]
if force_cuda:
logger.warn("force_cuda option has no effect on Gromacs engine.")
if mts:
logger.warn(
"Gromacs not configured for multiple timestep integrator.")
if anisotropic:
logger.warn("Gromacs not configured for anisotropic box scaling.")
elif engname == "tinker":
# Tinker-specific options
GenOpts["tinkerpath"] = TgtOptions["tinkerpath"]
EngOpts["lipid"]["tinker_key"] = os.path.splitext(
lipid_fnm)[0] + ".key"
if force_cuda:
logger.warn("force_cuda option has no effect on Tinker engine.")
if mts:
logger.warn(
"Tinker not configured for multiple timestep integrator.")
EngOpts["lipid"].update(GenOpts)
for i in EngOpts:
printcool_dictionary(EngOpts[i], "Engine options for %s" % i)
# Set up MD options
MDOpts = OrderedDict()
MDOpts["lipid"] = OrderedDict([("nsteps", lipid_nsteps),
("timestep", lipid_timestep),
("temperature", temperature),
("pressure", pressure),
("nequil", lipid_nequil),
("minimize", minimize),
("nsave",
int(1000 * lipid_intvl / lipid_timestep)),
("verbose", False),
('save_traj', TgtOptions['save_traj']),
("threads", threads),
("anisotropic", anisotropic), ("mts", mts),
("faststep", faststep), ("bilayer", True)])
# Energy components analysis disabled for OpenMM MTS because it uses force groups
if (engname == "openmm" and mts):
logger.warn(
"OpenMM with MTS integrator; energy components analysis will be disabled.\n"
)
# Create instances of the MD Engine objects.
Lipid = Engine(name="lipid", **EngOpts["lipid"])
#=================================================================#
# Run the simulation for the full system and analyze the results. #
#=================================================================#
printcool("Condensed phase molecular dynamics", color=4, bold=True)
# This line runs the condensed phase simulation.
prop_return = Lipid.molecular_dynamics(**MDOpts["lipid"])
Rhos = prop_return['Rhos']
Potentials = prop_return['Potentials']
Kinetics = prop_return['Kinetics']
Volumes = prop_return['Volumes']
Dips = prop_return['Dips']
EDA = prop_return['Ecomps']
Als = prop_return['Als']
Scds = prop_return['Scds']
# Create a bunch of physical constants.
# Energies are in kJ/mol
# Lengths are in nanometers.
L = len(Rhos)
kB = 0.008314472471220214
T = temperature
kT = kB * T
mBeta = -1.0 / kT
Beta = 1.0 / kT
atm_unit = 0.061019351687175
bar_unit = 0.060221417930000
# This is how I calculated the prefactor for the dielectric constant.
# eps0 = 8.854187817620e-12 * coulomb**2 / newton / meter**2
# epsunit = 1.0*(debye**2) / nanometer**3 / BOLTZMANN_CONSTANT_kB / kelvin
# prefactor = epsunit/eps0/3
prefactor = 30.348705333964077
# Gather some physical variables.
Energies = Potentials + Kinetics
Ene_avg, Ene_err = mean_stderr(Energies)
pV = atm_unit * pressure * Volumes
pV_avg, pV_err = mean_stderr(pV)
Rho_avg, Rho_err = mean_stderr(Rhos)
PrintEDA(EDA, NMol)
#============================================#
# Compute the potential energy derivatives. #
#============================================#
logger.info(
"Calculating potential energy derivatives with finite difference step size: %f\n"
% h)
# Switch for whether to compute the derivatives two different ways for consistency.
FDCheck = False
# Create a double-precision simulation object if desired (seems unnecessary).
DoublePrecisionDerivatives = False
if engname == "openmm" and DoublePrecisionDerivatives and AGrad:
logger.info(
"Creating Double Precision Simulation for parameter derivatives\n")
Lipid = Engine(name="lipid",
openmm_precision="double",
**EngOpts["lipid"])
# Compute the energy and dipole derivatives.
printcool(
"Condensed phase energy and dipole derivatives\nInitializing array to length %i"
% len(Energies),
color=4,
bold=True)
G, GDx, GDy, GDz = energy_derivatives(Lipid,
FF,
mvals,
h,
pgrad,
len(Energies),
AGrad,
dipole=True)
#==============================================#
# Condensed phase properties and derivatives. #
#==============================================#
#----
# Density
#----
# Build the first density derivative.
GRho = mBeta * (flat(np.dot(G, col(Rhos))) / L -
np.mean(Rhos) * np.mean(G, axis=1))
# Print out the density and its derivative.
Sep = printcool("Density: % .4f +- % .4f kg/m^3\nAnalytic Derivative:" %
(Rho_avg, Rho_err))
FF.print_map(vals=GRho)
logger.info(Sep)
def calc_rho(b=None, **kwargs):
if b is None: b = np.ones(L, dtype=float)
if 'r_' in kwargs:
r_ = kwargs['r_']
return bzavg(r_, b)
# No need to calculate error using bootstrap, but here it is anyway
# Rhoboot = []
# for i in range(numboots):
# boot = np.random.randint(N,size=N)
# Rhoboot.append(calc_rho(None,**{'r_':Rhos[boot]}))
# Rhoboot = np.array(Rhoboot)
# Rho_err = np.std(Rhoboot)
if FDCheck:
Sep = printcool("Numerical Derivative:")
GRho1 = property_derivatives(Lipid, FF, mvals, h, pgrad, kT, calc_rho,
{'r_': Rhos})
FF.print_map(vals=GRho1)
Sep = printcool("Difference (Absolute, Fractional):")
absfrac = [
"% .4e % .4e" % (i - j, (i - j) / j) for i, j in zip(GRho, GRho1)
]
FF.print_map(vals=absfrac)
#----
# Enthalpy of vaporization. Removed.
#----
H = Energies + pV
V = np.array(Volumes)
# Define some things to make the analytic derivatives easier.
Gbar = np.mean(G, axis=1)
def deprod(vec):
return flat(np.dot(G, col(vec))) / L
def covde(vec):
return flat(np.dot(G, col(vec))) / L - Gbar * np.mean(vec)
def avg(vec):
return np.mean(vec)
#----
# Thermal expansion coefficient
#----
def calc_alpha(b=None, **kwargs):
if b is None: b = np.ones(L, dtype=float)
if 'h_' in kwargs:
h_ = kwargs['h_']
if 'v_' in kwargs:
v_ = kwargs['v_']
return 1 / (kT * T) * (bzavg(h_ * v_, b) -
bzavg(h_, b) * bzavg(v_, b)) / bzavg(v_, b)
Alpha = calc_alpha(None, **{'h_': H, 'v_': V})
Alphaboot = []
numboots = 1000
for i in range(numboots):
boot = np.random.randint(L, size=L)
Alphaboot.append(calc_alpha(None, **{'h_': H[boot], 'v_': V[boot]}))
Alphaboot = np.array(Alphaboot)
Alpha_err = np.std(Alphaboot) * max([
np.sqrt(statisticalInefficiency(V)),
np.sqrt(statisticalInefficiency(H))
])
# Thermal expansion coefficient analytic derivative
GAlpha1 = -1 * Beta * deprod(H * V) * avg(V) / avg(V)**2
GAlpha2 = +1 * Beta * avg(H * V) * deprod(V) / avg(V)**2
GAlpha3 = deprod(V) / avg(V) - Gbar
GAlpha4 = Beta * covde(H)
GAlpha = (GAlpha1 + GAlpha2 + GAlpha3 + GAlpha4) / (kT * T)
Sep = printcool(
"Thermal expansion coefficient: % .4e +- %.4e K^-1\nAnalytic Derivative:"
% (Alpha, Alpha_err))
FF.print_map(vals=GAlpha)
if FDCheck:
GAlpha_fd = property_derivatives(Lipid, FF, mvals, h, pgrad, kT,
calc_alpha, {
'h_': H,
'v_': V
})
Sep = printcool("Numerical Derivative:")
FF.print_map(vals=GAlpha_fd)
Sep = printcool("Difference (Absolute, Fractional):")
absfrac = [
"% .4e % .4e" % (i - j, (i - j) / j)
for i, j in zip(GAlpha, GAlpha_fd)
]
FF.print_map(vals=absfrac)
#----
# Isothermal compressibility
#----
def calc_kappa(b=None, **kwargs):
if b is None: b = np.ones(L, dtype=float)
if 'v_' in kwargs:
v_ = kwargs['v_']
return bar_unit / kT * (bzavg(v_**2, b) - bzavg(v_, b)**2) / bzavg(
v_, b)
Kappa = calc_kappa(None, **{'v_': V})
Kappaboot = []
for i in range(numboots):
boot = np.random.randint(L, size=L)
Kappaboot.append(calc_kappa(None, **{'v_': V[boot]}))
Kappaboot = np.array(Kappaboot)
Kappa_err = np.std(Kappaboot) * np.sqrt(statisticalInefficiency(V))
# Isothermal compressibility analytic derivative
Sep = printcool(
"Isothermal compressibility: % .4e +- %.4e bar^-1\nAnalytic Derivative:"
% (Kappa, Kappa_err))
GKappa1 = +1 * Beta**2 * avg(V**2) * deprod(V) / avg(V)**2
GKappa2 = -1 * Beta**2 * avg(V) * deprod(V**2) / avg(V)**2
GKappa3 = +1 * Beta**2 * covde(V)
GKappa = bar_unit * (GKappa1 + GKappa2 + GKappa3)
FF.print_map(vals=GKappa)
if FDCheck:
GKappa_fd = property_derivatives(Lipid, FF, mvals, h, pgrad, kT,
calc_kappa, {'v_': V})
Sep = printcool("Numerical Derivative:")
FF.print_map(vals=GKappa_fd)
Sep = printcool("Difference (Absolute, Fractional):")
absfrac = [
"% .4e % .4e" % (i - j, (i - j) / j)
for i, j in zip(GKappa, GKappa_fd)
]
FF.print_map(vals=absfrac)
#----
# Isobaric heat capacity
#----
def calc_cp(b=None, **kwargs):
if b is None: b = np.ones(L, dtype=float)
if 'h_' in kwargs:
h_ = kwargs['h_']
Cp_ = 1 / (NMol * kT * T) * (bzavg(h_**2, b) - bzavg(h_, b)**2)
Cp_ *= 1000 / 4.184
return Cp_
Cp = calc_cp(None, **{'h_': H})
Cpboot = []
for i in range(numboots):
boot = np.random.randint(L, size=L)
Cpboot.append(calc_cp(None, **{'h_': H[boot]}))
Cpboot = np.array(Cpboot)
Cp_err = np.std(Cpboot) * np.sqrt(statisticalInefficiency(H))
# Isobaric heat capacity analytic derivative
GCp1 = 2 * covde(H) * 1000 / 4.184 / (NMol * kT * T)
GCp2 = mBeta * covde(H**2) * 1000 / 4.184 / (NMol * kT * T)
GCp3 = 2 * Beta * avg(H) * covde(H) * 1000 / 4.184 / (NMol * kT * T)
GCp = GCp1 + GCp2 + GCp3
Sep = printcool(
"Isobaric heat capacity: % .4e +- %.4e cal mol-1 K-1\nAnalytic Derivative:"
% (Cp, Cp_err))
FF.print_map(vals=GCp)
if FDCheck:
GCp_fd = property_derivatives(Lipid, FF, mvals, h, pgrad, kT, calc_cp,
{'h_': H})
Sep = printcool("Numerical Derivative:")
FF.print_map(vals=GCp_fd)
Sep = printcool("Difference (Absolute, Fractional):")
absfrac = [
"% .4e % .4e" % (i - j, (i - j) / j) for i, j in zip(GCp, GCp_fd)
]
FF.print_map(vals=absfrac)
#----
# Dielectric constant
#----
def calc_eps0(b=None, **kwargs):
if b is None: b = np.ones(L, dtype=float)
if 'd_' in kwargs: # Dipole moment vector.
d_ = kwargs['d_']
if 'v_' in kwargs: # Volume.
v_ = kwargs['v_']
b0 = np.ones(L, dtype=float)
dx = d_[:, 0]
dy = d_[:, 1]
dz = d_[:, 2]
D2 = bzavg(dx**2, b) - bzavg(dx, b)**2
D2 += bzavg(dy**2, b) - bzavg(dy, b)**2
D2 += bzavg(dz**2, b) - bzavg(dz, b)**2
return prefactor * D2 / bzavg(v_, b) / T
Eps0 = calc_eps0(None, **{'d_': Dips, 'v_': V})
Eps0boot = []
for i in range(numboots):
boot = np.random.randint(L, size=L)
Eps0boot.append(calc_eps0(None, **{'d_': Dips[boot], 'v_': V[boot]}))
Eps0boot = np.array(Eps0boot)
Eps0_err = np.std(Eps0boot) * np.sqrt(
np.mean([
statisticalInefficiency(Dips[:, 0]),
statisticalInefficiency(Dips[:, 1]),
statisticalInefficiency(Dips[:, 2])
]))
# Dielectric constant analytic derivative
Dx = Dips[:, 0]
Dy = Dips[:, 1]
Dz = Dips[:, 2]
D2 = avg(Dx**2) + avg(Dy**2) + avg(
Dz**2) - avg(Dx)**2 - avg(Dy)**2 - avg(Dz)**2
GD2 = 2 * (flat(np.dot(GDx, col(Dx))) / L - avg(Dx) *
(np.mean(GDx, axis=1))) - Beta * (covde(Dx**2) -
2 * avg(Dx) * covde(Dx))
GD2 += 2 * (flat(np.dot(GDy, col(Dy))) / L - avg(Dy) *
(np.mean(GDy, axis=1))) - Beta * (covde(Dy**2) -
2 * avg(Dy) * covde(Dy))
GD2 += 2 * (flat(np.dot(GDz, col(Dz))) / L - avg(Dz) *
(np.mean(GDz, axis=1))) - Beta * (covde(Dz**2) -
2 * avg(Dz) * covde(Dz))
GEps0 = prefactor * (GD2 / avg(V) - mBeta * covde(V) * D2 / avg(V)**2) / T
Sep = printcool(
"Dielectric constant: % .4e +- %.4e\nAnalytic Derivative:" %
(Eps0, Eps0_err))
FF.print_map(vals=GEps0)
if FDCheck:
GEps0_fd = property_derivatives(Lipid, FF, mvals, h, pgrad, kT,
calc_eps0, {
'd_': Dips,
'v_': V
})
Sep = printcool("Numerical Derivative:")
FF.print_map(vals=GEps0_fd)
Sep = printcool("Difference (Absolute, Fractional):")
absfrac = [
"% .4e % .4e" % (i - j, (i - j) / j)
for i, j in zip(GEps0, GEps0_fd)
]
FF.print_map(vals=absfrac)
#----
# Average area per lipid
#----
Al_avg, Al_err = mean_stderr(Als)
# Build the first A_l derivative.
GAl = mBeta * (flat(np.dot(G, col(Als))) / L -
np.mean(Als) * np.mean(G, axis=1))
# Print out A_l and its derivative.
Sep = printcool(
"Average Area per Lipid: % .4f +- % .4f nm^2\nAnalytic Derivative:" %
(Al_avg, Al_err))
FF.print_map(vals=GAl)
logger.info(Sep)
def calc_al(b=None, **kwargs):
if b is None: b = np.ones(L, dtype=float)
if 'a_' in kwargs:
a_ = kwargs['a_']
return bzavg(a_, b)
# calc_al(None, **{'a_': Als})
#----
# Bilayer Isothermal compressibility
#----
kbT = 1.3806488e-23 * T
def calc_lkappa(b=None, **kwargs):
if b is None: b = np.ones(L, dtype=float)
if 'a_' in kwargs:
a_ = kwargs['a_']
al_var = bzavg(a_**2, b) - bzavg(a_, b)**2
# Avoid dividing by zero if A_L time series is too short.
if abs(al_var) > 0:
return (1e3 * 2 * kbT / 128) * (bzavg(a_, b) / al_var)
else:
return 0 * bzavg(a_, b)
# Convert Als time series from nm^2 to m^2
Als_m2 = Als * 1e-18
LKappa = calc_lkappa(None, **{'a_': Als_m2})
al_avg = avg(Als_m2)
al_sq_avg = avg(Als_m2**2)
al_avg_sq = al_avg**2
al_var = al_sq_avg - al_avg_sq
LKappaboot = []
for i in range(numboots):
boot = np.random.randint(L, size=L)
LKappaboot.append(calc_lkappa(None, **{'a_': Als_m2[boot]}))
LKappaboot = np.array(LKappaboot)
LKappa_err = np.std(LKappaboot) * np.sqrt(statisticalInefficiency(Als_m2))
# Bilayer Isothermal compressibility analytic derivative
Sep = printcool(
"Lipid Isothermal compressibility: % .4e +- %.4e N/nm^-1\nAnalytic Derivative:"
% (LKappa, LKappa_err))
GLKappa1 = covde(Als_m2) / al_var
GLKappa2 = (al_avg / al_var**2) * (covde(Als_m2**2) -
(2 * al_avg * covde(Als_m2)))
GLKappa = (1e3 * 2 * kbT / 128) * (GLKappa1 - GLKappa2)
FF.print_map(vals=GLKappa)
if FDCheck:
GLKappa_fd = property_derivatives(Lipid, FF, mvals, h, pgrad, kT,
calc_lkappa, {'a_': Als_m2})
Sep = printcool("Numerical Derivative:")
FF.print_map(vals=GLKappa_fd)
Sep = printcool("Difference (Absolute, Fractional):")
absfrac = [
"% .4e % .4e" % (i - j, (i - j) / j)
for i, j in zip(GLKappa, GLKappa_fd)
]
FF.print_map(vals=absfrac)
#----
# Deuterium Order Parameter
#----
Scd_avg, Scd_e = mean_stderr(Scds)
Scd_err = flat(Scd_e)
# In case I did the conversion incorrectly, this is the code that was here previously:
# GScd = mBeta * (((np.mat(G) * Scds) / L) - (np.mat(np.average(G, axis = 1)).T * np.average(Scds, axis = 0)))
GScd = mBeta * (
((np.dot(G, Scds)) / L) -
np.dot(col(np.average(G, axis=1)), row(np.average(Scds, axis=0))))
# Print out S_cd and its derivative.
scd_avgerr = ' '.join('%.4f +- %.4f \n' % F for F in zip(Scd_avg, Scd_err))
Sep = printcool("Deuterium order parameter: %s \nAnalytic Derivative:" %
scd_avgerr)
FF.print_map(vals=GScd)
logger.info(Sep)
def calc_scd(b=None, **kwargs):
if b is None: b = np.ones(L, dtype=float)
if 's_' in kwargs:
s_ = kwargs['s_']
return bzavg(s_, b)
# calc_scd(None, **{'s_': Scds})
logger.info("Writing final force field.\n")
pvals = FF.make(mvals)
logger.info("Writing all simulation data to disk.\n")
lp_dump((Rhos, Volumes, Potentials, Energies, Dips, G, [GDx, GDy, GDz],
Rho_err, Alpha_err, Kappa_err, Cp_err, Eps0_err, NMol, Als,
Al_err, Scds, Scd_err, LKappa_err), 'npt_result.p')
def main():
"""Usage:
(prefix.sh) md_one.py -T, --temperature <temperature in kelvin>
-P, --pressure <pressure in atm>
-g, --grad (if gradients of output timeseries are desired)
-eq, --nequil <number of equilibration MD steps>
-md, --nsteps <number of production MD steps>
-dt, --timestep <number of production MD steps>
-sp, --sample <number of production MD steps>
-nt, --threads <number of CPU threads to use>
-min, --minimize <minimize the energy>
This program is meant to be called automatically by ForceBalance because
force field options are loaded from the 'forcefield.p' file, and
simulation options are loaded from the 'simulation.p' file.
The files are separated because the same force field file
may be used for many simulations.
"""
# Write the force field file.
FF.make(mvals)
# Read the command line options (they may override the options from file.)
AGrad = args['gradient']
for i in [
'temperature', 'pressure', 'nequil', 'nsteps', 'timestep',
'sample', 'threads', 'minimize'
]:
if i in args:
MDOpts[i] = args[i]
MDOpts['nsave'] = int(1000.0 * MDOpts['sample'] / MDOpts['timestep'])
if 'save_traj' in TgtOpts:
MDOpts['save_traj'] = TgtOpts['save_traj']
#----
# Print some options.
# At this point, engine and MD options should be SET!
#----
printcool("ForceBalance simulation using engine: %s" % engname.upper(),
color=4,
bold=True)
printcool_dictionary(args, title="Options from command line")
printcool_dictionary(EngOpts, title="Engine options")
printcool_dictionary(MDOpts, title="Molecular dynamics options")
#----
# For convenience, assign some local variables.
#----
# Finite difference step size
h = TgtOpts['h']
# Active parameters to differentiate
pgrad = TgtOpts['pgrad']
# Create instances of the MD Engine objects.
Engine = EngineClass(**EngOpts)
click() # Start timer.
# This line runs the condensed phase simulation.
#----
# The molecular dynamics simulation returns a dictionary of properties
# In the future, the properties will be stored as data inside the object
Results = Engine.molecular_dynamics(**MDOpts)
if AGrad:
Results['Potential_Derivatives'] = energy_derivatives(
Engine, FF, mvals, h, pgrad, dipole=False)['potential']
# Set up engine and calculate the potential in the other phase.
EngOpts_ = deepcopy(EngOpts)
EngOpts_['implicit_solvent'] = not EngOpts['implicit_solvent']
Engine_ = EngineClass(**EngOpts_)
Engine_.xyz_omms = Engine.xyz_omms
Energy_ = Engine_.energy()
Results_ = {'Potentials': Energy_}
if AGrad:
Derivs_ = energy_derivatives(Engine_,
FF,
mvals,
h,
pgrad,
dipole=False)['potential']
Results_['Potential_Derivatives'] = Derivs_
# Calculate the hydration energy of each snapshot and its parametric derivatives.
if EngOpts['implicit_solvent']:
Energy_liq = Results['Potentials']
Energy_gas = Results_['Potentials']
if AGrad:
Derivs_liq = Results['Potential_Derivatives']
Derivs_gas = Results_['Potential_Derivatives']
else:
Energy_gas = Results['Potentials']
Energy_liq = Results_['Potentials']
if AGrad:
Derivs_gas = Results['Potential_Derivatives']
Derivs_liq = Results_['Potential_Derivatives']
Results['Hydration'] = Energy_liq - Energy_gas
if AGrad:
Results['Hydration_Derivatives'] = Derivs_liq - Derivs_gas
# Code of the future!
# Don't know how to use it yet though.
# Engine.molecular_dynamics(**MDOpts)
# logger.info("MD simulation took %.3f seconds\n" % click())
# # Extract properties.
# Results = Engine.md_extract(OrderedDict([(i, {}) for i in Tgt.timeseries.keys()]))
# potential = properties['Potential']
# Calculate energy and dipole derivatives if needed.
# if AGrad:
# Results['derivatives'] = energy_derivatives(Engine, FF, mvals, h, pgrad, dipole='dipole' in Tgt.timeseries.keys())
# Dump results to file
logger.info("Writing final force field.\n")
pvals = FF.make(mvals)
logger.info("Writing all simulation data to disk.\n")
lp_dump(Results, 'md_result.p')
def extract(self, engines, FF, mvals, h, pgrad, AGrad=True):
#==========================================#
# Physical constants and local variables. #
#==========================================#
# Energies in kJ/mol and lengths in nanometers.
kB = 0.008314472471220214
kT = kB * self.temperature
Beta = 1.0 / kT
mBeta = -Beta
# Conversion factor between 1 kJ/mol -> bar nm^3
pconv = 16.6054
# Number of molecules in the liquid phase.
mol = Molecule(
os.path.basename(os.path.splitext(engines[0].mdtraj)[0]) + ".gro")
nmol = len(mol.molecules)
#======================================================#
# Get simulation properties depending on the engines. #
#======================================================#
if self.engname == "gromacs":
# Default names
deffnm1 = os.path.basename(os.path.splitext(engines[0].mdene)[0])
deffnm2 = os.path.basename(os.path.splitext(engines[1].mdene)[0])
# Figure out which energy terms and present and their order.
energyterms1 = engines[0].energy_termnames(edrfile="%s.%s" %
(deffnm1, "edr"))
energyterms2 = engines[1].energy_termnames(edrfile="%s.%s" %
(deffnm2, "edr"))
# Grab energy terms to print and keep track of energy term order.
ekeep1 = [
'Total-Energy', 'Potential', 'Kinetic-En.', 'Temperature',
'Volume'
]
ekeep2 = [
'Total-Energy', 'Potential', 'Kinetic-En.', 'Temperature'
]
ekeep_order1 = [
key
for (key, value
) in sorted(energyterms1.items(), key=lambda (k, v): v)
if key in ekeep1
]
ekeep_order2 = [
key
for (key, value
) in sorted(energyterms2.items(), key=lambda (k, v): v)
if key in ekeep2
]
# Perform energy component analysis and return properties.
engines[0].callgmx(
("g_energy " + "-f %s.%s " %
(deffnm1, "edr") + "-o %s-energy.xvg " % deffnm1 + "-xvg no"),
stdin="\n".join(ekeep1))
engines[1].callgmx(
("g_energy " + "-f %s.%s " %
(deffnm2, "edr") + "-o %s-energy.xvg " % deffnm2 + "-xvg no"),
stdin="\n".join(ekeep2))
# Read data and store properties by grabbing columns in right order.
data1 = np.loadtxt("%s-energy.xvg" % deffnm1)
data2 = np.loadtxt("%s-energy.xvg" % deffnm2)
Energy = data1[:, ekeep_order1.index("Total-Energy") + 1]
Potential = data1[:, ekeep_order1.index("Potential") + 1]
Kinetic = data1[:, ekeep_order1.index("Kinetic-En.") + 1]
Temperature = data1[:, ekeep_order1.index("Temperature") + 1]
Volume = data1[:, ekeep_order1.index("Volume") + 1]
mEnergy = data2[:, ekeep_order2.index("Total-Energy") + 1]
mPotential = data2[:, ekeep_order2.index("Potential") + 1]
mKinetic = data2[:, ekeep_order2.index("Kinetic-En.") + 1]
#============================================#
# Compute the potential energy derivatives. #
#============================================#
logger.info(("Calculating potential energy derivatives " +
"with finite difference step size: %f\n" % h))
printcool("Initializing arrays to lengths %d" % len(Energy),
color=4,
bold=True)
G = energy_derivatives(engines[0], FF, mvals, h, pgrad, len(Energy),
AGrad)
Gm = energy_derivatives(engines[1], FF, mvals, h, pgrad, len(mEnergy),
AGrad)
#=======================================#
# Quantity properties and derivatives. #
#=======================================#
# Average and error.
E_avg, E_err = mean_stderr(Energy)
Em_avg, Em_err = mean_stderr(mEnergy)
Vol_avg, Vol_err = mean_stderr(Volume)
Hvap_avg = Em_avg - E_avg / nmol - self.pressure * Vol_avg / nmol / pconv + kT
Hvap_err = np.sqrt((E_err / nmol)**2 + Em_err**2 + (self.pressure**2) *
(Vol_err**2) / (float(nmol)**2) / (pconv**2))
# Analytic first derivative.
Hvap_grad = np.mean(Gm, axis=1)
Hvap_grad += mBeta * (flat(np.mat(Gm) * col(mEnergy)) / len(mEnergy) \
- np.mean(mEnergy) * np.mean(Gm, axis=1))
Hvap_grad -= np.mean(G, axis=1) / nmol
Hvap_grad += Beta * (flat(np.mat(G) * col(Energy)) / len(Energy) \
- np.mean(Energy) * np.mean(G, axis=1))/nmol
Hvap_grad += (Beta*self.pressure/nmol/pconv) * \
(flat(np.mat(G) * col(Volume)) / len(Volume) \
- np.mean(Volume) * np.mean(G, axis=1))
return Hvap_avg, Hvap_err, Hvap_grad
def main():
printcool(
"Welcome to ForceBalance version 1.7.5! =D\nForce Field Optimization System\n\nAuthors:\nLee-Ping Wang\nYudong Qiu, Keri A. McKiernan\nJeffrey R. Wagner, Hyesu Jang, Simon Boothroyd\nArthur Vigil, Erik G. Brandt\nJohnny Israeli, John Stoppelman",
ansi="1",
bold=True,
minwidth=64)
logostr = """
,'+++
,++++++. .:,,.
:+++++'` `; `,:::::.`
'+++++' `'++++ `,::::,,`
`;+++++: ,+++++'. `.:::::,`
`++++++, :+++++'` .,::::,`
.+++++'. ;+++++' `,,:::,`
:+++++'` `;+++++: `,::::,.`
++++;` `++++++: `.:+@@###@' `,,::::.`
: ,++++++. ,;'+###############. .,::,
:++++++` +################':` .
+++;` `.,,...####+.
,##### +##. +++ +++
,,,, ##### ###### +++ +++
,::, ###' ####' :#####' +++ +++
,::, :####@ ####. ,####' +++ +++
,::, ###### #### +###+ +++ +++
,::, ##### #### ###; +++ +++
,::, :## #### ++` +++ +++
,::, ####``..:;+##############+` +++ +++
,::, .,:;;'++##################################` +++ +++
,::, `############################++++''';;;;;;;;;;;''; +++ +++
,::, ,########':,.`` #### +++ +++
,::, #### +++ +++
,::, #### +++ +++
,::, #### +++ +++
,::, #### +++ +++
,::, #### +++ +++
,::, #### +++ +++
,,,, #### +++ +++
;++, ####
`'+++++: ####
` '+++++; #### `.,:.
++++, :+++++'` #### `,:::::.
.'+++++, :++++++. ### `,::::,.`
`'+++++; .++++++, +` .,::::,`
;+++++'` `++++++: .,:::,,`
:+++++'. `;+++++;` `.:::::,`
,++++++` '++++++ `,::::,,`
.'+++++: ,+; `,:::::.
`'+++++: ,::,,.
;++++. ,`
,`
"""
b = 'blue'
g = 'gold'
k = 'black'
colorlist = [[], [b], [b, g], [b, b, g], [b, b, g], [b, b, g], [b, b, g],
[b, b, g], [b, b, g], [b, b, k, g], [b, b, k, g], [b, k, g],
[b, k], [k, k, b, b], [g, k, k, b, b], [g, k, k, k, b, b],
[g, k, k, k, b, b], [g, k, k, k, b, b], [g, k, k, k, b, b],
[g, k, k, k, b, b], [g, k, b, b], [g, k, b, b], [g, k, b, b],
[g, k, k, b, b], [g, k, b, b], [g, k, b, b], [g, k, b, b],
[g, k, b, b], [g, k, b, b], [g, k, b, b], [g, k, b, b],
[b, k], [b, k], [b, b, k, g], [b, b, k, g], [b, b, k, g],
[b, b, k, g], [b, b, g], [b, b, g], [b, b, g], [b, b, g],
[b, g], [b, g], [b], []]
words = [l.split() for l in logostr.split('\n')]
for ln, line in enumerate(logostr.split('\n')):
# Reconstruct the line.
words = line.split()
whites = re.findall('[ ]+', line)
newline = ''
i = 0
if len(line) > 0 and line[0] == ' ':
while i < max(len(words), len(whites)):
try:
newline += whites[i]
except:
pass
try:
newline += process(words[i], colorlist[ln][i])
except:
pass
i += 1
elif len(line) > 0:
while i < max(len(words), len(whites)):
try:
newline += process(words[i], colorlist[ln][i])
except:
pass
try:
newline += whites[i]
except:
pass
i += 1
print(newline)
parser = argparse.ArgumentParser(
description="Force Field Optimization System")
parser.add_argument("-c",
"--continue",
action="store_true",
help="Continue from a previous run")
parser.add_argument("-d",
"--debug",
action="store_true",
help="Run interactive debugger on program crash")
parser.add_argument("input", help="Forcebalance input file")
args = parser.parse_args()
continue_ = getattr(args, 'continue')
Run_ForceBalance(args.input, debug=args.debug, continue_=continue_)
def _initialize(self):
"""Initializes the property estimator target from an input json file.
1. Reads the user specified input file.
2. Creates a `propertyestimator` client object.
3. Loads in a reference experimental data set.
4. Assigns and normalises weights for each property.
"""
# Load in the options from a user provided JSON file.
print(os.path.join(self.tgtdir, self.prop_est_input))
options_file_path = os.path.join(self.tgtdir, self.prop_est_input)
self._options = self.OptionsFile.from_json(options_file_path)
# Attempt to create a property estimator client object using the specified
# connection options.
self._client = PropertyEstimatorClient(
connection_options=self._options.connection_options)
# Load in the experimental data set.
data_set_path = os.path.join(self.tgtdir, self._options.data_set_path)
with open(data_set_path, 'r') as file:
self._data_set = PhysicalPropertyDataSet.parse_json(file.read())
if len(self._data_set.properties) == 0:
raise ValueError(
'The physical property data set to optimise against is empty.')
# Convert the reference data into a more easily comparable form.
self._reference_properties = self._refactor_properties_dictionary(
self._data_set.properties)
# Print the reference data, and count the number of instances of
# each property type.
printcool("Loaded experimental data from property estimator")
number_of_properties = {
property_name: 0.0
for property_name in self._reference_properties
}
for property_name in self._reference_properties:
for substance_id in self._reference_properties[property_name]:
dict_for_print = {}
for state_tuple in self._reference_properties[property_name][
substance_id]:
value = self._reference_properties[property_name][
substance_id][state_tuple]['value']
uncertainty = self._reference_properties[property_name][
substance_id][state_tuple]['uncertainty']
dict_for_print["%sK-%satm" %
state_tuple] = ("%f+/-%f" %
(value, uncertainty))
number_of_properties[property_name] += 1.0
printcool_dictionary(dict_for_print,
title="Reference %s (%s) data" %
(property_name, substance_id))
# Assign and normalize weights for each phase point (average for now)
self._normalised_weights = {}
for property_name in self._reference_properties:
self._normalised_weights[property_name] = (
self._options.weights[property_name] /
number_of_properties[property_name])
