def test_sim_factory():
# check sim_factory returns a function when passed a testsystem
construct_sim = utils.sim_factory(AlanineDipeptideVacuum())
assert (callable(construct_sim))
# check that the resulting function returns an app.Simulation when passed an integrator
sim = construct_sim(LangevinIntegrator())
assert (isinstance(sim, app.Simulation))
def test_measure_shadow_work():
# test that it's consistent with openmmtools
construct_sim = utils.sim_factory(AlanineDipeptideVacuum(constraints=None))
sim = construct_sim(
LangevinIntegrator(splitting='O V R V O',
measure_heat=True,
measure_shadow_work=True,
timestep=2.0 * unit.femtoseconds))
sim.runForClockTime(1 * unit.seconds)
w_shads_here = []
w_shads_openmmtools = []
for _ in range(10):
w_shad_prev = sim.integrator.get_shadow_work(dimensionless=True)
w_shads_here.append(utils.measure_shadow_work(sim, 10))
w_shad_new = sim.integrator.get_shadow_work(dimensionless=True)
w_shads_openmmtools.append(w_shad_new - w_shad_prev)
assert (np.isclose(w_shads_here, w_shads_openmmtools).all())
def test_clone_state():
# construct source system
construct_sim = utils.sim_factory(AlanineDipeptideVacuum())
sim_a = construct_sim(LangevinIntegrator())
sim_b = construct_sim(LangevinIntegrator())
sim_a.step(50)
sim_b.step(50)
utils.clone_state(sim_a, sim_b)
state_a = sim_a.context.getState(getPositions=True, getVelocities=True)
state_b = sim_b.context.getState(getPositions=True, getVelocities=True)
# check that the positions were cloned
assert (np.isclose(state_a.getPositions(asNumpy=True),
state_b.getPositions(asNumpy=True)).all())
# check that the velocities were cloned
assert (np.isclose(state_a.getVelocities(asNumpy=True),
state_b.getVelocities(asNumpy=True)).all())
def test_get_a_paired_kldiv_sample():
# just make sure it returns floats?
testsystem = AlanineDipeptideVacuum(constraints=None)
construct_sim = utils.sim_factory(testsystem)
equilibrium_sim = construct_sim(GHMCIntegrator(timestep=0.25 * unit.femtosecond))
equilibrium_sim.minimizeEnergy()
equilibrium_sim.step(1000)
reference_sim = construct_sim(
LangevinIntegrator(splitting='O V R V O', measure_shadow_work=True, measure_heat=True,
timestep=0.01 * unit.femtosecond))
test_sim = construct_sim(
LangevinIntegrator(splitting='O V R V O', measure_shadow_work=True, measure_heat=True,
timestep=3 * unit.femtosecond))
kldiv_reference, kldiv_test = error.get_a_paired_kldiv_sample(equilibrium_sim, reference_sim, test_sim,
protocol_length=100)
assert (isinstance(kldiv_reference, float))
assert (isinstance(kldiv_test, float))
# more stringent test: check that median of reference here is lower than median of test_sim
reference_samples, test_samples = [], []
for _ in range(100):
equilibrium_sim.step(100)
kldiv_reference, kldiv_test = error.get_a_paired_kldiv_sample(equilibrium_sim, reference_sim, test_sim,
protocol_length=100)
reference_samples.append(kldiv_reference)
test_samples.append(kldiv_test)
assert (np.median(reference_samples) <= np.median(test_samples))
# check that recycle_v works
_ = error.get_a_paired_kldiv_sample(equilibrium_sim, reference_sim, test_sim,
protocol_length=100, recycle_v=True)
# check that it doesn't fail silently when reference_sim and test_sim are at different temperatures
with pytest.raises(ValueError):
test_sim.integrator.setTemperature(200 * unit.kelvin)
error.get_a_paired_kldiv_sample(equilibrium_sim, reference_sim, test_sim)
from openmmtools.integrators import LangevinIntegrator, GHMCIntegrator
from openmmtools.testsystems import AlanineDipeptideVacuum
from simtk import unit
from thresholds import utils, bisect, stability
if __name__ == '__main__':
testsystem = AlanineDipeptideVacuum()
def make_integrator(splitting):
return LangevinIntegrator(splitting=splitting,
timestep=2 * unit.femtoseconds,
measure_shadow_work=False,
measure_heat=False)
construct_sim = utils.sim_factory(testsystem)
equilibrium_sim = construct_sim(
GHMCIntegrator(timestep=0.5 * unit.femtoseconds))
equilibrium_sim.context.setVelocitiesToTemperature(
equilibrium_sim.integrator.getTemperature())
equilibrium_sim.step(1000)
def set_initial_conditions(sim):
equilibrium_sim.step(100)
utils.clone_state(equilibrium_sim, sim)
final_beliefs = {}
hmr_range = np.linspace(1, 4)
for hydrogen_mass in hmr_range:
import pytest
from openmmtools.integrators import LangevinIntegrator
from openmmtools.testsystems import AlanineDipeptideVacuum
from simtk import unit
from thresholds import utils, stability
testsystem = AlanineDipeptideVacuum()
construct_sim = utils.sim_factory(testsystem)
tiny_dt = 0.1 * unit.femtoseconds
stable_sim = construct_sim(LangevinIntegrator(timestep=tiny_dt))
huge_dt = 100 * unit.femtoseconds
unstable_sim = construct_sim(LangevinIntegrator(timestep=huge_dt))
def test_check_stability():
# check that stable simulation is labeled stable
assert (stability.check_stability(stable_sim, n_steps=100))
# check that unstable simulation is labeled unstable
assert (not stability.check_stability(unstable_sim, n_steps=100))
def test_stability_oracle_factory():
def set_initial_conditions(sim):
sim.context.setPositions(testsystem.positions)
sim.context.setVelocitiesToTemperature(298 * unit.kelvin)
iterated_stability_oracle = stability.stability_oracle_factory(