def build_timelapse(self, obs):
        """Builds timeseries corresponding to observable of mode 'dynamics'.

        Result is an array of same length as time array, stored in a dictionary
        _sdata, which keys are obs.label. When using sliding windows,
        estimate in a given cell actualize data in its parent cell, if and only
        if it has not been actualized before (check disjoint time intervals).

        Parameters
        ----------
        obs : Observable instance
            mode must be 'dynamics'

        Note
        -----
        Some observables carry the 'local_fit' option True. In this case,
        local fits over shifting time-windows are performed. If one would keep
        only a given cell's data, then the constraints on shifting time-window
        would let some 'empty' times, at which no evaluation can be performed.
        This is solved by getting data from the cell's parent cell's data. This
        operation computes time-window fiited data in the cell's parent cycle.
        Two precautions must then be taken:
            1. a given cell's data must be used only once for evaluating parent
               cell's data,
            2. when data has been used from one daughter cell, concatenate
               the current cell's evaluated data to it.

        .. warning::
           For some computations, the time interval between consecutive
           acquisitions is needed. If it's defined in the container or the
           experiment metadata, this parameter will be imported; otherwise if
           there are at least 2 consecutive values, it will be inferred from
           data (at the risk of making mistakes if there are too many missing
           values)
        """
        label = str(obs.label)
        raw = obs.raw
        coords = Coordinates(self.data['time'], self.data[raw])
        if self.parent is not None and len(self.parent.data) > 0:
            anteriors = Coordinates(self.parent.data['time'],
                                    self.parent.data[raw])
        else:
            anteriors = Coordinates(np.array([], dtype=float),
                                    np.array([], dtype=float))
        # if empty, return empty array of appropriate type
        if len(self.data) == 0:  # there is no data, but it has some dtype
            return Coordinates(np.array([], dtype=float),
                               np.array([], dtype=float))

        dt = self.container.period
        if dt is None:
            # automatically finds dt
            if len(self.data) > 1:
                arr = self.data['time']
                time_increments = arr[1:] - arr[:-1]
                dt = np.round(np.amin(np.abs(time_increments)), decimals=2)

        # case : no local fit, use data, or finite differences
        if not obs.local_fit:
            if obs.differentiate:
                if obs.scale == 'linear':
                    new = derivative(coords)
                elif obs.scale == 'log':
                    new = logderivative(coords)