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 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 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 __init__(self,
initial_state,
known_states,
stable_contact_state,
excluded_volume=None):
super(MultipleBindingEnsemble, self).__init__()
self.initial_state = initial_state
self.known_states = known_states
self.final_state = paths.join_volumes(
set(known_states) - set([initial_state]))
self.states = paths.join_volumes(set([initial_state] + known_states))
self.stable_contact_state = stable_contact_state
if excluded_volume is None:
excluded_volume = paths.EmptyVolume()
self.excluded_volume = excluded_volume
self.excluded_volume_ensemble = \
paths.AllOutXEnsemble(self.excluded_volume)
self.cache = self._initialize_cache()
def test_validate_states_extra_volumes(self):
annotated = AnnotatedTrajectory(self.traj, self.annotations)
states = self.states
states['magic'] = paths.EmptyVolume()
with pytest.raises(RuntimeError):
(results, conflicts) = annotated.validate_states(states)