def deserialize_input(self, content):
"""Retreive the state and topology from the message content
The message protocol tries not to pass 'data' around within the
messages, but instead pass paths to data. So far we're only sending
paths on the local filesystem, but we might could generalize this to
HTTP or S3 or something later.
The assumption that data can be passed around on the local filesystem
shouldn't be built deep into the code at all
"""
# todo: better name for this function?
if content.starting_state.protocol == 'localfs':
with open(content.starting_state.path) as f:
self.log.info('Opening state file: %s', content.starting_state.path)
state = XmlSerializer.deserialize(f.read())
else:
raise ValueError('Unknown protocol')
if content.topology_pdb.protocol == 'localfs':
topology = PDBFile(content.topology_pdb.path).topology
else:
raise ValueError('Unknown protocol')
return state, topology
def _extract_charges(self):
"""Extracts all of the charges from a system object.
Returns
-------
list of float
"""
from simtk import unit as simtk_unit
charge_list = []
with open(self._system_path, 'r') as file:
system = XmlSerializer.deserialize(file.read())
for force_index in range(system.getNumForces()):
force = system.getForce(force_index)
if not isinstance(force, openmm.NonbondedForce):
continue
for atom_index in range(force.getNumParticles()):
charge = force.getParticleParameters(atom_index)[0]
charge = charge.value_in_unit(simtk_unit.elementary_charge)
charge_list.append(charge)
return charge_list
def minimization():
# Load OpenMM System
file = open(xml_filename, 'r')
serialized_system = file.read()
system = XmlSerializer.deserialize(serialized_system)
# Select Integrator
integrator = mm.LangevinIntegrator(TEMPERATURE, MIN_FRICTION,
MIN_TIME_STEP)
# Set Simulation
simulation = app.Simulation(prmtop.topology, system, integrator,
MIN_PLATFORM)
# Set Position
simulation.context.setPositions(inpcrd.positions)
state = simulation.context.getState(getEnergy=True)
if np.isnan(state.getPotentialEnergy() / kilojoule_per_mole):
raise ValueError("The Potential Energy before minimization is NaN")
# Minimization
print('Minimizing...\n')
simulation.minimizeEnergy(tolerance=MIN_TOLERANCE, maxIterations=MIN_STEPS)
state = simulation.context.getState(getPositions=True, getEnergy=True)
if np.isnan(state.getPotentialEnergy() / kilojoule_per_mole):
raise ValueError("The Potential Energy after minimization is NaN")
coords = state.getPositions()
return coords
def deserialize_input(self, content):
"""Retreive the state and topology from the message content
The message protocol tries not to pass 'data' around within the
messages, but instead pass paths to data. So far we're only sending
paths on the local filesystem, but we might could generalize this to
HTTP or S3 or something later.
The assumption that data can be passed around on the local filesystem
shouldn't be built deep into the code at all
"""
# todo: better name for this function?
if content.starting_state.protocol == 'localfs':
with open(content.starting_state.path) as f:
self.log.info('Opening state file: %s',
content.starting_state.path)
state = XmlSerializer.deserialize(f.read())
else:
raise ValueError('Unknown protocol')
if content.topology_pdb.protocol == 'localfs':
topology = PDBFile(content.topology_pdb.path).topology
else:
raise ValueError('Unknown protocol')
return state, topology
def from_xml(cls, path):
with open(path) as f:
xml = XmlSerializer.deserialize(f.read())
positions = xml.getPositions()
velocities = xml.getVelocities()
box = xml.getPeriodicBoxVectors()
return cls(positions=positions, velocities=velocities, box=box)
def fix_system(system_xml_filename):
"""
Set the PME parameters explicitly in a specified system XML file if they are not already set.
The file is renamed with '.old' appended, and a corrected file written in its place.
Parameters
----------
system_xml_filename : str
The name of the serialized system XML file to be modified
"""
system = XmlSerializer.deserialize(read_file(system_xml_filename))
forces = {
system.getForce(force_index).__class__.__name__:
system.getForce(force_index)
for force_index in range(system.getNumForces())
}
force = forces['NonbondedForce']
(alpha, nx, ny, nz) = force.getPMEParameters()
if alpha == 0.0 / unit.nanometers:
(alpha, nx, ny, nz) = calc_pme_parameters(system)
force.setPMEParameters(alpha, nx, ny, nz)
serialized_system = XmlSerializer.serialize(system)
os.rename(system_xml_filename, system_xml_filename + '.old')
write_file(system_xml_filename, serialized_system)
return
def __init__(self, **kwargs):
Calculator.__init__(self, **kwargs)
input = self.parameters.input
fileType = self.parameters.fileType
if fileType == "xyz":
print("Generating OpenMM system")
self.system,self.topology = self.setUpMM3(self.parameters.ASEmol, self.parameters.atomTypes)
positions = [x for x in self.parameters.ASEmol.get_positions()]
if fileType == "xml":
print("Generating OpenMM system")
f = open('OpenMM.xml','r')
sys = f.read()
#self.system = forcefield.createSystem(topology, nonbondedMethod=self.parameters.nonbondedMethod,nonbondedCutoff=self.parameters.nonbondedCutoff)
self.system = XmlSerializer.deserialize(sys)
#box_vec = self.system.getDefaultPeriodicBoxVectors()
#self.parameters.ASEmol.set_cell([box_vec[0]._value[0]*10,box_vec[1]._value[1]*10,box_vec[2]._value[2]*10])
#self.parameters.ASEmol.pbc = (True,True,True)
#self.parameters.ASEmol.wrap()
positions = [x for x in self.parameters.ASEmol.get_positions()]
# Create a dummy integrator, this doesn't really matter.
self.integrator = VerletIntegrator(0.001 * picosecond)
self.platform = Platform.getPlatformByName("CPU")
self.context = openmm.Context(self.system, self.integrator)
self.context.setPositions(positions * angstrom)
state = self.context.getState(getEnergy=True)
print("Energy: ", state.getPotentialEnergy(), len(positions))
self.n_atoms = len(positions)
def __init__(self, system, integrator=None):
# if strings are passed in, assume that they are paths to
# xml files on disk
if isinstance(system, basestring):
with open(system) as f:
system = XmlSerializer.deserialize(f.read())
if isinstance(integrator, basestring):
with open(integrator) as f:
integrator = XmlSerializer.deserialize(f.read())
if integrator is None:
# this integrator isn't really necessary, but it has to be something
# for the openmm API to let us serialize the state
integrator = VerletIntegrator(2*femtoseconds)
self.context = Context(system, integrator, Platform.getPlatformByName('Reference'))
def from_xml(cls, path):
with open(path) as f:
xml = XmlSerializer.deserialize(f.read())
positions = xml.getPositions()
velocities = xml.getVelocities()
box = xml.getPeriodicBoxVectors()
return cls(positions=positions, velocities=velocities, box=box)
def __init__(self, system, integrator=None):
# if strings are passed in, assume that they are paths to
# xml files on disk
if isinstance(system, basestring):
with open(system) as f:
system = XmlSerializer.deserialize(f.read())
if isinstance(integrator, basestring):
with open(integrator) as f:
integrator = XmlSerializer.deserialize(f.read())
if integrator is None:
# this integrator isn't really necessary, but it has to be something
# for the openmm API to let us serialize the state
integrator = VerletIntegrator(2 * femtoseconds)
self.context = Context(system, integrator,
Platform.getPlatformByName('Reference'))
def start(self):
# load up the system and integrator files
with open(self.system_xml) as f:
self.system = XmlSerializer.deserialize(f.read())
# reset the random number seed for any random
# forces (andersen thermostat, montecarlo barostat)
for i in range(self.system.getNumForces()):
force = self.system.getForce(i)
if hasattr(force, 'setRandomNumberSeed'):
force.setRandomNumberSeed(random_seed())
with open(self.integrator_xml) as f:
self.integrator = XmlSerializer.deserialize(f.read())
# reset the random number seed for a stochastic integrator
if hasattr(self.integrator, 'setRandomNumberSeed'):
self.integrator.setRandomNumberSeed(random_seed())
super(OpenMMSimulator, self).start()
def start(self):
# load up the system and integrator files
with open(self.system_xml) as f:
self.system = XmlSerializer.deserialize(f.read())
# reset the random number seed for any random
# forces (andersen thermostat, montecarlo barostat)
for i in range(self.system.getNumForces()):
force = self.system.getForce(i)
if hasattr(force, 'setRandomNumberSeed'):
force.setRandomNumberSeed(random_seed())
with open(self.integrator_xml) as f:
self.integrator = XmlSerializer.deserialize(f.read())
# reset the random number seed for a stochastic integrator
if hasattr(self.integrator, 'setRandomNumberSeed'):
self.integrator.setRandomNumberSeed(random_seed())
super(OpenMMSimulator, self).start()
def nvt(coords):
# Load OpenMM System
file = open(xml_filename, 'r')
serialized_system = file.read()
system = XmlSerializer.deserialize(serialized_system)
# Select Integrator
integrator = mm.LangevinIntegrator(TEMPERATURE, NVT_FRICTION,
NVT_TIME_STEP)
# Set Simulation
simulation = app.Simulation(pdb.topology, system, integrator, NVT_PLATFORM,
NVT_PROPERTIES)
#DEBUG STUFF
properties = NVT_PLATFORM.getPropertyValue(simulation.context,
'DeviceIndex')
print(properties)
print(NVT_PLATFORM.getPropertyNames())
print(NVT_PLATFORM.getSpeed())
#DEBUG STUFF
# Set Position and velocities
simulation.context.setPositions(coords)
simulation.context.setVelocitiesToTemperature(TEMPERATURE)
# Set Reporter
simulation.reporters.append(
app.DCDReporter(nvt_dcd_filename, NVT_OUTPUT_FREQ))
simulation.reporters.append(
app.StateDataReporter(nvt_data_filename,
NVT_DATA_FREQ,
step=True,
potentialEnergy=True,
temperature=True,
density=True))
state = simulation.context.getState(getEnergy=True)
if np.isnan(state.getPotentialEnergy() / kilojoule_per_mole):
raise ValueError("The Potential Energy before NVT is NaN")
print('NVT...\n')
simulation.step(NVT_STEPS)
state = simulation.context.getState(getPositions=True,
getVelocities=True,
getEnergy=True)
if np.isnan(state.getPotentialEnergy() / kilojoule_per_mole):
raise ValueError("The Potential Energy after NVT is NaN")
coords = state.getPositions()
velocities = state.getVelocities()
return coords, velocities
def npt(coords, velocities):
# Create OpenMM System
file = open(xml_filename, 'r')
serialized_system = file.read()
system = XmlSerializer.deserialize(serialized_system)
# Select Integrator
integrator = mm.LangevinIntegrator(TEMPERATURE, NPT_FRICTION,
NPT_TIME_STEP)
# Set Barostat
system.addForce(
mm.MonteCarloBarostat(PRESSURE, TEMPERATURE, BAROSTAT_FREQUENCY))
# Set Simulation
simulation = app.Simulation(prmtop.topology, system, integrator,
NPT_PLATFORM, NPT_PROPERTIES)
# Set Position and velocities
simulation.context.setPositions(coords)
simulation.context.setVelocities(velocities)
# Set Reporter
simulation.reporters.append(
app.DCDReporter(npt_dcd_filename, NPT_OUTPUT_FREQ))
simulation.reporters.append(
app.StateDataReporter(npt_data_filename,
NPT_DATA_FREQ,
step=True,
potentialEnergy=True,
temperature=True,
density=True))
state = simulation.context.getState(getEnergy=True)
if np.isnan(state.getPotentialEnergy() / kilojoule_per_mole):
raise ValueError("The Potential Energy before NPT is NaN")
print('NPT...\n')
simulation.step(NPT_STEPS)
state = simulation.context.getState(getPositions=True,
getVelocities=True,
getEnergy=True)
if np.isnan(state.getPotentialEnergy() / kilojoule_per_mole):
raise ValueError("The Potential Energy after NPT is NaN")
coords = state.getPositions()
velocities = state.getVelocities()
box = state.getPeriodicBoxVectors()
return coords, velocities, box
def get_xml(xml_file):
# TODO file access control
attempt = 0
retries = 500
if not xml_file.endswith('.xml'):
raise IOError("{} must end in '.xml' for reading as XML file".format(xml_file))
while True:
try:
with open(xml_file) as f:
xml = f.read()
cereal = XmlSerializer.deserialize(xml)
return xml, cereal
except ValueError as e:
if attempt < retries:
attempt += 1
time.sleep(5*random.random())
else:
raise e
def from_dict(cls, dct):
system_xml = dct['system_xml']
subsets = dct['subsets']
return cls(XmlSerializer.deserialize(system_xml), subsets)
def deserialize(file):
with open(file) as stream:
data = stream.read().replace('\n', '')
return XmlSerializer.deserialize(data)
# coding: utf-8
import os
import nglview as nv
import pytraj as pt
from progressbar import ProgressBar, Bar, Percentage, Timer, ETA, progressbar
import simtk.unit as unit
from simtk.openmm.app import PDBFile, DCDReporter, StateDataReporter, Simulation
from simtk.openmm import XmlSerializer, LangevinIntegrator, MonteCarloBarostat, Platform
# Initialization
with open("restrained.xml", "r") as f:
system = XmlSerializer.deserialize(f.read())
coords = PDBFile(os.path.join('simulations', 'npt_production', 'input.pdb'))
dt = 4.0 * unit.femtoseconds
Temp = 298.15 * unit.kelvin
Pres = 1.01325 * unit.bar
out_freq = 2500
print_freq = 50000
MD_steps = 12500000
bar_freq = int(MD_steps / print_freq)
integrator = LangevinIntegrator(Temp, 1.0 / unit.picoseconds, dt)
barostat = MonteCarloBarostat(Pres, Temp, 100)
system.addForce(barostat)
# Simulation Object
def production(coords, velocities, box):
# Create OpenMM System
file = open(xml_filename, 'r')
serialized_system = file.read()
system = XmlSerializer.deserialize(serialized_system)
# Select Integrator
integrator = mm.LangevinIntegrator(TEMPERATURE, PROD_FRICTION,
PROD_TIME_STEP)
# Set Barostat
system.addForce(
mm.MonteCarloBarostat(PRESSURE, TEMPERATURE, BAROSTAT_FREQUENCY))
# Set Simulation
simulation = app.Simulation(prmtop.topology, system, integrator,
PROD_PLATFORM, PROD_PROPERTIES)
# Set Position and velocities
simulation.context.setPositions(coords)
if velocities is not None:
simulation.context.setVelocities(velocities)
else: #reset
simulation.context.setVelocitiesToTemperature(TEMPERATURE)
# Set Box
#box = box.in_units_of(nanometer)
simulation.context.setPeriodicBoxVectors(box[0], box[1], box[2])
# Set Reporter
simulation.reporters.append(
app.DCDReporter(prod_dcd_filename, PROD_OUTPUT_FREQ))
simulation.reporters.append(
app.StateDataReporter(prod_data_filename,
PROD_DATA_FREQ,
step=True,
potentialEnergy=True,
temperature=True,
density=True))
state = simulation.context.getState(getEnergy=True)
if np.isnan(state.getPotentialEnergy() / kilojoule_per_mole):
raise ValueError("The Potential Energy before Production is NaN")
print('PRODUCTION...\n')
converged = False
while not converged:
simulation.step(PROD_STEPS)
d = pd.read_csv(prod_data_filename,
names=["step", "U", "Temperature", "Density"],
skiprows=1)
density_ts = np.array(d.Density)
[t0, g, Neff] = ts.detectEquilibration(density_ts, nskip=1000)
density_ts = density_ts[t0:]
density_mean_stderr = density_ts.std() / np.sqrt(Neff)
print("Current density mean std error = %f g/mL" % density_mean_stderr)
if density_mean_stderr < STD_ERROR_TOLERANCE:
converged = True
print("...Convergence is OK\n")
state = simulation.context.getState(getPositions=True,
getVelocities=True,
getEnergy=True)
if np.isnan(state.getPotentialEnergy() / kilojoule_per_mole):
raise ValueError("The Potential Energy after Production is NaN")
coords = state.getPositions()
velocities = state.getVelocities()
box = state.getPeriodicBoxVectors()
return coords, velocities, box
context.setPositions(positions)
# Evaluate the potential energy.
state = context.getState(getEnergy=True, getForces=True, getPositions=True)
initial_potential = state.getPotentialEnergy()
initial_force = state.getForces(asNumpy=True)
# Clean up
del context, integrator
from simtk.openmm import XmlSerializer
# Serialize.
system_xml = XmlSerializer.serialize(system)
state_xml = XmlSerializer.serialize(state)
# Deserialize.
system = XmlSerializer.deserialize(system_xml)
state = XmlSerializer.deserialize(state_xml)
# Compute final potential and force.
# Create a Context.
timestep = 1.0 * units.femtoseconds
integrator = openmm.VerletIntegrator(timestep)
context = openmm.Context(system, integrator)
# Set positions
context.setPositions(positions)
# Evaluate the potential energy.
state = context.getState(getEnergy=True, getForces=True, getPositions=True)
final_potential = state.getPotentialEnergy()
final_force = state.getForces(asNumpy=True)
# Clean up
del context, integrator
from simtk import openmm, unit
from simtk.openmm import app
from mdtraj.reporters import NetCDFReporter
from simtk.openmm import XmlSerializer
logger = logging.getLogger(__name__)
platform = openmm.Platform.getPlatformByName('CUDA')
integrator = openmm.LangevinIntegrator(310 * unit.kelvin,
1.0 / unit.picoseconds,
2 * unit.femtosecond)
#integrator.setRandomNumberSeed(129)
with open('openmm_system.xml', 'r') as infile:
openmm_system = XmlSerializer.deserialize(infile.read())
pdbx = app.PDBxFile('mem_prot_md_system.pdbx')
positions = [(pos[0], pos[1], pos[2] + 1 * unit.nanometers)
for pos in pdbx.positions]
openmm_simulation = app.Simulation(pdbx.topology, openmm_system, integrator,
platform)
####### Reading positions from mdtraj trajectory ##########################
#topology = md.Topology.from_openmm(pdbx.topology)
#t = md.load('traj.nc',top=topology)
#positions = t.openmm_positions(1999)
############################################################################
openmm_simulation.context.setPositions(positions)
mdtraj_reporter = NetCDFReporter('steered_forward.nc', 500)
openmm_simulation.reporters.append(mdtraj_reporter)
openmm_simulation.reporters.append(
app.StateDataReporter('state_forward.log',
def main():
import doctest
import argparse
parser = argparse.ArgumentParser(
description=
"Check OpenMM computed energies and forces across all platforms for a suite of test systems."
)
parser.add_argument('-o',
'--outfile',
dest='logfile',
action='store',
type=str,
default=None)
parser.add_argument('-v', dest='verbose', action='store_true')
parser.add_argument('-i',
'--input',
dest="input_data_path",
action="store",
type=str)
parser.add_argument('-t',
'--tuneplatform',
dest="tune_pme_platform",
action="store",
type=str,
default=None)
parser.add_argument('-p',
'--precision',
dest="precision",
action="store",
type=str,
default='single')
args = parser.parse_args()
verbose = args.verbose # Don't display extra debug information.
config_root_logger(verbose, log_file_path=args.logfile)
# Print version.
logger.info("OpenMM version: %s" % openmm.version.version)
logger.info("")
# List all available platforms
logger.info("Available platforms:")
for platform_index in range(openmm.Platform.getNumPlatforms()):
platform = openmm.Platform.getPlatform(platform_index)
logger.info("%5d %s" % (platform_index, platform.getName()))
logger.info("")
# Test all systems on Reference platform.
platform = openmm.Platform.getPlatformByName("Reference")
print('Testing Reference platform...')
doctest.testmod()
# Compute energy error made on all test systems for other platforms.
# Make a count of how often set tolerance is exceeded.
tests_failed = 0 # number of times tolerance is exceeded
tests_passed = 0 # number of times tolerance is not exceeded
logger.info("%16s%16s %16s %16s %16s %16s" %
("platform", "precision", "potential", "error", "force mag",
"rms error"))
reference_platform = openmm.Platform.getPlatformByName("Reference")
n_runs = get_num_runs(args.input_data_path)
for run in range(n_runs):
print("Deserializing XML files for RUN%d" % run)
state = XmlSerializer.deserialize(
read_file(
os.path.join(args.input_data_path, "RUN%d" % run,
"state0.xml")))
integrator = XmlSerializer.deserialize(
read_file(
os.path.join(args.input_data_path, "RUN%d" % run,
"integrator.xml")))
system = XmlSerializer.deserialize(
read_file(
os.path.join(args.input_data_path, "RUN%d" % run,
"system.xml")))
# Update system periodic box vectors based on state.
system.setDefaultPeriodicBoxVectors(*state.getPeriodicBoxVectors())
# Create test system instance.
positions = state.getPositions()
# Get PME parameters
forces = [
system.getForce(force_index)
for force_index in range(system.getNumForces())
]
force_dict = {force.__class__.__name__: force for force in forces}
print("PME parameters:")
force = force_dict['NonbondedForce']
print(force.getPMEParameters())
(alpha, nx, ny, nz) = force.getPMEParameters()
if alpha == 0.0 / unit.nanometers:
# Set PME parameters explicitly.
print("Setting PME parameters explicitly...")
(alpha, nx, ny, nz) = calc_pme_parameters(system)
print(alpha, nx, ny, nz)
print(type(nx))
force.setPMEParameters(alpha, int(nx), int(ny), int(nz))
print(force.getPMEParameters())
if args.tune_pme_platform:
# Tune PME parameters for specified platform.
from optimizepme import optimizePME
properties = dict()
platform = openmm.Platform.getPlatformByName(
args.tune_pme_platform)
print(
"Tuning PME parameters for platform '%s' precision model '%s'..."
% (platform.getName(), args.precision))
if (platform.getName() == 'OpenCL'):
properties['OpenCLPrecision'] = args.precision
elif (platform.getName() == 'CUDA'):
properties['CudaPrecision'] = args.precision
minCutoff = 0.8 * unit.nanometers
maxCutoff = 1.2 * unit.nanometers
optimizePME(system, integrator, positions, platform, properties,
minCutoff, maxCutoff)
class_name = 'RUN%d' % run
logger.info("%s (%d atoms)" % (class_name, system.getNumParticles()))
# Compute reference potential and force
[reference_potential, reference_force
] = compute_potential_and_force(system, positions, reference_platform)
# Test all platforms.
test_success = True
for platform_index in range(openmm.Platform.getNumPlatforms()):
try:
platform = openmm.Platform.getPlatform(platform_index)
platform_name = platform.getName()
# Define precision models to test.
if platform_name == 'Reference':
precision_models = ['double']
else:
precision_models = ['single']
if platform.supportsDoublePrecision():
precision_models.append('double')
for precision_model in precision_models:
# Set precision.
if platform_name == 'CUDA':
platform.setPropertyDefaultValue(
'CudaPrecision', precision_model)
if platform_name == 'OpenCL':
platform.setPropertyDefaultValue(
'OpenCLPrecision', precision_model)
# Compute potential and force.
[platform_potential, platform_force
] = compute_potential_and_force(system, positions,
platform)
# Compute error in potential.
potential_error = platform_potential - reference_potential
# Compute per-atom RMS (magnitude) and RMS error in force.
force_unit = unit.kilocalories_per_mole / unit.nanometers
natoms = system.getNumParticles()
force_mse = ((
(reference_force - platform_force) / force_unit)**
2).sum() / natoms * force_unit**2
force_rmse = unit.sqrt(force_mse)
force_ms = ((platform_force / force_unit)**
2).sum() / natoms * force_unit**2
force_rms = unit.sqrt(force_ms)
logger.info(
"%16s%16s %16.6f kcal/mol %16.6f kcal/mol %16.6f kcal/mol/nm %16.6f kcal/mol/nm"
% (platform_name, precision_model,
platform_potential / unit.kilocalories_per_mole,
potential_error / unit.kilocalories_per_mole,
force_rms / force_unit, force_rmse / force_unit))
# Mark whether tolerance is exceeded or not.
if abs(potential_error) > ENERGY_TOLERANCE:
test_success = False
logger.info(
"%32s WARNING: Potential energy error (%.6f kcal/mol) exceeds tolerance (%.6f kcal/mol). Test failed."
%
("", potential_error / unit.kilocalories_per_mole,
ENERGY_TOLERANCE / unit.kilocalories_per_mole))
if abs(force_rmse) > FORCE_RMSE_TOLERANCE:
test_success = False
logger.info(
"%32s WARNING: Force RMS error (%.6f kcal/mol/nm) exceeds tolerance (%.6f kcal/mol/nm). Test failed."
% ("", force_rmse / force_unit,
FORCE_RMSE_TOLERANCE / force_unit))
if verbose:
for atom_index in range(natoms):
for k in range(3):
logger.info(
"%12.6f" %
(reference_force[atom_index, k] /
force_unit),
end="")
logger.info(" : ", end="")
for k in range(3):
logger.info(
"%12.6f" %
(platform_force[atom_index, k] /
force_unit),
end="")
except Exception as e:
logger.info(e)
if test_success:
tests_passed += 1
else:
tests_failed += 1
if (test_success is False):
# Write XML files of failed tests to aid in debugging.
# Place forces into different force groups.
forces = [
system.getForce(force_index)
for force_index in range(system.getNumForces())
]
force_group_names = dict()
group_index = 0
for force_index in range(system.getNumForces()):
force_name = forces[force_index].__class__.__name__
if force_name == 'NonbondedForce':
forces[force_index].setForceGroup(group_index + 1)
force_group_names[group_index] = 'NonbondedForce (direct)'
group_index += 1
forces[force_index].setReciprocalSpaceForceGroup(
group_index + 1)
force_group_names[
group_index] = 'NonbondedForce (reciprocal)'
group_index += 1
else:
forces[force_index].setForceGroup(group_index + 1)
force_group_names[group_index] = force_name
group_index += 1
ngroups = len(force_group_names)
# Test by force group.
logger.info("Breakdown of discrepancies by Force component:")
nforces = system.getNumForces()
for force_group in range(ngroups):
force_name = force_group_names[force_group]
logger.info(force_name)
[reference_potential,
reference_force] = compute_potential_and_force_by_force_group(
system, positions, reference_platform, force_group)
logger.info(
"%16s%16s %16s %16s %16s %16s" %
("platform", "precision", "potential", "error",
"force mag", "rms error"))
for platform_index in range(openmm.Platform.getNumPlatforms()):
try:
platform = openmm.Platform.getPlatform(platform_index)
platform_name = platform.getName()
# Define precision models to test.
if platform_name == 'Reference':
precision_models = ['double']
else:
precision_models = ['single']
if platform.supportsDoublePrecision():
precision_models.append('double')
for precision_model in precision_models:
# Set precision.
if platform_name == 'CUDA':
platform.setPropertyDefaultValue(
'CudaPrecision', precision_model)
if platform_name == 'OpenCL':
platform.setPropertyDefaultValue(
'OpenCLPrecision', precision_model)
# Compute potential and force.
[platform_potential, platform_force
] = compute_potential_and_force_by_force_group(
system, positions, platform, force_group)
# Compute error in potential.
potential_error = platform_potential - reference_potential
# Compute per-atom RMS (magnitude) and RMS error in force.
force_unit = unit.kilocalories_per_mole / unit.nanometers
natoms = system.getNumParticles()
force_mse = (
((reference_force - platform_force) /
force_unit)**2).sum() / natoms * force_unit**2
force_rmse = unit.sqrt(force_mse)
force_ms = ((platform_force / force_unit)**
2).sum() / natoms * force_unit**2
force_rms = unit.sqrt(force_ms)
logger.info(
"%16s%16s %16.6f kcal/mol %16.6f kcal/mol %16.6f kcal/mol/nm %16.6f kcal/mol/nm"
%
(platform_name, precision_model,
platform_potential /
unit.kilocalories_per_mole, potential_error /
unit.kilocalories_per_mole, force_rms /
force_unit, force_rmse / force_unit))
except Exception as e:
logger.info(e)
pass
logger.info("")
logger.info("%d tests failed" % tests_failed)
logger.info("%d tests passed" % tests_passed)
if (tests_failed > 0):
# Signal failure of test.
sys.exit(1)
else:
sys.exit(0)
async def run(io):
print(dir(parmed))
if not os.path.exists(datapath +
'complex.xml') or not os.path.exists(datapath +
'complex.pdb'):
print('1: loading Ligand molecule')
ligand_off_molecule = Molecule(datapath + 'ligand.sdf')
# Load the SMIRNOFF-format Parsley force field
#force_field = ForceField('openff_unconstrained-1.0.0.offxml')
print("2: Loading the Force Field")
force_field = ForceField('openff_unconstrained-1.2.0.offxml')
# Parametrize the ligand molecule by creating a Topology object from it
print("3: Create Ligand System")
ligand_system = force_field.create_openmm_system(
ligand_off_molecule.to_topology())
# Read in the coordinates of the ligand from the PDB file
ligand_pdbfile = PDBFile(datapath + 'ligand.pdb')
# Convert OpenMM System object containing ligand parameters into a ParmEd Structure.
print("4: Transforming Ligand System to Parmed")
ligand_structure = parmed.openmm.load_topology(
ligand_pdbfile.topology,
ligand_system,
xyz=ligand_pdbfile.positions)
print("5: Loading the protein pdb file")
receptor_pdbfile = PDBFile(datapath + 'receptor.pdb')
# Load the AMBER protein force field through OpenMM.
omm_forcefield = app.ForceField('amber14-all.xml')
# Parameterize the protein.
print("6: Create protein system")
receptor_system = omm_forcefield.createSystem(
receptor_pdbfile.topology)
# Convert the protein System into a ParmEd Structure.
print("7: Convert protein system to parmed")
receptor_structure = parmed.openmm.load_topology(
receptor_pdbfile.topology,
receptor_system,
xyz=receptor_pdbfile.positions)
print("8: Combinding protein & ligand system")
complex_structure = receptor_structure + ligand_structure
print(dir(complex_structure))
print("9: Create Openmm system")
# Convert the Structure to an OpenMM System in vacuum.
complex_system = complex_structure.createSystem(
nonbondedMethod=NoCutoff,
nonbondedCutoff=9.0 * unit.angstrom,
constraints=HBonds,
removeCMMotion=False)
complex_structure.save(datapath + 'complex.pdb', overwrite=True)
complex_structure = parmed.load_file(datapath + 'complex.pdb')
with open(datapath + 'complex.xml', 'w') as f:
f.write(XmlSerializer.serialize(complex_system))
complex_structure = parmed.load_file(datapath + 'complex.pdb')
with open(datapath + 'complex.xml', 'r') as f:
complex_system = XmlSerializer.deserialize(f.read())
print(dir(complex_structure))
platform = openmm.Platform.getPlatformByName('OpenCL')
properties = {'OpenCLPrecision': 'mixed'}
integrator = openmm.LangevinIntegrator(300 * unit.kelvin,
91 / unit.picosecond,
0.002 * unit.picoseconds)
simulation = openmm.app.Simulation(complex_structure, complex_system,
integrator, platform)
simulation.context.setPositions(complex_structure.positions)
print(" starting minimization")
state = simulation.context.getState(getEnergy=True, getForces=True)
lastEnergy = state.getPotentialEnergy()
potEnergyValue = state.getPotentialEnergy().value_in_unit(
unit.kilojoules_per_mole)
m = ' Starting pot energy: {:.3f} kJ/mol'.format(potEnergyValue)
print(m)
await io.emit("setMessage", m)
# io.emit("setMessage", m)
t0 = time.time()
emit_freq = 1
maxIter = 20
# iterations=1
for i in range(100):
simulation.minimizeEnergy(tolerance=0, maxIterations=maxIter)
state = simulation.context.getState(getPositions=True, getEnergy=True)
currentEnergy = state.getPotentialEnergy()
positions = state.getPositions(
asNumpy=True) * 10 #convert to angstroms
p = positions._value.flatten().tolist()
# if(abs(lastEnergy._value-currentEnergy._value)<100):
# m =' Last pot energy:'+ currentEnergy.__str__()+ " step: {}".format(i+1)
# await io.emit("setPositions", {'positions':p, 'message':m})
# break
lastEnergy = currentEnergy
#print("positions", p[0], p[1], p[2])
m = ' Current pot energy: {:.3f} kJ/mol - step: {:d}'.format(
currentEnergy.value_in_unit(unit.kilojoules_per_mole), i + 1)
#print(m)
if not (i + 1) % emit_freq:
await io.emit("setPositions", {
'positions': p,
'message': m,
'step': i
})
# io.emit("setPositions", {'positions':p, 'message':m})
# await io.emit("setEnergy", m)
#simulation.context.setPositions(complex_structure.positions)
state = simulation.context.getState(getPositions=True,
getEnergy=True,
getForces=True)
print(' Final pot energy:', state.getPotentialEnergy())
print(" in ", time.time() - t0)
return state
def _setup_simulation_objects(self, temperature, pressure,
available_resources):
"""Initializes the objects needed to perform the simulation.
This comprises of a context, and an integrator.
Parameters
----------
temperature: simtk.unit.Quantity
The temperature to run the simulation at.
pressure: simtk.unit.Quantity
The pressure to run the simulation at.
available_resources: ComputeResources
The resources available to run on.
Returns
-------
simtk.openmm.Context
The created openmm context which takes advantage
of the available compute resources.
openmmtools.integrators.LangevinIntegrator
The Langevin integrator which will propogate
the simulation.
"""
import openmmtools
from simtk.openmm import XmlSerializer
# Create a platform with the correct resources.
if not self.allow_gpu_platforms:
from propertyestimator.backends import ComputeResources
available_resources = ComputeResources(
available_resources.number_of_threads)
platform = setup_platform_with_resources(available_resources,
self.high_precision)
# Load in the system object from the provided xml file.
with open(self.system_path, 'r') as file:
system = XmlSerializer.deserialize(file.read())
# Disable the periodic boundary conditions if requested.
if not self.enable_pbc:
disable_pbc(system)
pressure = None
# Use the openmmtools ThermodynamicState object to help
# set up a system which contains the correct barostat if
# one should be present.
openmm_state = openmmtools.states.ThermodynamicState(
system=system, temperature=temperature, pressure=pressure)
system = openmm_state.get_system(remove_thermostat=True)
# Set up the integrator.
thermostat_friction = pint_quantity_to_openmm(self.thermostat_friction)
timestep = pint_quantity_to_openmm(self.timestep)
integrator = openmmtools.integrators.LangevinIntegrator(
temperature=temperature,
collision_rate=thermostat_friction,
timestep=timestep)
# Create the simulation context.
context = openmm.Context(system, integrator, platform)
# Initialize the context with the correct positions etc.
input_pdb_file = app.PDBFile(self.input_coordinate_file)
if self.enable_pbc:
# Optionally set up the box vectors.
box_vectors = input_pdb_file.topology.getPeriodicBoxVectors()
if box_vectors is None:
raise ValueError('The input file must contain box vectors '
'when running with PBC.')
context.setPeriodicBoxVectors(*box_vectors)
context.setPositions(input_pdb_file.positions)
context.setVelocitiesToTemperature(temperature)
return context, integrator
def main():
import doctest
import argparse
parser = argparse.ArgumentParser(description="Check OpenMM computed energies and forces across all platforms for a suite of test systems.")
parser.add_argument('-o', '--outfile', dest='logfile', action='store', type=str, default=None)
parser.add_argument('-v', dest='verbose', action='store_true')
parser.add_argument('-i', '--input', dest="input_data_path", action="store", type=str)
parser.add_argument('-t', '--tuneplatform', dest="tune_pme_platform", action="store", type=str, default=None)
parser.add_argument('-p', '--precision', dest="precision", action="store", type=str, default='single')
args = parser.parse_args()
verbose = args.verbose # Don't display extra debug information.
config_root_logger(verbose, log_file_path=args.logfile)
# Print version.
logger.info("OpenMM version: %s" % openmm.version.version)
logger.info("")
# List all available platforms
logger.info("Available platforms:")
for platform_index in range(openmm.Platform.getNumPlatforms()):
platform = openmm.Platform.getPlatform(platform_index)
logger.info("%5d %s" % (platform_index, platform.getName()))
logger.info("")
# Test all systems on Reference platform.
platform = openmm.Platform.getPlatformByName("Reference")
print('Testing Reference platform...')
doctest.testmod()
# Compute energy error made on all test systems for other platforms.
# Make a count of how often set tolerance is exceeded.
tests_failed = 0 # number of times tolerance is exceeded
tests_passed = 0 # number of times tolerance is not exceeded
logger.info("%16s%16s %16s %16s %16s %16s" % ("platform", "precision", "potential", "error", "force mag", "rms error"))
reference_platform = openmm.Platform.getPlatformByName("Reference")
n_runs=get_num_runs(args.input_data_path)
for run in range(n_runs):
print("Deserializing XML files for RUN%d" % run)
state = XmlSerializer.deserialize(read_file(os.path.join(args.input_data_path,"RUN%d" % run, "state0.xml")))
integrator = XmlSerializer.deserialize(read_file(os.path.join(args.input_data_path,"RUN%d" % run, "integrator.xml")))
system = XmlSerializer.deserialize(read_file(os.path.join(args.input_data_path,"RUN%d" % run, "system.xml")))
# Update system periodic box vectors based on state.
system.setDefaultPeriodicBoxVectors(*state.getPeriodicBoxVectors())
# Create test system instance.
positions = state.getPositions()
# Get PME parameters
forces = [ system.getForce(force_index) for force_index in range(system.getNumForces()) ]
force_dict = { force.__class__.__name__ : force for force in forces }
print("PME parameters:")
force = force_dict['NonbondedForce']
print(force.getPMEParameters())
(alpha, nx, ny, nz) = force.getPMEParameters()
if alpha == 0.0 / unit.nanometers:
# Set PME parameters explicitly.
print("Setting PME parameters explicitly...")
(alpha, nx, ny, nz) = calc_pme_parameters(system)
print (alpha, nx, ny, nz)
print(type(nx))
force.setPMEParameters(alpha, int(nx), int(ny), int(nz))
print(force.getPMEParameters())
if args.tune_pme_platform:
# Tune PME parameters for specified platform.
from optimizepme import optimizePME
properties = dict()
platform = openmm.Platform.getPlatformByName(args.tune_pme_platform)
print("Tuning PME parameters for platform '%s' precision model '%s'..." % (platform.getName(), args.precision))
if (platform.getName() == 'OpenCL'):
properties['OpenCLPrecision'] = args.precision
elif (platform.getName() == 'CUDA'):
properties['CudaPrecision'] = args.precision
minCutoff = 0.8 * unit.nanometers
maxCutoff = 1.2 * unit.nanometers
optimizePME(system, integrator, positions, platform, properties, minCutoff, maxCutoff)
class_name = 'RUN%d' % run
logger.info("%s (%d atoms)" % (class_name, system.getNumParticles()))
# Compute reference potential and force
[reference_potential, reference_force] = compute_potential_and_force(system, positions, reference_platform)
# Test all platforms.
test_success = True
for platform_index in range(openmm.Platform.getNumPlatforms()):
try:
platform = openmm.Platform.getPlatform(platform_index)
platform_name = platform.getName()
# Define precision models to test.
if platform_name == 'Reference':
precision_models = ['double']
else:
precision_models = ['single']
if platform.supportsDoublePrecision():
precision_models.append('double')
for precision_model in precision_models:
# Set precision.
if platform_name == 'CUDA':
platform.setPropertyDefaultValue('CudaPrecision', precision_model)
if platform_name == 'OpenCL':
platform.setPropertyDefaultValue('OpenCLPrecision', precision_model)
# Compute potential and force.
[platform_potential, platform_force] = compute_potential_and_force(system, positions, platform)
# Compute error in potential.
potential_error = platform_potential - reference_potential
# Compute per-atom RMS (magnitude) and RMS error in force.
force_unit = unit.kilocalories_per_mole / unit.nanometers
natoms = system.getNumParticles()
force_mse = (((reference_force - platform_force) / force_unit)**2).sum() / natoms * force_unit**2
force_rmse = unit.sqrt(force_mse)
force_ms = ((platform_force / force_unit)**2).sum() / natoms * force_unit**2
force_rms = unit.sqrt(force_ms)
logger.info("%16s%16s %16.6f kcal/mol %16.6f kcal/mol %16.6f kcal/mol/nm %16.6f kcal/mol/nm" % (platform_name, precision_model, platform_potential / unit.kilocalories_per_mole, potential_error / unit.kilocalories_per_mole, force_rms / force_unit, force_rmse / force_unit))
# Mark whether tolerance is exceeded or not.
if abs(potential_error) > ENERGY_TOLERANCE:
test_success = False
logger.info("%32s WARNING: Potential energy error (%.6f kcal/mol) exceeds tolerance (%.6f kcal/mol). Test failed." % ("", potential_error/unit.kilocalories_per_mole, ENERGY_TOLERANCE/unit.kilocalories_per_mole))
if abs(force_rmse) > FORCE_RMSE_TOLERANCE:
test_success = False
logger.info("%32s WARNING: Force RMS error (%.6f kcal/mol/nm) exceeds tolerance (%.6f kcal/mol/nm). Test failed." % ("", force_rmse/force_unit, FORCE_RMSE_TOLERANCE/force_unit))
if verbose:
for atom_index in range(natoms):
for k in range(3):
logger.info("%12.6f" % (reference_force[atom_index,k]/force_unit), end="")
logger.info(" : ", end="")
for k in range(3):
logger.info("%12.6f" % (platform_force[atom_index,k]/force_unit), end="")
except Exception as e:
logger.info(e)
if test_success:
tests_passed += 1
else:
tests_failed += 1
if (test_success is False):
# Write XML files of failed tests to aid in debugging.
# Place forces into different force groups.
forces = [ system.getForce(force_index) for force_index in range(system.getNumForces()) ]
force_group_names = dict()
group_index = 0
for force_index in range(system.getNumForces()):
force_name = forces[force_index].__class__.__name__
if force_name == 'NonbondedForce':
forces[force_index].setForceGroup(group_index+1)
force_group_names[group_index] = 'NonbondedForce (direct)'
group_index += 1
forces[force_index].setReciprocalSpaceForceGroup(group_index+1)
force_group_names[group_index] = 'NonbondedForce (reciprocal)'
group_index += 1
else:
forces[force_index].setForceGroup(group_index+1)
force_group_names[group_index] = force_name
group_index += 1
ngroups = len(force_group_names)
# Test by force group.
logger.info("Breakdown of discrepancies by Force component:")
nforces = system.getNumForces()
for force_group in range(ngroups):
force_name = force_group_names[force_group]
logger.info(force_name)
[reference_potential, reference_force] = compute_potential_and_force_by_force_group(system, positions, reference_platform, force_group)
logger.info("%16s%16s %16s %16s %16s %16s" % ("platform", "precision", "potential", "error", "force mag", "rms error"))
for platform_index in range(openmm.Platform.getNumPlatforms()):
try:
platform = openmm.Platform.getPlatform(platform_index)
platform_name = platform.getName()
# Define precision models to test.
if platform_name == 'Reference':
precision_models = ['double']
else:
precision_models = ['single']
if platform.supportsDoublePrecision():
precision_models.append('double')
for precision_model in precision_models:
# Set precision.
if platform_name == 'CUDA':
platform.setPropertyDefaultValue('CudaPrecision', precision_model)
if platform_name == 'OpenCL':
platform.setPropertyDefaultValue('OpenCLPrecision', precision_model)
# Compute potential and force.
[platform_potential, platform_force] = compute_potential_and_force_by_force_group(system, positions, platform, force_group)
# Compute error in potential.
potential_error = platform_potential - reference_potential
# Compute per-atom RMS (magnitude) and RMS error in force.
force_unit = unit.kilocalories_per_mole / unit.nanometers
natoms = system.getNumParticles()
force_mse = (((reference_force - platform_force) / force_unit)**2).sum() / natoms * force_unit**2
force_rmse = unit.sqrt(force_mse)
force_ms = ((platform_force / force_unit)**2).sum() / natoms * force_unit**2
force_rms = unit.sqrt(force_ms)
logger.info("%16s%16s %16.6f kcal/mol %16.6f kcal/mol %16.6f kcal/mol/nm %16.6f kcal/mol/nm" % (platform_name, precision_model, platform_potential / unit.kilocalories_per_mole, potential_error / unit.kilocalories_per_mole, force_rms / force_unit, force_rmse / force_unit))
except Exception as e:
logger.info(e)
pass
logger.info("")
logger.info("%d tests failed" % tests_failed)
logger.info("%d tests passed" % tests_passed)
if (tests_failed > 0):
# Signal failure of test.
sys.exit(1)
else:
sys.exit(0)
def from_dict(cls, dct):
system_xml = dct['system_xml']
return cls(XmlSerializer.deserialize(system_xml))
integrator_xml_filename = "integrator_2fs.xml"
state_xml_filename = "pr_output_state.xml"
state_pdb_filename = "pr_output_state.pdb"
system_xml_filename = "pr_output_system.xml"
checkpoint_filename = "pr_output_checkpoint.chk"
traj_output_filename = "pr_output_traj.xtc"
# Define the barostat for the system
barostat = mm.MonteCarloBarostat(pressure, temperature)
# Read in equilibrated system (PDB)
pdb = PDBFile(input_pdb)
# Deserialize system file and load system
with open(input_system, 'r') as f:
system = XmlSerializer.deserialize(f.read())
# Make and serialize integrator - Langevin dynamics
print("Serializing integrator to %s" %
os.path.join(output_prefix, integrator_xml_filename))
integrator = mm.LangevinIntegrator(
temperature,
collision_rate,
timestep # Friction coefficient
)
with open(os.path.join(output_prefix, integrator_xml_filename),
"w") as outfile:
xml = mm.XmlSerializer.serialize(integrator)
outfile.write(xml)
# Define the platform to use; CUDA, OpenCL, CPU, or Reference. Or do not specify
def _execute(self, directory, available_resources):
from simtk.openmm import XmlSerializer
solute_components = [
component for component in self.solute.components
if component.role == Component.Role.Solute
]
solvent_1_components = [
component for component in self.solvent_1.components
if component.role == Component.Role.Solvent
]
solvent_2_components = [
component for component in self.solvent_2.components
if component.role == Component.Role.Solvent
]
if len(solute_components) != 1:
raise ValueError(
"There must only be a single component marked as a solute.")
if len(solvent_1_components) == 0 and len(solvent_2_components) == 0:
raise ValueError(
"At least one of the solvents must not be vacuum.")
# Because of quirks in where Yank looks files while doing temporary
# directory changes, we need to copy the coordinate files locally so
# they are correctly found.
shutil.copyfile(
self.solvent_1_coordinates,
os.path.join(directory, self._local_solvent_1_coordinates),
)
shutil.copyfile(self.solvent_1_system,
os.path.join(directory, self._local_solvent_1_system))
shutil.copyfile(
self.solvent_2_coordinates,
os.path.join(directory, self._local_solvent_2_coordinates),
)
shutil.copyfile(self.solvent_2_system,
os.path.join(directory, self._local_solvent_2_system))
# Disable the pbc of the any solvents which should be treated
# as vacuum.
vacuum_system_path = None
if len(solvent_1_components) == 0:
vacuum_system_path = self._local_solvent_1_system
elif len(solvent_2_components) == 0:
vacuum_system_path = self._local_solvent_2_system
if vacuum_system_path is not None:
logger.info(
f"Disabling the periodic boundary conditions in {vacuum_system_path} "
f"by setting the cutoff type to NoCutoff")
with open(os.path.join(directory, vacuum_system_path),
"r") as file:
vacuum_system = XmlSerializer.deserialize(file.read())
disable_pbc(vacuum_system)
with open(os.path.join(directory, vacuum_system_path),
"w") as file:
file.write(XmlSerializer.serialize(vacuum_system))
# Set up the yank input file.
super(SolvationYankProtocol, self)._execute(directory,
available_resources)
if self.setup_only:
return
solvent_1_yank_path = os.path.join(directory, "experiments",
"solvent1.nc")
solvent_2_yank_path = os.path.join(directory, "experiments",
"solvent2.nc")
self.solvent_1_trajectory_path = os.path.join(directory,
"solvent1.dcd")
self.solvent_2_trajectory_path = os.path.join(directory,
"solvent2.dcd")
self._extract_trajectory(solvent_1_yank_path,
self.solvent_1_trajectory_path)
self._extract_trajectory(solvent_2_yank_path,
self.solvent_2_trajectory_path)
def main():
parser = argparse.ArgumentParser(
description=
'Compute a potential of mean force (PMF) for porin permeation.')
parser.add_argument('--index',
dest='index',
action='store',
type=int,
help='Index of ')
parser.add_argument('--output',
dest='output_filename',
action='store',
default='output.nc',
help='output netcdf filename (default: output.nc)')
args = parser.parse_args()
index = args.index
output_filename = args.output_filename
logger = logging.getLogger(__name__)
logging.root.setLevel(logging.DEBUG)
logging.basicConfig(level=logging.DEBUG)
yank.utils.config_root_logger(verbose=True, log_file_path=None)
# Configure ContextCache, platform and precision
from yank.experiment import ExperimentBuilder
platform = ExperimentBuilder._configure_platform('CUDA', 'mixed')
try:
openmmtools.cache.global_context_cache.platform = platform
except RuntimeError:
# The cache has been already used. Empty it before switching platform.
openmmtools.cache.global_context_cache.empty()
openmmtools.cache.global_context_cache.platform = platform
# Topology
pdbx = app.PDBxFile('mem_prot_md_system.pdbx')
# This system contains the CVforce with parameters different than zero
with open('openmm_system.xml', 'r') as infile:
openmm_system = XmlSerializer.deserialize(infile.read())
####### Indexes of configurations in trajectory ############################
configs = [
39, 141, 276, 406, 562, 668, 833, 1109, 1272, 1417, 1456, 1471, 1537,
1645, 1777, 1882
]
####### Indexes of states for series of replica exchange simulations #######
limits = [(0, 9), (10, 19), (20, 29), (30, 39), (40, 49), (50, 59),
(60, 69), (70, 79), (80, 89), (90, 99), (100, 109), (110, 119),
(120, 129), (130, 139), (140, 149), (150, 159)]
####### Reading positions from mdtraj trajectory ###########################
topology = md.Topology.from_openmm(pdbx.topology)
t = md.load('../../steered_md/comp7/forward/seed_0/steered_forward.nc',
top=topology)
positions = t.openmm_positions(configs[index])
thermodynamic_state_deserialized = states.ThermodynamicState(
system=openmm_system,
temperature=310 * unit.kelvin,
pressure=1.0 * unit.atmospheres)
sampler_state = states.SamplerState(
positions=positions,
box_vectors=t.unitcell_vectors[configs[index], :, :] * unit.nanometer)
logger.debug(type(sampler_state))
move = mcmc.LangevinDynamicsMove(timestep=2 * unit.femtosecond,
collision_rate=1.0 / unit.picoseconds,
n_steps=500,
reassign_velocities=False)
simulation = ReplicaExchangeSampler(mcmc_moves=move,
number_of_iterations=1)
analysis_particle_indices = topology.select(
'(protein and mass > 3.0) or (resname MER and mass > 3.0)')
reporter = MultiStateReporter(
output_filename,
checkpoint_interval=2000,
analysis_particle_indices=analysis_particle_indices)
first, last = limits[index]
# Initialize compound thermodynamic states
protocol = {
'lambda_restraints': [i / 159 for i in range(first, last + 1)],
'K_parallel': [
1250 * unit.kilojoules_per_mole / unit.nanometer**2
for i in range(first, last + 1)
],
'Kmax': [
500 * unit.kilojoules_per_mole / unit.nanometer**2
for i in range(first, last + 1)
],
'Kmin': [
500 * unit.kilojoules_per_mole / unit.nanometer**2
for i in range(first, last + 1)
]
}
my_composable_state = MyComposableState.from_system(openmm_system)
compound_states = states.create_thermodynamic_state_protocol(
thermodynamic_state_deserialized,
protocol=protocol,
composable_states=[my_composable_state])
simulation.create(thermodynamic_states=compound_states,
sampler_states=[sampler_state],
storage=reporter)
simulation.equilibrate(50, mcmc_moves=move)
simulation.run()
ts = simulation._thermodynamic_states[0]
context, _ = openmmtools.cache.global_context_cache.get_context(ts)
files_names = [
'state_{}_{}.log'.format(index, i) for i in range(first, last + 1)
]
files = []
for i, file in enumerate(files_names):
files.append(open(file, 'w'))
mpi.distribute(write_cv,
range(simulation.n_replicas),
context,
simulation,
files,
send_results_to=None)
for i in range(10000):
simulation.extend(n_iterations=2)
mpi.distribute(write_cv,
range(simulation.n_replicas),
context,
simulation,
files,
send_results_to=None)
def execute(self, directory, available_resources):
import openmmtools
import mdtraj
from simtk import openmm, unit as simtk_unit
from simtk.openmm import XmlSerializer
trajectory = mdtraj.load_dcd(self.trajectory_file_path, self.coordinate_file_path)
with open(self.system_path, 'rb') as file:
system = XmlSerializer.deserialize(file.read().decode())
temperature = pint_quantity_to_openmm(self.thermodynamic_state.temperature)
pressure = pint_quantity_to_openmm(self.thermodynamic_state.pressure)
if self.enable_pbc:
system.setDefaultPeriodicBoxVectors(*trajectory.openmm_boxes(0))
else:
pressure = None
openmm_state = openmmtools.states.ThermodynamicState(system=system,
temperature=temperature,
pressure=pressure)
integrator = openmmtools.integrators.VelocityVerletIntegrator(0.01*simtk_unit.femtoseconds)
# Setup the requested platform:
platform = setup_platform_with_resources(available_resources, self.high_precision)
openmm_system = openmm_state.get_system(True, True)
if not self.enable_pbc:
disable_pbc(openmm_system)
openmm_context = openmm.Context(openmm_system, integrator, platform)
potential_energies = np.zeros(trajectory.n_frames)
reduced_potentials = np.zeros(trajectory.n_frames)
for frame_index in range(trajectory.n_frames):
if self.enable_pbc:
box_vectors = trajectory.openmm_boxes(frame_index)
openmm_context.setPeriodicBoxVectors(*box_vectors)
positions = trajectory.xyz[frame_index]
openmm_context.setPositions(positions)
potential_energy = openmm_context.getState(getEnergy=True).getPotentialEnergy()
potential_energies[frame_index] = potential_energy.value_in_unit(simtk_unit.kilojoule_per_mole)
reduced_potentials[frame_index] = openmm_state.reduced_potential(openmm_context)
kinetic_energies = StatisticsArray.from_pandas_csv(self.kinetic_energies_path)[ObservableType.KineticEnergy]
statistics_array = StatisticsArray()
statistics_array[ObservableType.PotentialEnergy] = potential_energies * unit.kilojoule / unit.mole
statistics_array[ObservableType.KineticEnergy] = kinetic_energies
statistics_array[ObservableType.ReducedPotential] = reduced_potentials * unit.dimensionless
statistics_array[ObservableType.TotalEnergy] = (statistics_array[ObservableType.PotentialEnergy] +
statistics_array[ObservableType.KineticEnergy])
statistics_array[ObservableType.Enthalpy] = (statistics_array[ObservableType.ReducedPotential] *
self.thermodynamic_state.inverse_beta + kinetic_energies)
if self.use_internal_energy:
statistics_array[ObservableType.ReducedPotential] += kinetic_energies * self.thermodynamic_state.beta
self.statistics_file_path = path.join(directory, 'statistics.csv')
statistics_array.to_pandas_csv(self.statistics_file_path)
return self._get_output_dictionary()
def execute(self, directory, available_resources):
import mdtraj
logging.info('Extracting dielectrics: ' + self.id)
base_exception = super(ExtractAverageDielectric,
self).execute(directory, available_resources)
if isinstance(base_exception, ExtractAverageDielectric):
return base_exception
charge_list = []
from simtk.openmm import XmlSerializer
with open(self._system_path, 'rb') as file:
self._system = XmlSerializer.deserialize(file.read().decode())
for force_index in range(self._system.getNumForces()):
force = self._system.getForce(force_index)
if not isinstance(force, openmm.NonbondedForce):
continue
for atom_index in range(force.getNumParticles()):
charge = force.getParticleParameters(atom_index)[0]
charge /= unit.elementary_charge
charge_list.append(charge)
dipole_moments = mdtraj.geometry.dipole_moments(
self.trajectory, charge_list)
dipole_moments, self._equilibration_index, self._statistical_inefficiency = \
timeseries.decorrelate_time_series(dipole_moments)
sample_indices = timeseries.get_uncorrelated_indices(
len(self.trajectory[self._equilibration_index:]),
self._statistical_inefficiency)
sample_indices = [
index + self._equilibration_index for index in sample_indices
]
volumes = self.trajectory[sample_indices].unitcell_volumes
self._uncorrelated_values = unit.Quantity(dipole_moments, None)
self._uncorrelated_volumes = volumes * unit.nanometer**3
value, uncertainty = bootstrap(self._bootstrap_function,
self._bootstrap_iterations,
self._bootstrap_sample_size,
dipoles=dipole_moments,
volumes=volumes)
self._value = EstimatedQuantity(unit.Quantity(value, None),
unit.Quantity(uncertainty, None),
self.id)
logging.info('Extracted dielectrics: ' + self.id)
return self._get_output_dictionary()
properties[args.platform + '_' + v.replace('_', '')] = value
if args.platform == 'fastest':
platform = None
else:
platform = Platform.getPlatformByName(args.platform)
print 'Reading PDB'
pdb = PDBFile(args.topology_pdb)
print 'Done'
with open(args.system_xml) as f:
system_xml = f.read()
system = XmlSerializer.deserialize(system_xml)
with open(args.integrator_xml) as f:
integrator_xml = f.read()
integrator = XmlSerializer.deserialize(integrator_xml)
print 'Initialize Simulation'
try:
simulation = Simulation(pdb.topology, system, integrator, platform,
properties)
except Exception:
print('EXCEPTION', (socket.gethostname()))
raise
print 'Done.'
def execute(self, directory, available_resources):
from simtk.openmm import XmlSerializer
solute_components = [
component for component in self.solute.components
if component.role == Substance.ComponentRole.Solute
]
solvent_1_components = [
component for component in self.solvent_1.components
if component.role == Substance.ComponentRole.Solvent
]
solvent_2_components = [
component for component in self.solvent_2.components
if component.role == Substance.ComponentRole.Solvent
]
if len(solute_components) != 1:
return PropertyEstimatorException(
directory,
'There must only be a single component marked as a solute.')
if len(solvent_1_components) == 0 and len(solvent_2_components) == 0:
return PropertyEstimatorException(
directory, 'At least one of the solvents must not be vacuum.')
# Because of quirks in where Yank looks files while doing temporary
# directory changes, we need to copy the coordinate files locally so
# they are correctly found.
shutil.copyfile(
self.solvent_1_coordinates,
os.path.join(directory, self._local_solvent_1_coordinates))
shutil.copyfile(self.solvent_1_system,
os.path.join(directory, self._local_solvent_1_system))
shutil.copyfile(
self.solvent_2_coordinates,
os.path.join(directory, self._local_solvent_2_coordinates))
shutil.copyfile(self.solvent_2_system,
os.path.join(directory, self._local_solvent_2_system))
# Disable the pbc of the any solvents which should be treated
# as vacuum.
vacuum_system_path = None
if len(solvent_1_components) == 0:
vacuum_system_path = self._local_solvent_1_system
elif len(solvent_2_components) == 0:
vacuum_system_path = self._local_solvent_2_system
if vacuum_system_path is not None:
logging.info(
f'Disabling the periodic boundary conditions in {vacuum_system_path} '
f'by setting the cutoff type to NoCutoff')
with open(os.path.join(directory, vacuum_system_path),
'r') as file:
vacuum_system = XmlSerializer.deserialize(file.read())
disable_pbc(vacuum_system)
with open(os.path.join(directory, vacuum_system_path),
'w') as file:
file.write(XmlSerializer.serialize(vacuum_system))
# Set up the yank input file.
result = super(SolvationYankProtocol,
self).execute(directory, available_resources)
if isinstance(result, PropertyEstimatorException):
return result
if self.setup_only:
return self._get_output_dictionary()
solvent_1_yank_path = os.path.join(directory, 'experiments',
'solvent1.nc')
solvent_2_yank_path = os.path.join(directory, 'experiments',
'solvent2.nc')
self.solvent_1_trajectory_path = os.path.join(directory,
'solvent1.dcd')
self.solvent_2_trajectory_path = os.path.join(directory,
'solvent2.dcd')
self._extract_trajectory(solvent_1_yank_path,
self.solvent_1_trajectory_path)
self._extract_trajectory(solvent_2_yank_path,
self.solvent_2_trajectory_path)
return self._get_output_dictionary()
def from_dict(cls, dct):
system_xml = dct["system_xml"]
subsets = dct["subsets"]
return cls(XmlSerializer.deserialize(system_xml), subsets)
