def get_interference_capacity(self) -> float: """Return the maximum extra interference(dB) that PUR can stands, using threshold.""" irp_decimal = get_decimal(self.__irp) if self.beta is not None: # using beta rp_decimal = get_decimal(self.rx.received_power) return get_db(rp_decimal / self.__beta - irp_decimal) else: # using threshold thr_decimal = get_decimal(self.threshold) return get_db(thr_decimal - irp_decimal)
def power_with_path_loss( self, tx: TX, rx: RX): # False for sign means negative otherwise positive """Return received power after applying tx power. rx_power = tx_power + rx_power""" tx_power = tx.power if tx_power == -float('inf'): return rx.received_power loss = self.propagation_model.path_loss(tx.element * self.cell_size, rx.element * self.cell_size) return get_db( get_decimal(rx.received_power) + get_decimal(tx_power - loss))
def add_interference(self, key: str, value: float): """Add power(dB) of a new element to PUR. If it exists, it raise a warning.""" if key in self.__irp_map: warnings.warn( "Power for {0} element already exists in {1}.".format( key, self.__id) + " Use update_interference() if you need to update power for an element." ) return self.__irp_map[key] = value self.__irp = get_db(get_decimal(self.__irp) + get_decimal(value))
def update_interference(self, key: str, value: float): """Update power(dB) for key to PUR. If it does not exist, it raise a warning.""" if key not in self.__irp_map: warnings.warn( "Power for {0} element does not exist in {1}.".format( key, self.__id) + " Use add_interference() if you need to add power for an element." ) return old_power = self.__irp_map[key] self.__irp_map[key] = value self.__irp = get_db( get_decimal(self.__irp) + get_decimal(value) - get_decimal(old_power))
def delete_interference_power_from(self, key): if key in self.__irp_map: value = self.__irp_map.pop(key) self.__irp = get_db(get_decimal(self.__irp) - get_decimal(value))
def interpolation_max_power(self, inter_sm_param: InterSMParam): k_pu = self.num_select(inter_sm_param.pu_size, len(self.pus)) k_ss = self.num_select(inter_sm_param.ss_size, len(self.sss)) su = self.sus[ -1] # TODO this code has written for only one SU. Fix for multiple before using it if type( self.propagation_model ) == LogDistancePM: # TODO only written for LogNormal Propagation Model pl_alpha = self.propagation_model.alpha else: raise ValueError("Only Log-Distance has been implemented") pu_inds, sss_inds, sss_dists = [], [], [] if not inter_sm_param.selection_algo: pu_inds = list(range(k_pu)) sss_inds = list(range(k_ss)) sss_dists = [ self.cell_size * su.tx.element.location.distance( self.sss[i].rx.element.location) for i in range(k_ss) ] elif inter_sm_param.selection_algo.lower() == 'sort': pu_dists = [] for i, pu in enumerate(self.pus): dist, ind = self.cell_size * su.tx.element.location.distance( pu.tx.element.location), i if i < k_pu: pu_inds.append(i) pu_dists.append(dist) else: for j in range(len(pu_inds)): if dist < pu_dists[j]: pu_dists[j], dist = dist, pu_dists[j] ind, pu_inds[j] = pu_inds[j], ind for i, ss in enumerate(self.sss): dist, ind = self.cell_size * su.tx.element.location.distance( ss.rx.element.location), i if i < k_ss: sss_inds.append(i) sss_dists.append(dist) else: for j in range(len(sss_inds)): if dist < sss_dists[j]: sss_dists[j], dist = dist, sss_dists[j] ind, sss_inds[j] = sss_inds[j], ind elif inter_sm_param.selection_algo.lower() == 'random': pu_inds = sample(range(len(self.pus)), k_pu) pu_dists = [ self.cell_size * su.tx.element.location.distance( self.pus[i].tx.element.location) for i in pu_inds ] sss_inds = sample(range(len(self.sss)), k_ss) sss_dists = [ self.cell_size * su.tx.element.location.distance( self.sss[i].rx.element.location) for i in sss_inds ] else: print('Unsupported selection algorithm!') return None # end selection # compute weights weights, tmp_sum_weight = [], 0.0 for ss_dist in sss_dists: d = ss_dist d = max(d, 0.0001) # TODO why 0.0001? # Weight of this SS with respect to this SU w = (1.0 / d)**pl_alpha weights.append(w) tmp_sum_weight += w # BY ME received_powers = [] pl_pu_ss = [] for i, ss_idx in enumerate(sss_inds): tmp_ss, all_power, tmp_pl_pu_ss = [], 0, [] for j, pu_idx in enumerate(pu_inds): tmp = get_decimal(self.pus[pu_idx].tx.power) / \ (self.cell_size * self.pus[pu_idx].tx.element.location.distance(self.sss[ss_idx].rx.element.location)) ** pl_alpha tmp_ss.append(tmp) all_power += tmp tmp_pl_pu_ss.append(get_decimal(self.pus[pu_idx].tx.power)) # tmp_pow = power_with_path_loss(TRX(pus[pu_idx].loc, pus[pu_idx].p), TRX(sss[ss_ # idx].loc, -float('inf')), # propagation_model=propagation_model, noise=noise) # # tmp_pow = max(tmp_pow, noise_floor) # tmp_ss.append(tmp_pow) received_powers.append([ get_decimal(self.sss[ss_idx].rx.received_power) / all_power * x for x in tmp_ss ]) pl_pu_ss.append( [x / y for x in tmp_pl_pu_ss for y in received_powers[-1]]) # Compute SU transmit power # tp = thresh * sum(w(SS)) / sum(r(SS) / t(PU) * w(SS)) max_transmit_power, estimated_path_loss = float('inf'), [] for y, j in enumerate(pu_inds): sum_weight = 0.0 sum_weighted_ratio = 0.0 for x, i in enumerate(sss_inds): sum_weight += weights[x] # only DB is implemented here sum_weighted_ratio += weights[x] * ( received_powers[i][j] / get_decimal(self.pus[j].tx.power)) this_pu_path_loss = sum_weighted_ratio / sum_weight # estimated_path_loss_tmp = [] for x, pur in enumerate(self.pus[j].purs): pur_element = Element( self.pus[j].tx.element.location + pur.rx.element.location, pur.rx.element.height) this_pr_path_loss = this_pu_path_loss - inter_sm_param.gamma * \ get_db(self.cell_size * su.tx.element.location.distance(pur_element.location) / su.tx.element.location.distance(self.pus[j].tx.element.location)) # this_pr_path_loss = this_pu_path_loss - 10.0 * inter_sm_param.gamma * \ # math.log10(cell_size * su.loc.distance(pur_location) / # (cell_size * su.loc.distance(pus[j].loc))) # estimated_path_loss_tmp.append(this_pr_path_loss) # this_transmit_power = pur.thr - this_pr_path_loss this_transmit_power = pur.rx.received_power/pur.beta - pur.interference_received_power + \ this_pr_path_loss max_transmit_power = min(max_transmit_power, this_transmit_power) # estimated_path_loss.append(estimated_path_loss_tmp) return max_transmit_power