def test_in_shooting_move(self):
for testfile in glob.glob("test*out") + glob.glob("test*inp"):
os.remove(testfile)
ens10 = paths.LengthEnsemble(10)
init_traj = self.fast_engine.generate(self.template,
[ens10.can_append])
assert_equal(ens10(init_traj), True)
init_conds = paths.SampleSet(
[paths.Sample(replica=0, ensemble=ens10, trajectory=init_traj)])
shooter = paths.OneWayShootingMover(ensemble=ens10,
selector=paths.UniformSelector(),
engine=self.fast_engine)
prev_sample_set = init_conds
default_traj = [[[0.0]], [[1.0]], [[2.0]], [[3.0]], [[4.0]], [[5.0]],
[[6.0]], [[7.0]], [[8.0]], [[9.0]]]
assert_items_equal(init_conds[0].trajectory.xyz, default_traj)
for step in range(10):
assert_equal(len(prev_sample_set), 1)
change = shooter.move(prev_sample_set)
new_sample_set = prev_sample_set.apply_samples(change.results)
assert_items_equal(new_sample_set[0].trajectory.xyz, default_traj)
prev_traj = prev_sample_set[0].trajectory
new_traj = new_sample_set[0].trajectory
shared = prev_traj.shared_configurations(new_traj)
assert_true(0 < len(list(shared)) < len(new_traj))
prev_sample_set = new_sample_set
for testfile in glob.glob("test*out") + glob.glob("test*inp"):
os.remove(testfile)
def __init__(self, transition, snapshot, storage=None, engine=None,
extra_interfaces=None, forbidden_states=None):
super(FullBootstrapping, self).__init__(storage, engine)
if extra_interfaces is None:
extra_interfaces = list()
if forbidden_states is None:
forbidden_states = list()
interface0 = transition.interfaces[0]
ensemble0 = transition.ensembles[0]
state = transition.stateA
self.state = state
self.first_traj_ensemble = paths.SequentialEnsemble([
paths.OptionalEnsemble(paths.AllOutXEnsemble(state)),
paths.AllInXEnsemble(state),
paths.OptionalEnsemble(
paths.AllOutXEnsemble(state) & paths.AllInXEnsemble(interface0)
),
paths.OptionalEnsemble(paths.AllInXEnsemble(interface0)),
paths.AllOutXEnsemble(interface0),
paths.OptionalEnsemble(paths.AllOutXEnsemble(state)),
paths.SingleFrameEnsemble(paths.AllInXEnsemble(state))
]) & paths.AllOutXEnsemble(paths.join_volumes(forbidden_states))
self.extra_ensembles = [paths.TISEnsemble(transition.stateA,
transition.stateB, iface,
transition.orderparameter)
for iface in extra_interfaces
]
self.transition_shooters = [
paths.OneWayShootingMover(selector=paths.UniformSelector(),
ensemble=ens)
for ens in transition.ensembles
]
self.extra_shooters = [
paths.OneWayShootingMover(selector=paths.UniformSelector(),
ensemble=ens)
for ens in self.extra_ensembles
]
self.snapshot = snapshot.copy()
self.ensemble0 = ensemble0
self.all_ensembles = transition.ensembles + self.extra_ensembles
self.n_ensembles = len(self.all_ensembles)
self.error_max_rounds = True
def __init__(self, ensemble, selector=None, engine=None, pre_joined=True):
super(ShootingStub, self).__init__()
if engine is None:
engine = NoEngine()
if selector is None:
selector = paths.UniformSelector() # default
self.engine = engine
self.selector = selector
self.ensemble = ensemble
self.pre_joined = pre_joined
self.mimic = paths.OneWayShootingMover(ensemble, selector, engine)
print("Setting up the simulation")
testsystem = openmmtools.testsystems.AlanineDipeptideVacuum()
integrator = openmmtools.integrators.VVVRIntegrator()
topology = paths.engines.openmm.topology.MDTrajTopology(testsystem.mdtraj_topology)
engine = paths.engines.openmm.Engine(topology=topology,
system=testsystem.system,
integrator=integrator,
options={
'n_frames_max': 100,
'n_steps_per_frame': 10,
}).named('fake_engine')
ensemble=paths.LengthEnsemble(5).named("length 5")
mover = paths.OneWayShootingMover(ensemble=ensemble,
selector=paths.UniformSelector(),
engine=engine)
scheme = paths.LockedMoveScheme(root_mover=mover)
### INITIAL SNAPSHOT #######################################################
print("Getting energy-minimized initial snapshot")
engine.simulation.context.setPositions(testsystem.positions)
engine.simulation.minimizeEnergy()
initial_snapshot = engine.current_snapshot
### SETUP INITIAL CONDITIONS ###############################################
print("Setting up initial conditions")
initial_trajectory = engine.generate(initial_snapshot, ensemble.can_append)
