def setup(self):
pes = paths.engines.toy.Gaussian(1, [1.0, 1.0], [0.0, 0.0])
integ = paths.engines.toy.LangevinBAOABIntegrator(0.01, 0.1, 2.5)
topology = paths.engines.toy.Topology(n_spatial=2,
n_atoms=1,
masses=[1.0],
pes=pes)
self.engine = paths.engines.toy.Engine(
options={
'n_frames_max': 1000,
'n_steps_per_frame': 10,
'integ': integ
},
topology=topology).named("engine")
self.other_engine = paths.engines.toy.Engine(options={
'n_frames_max': 5000,
'n_steps_per_frame': 1,
'integ': integ
},
topology=topology)
self.cv = paths.FunctionCV("x", lambda x: x.xyz[0][0])
self.state_A = paths.CVDefinedVolume(self.cv, float("-inf"),
0).named("A")
self.state_B = paths.CVDefinedVolume(self.cv, 10,
float("inf")).named("B")
self.network = paths.TPSNetwork(self.state_A,
self.state_B).named('network')
self.scheme = paths.OneWayShootingMoveScheme(
self.network, paths.UniformSelector(), self.engine).named("scheme")
self.other_scheme = paths.OneWayShootingMoveScheme(
self.network, paths.UniformSelector(), self.other_engine)
self.tempdir = tempfile.mkdtemp()
def test_nan_rejected(self):
stateA = paths.EmptyVolume() # will run indefinitely
stateB = paths.EmptyVolume()
tps = A2BEnsemble(stateA, stateB)
self.engine.n_frames_max = 10
init_traj = paths.Trajectory([nan_causing_template] * 5)
init_samp = paths.SampleSet([paths.Sample(
trajectory=init_traj,
replica=0,
ensemble=tps
)])
mover = paths.BackwardShootMover(
ensemble=tps,
selector=paths.UniformSelector(),
engine=self.engine
)
change = mover.move(init_samp)
assert (isinstance(change, paths.RejectedNaNSampleMoveChange))
assert_equal(change.details.rejection_reason, 'nan')
# since we shoot, we start with a shorter trajectory
assert(len(change.samples[0].trajectory) < len(init_traj))
newsamp = init_samp.apply_samples(change)
assert_equal(len(newsamp), 1)
# make sure there is no change!
assert_equal(init_samp[0].trajectory, init_traj)
def test_max_length_rejected(self):
stateA = paths.EmptyVolume() # will run indefinitely
stateB = paths.EmptyVolume()
tps = A2BEnsemble(stateA, stateB)
self.engine.options['n_frames_max'] = 10
self.engine.on_max_length = 'fail'
init_traj = paths.Trajectory([template] * 5)
init_samp = paths.SampleSet([paths.Sample(
trajectory=init_traj,
replica=0,
ensemble=tps
)])
mover = paths.BackwardShootMover(
ensemble=tps,
selector=paths.UniformSelector(),
engine=self.engine
)
change = mover.move(init_samp)
assert(isinstance(change, paths.RejectedMaxLengthSampleMoveChange))
assert_equal(change.details.rejection_reason, 'max_length')
assert_equal(
len(change.samples[0].trajectory), self.engine.n_frames_max)
newsamp = init_samp.apply_samples(change)
assert_equal(len(newsamp), 1)
# make sure there is no change!
assert_equal(init_samp[0].trajectory, init_traj)
def tps_fixture(flat_engine, tps_network_and_traj):
network, traj = tps_network_and_traj
scheme = paths.OneWayShootingMoveScheme(network=network,
selector=paths.UniformSelector(),
engine=flat_engine)
init_conds = scheme.initial_conditions_from_trajectories(traj)
return (scheme, network, flat_engine, init_conds)
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 setup(self):
paths.InterfaceSet._reset()
self.cv = paths.FunctionCV("x", lambda x: x.xyz[0][0])
self.state_A = paths.CVDefinedVolume(self.cv, float("-inf"), 0.0)
self.state_B = paths.CVDefinedVolume(self.cv, 1.0, float("inf"))
pes = paths.engines.toy.LinearSlope([0, 0, 0], 0)
integ = paths.engines.toy.LangevinBAOABIntegrator(0.01, 0.1, 2.5)
topology = paths.engines.toy.Topology(n_spatial=3,
masses=[1.0],
pes=pes)
self.engine = paths.engines.toy.Engine(options={'integ': integ},
topology=topology)
interfaces = paths.VolumeInterfaceSet(self.cv, float("-inf"),
[0.0, 0.1, 0.2])
network = paths.MISTISNetwork([(self.state_A, interfaces, self.state_B)
])
init_traj = make_1d_traj([-0.1, 0.2, 0.5, 0.8, 1.1])
scheme = paths.MoveScheme(network)
scheme.append([
paths.strategies.OneWayShootingStrategy(
selector=paths.UniformSelector(), engine=self.engine),
paths.strategies.PathReversalStrategy(),
paths.strategies.OrganizeByMoveGroupStrategy()
])
init_cond = scheme.initial_conditions_from_trajectories(init_traj)
self.sim = PathSampling(storage=None,
move_scheme=scheme,
sample_set=init_cond)
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, selector=None, ensembles=None, engine=None,
group="shooting", replace=True):
super(OneWayShootingStrategy, self).__init__(
ensembles=ensembles, group=group, replace=replace
)
if selector is None:
selector = paths.UniformSelector()
self.selector = selector
self.engine = engine
def __init__(self, multiple_binding_ensemble, subselector=None):
self.multiple_binding_ensemble = multiple_binding_ensemble
if subselector is None:
subselector = paths.UniformSelector()
self.subselector = subselector
# cache the previously tested trajectory and the resulting
# subtrajectory. This avoids wasteful recalc for most cases of
# multiple use of `f`, `pick`, `sum_bias` for the same input traj
self._cached_subtraj = paths.Trajectory([])
self._cached_traj = paths.Trajectory([])
def shoot_until_A_to_A(initial_ensemble, desired_ensemble, sample, engine):
# we only shoot forward because we know the final frame is the problem
mover = paths.ForwardShootMover(ensemble=initial_ensemble,
selector=paths.UniformSelector(),
engine=engine)
while not desired_ensemble(sample):
change = mover.move_core([sample])
if desired_ensemble(change.trials[0]):
sample = change.trials[0]
return sample
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)
def one_pot_tps_main(output_storage, states, engine, engine_hot, initial_frame,
nsteps):
import openpathsampling as paths
network = paths.TPSNetwork.from_states_all_to_all(states)
scheme = paths.OneWayShootingMoveScheme(network=network,
selector=paths.UniformSelector(),
engine=engine)
trajectory, _ = visit_all_main(None, states, engine_hot, initial_frame)
equil_multiplier = 1
equil_extra = 0
equil_set, _ = equilibrate_main(None, scheme, trajectory, equil_multiplier,
equil_extra)
return pathsampling_main(output_storage, scheme, equil_set, nsteps)
def test_tps_scheme(tps_network, toy_engine, as_scheme):
wizard = mock_wizard([])
wizard.networks = {tps_network.name: tps_network}
if as_scheme:
strategy = partial(paths.SpringShootingMoveScheme,
k_spring=0.01,
delta_max=10,
engine=toy_engine)
else:
strategy = strategies.OneWayShootingStrategy(
selector=paths.UniformSelector(), engine=toy_engine)
with mock.patch('paths_cli.wizard.tps.shooting',
new=mock.Mock(return_value=strategy)):
scheme = tps_scheme(wizard)
assert isinstance(scheme, paths.MoveScheme)
if as_scheme:
assert isinstance(scheme, paths.SpringShootingMoveScheme)
def __init__(self,
storage,
network,
initial_file,
topology_file,
options=None,
options_rejected=None):
self.topology_file = topology_file
mover = oink.ShootingStub(ensemble=network.sampling_ensembles[0],
selector=paths.UniformSelector(),
pre_joined=False)
super(GromacsOneWayTPSConverter,
self).__init__(storage=storage,
network=network,
initial_file=initial_file,
mover=mover,
options=options,
options_rejected=options_rejected)
#
# 1. Create a `network`
# 2. Create a `move_scheme`
# 3. Set up `initial_conditions`
# 4. Create the `PathSampling` object and run it.
#
# Since we already created all the input to these when we set up the first trajectory, we can load use the versions we loaded above.
# In[5]:
network = paths.TPSNetwork(C_7eq, alpha_R)
# In[6]:
scheme = paths.OneWayShootingMoveScheme(network,
selector=paths.UniformSelector(),
engine=engine)
# In[7]:
initial_conditions = scheme.initial_conditions_from_trajectories(traj)
# In[8]:
storage = paths.Storage("alanine_dipeptide_tps.nc", "w", template)
sampler = paths.PathSampling(storage=storage,
move_scheme=scheme,
sample_set=initial_conditions)
# Note: 10000 steps will take a long time. If you just want to run a little bit, reduce this number.
def uniform_selector(wizard):
"""Create a uniform selector (using the wizard)"""
import openpathsampling as paths
return paths.UniformSelector()
