def test_sample_by_sequence(self):
dtraj =[0,1,2,3,2,1,0]
idx = dt.index_states(dtraj)
seq = [0,1,1,1,0,0,0,0,1,1]
sidx = dt.sample_indexes_by_sequence(idx, seq)
assert(np.alltrue(sidx.shape == (len(seq),2)))
for t in range(sidx.shape[0]):
assert(sidx[t,0] == 0) # did we pick the right traj?
assert(dtraj[sidx[t,1]] == seq[t]) # did we pick the right states?
def generate_traj(self, N, start=None, stop=None, stride=1):
"""Generates a synthetic discrete trajectory of length N and simulation time stride * lag time * N
This information can be used
in order to generate a synthetic molecular dynamics trajectory - see
:func:`pyemma.coordinates.save_traj`
Note that the time different between two samples is the Markov model lag time tau. When comparing
quantities computing from this synthetic trajectory and from the input trajectories, the time points of this
trajectory must be scaled by the lag time in order to have them on the same time scale.
Parameters
----------
N : int
Number of time steps in the output trajectory. The total simulation time is stride * lag time * N
start : int, optional, default = None
starting state. If not given, will sample from the stationary distribution of P
stop : int or int-array-like, optional, default = None
stopping set. If given, the trajectory will be stopped before N steps
once a state of the stop set is reached
stride : int, optional, default = 1
Multiple of lag time used as a time step. By default, the time step is equal to the lag time
Returns
-------
indexes : ndarray( (N, 2) )
trajectory and time indexes of the simulated trajectory. Each row consist of a tuple (i, t), where i is
the index of the trajectory and t is the time index within the trajectory.
Note that the time different between two samples is the Markov model lag time tau
See also
--------
pyemma.coordinates.save_traj
in order to save this synthetic trajectory as a trajectory file with molecular structures
"""
# TODO: this is the only function left which does something time-related in a multiple of tau rather than dt.
# TODO: we could generate dt-strided trajectories by sampling tau times from the current state, but that would
# TODO: probably lead to a weird-looking trajectory. Maybe we could use a HMM to generate intermediate 'hidden'
# TODO: frames. Anyway, this is a nontrivial issue.
self._check_is_estimated()
# generate synthetic states
from msmtools.generation import generate_traj as _generate_traj
syntraj = _generate_traj(self.transition_matrix,
N,
start=start,
stop=stop,
dt=stride)
# result
from pyemma.util.discrete_trajectories import sample_indexes_by_sequence
return sample_indexes_by_sequence(self.active_state_indexes, syntraj)
