def setup(self):
# As a test system, let's use 1D motion on a flat potential. If the
# velocity is positive, you right the state on the right. If it is
# negative, you hit the state on the left.
pes = toys.LinearSlope(m=[0.0], c=[0.0]) # flat line
topology = toys.Topology(n_spatial=1, masses=[1.0], pes=pes)
integrator = toys.LeapfrogVerletIntegrator(0.1)
options = {
'integ': integrator,
'n_frames_max': 100000,
'n_steps_per_frame': 5
}
self.engine = toys.Engine(options=options, topology=topology)
self.snap0 = toys.Snapshot(coordinates=np.array([[0.0]]),
velocities=np.array([[1.0]]),
engine=self.engine)
cv = paths.FunctionCV("Id", lambda snap: snap.coordinates[0][0])
starting_volume = paths.CVDefinedVolume(cv, -0.01, 0.01)
forward_ensemble = paths.LengthEnsemble(5)
backward_ensemble = paths.LengthEnsemble(3)
randomizer = paths.NoModification()
self.filename = data_filename("shoot_from_snaps.nc")
self.storage = paths.Storage(self.filename, 'w')
self.simulation = ShootFromSnapshotsSimulation(
storage=self.storage,
engine=self.engine,
starting_volume=starting_volume,
forward_ensemble=forward_ensemble,
backward_ensemble=backward_ensemble,
randomizer=randomizer,
initial_snapshots=self.snap0)
self.simulation.output_stream = open(os.devnull, "w")
def __init__(self, storage, engine=None, states=None, randomizer=None,
initial_snapshots=None, direction=None):
all_state_volume = paths.join_volumes(states)
no_state_volume = ~all_state_volume
# shoot forward until we hit a state
forward_ensemble = paths.SequentialEnsemble([
paths.AllOutXEnsemble(all_state_volume),
paths.AllInXEnsemble(all_state_volume) & paths.LengthEnsemble(1)
])
# or shoot backward until we hit a state
backward_ensemble = paths.SequentialEnsemble([
paths.AllInXEnsemble(all_state_volume) & paths.LengthEnsemble(1),
paths.AllOutXEnsemble(all_state_volume)
])
super(CommittorSimulation, self).__init__(
storage=storage,
engine=engine,
starting_volume=no_state_volume,
forward_ensemble=forward_ensemble,
backward_ensemble=backward_ensemble,
randomizer=randomizer,
initial_snapshots=initial_snapshots
)
self.states = states
self.direction = direction
# override the default self.mover given by the superclass
if self.direction is None:
self.mover = paths.RandomChoiceMover([self.forward_mover,
self.backward_mover])
elif self.direction > 0:
self.mover = self.forward_mover
elif self.direction < 0:
self.mover = self.backward_mover
def analyze_transition_duration(self, trajectory, stateA, stateB):
"""Analysis to obtain transition durations for given state.
Parameters
----------
trajectory : :class:`.Trajectory`
trajectory to analyze
stateA : :class:`.Volume`
initial state volume for the transition
stateB : :class:`.Volume`
final state volume for the transition
Returns
-------
:class:`.TrajectorySegmentContainer`
transitions from `stateA` to `stateB` within `trajectory`
"""
# we define the transitions ensemble just in case the transition is,
# e.g., fixed path length TPS. We want flexible path length ensemble
transition_ensemble = paths.SequentialEnsemble([
paths.AllInXEnsemble(stateA) & paths.LengthEnsemble(1),
paths.OptionalEnsemble( # optional to allow instantaneous hops
paths.AllOutXEnsemble(stateA) & paths.AllOutXEnsemble(stateB)
),
paths.AllInXEnsemble(stateB) & paths.LengthEnsemble(1)
])
segments = [seg[1:-1] for seg in transition_ensemble.split(trajectory)]
return TrajectorySegmentContainer(segments, self.dt)
def A2BEnsemble(volume_a, volume_b, trusted=True):
# this is a little replacement for the same name that used to be in
# EnsembleFactory. It was only used in tests.
return paths.SequentialEnsemble([
paths.AllInXEnsemble(volume_a) & paths.LengthEnsemble(1),
paths.AllOutXEnsemble(volume_a | volume_b),
paths.AllInXEnsemble(volume_b) & paths.LengthEnsemble(1)
])
def get_lifetime_segments(trajectory, from_vol, to_vol, forbidden=None,
padding=[0, -1]):
"""General script to get lifetimes.
Lifetimes for a transition between volumes are used in several other
calculations: obviously, the state lifetime, but also the flux
through an interface. This is a generic function to calculate that.
Parameters
----------
trajectory : :class:`.Trajectory`
trajectory to analyze
from_vol : :class:`.Volume`
the volume for which this represents the lifetime: the
trajectory segments returned are associated with the lifetime of
`from_vol`
to_vol : :class:`.Volume`
the volume which indicates the end of the lifetime: a frame in
this volume means the trajectory is no longer associated with
`from_vol`
forbidden : :class:`.Volume`
if a frame is in `forbidden`, it cannot be part of the lifetime
of `from_vol`. This isn't needed in 2-state lifetime
calculations; however, it is useful to exclude other states
from a flux calculation
padding : list
adjusts which frames are returned as list indices. That is, the
returned segments are `full_segment[padding[0]:padding[1]]`.
The `full_segment`s are the segments from (and including) each
first frame in `from_vol` (after a visit to `to_vol`) until (and
including) the first frame in `to_vol`. To get the full segment
as output, use `padding=[None, None]`. The default is to remove
the final frame (`padding=[0, -1]`) so that it doesn't include
the frame in `to_vol`.
Returns
-------
list of :class:`.Trajectory`
the frames from (and including) each first entry from `to_vol`
into `from_vol` until (and including) the next entry into
`to_vol`, with no frames in `forbidden`, and with frames removed
from the ends according to `padding`
"""
if forbidden is None:
forbidden = paths.EmptyVolume()
ensemble_BAB = paths.SequentialEnsemble([
paths.LengthEnsemble(1) & paths.AllInXEnsemble(to_vol),
paths.PartInXEnsemble(from_vol) & paths.AllOutXEnsemble(to_vol),
paths.LengthEnsemble(1) & paths.AllInXEnsemble(to_vol)
]) & paths.AllOutXEnsemble(forbidden)
ensemble_AB = paths.SequentialEnsemble([
paths.LengthEnsemble(1) & paths.AllInXEnsemble(from_vol),
paths.OptionalEnsemble(paths.AllOutXEnsemble(to_vol)),
paths.LengthEnsemble(1) & paths.AllInXEnsemble(to_vol)
])
BAB_split = ensemble_BAB.split(trajectory)
AB_split = [ensemble_AB.split(part)[0] for part in BAB_split]
return [subtraj[padding[0]:padding[1]] for subtraj in AB_split]
def add_transition(self, stateA, stateB):
new_ens = paths.SequentialEnsemble([
paths.AllInXEnsemble(stateA) & paths.LengthEnsemble(1),
paths.AllOutXEnsemble(stateA | stateB),
paths.AllInXEnsemble(stateB) & paths.LengthEnsemble(1)
])
try:
self.ensembles[0] = self.ensembles[0] | new_ens
except AttributeError:
self.ensembles = [new_ens]
def __init__(self,
storage,
engine=None,
state_S=None,
randomizer=None,
initial_snapshots=None,
trajectory_length=None):
# Defintion of state S (A and B are only required for analysis).
self.state_S = state_S
# Set forward/backward shot length.
self.trajectory_length = trajectory_length
l = self.trajectory_length
# Define backward ensemble:
# trajectory starts in S and has fixed length l.
backward_ensemble = paths.SequentialEnsemble([
paths.LengthEnsemble(l),
paths.AllInXEnsemble(state_S) & paths.LengthEnsemble(1)
])
# Define forward ensemble:
# CAUTION: first trajectory is in backward ensemble,
# then continues with fixed length l.
forward_ensemble = paths.SequentialEnsemble([
paths.LengthEnsemble(l),
paths.AllInXEnsemble(state_S) & paths.LengthEnsemble(1),
paths.LengthEnsemble(l)
])
super(SShootingSimulation,
self).__init__(storage=storage,
engine=engine,
starting_volume=state_S,
forward_ensemble=forward_ensemble,
backward_ensemble=backward_ensemble,
randomizer=randomizer,
initial_snapshots=initial_snapshots)
# Create backward mover (starting from single point).
self.backward_mover = paths.BackwardExtendMover(
ensemble=self.starting_ensemble,
target_ensemble=self.backward_ensemble)
# Create forward mover (starting from the backward ensemble).
self.forward_mover = paths.ForwardExtendMover(
ensemble=self.backward_ensemble,
target_ensemble=self.forward_ensemble)
# Create mover combining forward and backward shooting. No condition
# here, shots in both directions are executed in any case.
self.mover = paths.NonCanonicalConditionalSequentialMover(
[self.backward_mover, self.forward_mover])
def __init__(self, stateA, stateB, name=None):
super(TPSTransition, self).__init__(stateA, stateB)
if name is not None:
self.name = name
if not hasattr(self, "ensembles"):
self.ensembles = [
paths.SequentialEnsemble([
paths.AllInXEnsemble(stateA) & paths.LengthEnsemble(1),
paths.AllOutXEnsemble(stateA | stateB),
paths.AllInXEnsemble(stateB) & paths.LengthEnsemble(1)
])
]
def __init__(self,
storage,
engine=None,
states=None,
randomizer=None,
initial_snapshots=None,
direction=None):
super(CommittorSimulation, self).__init__(storage)
self.engine = engine
paths.EngineMover.default_engine = engine
self.states = states
self.randomizer = randomizer
try:
initial_snapshots = list(initial_snapshots)
except TypeError:
initial_snapshots = [initial_snapshots]
self.initial_snapshots = initial_snapshots
self.direction = direction
all_state_volume = paths.join_volumes(states)
# we should always start from a single frame not in any state
self.starting_ensemble = (paths.AllOutXEnsemble(all_state_volume)
& paths.LengthEnsemble(1))
# shoot forward until we hit a state
self.forward_ensemble = paths.SequentialEnsemble([
paths.AllOutXEnsemble(all_state_volume),
paths.AllInXEnsemble(all_state_volume) & paths.LengthEnsemble(1)
])
# or shoot backward until we hit a state
self.backward_ensemble = paths.SequentialEnsemble([
paths.AllInXEnsemble(all_state_volume) & paths.LengthEnsemble(1),
paths.AllOutXEnsemble(all_state_volume)
])
self.forward_mover = paths.ForwardExtendMover(
ensemble=self.starting_ensemble,
target_ensemble=self.forward_ensemble)
self.backward_mover = paths.BackwardExtendMover(
ensemble=self.starting_ensemble,
target_ensemble=self.backward_ensemble)
if self.direction is None:
self.mover = paths.RandomChoiceMover(
[self.forward_mover, self.backward_mover])
elif self.direction > 0:
self.mover = self.forward_mover
elif self.direction < 0:
self.mover = self.backward_mover
def setup(self):
cv = paths.FunctionCV("Id", lambda snap: snap.xyz[0][0])
self.state_A = paths.CVDefinedVolume(cv, -0.1, 0.1)
self.state_B = ~paths.CVDefinedVolume(cv, -1.0, 1.0)
nml_increasing = paths.CVDefinedVolume(cv, 0.1, 1.0)
nml_decreasing = paths.CVDefinedVolume(cv, -1.0, -0.1)
increasing = paths.AllInXEnsemble(nml_increasing)
decreasing = paths.AllInXEnsemble(nml_decreasing)
self.ensemble = paths.SequentialEnsemble([
paths.LengthEnsemble(1) & paths.AllInXEnsemble(self.state_A),
paths.AllOutXEnsemble(self.state_A | self.state_B),
paths.LengthEnsemble(1) & paths.AllInXEnsemble(self.state_B)
])
self.incr_1 = self._make_active([0.0, 0.5, 1.1])
self.incr_2 = self._make_active([0.05, 0.6, 1.2])
self.decr_1 = self._make_active([0.0, -0.5, -1.1])
self.both_1 = self._make_active([0.0, 0.5, -0.5, 1.1])
self.both_2 = self._make_active([0.0, -0.4, 0.4, -1.1])
self.none_1 = self._make_active([0.0, 1.1])
self.none_2 = self._make_active([0.0, -1.1])
self.channels = {'incr': increasing, 'decr': decreasing}
# used in simplest tests of relabeling
self.toy_results = {
'a': [(0, 5), (8, 10)],
'b': [(3, 9)],
'c': [(7, 9)]
}
self.results_with_none = {
'a': [(0, 2), (6, 9)],
'b': [(5, 7), (9, 10)],
None: [(2, 5)]
}
self.set_a = frozenset(['a'])
self.set_b = frozenset(['b'])
self.set_c = frozenset(['c'])
self.toy_expanded_results = [(0, 5, self.set_a), (3, 9, self.set_b),
(7, 9, self.set_c), (8, 10, self.set_a)]
self.expanded_results_simultaneous_ending = [(0, 5, self.set_a),
(3, 9, self.set_b),
(7, 10, self.set_c),
(8, 10, self.set_a)]
self.expanded_oldest_skips_internal = [(0, 5, self.set_a),
(3, 9, self.set_b),
(7, 8, self.set_c),
(8, 10, self.set_a),
(10, 11, self.set_b)]
def setup(self):
self.descriptor = SnapshotDescriptor.construct(
snapshot_class=ToySnapshot,
snapshot_dimensions={
'n_spatial': 1,
'n_atoms': 1
})
slow_options = {
'n_frames_max': 10000,
'engine_sleep': 100,
'name_prefix': "test",
'engine_directory': engine_dir
}
fast_options = {
'n_frames_max': 10000,
'engine_sleep': 0,
'name_prefix': "test",
'engine_directory': engine_dir
}
self.template = peng.toy.Snapshot(coordinates=np.array([[0.0]]),
velocities=np.array([[1.0]]))
self.slow_engine = ExampleExternalEngine(slow_options, self.descriptor,
self.template)
self.fast_engine = ExampleExternalEngine(fast_options, self.descriptor,
self.template)
self.ensemble = paths.LengthEnsemble(5)
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, storage, engine, starting_volume, forward_ensemble,
backward_ensemble, randomizer, initial_snapshots):
super(ShootFromSnapshotsSimulation, self).__init__(storage)
self.engine = engine
# FIXME: this next line seems weird; but tests fail without it
paths.EngineMover.default_engine = engine
try:
initial_snapshots = list(initial_snapshots)
except TypeError:
initial_snapshots = [initial_snapshots]
self.initial_snapshots = initial_snapshots
self.randomizer = randomizer
self.starting_ensemble = (paths.AllInXEnsemble(starting_volume)
& paths.LengthEnsemble(1))
self.forward_ensemble = forward_ensemble
self.backward_ensemble = backward_ensemble
self.forward_mover = paths.ForwardExtendMover(
ensemble=self.starting_ensemble,
target_ensemble=self.forward_ensemble)
self.backward_mover = paths.BackwardExtendMover(
ensemble=self.starting_ensemble,
target_ensemble=self.backward_ensemble)
# subclasses will often override this
self.mover = paths.RandomChoiceMover(
[self.forward_mover, self.backward_mover])
def run():
template = peng.toy.Snapshot(coordinates=np.array([[0.0]]),
velocities=np.array([[1.0]]))
ensemble = paths.LengthEnsemble(20)
engine = build_engine(template)
logging.basicConfig(level=logging.INFO)
engine.generate(template, ensemble.can_append, direction=+1)
def setup(self):
self.cv = CollectiveVariable(lambda x: x.xyz[0][0])
self.traj = make_1d_traj([1.0, 2.0, 3.0])
ensemble = paths.LengthEnsemble(3)
self.sample = paths.Sample(replica=0,
trajectory=self.traj,
ensemble=ensemble)
self.snap = self.traj[0]
def test_assert_initial_conditions(self):
scheme = DefaultScheme(self.network)
traj3 = make_1d_traj([-0.6, -0.2, 0.2, 0.6])
init_cond = scheme.initial_conditions_from_trajectories(traj3)
init_cond.append_as_new_replica(
paths.Sample(trajectory=traj3,
ensemble=paths.LengthEnsemble(4),
replica=None))
scheme.assert_initial_conditions(init_cond)
def setup(self):
self.mytraj = make_1d_traj(coordinates=[-0.5, 0.1, 0.2, 0.3, 0.5],
velocities=[1.0, 1.0, 1.0, 1.0, 1.0])
self.dyn = CalvinistDynamics(
[-0.5, -0.4, -0.3, -0.2, -0.1, 0.1, 0.2, 0.3, 0.4, 0.5])
self.dyn.initialized = True
self.initial_guess = 3
self.ens = paths.LengthEnsemble(5)
self.ges = paths.SampleSet(
paths.Sample(replica=0, trajectory=self.mytraj, ensemble=self.ens))
def test_subtrajectory_indices(self):
# simplify more complicated expressions
stateA = self.stateA
stateB = self.stateB
pretraj = [
0.20, 0.30, 0.60, 0.40, 0.65, 2.10, 2.20, 2.60, 2.10, 0.80, 0.55,
0.40, 0.20
]
# 00, 01, 02, 03, 04, 05, 06, 07, 08, 09, 10, 11, 12
# A, A, I, A, I, B, B, X, B, X, I, A, A
trajectory = make_1d_traj(coordinates=pretraj,
velocities=[1.0] * len(pretraj))
ensemble_A = paths.AllInXEnsemble(stateA)
ensemble_B = paths.AllInXEnsemble(stateB)
ensemble_ABA = paths.SequentialEnsemble([
paths.AllInXEnsemble(stateA) & paths.LengthEnsemble(1),
paths.PartInXEnsemble(stateB) & paths.AllOutXEnsemble(stateA),
paths.AllInXEnsemble(stateA) & paths.LengthEnsemble(1)
])
subtrajectoriesA = ensemble_A.split(trajectory, overlap=0)
subtrajectoriesB = ensemble_B.split(trajectory, overlap=0)
subtrajectoriesABA = ensemble_ABA.split(trajectory)
# make sure we have the trajectories we expect
assert_equal(len(subtrajectoriesA), 3)
assert_equal(len(subtrajectoriesB), 2)
assert_equal(len(subtrajectoriesABA), 1)
# the following assertions check that the subtrajectories are the
# ones that we expect; the numbers here are linked to the indices
# we'll test next
assert_equal(subtrajectoriesA[0], trajectory[0:2])
assert_equal(subtrajectoriesA[1], trajectory[3:4])
assert_equal(subtrajectoriesA[2], trajectory[11:13])
assert_equal(subtrajectoriesB[0], trajectory[5:7])
assert_equal(subtrajectoriesB[1], trajectory[8:9])
assert_equal(subtrajectoriesABA[0], trajectory[3:12])
# now we run the subtrajectory_indices function and test it
indicesA = trajectory.subtrajectory_indices(subtrajectoriesA)
indicesB = trajectory.subtrajectory_indices(subtrajectoriesB)
indicesABA = trajectory.subtrajectory_indices(subtrajectoriesABA)
assert_equal(indicesA, [[0, 1], [3], [11, 12]])
assert_equal(indicesB, [[5, 6], [8]])
assert_equal(indicesABA, [[3, 4, 5, 6, 7, 8, 9, 10, 11]])
def setup(self):
cv = paths.CoordinateFunctionCV('x', lambda x: x.xyz[0][0])
vol_A = paths.CVDefinedVolume(cv, float("-inf"), 0.0)
vol_B = paths.CVDefinedVolume(cv, 1.0, float("inf"))
ensembles = [
paths.LengthEnsemble(1).named("len1"),
paths.LengthEnsemble(3).named("len3"),
paths.SequentialEnsemble([
paths.LengthEnsemble(1) & paths.AllInXEnsemble(vol_A),
paths.AllOutXEnsemble(vol_A | vol_B),
paths.LengthEnsemble(1) & paths.AllInXEnsemble(vol_A)
]).named('return'),
paths.SequentialEnsemble([
paths.LengthEnsemble(1) & paths.AllInXEnsemble(vol_A),
paths.AllOutXEnsemble(vol_A | vol_B),
paths.LengthEnsemble(1) & paths.AllInXEnsemble(vol_B)
]).named('transition'),
]
self.ensembles = {ens.name: ens for ens in ensembles}
self.traj_vals = [-0.1, 1.1, 0.5, -0.2, 0.1, -0.3, 0.4, 1.4, -1.0]
self.trajectory = make_1d_traj(self.traj_vals)
self.engine = CalvinistDynamics(self.traj_vals)
self.satisfied_when_traj_len = {
"len1": 1,
"len3": 3,
"return": 6,
"transition": 8,
}
self.conditions = EnsembleSatisfiedContinueConditions(ensembles)
def test_initial_conditions_report(self):
scheme = DefaultScheme(self.network)
traj3 = make_1d_traj([-0.6, -0.2, 0.2, 0.6])
init_cond = scheme.initial_conditions_from_trajectories(traj3)
init_cond.append_as_new_replica(
paths.Sample(trajectory=traj3,
ensemble=paths.LengthEnsemble(4),
replica=None)
)
expected = "Missing ensembles:\n"
expected += "* [[MinusInterfaceEnsemble]]\n"*2
expected += "Extra ensembles:\n* [LengthEnsemble]\n"
assert_equal(scheme.initial_conditions_report(init_cond), expected)
def run_steps(steps):
template = peng.snapshot_from_pdb(
"/Users/jan-hendrikprinz/Studium/git/openpathsampling/examples/data/Alanine_solvated.pdb")
topology = peng.to_openmm_topology(template)
# Generated using OpenMM Script Builder
# http://builder.openmm.org
forcefield = mm.app.ForceField(
'amber96.xml', # solute FF
'tip3p.xml' # solvent FF
)
# OpenMM System
system = forcefield.createSystem(
topology,
nonbondedMethod=mm.app.PME,
nonbondedCutoff=1.0*u.nanometers,
constraints=mm.app.HBonds,
ewaldErrorTolerance=0.0005
)
# OpenMM Integrator
integrator = mm.LangevinIntegrator(
300 * u.kelvin,
1.0 / u.picoseconds,
2.0 * u.femtoseconds
)
integrator.setConstraintTolerance(0.00001)
# Engine options
options = {
'n_steps_per_frame': 2,
'n_frames_max': 5
}
engine = peng.Engine(
template.topology,
system,
integrator,
options=options
)
engine.initialize('CPU')
traj = engine.generate(template, paths.LengthEnsemble(steps).can_append)
return traj
def __init__(self, states, progress='default', timestep=None):
self.states = states
self.all_states = paths.join_volumes(states)
all_states_ens = paths.join_ensembles([paths.AllOutXEnsemble(s)
for s in states])
ensemble = paths.SequentialEnsemble([
all_states_ens,
paths.AllInXEnsemble(self.all_states) & paths.LengthEnsemble(1)
])
super(VisitAllStatesEnsemble, self).__init__(ensemble)
self.timestep = timestep
self.report_frequency = 10
self.progress_formatter, self.progress_emitter = \
self._progress_indicator(progress)
self.cache = EnsembleCache(direction=+1)
self._reset_cache_contents()
def test_generate_n_frames(self):
self.sim.initialized = True
ens = paths.LengthEnsemble(4) # first snap plus n_frames
orig = self.sim.current_snapshot.copy()
traj1 = self.sim.generate(self.sim.current_snapshot, [ens.can_append])
self.sim.current_snapshot = orig
traj2 = [orig] + self.sim.generate_n_frames(3)
assert_equal(len(traj1), len(traj2))
for (s1, s2) in zip(traj1, traj2):
# snapshots are not the same object
assert_not_equal(s1, s2)
# however, they have the same values stored in them
assert_equal(len(s1.coordinates), 1)
assert_equal(len(s1.coordinates[0]), 2)
assert_items_equal(s1.coordinates[0], s2.coordinates[0])
assert_items_equal(s1.velocities[0], s2.velocities[0])
def test_check_initial_conditions(self):
scheme = DefaultScheme(self.network)
traj3 = make_1d_traj([-0.6, -0.2, 0.2, 0.6])
# cheating a bit, since we know what this gives
init_cond = scheme.initial_conditions_from_trajectories(traj3)
assert_equal(len(init_cond), 7)
assert_equal(len(scheme.list_initial_ensembles()), 9)
(missing, extra) = scheme.check_initial_conditions(init_cond)
assert_equal(len(missing), 2)
assert_equal(len(extra), 0)
for ens in list(self.network.special_ensembles['minus'].keys()):
assert_in([ens], missing)
init_cond.append_as_new_replica(
paths.Sample(trajectory=traj3,
ensemble=paths.LengthEnsemble(4),
replica=None))
(missing, extra) = scheme.check_initial_conditions(init_cond)
assert_equal(len(missing), 2)
assert_equal(len(extra), 1)
def test_initial_conditions_report(self):
scheme = DefaultScheme(self.network)
traj3 = make_1d_traj([-0.6, -0.2, 0.2, 0.6])
init_cond = scheme.initial_conditions_from_trajectories(traj3)
init_cond.append_as_new_replica(
paths.Sample(trajectory=traj3,
ensemble=paths.LengthEnsemble(4),
replica=None))
start = "Missing ensembles:\n"
missing_A = "* [Out A minus]\n"
missing_B = "* [Out B minus]\n"
finish = "Extra ensembles:\n* [LengthEnsemble]\n"
expected_AB = start + missing_A + missing_B + finish
expected_BA = start + missing_B + missing_A + finish
result = scheme.initial_conditions_report(init_cond)
try:
assert_equal(result, expected_AB)
except AssertionError:
assert_equal(result, expected_BA)
def test_generate(self):
if not has_gmx:
raise SkipTest("Gromacs 5 (gmx) not found. Skipping test.")
if not HAS_MDTRAJ:
pytest.skip("MDTraj not found. Skipping test.")
traj_0 = self.engine.trajectory_filename(0)
snap = self.engine.read_frame_from_file(traj_0, 0)
self.engine.filename_setter.reset(0)
ens = paths.LengthEnsemble(5)
traj = self.engine.generate(snap, running=[ens.can_append])
assert_equal(self.engine.proc.is_running(), False)
assert_equal(len(traj), 5)
ttraj = md.load(self.engine.trajectory_filename(1),
top=self.engine.gro)
# the mdp suggests a max length of 100 frames
assert_true(len(ttraj) < 100)
def __init__(self,
storage,
initial_file,
mover,
network,
options=None,
options_rejected=None):
# TODO: mke the initial file into an initial trajectory
if options is None:
options = TPSConverterOptions()
if options_rejected is None:
options_rejected = options
self.options = options
self.options_rejected = options_rejected
self.initial_file = initial_file # needed for restore
traj = self.load_trajectory(initial_file)
# assume we're TPS here
ensemble = network.sampling_ensembles[0]
initial_trajectories = ensemble.split(traj)
if len(initial_trajectories) == 0: # pragma: no cover
raise RuntimeError("Initial trajectory in " + str(initial_file) +
" has no subtrajectory satisfying the " +
"TPS ensemble.")
elif len(initial_trajectories) > 1: # pragma: no cover
raise RuntimeWarning("More than one potential initial " +
"subtrajectory. We use the first.")
initial_trajectory = initial_trajectories[0]
initial_conditions = paths.SampleSet([
paths.Sample(replica=0,
trajectory=initial_trajectory,
ensemble=ensemble)
])
self.extra_bw_frames = traj.index(initial_trajectory[0])
final_frame_index = traj.index(initial_trajectory[-1])
self.extra_fw_frames = len(traj) - final_frame_index - 1
# extra -1 bc frame index counts from 0; len counts from 1
self.summary_root_dir = None
self.report_progress = None
super(OneWayTPSConverter,
self).__init__(storage=storage,
initial_conditions=initial_conditions,
mover=mover,
network=network)
# initial_states = self.network.initial_states
# final_states = self.network.final_states
# TODO: prefer the above, but the below work until fix for network
# storage
initial_states = [self.network.sampling_transitions[0].stateA]
final_states = [self.network.sampling_transitions[0].stateB]
all_states = paths.join_volumes(initial_states + final_states)
self.fw_ensemble = paths.SequentialEnsemble([
paths.AllOutXEnsemble(all_states),
paths.AllInXEnsemble(all_states) & paths.LengthEnsemble(1)
])
self.bw_ensemble = paths.SequentialEnsemble([
paths.AllInXEnsemble(all_states) & paths.LengthEnsemble(1),
paths.AllOutXEnsemble(all_states)
])
self.full_ensemble = paths.SequentialEnsemble([
paths.AllInXEnsemble(all_states) & paths.LengthEnsemble(1),
paths.AllOutXEnsemble(all_states),
paths.AllInXEnsemble(all_states) & paths.LengthEnsemble(1)
])
self.all_states = all_states
def _tps_ensemble(self, stateA, stateB):
return paths.SequentialEnsemble([
paths.LengthEnsemble(1) & paths.AllInXEnsemble(stateA),
paths.LengthEnsemble(self.length - 2),
paths.LengthEnsemble(1) & paths.AllInXEnsemble(stateB)
])
def _tps_ensemble(self, stateA, stateB):
return paths.SequentialEnsemble([
paths.AllInXEnsemble(stateA) & paths.LengthEnsemble(1),
paths.AllOutXEnsemble(stateA | stateB),
paths.AllInXEnsemble(stateB) & paths.LengthEnsemble(1)
])
def __init__(self,
transition,
snapshot,
storage=None,
engine=None,
extra_interfaces=None,
extra_ensembles=None,
forbidden_states=None,
initial_max_length=None):
super(FullBootstrapping, self).__init__(storage)
self.engine = engine
paths.EngineMover.default_engine = engine # set the default
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.initial_max_length = initial_max_length
if self.initial_max_length is not None:
self.first_traj_ensemble = (paths.LengthEnsemble(
slice(0, self.initial_max_length)) & self.first_traj_ensemble)
if extra_ensembles is None:
extra_ensembles = []
self.extra_ensembles = [
paths.TISEnsemble(transition.stateA, transition.stateB, iface,
transition.orderparameter)
for iface in extra_interfaces
] + extra_ensembles
self.transition_shooters = [
paths.OneWayShootingMover(selector=paths.UniformSelector(),
ensemble=ens,
engine=self.engine)
for ens in transition.ensembles
]
self.extra_shooters = [
paths.OneWayShootingMover(selector=paths.UniformSelector(),
ensemble=ens,
engine=self.engine)
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
