def Delay(self, delayProf): """ Compute the delayed profile composed of *self* profile and *delayProf*, received by a node for which this *self* profile is the output profile on the sender side. The delay profile describes the delay as a function of time for the link. This function implements the operation: .. math:: o[t + \delta[t]] = l[t] Where * :math:`\delta[t]` is the delay profile * :math:`l[t]` is the profile transmitted into the link (*self*) * :math:`o[t]` is the output profile received at the other end of the link :rtype: :class:`Profile`, :math:`o[t]` :param in delayProf: :class:`Profile` describing the delay """ delays = delayProf.entries['latency'] all0 = True for time, delay in delays: if delay != 0: all0 = False if all0: return copy.deepcopy(self) datas = self.entries['data'] endTime = datas[-1][0] times = [ x[0] for x in delays ] times.extend( [ x[0] for x in datas ] ) times = sorted(list(set(times))) newDatas = [] for t in times: d = utils.get_value_at_time(datas, t) delay = utils.get_value_at_time(delays, t, interpolate = 'latency' in self.interpolated_profiles) newDatas.append([ t + delay, d ]) newDatas = utils.remove_degenerates(newDatas) newDatas, remainder = utils.split(newDatas, endTime) if remainder: t = -remainder[0][0] utils.shift(remainder, t) r_slopes = utils.derive(remainder) d_slopes = utils.derive(newDatas) d_slopes = utils.add_values(d_slopes,r_slopes) newDatas = utils.integrate(d_slopes, endTime) retProf = Profile() retProf.entries['data'] = newDatas retProf.Derive() return retProf
def updateDatasets(self, fields, helper): """ This function should *update* the dataset(s) returned by getDatasets """ # get the input dataset - helper provides methods for getting other # datasets from Veusz ds_y = np.array(helper.getDataset(fields['ds_y']).data) # get the value to add order = fields['order'] method = fields['method'] smooth_num = fields['smooth'] ds_x = None if smooth_num > 0: ds_y = smooth(ds_y, smooth_num, 'hanning') if fields['ds_x'] != '': # Derive with respect to X ds_x = np.array(helper.getDataset(fields['ds_x']).data) if smooth_num > 0: ds_x = smooth(ds_x, smooth_num, 'hanning') out = xyderive(ds_x, ds_y, order, method) else: # Derive with respect to point indexes out = derive(ds_y, method, order) self.ds_out.update(data=out) return [self.ds_out]
def Derive(self): """Derives the slope entries from the data entries""" self.entries['slope'] = utils.derive( self.entries['data'] ) self.AggregateSlopes()