def compute_cyclized(self, obs):
        """Computes observable when mode is different from 'dynamics'.

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

        Raises
        ------
        ValueError
            when Observable mode is 'dynamics'

        Note
        ----
        To compute a cell-cycle observable (e.g. birth growth rate), it is
        necessary to know the value of the timelapse counterpart (e.g. growth
        rate here). The timelapse observable may work by joining values at
        divisions, and hence a single call to Cell.build_timelapse() will
        result in a different result array than when it has beenalso  called in
        a daughter cell (potentially affecting values toward the end of current
        cell cycle). Hence, in that circumstances when continuity is used to
        join timeseries at divisions, enhancing results with fitting
        over sliding windows, it is the user's task to compute first the
        timelapse observable over the entire lineage, and only then, evaluate
        cell-cycle values. This is why the function below tries first to read
        an already present array from timelapse counterpart, and only if it
        fails will it compute it using only this current cell data.
        """
        scale = obs.scale
        npts = obs.join_points
        label = obs.label
        if obs.mode == 'dynamics':
            raise ValueError('Called build_cyclized for dynamics mode')
        # associate timelapse counterpart
        cobs = obs.as_timelapse()
        clabel = cobs.label
        time = self.data['time']
        # if it has been computed already, the clabel key exists in sdata
        try:
            array = self._sdata[clabel]
        # otherwise compute the timelapse counterpart
        except KeyError:
            self.build_timelapse(cobs)
            array = self._sdata[clabel]
        # get value
        try:                
            if obs.mode == 'birth':
                value = extrapolate_endpoints(time, array, self.birth_time,
                                              scale=scale, join_points=npts)
            elif obs.mode == 'division':
                value = extrapolate_endpoints(time, array, self.division_time,
                                              scale=scale, join_points=npts)
            elif 'net-increase' in obs.mode:
                dval = extrapolate_endpoints(time, array, self.division_time,
                                              scale=scale, join_points=npts)
                bval = extrapolate_endpoints(time, array, self.birth_time,
                                              scale=scale, join_points=npts)
                if obs.mode == 'net-increase-additive':
                    value = dval - bval
                elif obs.mode == 'net-increase-multiplicative':
                    value = dval/bval
            elif obs.mode == 'average':
                value = np.nanmean(array)
            elif obs.mode == 'rate':
                if len(array) < 2:
                    value = np.nan  # not enough values to estimate rate
                if obs.scale == 'log':
                    array = np.log(array)
                value, intercept = np.polyfit(time, array, 1)
        except ExtrapolationError as err: