@classmethod
def read_iter(cls, file_name, start=None, stop=None, step=None, atom_i=None):
    """
        Create an iterator over each frame of the given trajectory file
        in the selected range.
        
        Parameters
        ----------
        file_name : str
            The path of the file to be read.
            A file-like-object cannot be used.
        start : int, optional
            The frame index, where file parsing is started. If no value
            is given, parsing starts at the first frame.
            The index starts at 0.
        stop : int, optional
            The exclusive frame index, where file parsing ends.
            If no value is given, parsing stops at the end of file.
            The index starts at 0.
        step : int, optional
            If this value is set, the function reads only every n-th
            frame from the file.
        atom_i : ndarray, dtype=int, optional
            If this parameter is set, only the atoms at the given
            indices are read from each frame.
        
        Yields
        ------
        coord : ndarray, dtype=float32, shape=(n,3)
            The atom coordinates in the current frame.
        box : ndarray, dtype=float32, shape=(3,3)
            The box vectors of the current frame.
        time : float
            the simlation time of the current frame in *ps*.
        
        See also
        --------
        read_iter_structure
        
        Notes
        -----
        The `step` parameter does currently not work for *DCD* files.
        """
    traj_type = cls.traj_type()
    with traj_type(file_name, 'r') as f:
        if start is None:
            start = 0
        if start != 0:
            f.read(n_frames=start, stride=None, atom_indices=atom_i)
        if stop is None:
            n_frames = None
        else:
            n_frames = stop - start
        if step is not None and n_frames is not None:
            n_frames = (n_frames - 1) // step + 1
        frame_i = 0
        while True:
            if n_frames is not None and frame_i >= n_frames:
                break
            result = f.read(1, stride=step, atom_indices=atom_i)
            if len(result[0]) == 0:
                break
            coord, box, time = cls.process_read_values(result)
            coord = coord[0]
            box = box[0] if box is not None else None
            time = float(time[0]) if time is not None else None
            yield coord, box, time
            frame_i += 1
