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)