def cal_interference(self, idx_d2d, idx_cc, method=UL):
s = self.d2d_tr[idx_d2d]
d = self.d2d_rc[idx_d2d]
cc_ues = self.cc_ue[idx_cc]
if method == 0:
cc_inter_tr = np.array([ue.pos for ue in cc_ues])
cc_inter_tp = np.array([ue.tp for ue in cc_ues])
n_d2d_inter = self.n_cc
n_channel = 1
else:
cc_inter_tr = self.bs.pos
cc_inter_tp = self.bs.tp
n_d2d_inter = 1
n_channel = self.n_cc
# !FIXME: only [cc->d2d]
return cal_recv_power(cc_inter_tr,
d.pos,
10**(cc_inter_tp / 10.0),
n_d2d_inter,
n_channel,
cal_dist_2d, [],
cal_umi_nlos, [3.5, s.freq],
fading_func=gen_rayleigh,
fading_args=[],
shadowing_func=gen_logNshadowing,
shadowing_args=[4])
def cal_signal_power(self, d2d_tps, alpha=3.5):
# cc signal recv power
cc_trs = np.reshape(np.array([c.pos for c in self.cc_ue]),
(self.n_cc, 1))
cc_tps = np.reshape(self.cc_tps, (self.n_cc, 1))
cc_rvs = 0
cc_signal_power = cal_recv_power(cc_trs,
cc_rvs,
cc_tps,
self.n_cc_rb,
True,
cal_dist_2d, [],
cal_umi_nlos,
[alpha, self.cc_ue[0].freq],
fading_func=gen_rayleigh,
fading_args=[1.0],
shadowing_func=gen_logNshadowing,
shadowing_args=[4])
# d2d signal recv power
d2d_trs = [d.pos for d in self.d2d_tr]
d2d_rvs = [d.pos for d in self.d2d_rc]
d2d_signal_power = []
for d2d_tr, d2d_rv, d2d_tp in zip(d2d_trs, d2d_rvs, d2d_tps):
d_signal = cal_recv_power(d2d_tr,
d2d_rv,
d2d_tp,
self.n_rb,
False,
cal_dist_2d, [],
cal_umi_nlos,
[alpha, self.cc_ue[0].freq],
fading_func=gen_rayleigh,
fading_args=[1.0],
shadowing_func=gen_logNshadowing,
shadowing_args=[4])
d2d_signal_power.append(d_signal)
return cc_signal_power, d2d_signal_power
def cal_lteu_throughput(self, tr, rv, interference=0):
bw = self.lbt()
if bw == 0:
return 0
noise = cal_thermal_noise(bw, 290.0)
sp = cal_recv_power(tr.pos,
rv.pos,
10**(tr.tp / 10.0),
1,
1,
cal_dist_2d, [],
cal_umi_nlos, [3.5, tr.freq],
fading_func=gen_rayleigh,
fading_args=[],
shadowing_func=gen_logNshadowing,
shadowing_args=[4])
return cal_shannon_cap(bw, sp, interference, noise)
def cal_throughput(self, idx_d2d, inter=0, method=UL):
tr = self.d2d_tr[idx_d2d]
rv = self.d2d_rc[idx_d2d]
d2d_intra = self.cal_interference(idx_d2d, range(self.n_cc), method)
bw = self.total_bw / self.n_cc
noise = cal_thermal_noise(bw, 290.0)
sp = cal_recv_power(tr.pos,
rv.pos,
10**(tr.tp / 10.0),
1,
1,
cal_dist_2d, [],
cal_umi_nlos, [3.5, tr.freq],
fading_func=gen_rayleigh,
fading_args=[],
shadowing_func=gen_logNshadowing,
shadowing_args=[4])
d2d_cap = sum(cal_shannon_cap(bw, sp, d2d_intra + inter, noise))
return d2d_cap
def cal_interference(self, d2d_tps, alpha=3.5):
# cal cc interference
cc_inter_tr = np.array([d.pos for d in self.d2d_tr])
cc_inter_tr = np.reshape(cc_inter_tr, (self.n_pairs, 1))
cc_inter_rv = np.zeros(self.n_cc)
cc_inter_tp = np.reshape(d2d_tps, (self.n_pairs, self.n_rb))
for i in range(self.n_cc):
c_ip = cal_recv_power(cc_inter_tr,
cc_inter_rv,
cc_inter_tp,
self.n_cc_rb,
False,
cal_dist_2d, [],
cal_umi_nlos, [alpha, self.d2d_tr[0].freq],
fading_func=gen_rayleigh,
fading_args=[1.0],
shadowing_func=gen_logNshadowing,
shadowing_args=[4])
cc_interference = np.sum(c_ip, axis=0)
# cal d2d interference
# cc -> d2d
cc_d2d_ip = []
d2d_rvs = np.array([d.pos for d in self.d2d_rc])
for d2d_rv in d2d_rvs:
cc_tr = np.array([c.pos for c in self.cc_ue])
cc_tr = np.reshape(cc_tr, (self.n_cc, 1))
cc_inter_tps = np.reshape(np.array(self.cc_tps), (self.n_cc, 1))
tmp = cal_recv_power(cc_tr,
d2d_rv,
cc_inter_tps,
self.n_cc_rb,
True,
cal_dist_2d, [],
cal_umi_nlos, [alpha, self.cc_ue[0].freq],
fading_func=gen_rayleigh,
fading_args=[1.0],
shadowing_func=gen_logNshadowing,
shadowing_args=[4])
cc_d2d_ip.append(np.reshape(tmp, self.n_rb))
# other d2d -> d2d
d2d_d2d_ip = []
d2d_trs = [d.pos for d in self.d2d_tr]
for idx, d in enumerate(d2d_rvs):
d2d_inter_tr = d2d_trs.copy()
del d2d_inter_tr[idx]
d2d_inter_tr = np.reshape(d2d_inter_tr, (self.n_pairs - 1, 1))
d2d_inter_tps = list(d2d_tps.copy())
del d2d_inter_tps[idx]
d2d_inter_tps = np.reshape(np.array(d2d_inter_tps),
(self.n_pairs - 1, self.n_rb))
d_d2d_ip = cal_recv_power(d2d_inter_tr,
d,
d2d_inter_tps,
self.n_rb,
False,
cal_dist_2d, [],
cal_umi_nlos,
[alpha, self.cc_ue[0].freq],
fading_func=gen_rayleigh,
fading_args=[1.0],
shadowing_func=gen_logNshadowing,
shadowing_args=[4])
d_d2d_ip = np.sum(d_d2d_ip, axis=0)
d2d_d2d_ip.append(d_d2d_ip)
d2d_interference = np.array(cc_d2d_ip) + np.array(d2d_d2d_ip)
return cc_interference, d2d_interference