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)