def test_topography_serialization():
"""Correct serialization of Topography objects."""
test_system = testsystems.AlanineDipeptideImplicit()
topography = Topography(test_system.topology)
topography.add_region('atest', [0, 1, 2, 3])
serialized_topography = mmtools.utils.serialize(topography)
restored_topography = mmtools.utils.deserialize(serialized_topography)
assert topography.topology == restored_topography.topology
assert topography.ligand_atoms == restored_topography.ligand_atoms
assert topography.solvent_atoms == restored_topography.solvent_atoms
assert topography.get_region('atest') == restored_topography.get_region('atest')
def test_context_cache():
"""Test configuration of the context cache."""
testsystem = testsystems.AlanineDipeptideImplicit()
sampler_state = SamplerState(testsystem.positions)
thermodynamic_state = ThermodynamicState(testsystem.system,
300 * unit.kelvin)
# By default the global context cache is used.
cache.global_context_cache.empty() # Clear cache from previous tests.
move = SequenceMove([LangevinDynamicsMove(n_steps=5), GHMCMove(n_steps=5)])
move.apply(thermodynamic_state, sampler_state)
assert len(cache.global_context_cache) == 2
# Configuring the global cache works correctly.
cache.global_context_cache = cache.ContextCache(time_to_live=1)
move.apply(thermodynamic_state, sampler_state)
assert len(cache.global_context_cache) == 1
# The ContextCache creates only one context with compatible moves.
cache.global_context_cache = cache.ContextCache(capacity=10,
time_to_live=None)
move = SequenceMove([
LangevinDynamicsMove(n_steps=1),
LangevinDynamicsMove(n_steps=1),
LangevinDynamicsMove(n_steps=1),
LangevinDynamicsMove(n_steps=1)
])
move.apply(thermodynamic_state, sampler_state)
assert len(cache.global_context_cache) == 1
# We can configure a local context cache instead of global.
local_cache = cache.ContextCache()
move = SequenceMove([LangevinDynamicsMove(n_steps=5),
GHMCMove(n_steps=5)],
context_cache=local_cache)
for m in move:
assert m.context_cache == local_cache
# Running with the local cache doesn't affect the global one.
cache.global_context_cache = cache.ContextCache() # empty global
move.apply(thermodynamic_state, sampler_state)
assert len(cache.global_context_cache) == 0
assert len(local_cache) == 2
# DummyContextCache works for all platforms.
platforms = utils.get_available_platforms()
dummy_cache = cache.DummyContextCache()
for platform in platforms:
dummy_cache.platform = platform
move = LangevinDynamicsMove(n_steps=5, context_cache=dummy_cache)
move.apply(thermodynamic_state, sampler_state)
assert len(cache.global_context_cache) == 0
def test_stabilities_alanine_dipeptide():
"""
Test integrators for stability over a short number of steps of a harmonic oscillator.
"""
test = testsystems.AlanineDipeptideImplicit()
for methodname in dir(integrators):
if re.match('.*Integrator$', methodname):
integrator = getattr(integrators, methodname)()
integrator.__doc__ = methodname
check_stability.description = "Testing %s for stability over a short number of integration steps of alanine dipeptide in implicit solvent." % methodname
yield check_stability, integrator, test
def load(sysname):
cutoff = 0.9 * u.nanometers
temperature = 300. * u.kelvin
langevin_timestep = 0.5 * u.femtoseconds
timestep = 2 * u.femtoseconds
equil_steps = 40000
groups = [(0, 1)]
steps_per_hmc = 25
if sysname == "chargedljbox":
testsystem, system, positions, timestep, langevin_timestep = load_lj(
charge=0.15 * u.elementary_charge)
if sysname == "chargedswitchedljbox":
testsystem, system, positions, timestep, langevin_timestep = load_lj(
charge=0.15 * u.elementary_charge,
switch_width=0.34 * u.nanometers)
if sysname == "chargedlongljbox":
testsystem, system, positions, timestep, langevin_timestep = load_lj(
cutoff=1.333 * u.nanometers, charge=0.15 * u.elementary_charge)
if sysname == "chargedswitchedlongljbox":
testsystem, system, positions, timestep, langevin_timestep = load_lj(
cutoff=1.333 * u.nanometers,
charge=0.15 * u.elementary_charge,
switch_width=0.34 * u.nanometers)
if sysname == "chargedswitchedaccuratelongljbox":
testsystem, system, positions, timestep, langevin_timestep = load_lj(
cutoff=1.333 * u.nanometers,
charge=0.15 * u.elementary_charge,
switch_width=0.34 * u.nanometers,
ewaldErrorTolerance=5E-5)
if sysname == "chargedswitchedaccurateljbox":
testsystem, system, positions, timestep, langevin_timestep = load_lj(
charge=0.15 * u.elementary_charge,
switch_width=0.34 * u.nanometers,
ewaldErrorTolerance=5E-5)
if sysname == "ljbox":
testsystem, system, positions, timestep, langevin_timestep = load_lj()
if sysname == "longljbox":
testsystem, system, positions, timestep, langevin_timestep = load_lj(
cutoff=1.333 * u.nanometers)
if sysname == "shortljbox":
testsystem, system, positions, timestep, langevin_timestep = load_lj(
cutoff=0.90 * u.nanometers)
if sysname == "shiftedljbox":
testsystem, system, positions, timestep, langevin_timestep = load_lj(
shift=True)
if sysname == "switchedljbox":
testsystem, system, positions, timestep, langevin_timestep = load_lj(
switch_width=0.34 * u.nanometers)
if sysname == "switchedshortljbox":
testsystem, system, positions, timestep, langevin_timestep = load_lj(
cutoff=0.90 * u.nanometers, switch_width=0.34 * u.nanometers)
if sysname == "cluster":
testsystem = testsystems.LennardJonesCluster(nx=8, ny=8, nz=8)
system, positions = testsystem.system, testsystem.positions
hmc_integrators.guess_force_groups(system, nonbonded=0)
groups = [(0, 1)]
temperature = 25. * u.kelvin
timestep = 40 * u.femtoseconds
if sysname == "shortbigcluster":
testsystem = testsystems.LennardJonesCluster(nx=20,
ny=20,
nz=20,
cutoff=0.75 *
u.nanometers)
system, positions = testsystem.system, testsystem.positions
hmc_integrators.guess_force_groups(system, nonbonded=0)
groups = [(0, 1)]
temperature = 25. * u.kelvin
timestep = 10 * u.femtoseconds
if sysname == "switchedshortbigcluster":
testsystem = testsystems.LennardJonesCluster(
nx=20,
ny=20,
nz=20,
cutoff=0.75 * u.nanometers,
switch_width=0.1 * u.nanometers)
system, positions = testsystem.system, testsystem.positions
hmc_integrators.guess_force_groups(system, nonbonded=0)
groups = [(0, 1)]
temperature = 25. * u.kelvin
timestep = 10 * u.femtoseconds
if sysname == "bigcluster":
testsystem = testsystems.LennardJonesCluster(nx=20,
ny=20,
nz=20,
cutoff=1.25 *
u.nanometers)
system, positions = testsystem.system, testsystem.positions
hmc_integrators.guess_force_groups(system, nonbonded=0)
groups = [(0, 1)]
temperature = 25. * u.kelvin
timestep = 10 * u.femtoseconds
if sysname == "shortcluster":
testsystem = testsystems.LennardJonesCluster(nx=8,
ny=8,
nz=8,
cutoff=0.75 *
u.nanometers)
system, positions = testsystem.system, testsystem.positions
hmc_integrators.guess_force_groups(system, nonbonded=0)
groups = [(0, 1)]
temperature = 25. * u.kelvin
timestep = 40 * u.femtoseconds
if sysname == "shortwater":
testsystem = testsystems.WaterBox(
box_edge=3.18 * u.nanometers,
cutoff=0.9 * u.nanometers,
switch_width=None) # Around 1060 molecules of water
system, positions = testsystem.system, testsystem.positions
if sysname == "shortswitchedwater":
testsystem = testsystems.WaterBox(
box_edge=3.18 * u.nanometers,
cutoff=0.9 * u.nanometers,
switch_width=3.0 * u.angstroms) # Around 1060 molecules of water
system, positions = testsystem.system, testsystem.positions
if sysname == "water":
testsystem = testsystems.WaterBox(
box_edge=3.18 * u.nanometers,
cutoff=1.1 * u.nanometers,
switch_width=None) # Around 1060 molecules of water
system, positions = testsystem.system, testsystem.positions
if sysname == "switchedwater":
testsystem = testsystems.WaterBox(
box_edge=3.18 * u.nanometers,
cutoff=1.1 * u.nanometers,
switch_width=3.0 * u.angstroms) # Around 1060 molecules of water
system, positions = testsystem.system, testsystem.positions
if sysname == "switchedaccuratewater":
testsystem = testsystems.WaterBox(
box_edge=3.18 * u.nanometers,
cutoff=1.1 * u.nanometers,
switch_width=3.0 * u.angstroms,
ewaldErrorTolerance=5E-5) # Around 1060 molecules of water
system, positions = testsystem.system, testsystem.positions
hmc_integrators.guess_force_groups(
system, nonbonded=0, fft=1, others=0) # We may want to try reduce
if sysname == "switchedaccurateflexiblewater":
testsystem = testsystems.WaterBox(
box_edge=3.18 * u.nanometers,
cutoff=1.1 * u.nanometers,
switch_width=3.0 * u.angstroms,
ewaldErrorTolerance=5E-5,
constrained=False) # Around 1060 molecules of water
system, positions = testsystem.system, testsystem.positions
# Using these groups for hyperopt-optimal RESPA integrators
#hmc_integrators.guess_force_groups(system, nonbonded=0, others=1, fft=0)
hmc_integrators.guess_force_groups(system,
nonbonded=1,
others=1,
fft=0)
equil_steps = 100000
langevin_timestep = 0.25 * u.femtoseconds
if sysname == "switchedaccuratebigflexiblewater":
testsystem = testsystems.WaterBox(
box_edge=10.0 * u.nanometers,
cutoff=1.1 * u.nanometers,
switch_width=3.0 * u.angstroms,
ewaldErrorTolerance=5E-5,
constrained=False) # Around 1060 molecules of water
system, positions = testsystem.system, testsystem.positions
# Using these groups for hyperopt-optimal RESPA integrators
hmc_integrators.guess_force_groups(system,
nonbonded=1,
others=0,
fft=1)
equil_steps = 100000
langevin_timestep = 0.1 * u.femtoseconds
if sysname == "switchedaccuratestiffflexiblewater":
testsystem = testsystems.WaterBox(
box_edge=3.18 * u.nanometers,
cutoff=1.1 * u.nanometers,
switch_width=3.0 * u.angstroms,
ewaldErrorTolerance=5E-5,
constrained=False) # Around 1060 molecules of water
system, positions = testsystem.system, testsystem.positions
# Using these groups for hyperopt-optimal RESPA integrators
#hmc_integrators.guess_force_groups(system, nonbonded=0, others=1, fft=0)
hmc_integrators.guess_force_groups(system,
nonbonded=1,
others=1,
fft=0)
equil_steps = 100000
langevin_timestep = 0.25 * u.femtoseconds
FACTOR = 10.0
# Make bonded terms stiffer to highlight RESPA advantage
for force in system.getForces():
if type(force) == mm.HarmonicBondForce:
for i in range(force.getNumBonds()):
(a0, a1, length, strength) = force.getBondParameters(i)
force.setBondParameters(i, a0, a1, length,
strength * FACTOR)
elif type(force) == mm.HarmonicAngleForce:
for i in range(force.getNumAngles()):
(a0, a1, a2, length,
strength) = force.getAngleParameters(i)
force.setAngleParameters(i, a0, a1, a2, length,
strength * FACTOR)
if sysname == "switchedaccuratenptwater":
testsystem = testsystems.WaterBox(
box_edge=3.18 * u.nanometers,
cutoff=1.1 * u.nanometers,
switch_width=3.0 * u.angstroms,
ewaldErrorTolerance=5E-5) # Around 1060 molecules of water
system, positions = testsystem.system, testsystem.positions
system.addForce(
mm.MonteCarloBarostat(1.0 * u.atmospheres, temperature, 1))
if sysname == "longswitchedwater":
testsystem = testsystems.WaterBox(
box_edge=3.18 * u.nanometers,
cutoff=1.5 * u.nanometers,
switch_width=3.0 * u.angstroms) # Around 1060 molecules of water
system, positions = testsystem.system, testsystem.positions
if sysname == "rfwater":
testsystem = testsystems.WaterBox(
box_edge=3.18 * u.nanometers,
cutoff=1.1 * u.nanometers,
nonbondedMethod=app.CutoffPeriodic,
switch_width=None) # Around 1060 molecules of water
system, positions = testsystem.system, testsystem.positions
if sysname == "switchedrfwater":
testsystem = testsystems.WaterBox(
box_edge=3.18 * u.nanometers,
cutoff=1.1 * u.nanometers,
nonbondedMethod=app.CutoffPeriodic,
switch_width=3.0 * u.angstroms) # Around 1060 molecules of water
system, positions = testsystem.system, testsystem.positions
if sysname == "longswitchedrfwater":
testsystem = testsystems.WaterBox(
box_edge=3.18 * u.nanometers,
cutoff=1.5 * u.nanometers,
nonbondedMethod=app.CutoffPeriodic,
switch_width=3.0 * u.angstroms) # Around 1060 molecules of water
system, positions = testsystem.system, testsystem.positions
if sysname == "density":
system, positions = load_lb(hydrogenMass=3.0 * u.amu)
hmc_integrators.guess_force_groups(system,
nonbonded=1,
fft=1,
others=0)
groups = [(0, 4), (1, 1)]
timestep = 2.0 * u.femtoseconds
if sysname == "dhfr":
testsystem = testsystems.DHFRExplicit(nonbondedCutoff=1.1 *
u.nanometers,
nonbondedMethod=app.PME,
switch_width=2.0 * u.angstroms,
ewaldErrorTolerance=5E-5)
system, positions = testsystem.system, testsystem.positions
hmc_integrators.guess_force_groups(system,
nonbonded=1,
fft=2,
others=0)
groups = [(0, 4), (1, 2), (2, 1)]
timestep = 0.75 * u.femtoseconds
equil_steps = 10000
if sysname == "src":
testsystem = testsystems.SrcExplicit(nonbondedCutoff=1.1 *
u.nanometers,
nonbondedMethod=app.PME,
switch_width=2.0 * u.angstroms,
ewaldErrorTolerance=5E-5)
system, positions = testsystem.system, testsystem.positions
hmc_integrators.guess_force_groups(system,
nonbonded=1,
fft=1,
others=0)
groups = [(0, 2), (1, 1)]
timestep = 0.25 * u.femtoseconds
equil_steps = 1000
if sysname == "ho":
K = 90.0 * u.kilocalories_per_mole / u.angstroms**2
mass = 39.948 * u.amu
timestep = np.sqrt(mass / K) * 0.4
testsystem = testsystems.HarmonicOscillatorArray()
system, positions = testsystem.system, testsystem.positions
groups = [(0, 1)]
if sysname == "customho":
timestep = 1000.0 * u.femtoseconds
testsystem = testsystems.CustomExternalForcesTestSystem()
system, positions = testsystem.system, testsystem.positions
groups = [(0, 1)]
if sysname == "customsplitho":
timestep = 1000.0 * u.femtoseconds
energy_expressions = ("0.75 * (x^2 + y^2 + z^2)",
"0.25 * (x^2 + y^2 + z^2)")
testsystem = testsystems.CustomExternalForcesTestSystem(
energy_expressions=energy_expressions)
system, positions = testsystem.system, testsystem.positions
groups = [(0, 2), (1, 1)]
if sysname == "alanine":
testsystem = testsystems.AlanineDipeptideImplicit()
system, positions = testsystem.system, testsystem.positions
groups = [(0, 2), (1, 1)]
timestep = 2.0 * u.femtoseconds
hmc_integrators.guess_force_groups(system, nonbonded=1, others=0)
#remove_cmm(system) # Unrolled shouldn't need this
equil_steps = 10000
if sysname == "alanineexplicit":
testsystem = testsystems.AlanineDipeptideExplicit(
cutoff=1.1 * u.nanometers,
switch_width=2 * u.angstrom,
ewaldErrorTolerance=5E-5)
system, positions = testsystem.system, testsystem.positions
#groups = [(0, 2), (1, 1), (2, 1)]
#groups = [(0, 2), (1, 1)]
timestep = 1.0 * u.femtoseconds
#hmc_integrators.guess_force_groups(system, nonbonded=1, others=0, fft=2)
#hmc_integrators.guess_force_groups(system, nonbonded=0, others=0, fft=1)
groups = [(0, 1), (1, 2)]
hmc_integrators.guess_force_groups(system,
nonbonded=0,
others=1,
fft=0)
#remove_cmm(system) # Unrolled doesn't need this
equil_steps = 4000
# guess force groups
if "ljbox" in sysname:
timestep = 25 * u.femtoseconds
temperature = 25. * u.kelvin
system, positions = testsystem.system, testsystem.positions
hmc_integrators.guess_force_groups(system, nonbonded=0, fft=1)
groups = [(0, 2), (1, 1)]
equil_steps = 10000
steps_per_hmc = 15
if sysname == "amoeba":
testsystem = testsystems.AMOEBAIonBox()
system, positions = testsystem.system, testsystem.positions
hmc_integrators.guess_force_groups(system,
nonbonded=0,
fft=1,
others=0)
return system, positions, groups, temperature, timestep, langevin_timestep, testsystem, equil_steps, steps_per_hmc
def test_topology_serialization():
"""Correct serialization of Topology objects."""
topology = testsystems.AlanineDipeptideImplicit().topology
topology_str = serialize_topology(topology)
deserialized_topology = deserialize_topology(topology_str)
assert mdtraj.Topology.from_openmm(topology) == deserialized_topology
# force_dict = { system.getForce(index).__class__.__name__ : system.getForce(index) for index in range(system.getNumForces()) }
forces = list()
for index in range(system.getNumForces()):
force = system.getForce(index)
if (force.__class__.__name__ == force_name):
forces.append(force)
if first_only and (len(forces) > 0):
forces = forces[0]
return forces
if __name__ == "__main__":
from openmmtools import testsystems
testsystem = testsystems.AlanineDipeptideImplicit()
[system, positions, topology
] = [testsystem.system, testsystem.positions, testsystem.topology]
# Get NonbondedForce objects for system copy.
force = _findForces(system, 'NonbondedForce', first_only=True)
# Turn off standard particle interactions.
zero_charge = 0.0 * unit.elementary_charge
unit_sigma = 1.0 * unit.angstroms
zero_epsilon = 0.0 * unit.kilocalories_per_mole
for atom in topology.atoms():
[charge, sigma, epsilon] = force.getParticleParameters(atom.index)
force.setParticleParameters(atom.index, zero_charge, unit_sigma,
zero_epsilon)
