Skip to content

Commit 93735a5

Browse files
grasscodergrasscoder
committed
5-5
5-5
1 parent 14a9d34 commit 93735a5

File tree

2 files changed

+140
-30
lines changed

2 files changed

+140
-30
lines changed

‎CAPalloction.py

Lines changed: 68 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -35,6 +35,7 @@
3535
RelayNum = 2
3636
TotalNum = MacroNum+PicoNum+FemtoNum+RelayNum
3737
usernum = np.random.randint(20,50)
38+
# usernum = np.random.randint(50,60)
3839
print "usernum=%d"%usernum
3940

4041
macroR = 500.0 ##宏基站的覆盖半径/m
@@ -56,7 +57,9 @@
5657

5758
# 用户的坐标位置和基站的坐标位置
5859
UserX,UserY, BSX,BSY = Draw(samples_num= usernum,R = 500)#接收用户坐标和基站坐标(不包括宏基站)
59-
60+
61+
'''
62+
"""------------------------------------此 函 数 已 经 废 弃----------------------------------------"""
6063
def sinr(BSid,Userchannellist,chan):###BSid基站类型：0:picoBS;1:MacroBS，已分配信道列表Userchannellist,chan要给用户分配的信道
6164
"""
6265
信噪比公式 sinr = P(n,s)*D(n,k)**(-4)/(Interference+Noise)
@@ -66,10 +69,12 @@ def sinr(BSid,Userchannellist,chan):###BSid基站类型：0:picoBS;1:MacroBS，
6669
L(n):基站n的覆盖半径
6770
"""
6871
pass
72+
'''
6973

70-
def classifyUser(ux,uy,bsx,bsy,r):##定义一个分类函数
74+
def classifyUser(r,ux=UserX,uy=UserY,bsx=BSX,bsy=BSY):##定义一个分类函数
7175
'''
7276
将用户按照：是否处于某个基站覆盖范围分类,r基站的半径
77+
基站坐标不能包含宏基站坐标，宏基站用户需等待所有其他类型的基站分类完毕之后才能得到
7378
7479
'''
7580
if(len(ux)>len(uy)):ux = ux[:len(uy)]
@@ -78,15 +83,15 @@ def classifyUser(ux,uy,bsx,bsy,r):##定义一个分类函数
7883
elif(len(bsx)<len(bsy)):uy = uy[:len(ux)]
7984
#初始化一个列表，每一行代表一个基站范围内的用户列表
8085
BSCoverage = []
81-
for i in xrange(len(BSX)):##处于两个基站交叉区域的用户会出现在两个基站的list中
86+
for i in xrange(len(bsx)):##处于两个基站交叉区域的用户会出现在两个基站的list中
8287
BSCoverage.append( [(x,y) for x,y in zip(ux ,uy) if distance(x, y, bsx[i], bsy[i])<=r])
8388
temp =[]
8489
for i in BSCoverage:
8590
temp += i
86-
#过滤掉重复的坐标
91+
###过滤掉重复的坐标
8792
temp = list(set(temp))
88-
#筛选只在宏基站内的用户坐标, 最后一行为只分布在宏基站范围内的用户
89-
BSCoverage.append([(x,y) for x,y in zip(UserX,UserY) if (x,y) not in temp])
93+
###筛选只在宏基站内的用户坐标, 最后一行为只分布在宏基站范围内的用户
94+
BSCoverage.append([(x,y) for x,y in zip(ux,uy) if (x,y) not in temp])
9095
return BSCoverage
9196

9297
def getDM(ux,uy,bsx,bsy):
@@ -102,18 +107,20 @@ def getDM(ux,uy,bsx,bsy):
102107
else:exit(0)
103108
return DM
104109

105-
def interfere(n,s,chanlist,BSX,BSY):
110+
def interfere(n,s,chanlist,bsx=BSX,bsy=BSY):
106111
'''
107112
##不同基站相同信道才会产生干扰，除此之外只有噪声,基站BS_n 在信道chan_s上的干扰,不同基站只要分配了相同编号的信道，
108113
##无论是否给同一个用户都会相互干扰，只是相同编号的信道分配给同一个用户干扰最大
109114
chanlist 是信道的分配列表 等同于下面的BSchanAllocate，已分配信道是用用户坐标表示的，未分配信道值为-1
110115
'''
116+
BSX +=[0]
117+
BSY +=[0]
111118
interf = 0
112119
for i in xrange(len(chanlist)):#循环基站数量次
113120
if(i!=n and chanlist[i][s]!=-1):##如果不是参数中的基站,且信道已经分配给用户(信道值为-1说明：此信道未分配，值为用户坐标说明此信道已经分配给该坐标用户)
114121
k = chanlist[n][s] #定位连接基站n分配信道s的用户
115122

116-
d = distance(k[0],k[1],BSX[i],BSY[i])
123+
d = distance(k[0],k[1],bsx[i],bsy[i])
117124
if i!=(len(chanlist)-1):#最后一个基站为宏基站，如果不是最后一个基站，功率p为微基站功率
118125
p = microAveragePower
119126
else: #否则为宏基站功率
@@ -140,16 +147,45 @@ def interfere(n,s,chanlist,BSX,BSY):
140147
BS5 : [-1,-1,....,-1]
141148
]
142149
'''
143-
def channelAllocate(BSCover):
150+
def RateNow(chanlist,user,bsx=BSX,bsy=BSY):
151+
"""
152+
根据当前的用户分配求当前用户的速率 ,BSchanAllocate是信道分配列表，user表示要获取速率的用户
153+
"""
154+
BSX +=[0]
155+
BSY +=[0]
156+
rate = 0##初始速率设置为0
157+
for BSn in xrange(len(chanlist)):##以信道分配的矩阵长度作为循环次数
158+
AvgBand = channelbandwidth
159+
if BSn!=(len(chanlist)-1):
160+
pt = pt = microAveragePower###微基站的平均信道功率
161+
P = picoPower ##基站总共功率
162+
radius = 100##m
163+
else:
164+
pt =macroAveragePower###微基站的平均信道功率
165+
P = macroPower ##基站总共功率
166+
radius = 500##m
167+
168+
for userindex in xrange(len(chanlist[BSn])):##第BSn个基站信道长度做循环次数
169+
if user == chanlist[BSn][userindex]:###判断用户是否在当前循环基站分配了信道
170+
Interf = interfere(BSn, userindex, chanlist, bsx, bsy)##求干扰
171+
d = distance(user[0],user[1],bsx[BSn],bsy[BSn])###求用户与基站的距离
172+
sinr = pt*(d)**(-4)/(Interf + P*radius**(-4)/alpha)##求信噪比sinr
173+
rate += AvgBand*log2(1+sinr)
174+
175+
return rate
176+
177+
178+
def channelAllocate(BSCover,bsx=BSX,bsy=BSY):
144179
"""
145180
146-
<<<<<<< HEAD
147181
"""
182+
BSX=BSX+[0]
183+
BSY=BSY+[0]
148184
BSchanAllocate = [[-1]*channelnum]*TotalNum ####定义一个信道分配的矩阵，行代表一个基站，列代表基站的信道
149-
n = 0##由于list会出现多个相同值(基站范围内不一定总是存在用户)取下标得到第一此出现的值，故循环n,作为全局的控制变量
150-
for bs in BSCover:##bs表示当前循环的基站下所有用户的集合bs = [user(0),user(1),user(1),...,user(n)]
185+
186+
for n in xrange(len(BSCover)):##n表示当前循环的基站下所有用户的集合编号
151187

152-
if len(bs) > 0 : ##判断bs中如果有用户的话,且不是最有一个基站，最后一个基站是宏基站
188+
if len(BSCover[n]) > 0 : ##当前编号对应的基站中如果有用户的话，继续执行
153189
##初始化计算基站信息的数据
154190
if n!=(len(BSCover)-1):
155191
pt = microAveragePower###微基站的平均信道功率
@@ -163,9 +199,9 @@ def channelAllocate(BSCover):
163199
AvgBand = channelbandwidth##每个信道的平均带宽
164200

165201
"""第一步：获得当前前基站下：每一个用户与所有信道连接条件下得到的用户速率"""
166-
R = []#初始化一个速度矩阵，一行代表当前基站下用户与所有信道的链接所获得速率值列表，列代表信道
167-
for user in bs:
168-
d = distance(user[0],user[1],BSX[n],BSY[n])## 用户与当前基站的距离
202+
R = []#初始化一个速度矩阵，一行代表当前基站下一个用户与所有信道的链接所获得速率值列表，列代表信道
203+
for userindex in xrange(len(BSCover[n])):##userindex表示对应用户的下标值
204+
d = distance(BSCover[n][userindex][0],BSCover[n][userindex][1],bsx[n],bsy[n])## 用户与当前基站的距离
169205
r = []
170206
for j in xrange(channelnum):
171207

@@ -181,11 +217,11 @@ def channelAllocate(BSCover):
181217
#print len(R)
182218

183219
"""第二步：进行信道的分配，使用的贪心算法，用户选择(或者说基站分配)当前速率值最大的信道"""
184-
for userj in bs:
185-
j = bs.index(userj)##获取当前用户的下标(用户坐标不存在两个相同的)
220+
for userj in xrange(len(BSCover[n])):
221+
j = userj##获取当前用户的下标(用户坐标不存在两个相同的)
186222
print "基站编号: %d"%(n)
187223

188-
Rnow=0##表示用户当下的速率，这样做是有问题的!!!!？？？？？？？
224+
Rnow=RateNow(BSchanAllocate, BSCover[n][j], BSX, BSY)##表示用户当下的速率，已改正【【【应该从信道分配list中获取当前用户的当前速率，刚开始用户的求得速率值为0】】】
189225
while(Rnow < Rmin):##用户速率大于最低速率，
190226
if BSchanAllocate[n].count(-1)>0:#当前基站还有未分配的信道，还有一个else，如果当前基站的信道数量不够该如何处理
191227
Rnow += max(R[j])
@@ -204,22 +240,24 @@ def channelAllocate(BSCover):
204240
print "All channels are busy"
205241
exit(0)
206242
print "\n"
207-
n=n+1 ##当前基站的分配完毕，n+1进入下一个基站的额信道分配
243+
# n = n + 1 ##当前基站的分配完毕，n+1进入下一个基站的额信道分配
208244

209245
return BSchanAllocate
210246

211247
if __name__=="__main__":
212248

213-
BSCover = classifyUser(UserX,UserY,BSX,BSY, r=100)
249+
BSCover = classifyUser(r=100)
214250
##将用户按照基站的覆盖范围分类之后，将宏基站的坐标加入到基站坐标列表中去
215-
BSX = BSX + [0]
216-
BSY = BSY + [0]
217-
# for i in xrange(len(BSX)):
218-
# print (BSX[i],BSY[i])
219-
# print "\n"
220-
#
221-
BSchanAllocate = channelAllocate(BSCover)
222-
for i in BSchanAllocate:
223-
print i
251+
# s = 0
252+
# for i in BSCover:
253+
# print i
254+
# s += len(i)
255+
# print "len(i)=%d"%len(i)
256+
# print "sum user:%d"%s
257+
258+
for i in [0,1]:
259+
BSchanAllocate = channelAllocate(BSCover)
260+
for i in BSchanAllocate:
261+
print i
224262

225263

‎chanAllocate.py

Lines changed: 72 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,72 @@
1+
# -*-coding:utf-8 -*-
2+
'''
3+
Created on 2017年5月5日
4+
5+
@author: Administrator
6+
'''
7+
# def channelAllocate(BSCover,bsx=BSX+[0],bsy=BSY+[0]):
8+
# """
9+
#
10+
# """
11+
# BSchanAllocate = [[-1]*channelnum]*TotalNum ####定义一个信道分配的矩阵，行代表一个基站，列代表基站的信道
12+
# n = 0##由于list会出现多个相同值(基站范围内不一定总是存在用户)取下标得到第一此出现的值，故循环n,作为全局的控制变量
13+
# for bs in BSCover:##bs表示当前循环的基站下所有用户的集合bs = [user(0),user(1),user(1),...,user(n)]
14+
#
15+
# if len(bs) > 0 and n<=TotalNum : ##判断bs中如果有用户的话,且不是最有一个基站，最后一个基站是宏基站
16+
# ##初始化计算基站信息的数据
17+
# if n!=(len(BSCover)-1):
18+
# pt = microAveragePower###微基站的平均信道功率
19+
# P = picoPower ##基站总共功率
20+
# radius = 100##m
21+
# else:
22+
# pt = macroAveragePower##宏基站的平均信道功率
23+
# P = macroPower
24+
# radius = 500##m
25+
#
26+
# AvgBand = channelbandwidth##每个信道的平均带宽
27+
#
28+
# """第一步：获得当前前基站下：每一个用户与所有信道连接条件下得到的用户速率"""
29+
# R = []#初始化一个速度矩阵，一行代表当前基站下用户与所有信道的链接所获得速率值列表，列代表信道
30+
# for user in bs:
31+
# d = distance(user[0],user[1],bsx[n],bsy[n])## 用户与当前基站的距离
32+
# r = []
33+
# for j in xrange(channelnum):
34+
#
35+
# Interf = interfere(n, j, BSchanAllocate, BSX, BSY)##n表示的是基站，j 是信道，chanlist是信道分配的列表
36+
# # sinr = pt*(D[bs.index(user)])**(-4)/(Interf + P*radius**(-4)/alpha)##求sinr
37+
# sinr = pt*(d)**(-4)/(Interf + P*radius**(-4)/alpha)##求sinr
38+
# rate = AvgBand*log2(1+sinr)
39+
# r.append(rate)
40+
# ##将得到的速率值r，追加到当前 用户速度一维列表中,
41+
# #每一个速率值对应一个信道:R =[r0,r1,r2,..]
42+
#
43+
# R.append(r)
44+
# #print len(R)
45+
#
46+
# """第二步：进行信道的分配，使用的贪心算法，用户选择(或者说基站分配)当前速率值最大的信道"""
47+
# for userj in bs:
48+
# j = bs.index(userj)##获取当前用户的下标(用户坐标不存在两个相同的)
49+
# print "基站编号: %d"%(n)
50+
#
51+
# Rnow=RateNow(BSchanAllocate, userj, BSX, BSY)##表示用户当下的速率，这样做是有问题的!？？【【【应该从信道分配list中获取当前用户的当前速率，刚开始用户的求得速率值为0】】】
52+
# while(Rnow < Rmin):##用户速率大于最低速率，
53+
# if BSchanAllocate[n].count(-1)>0:#当前基站还有未分配的信道，还有一个else，如果当前基站的信道数量不够该如何处理
54+
# Rnow += max(R[j])
55+
# chanid = R[j].index(max(R[j]))##将当前用户速率值最大值对应的第一个(可能会出现速率并列最大的)信道标号赋值给chanid
56+
# BSchanAllocate[n][chanid]=userj##在基站n的信道s对应位置写入用户坐标
57+
# print "channelid:%d user:%s"%(chanid,userj)
58+
#
59+
# for rm in xrange(len(R)):##循环速率矩阵行，将本基站其他用户对应这条信道的速率设置为0
60+
# # row = R.index(rm)#获取行坐标
61+
# for rn in xrange(len(R[j])):
62+
# # col = rm.index(rn)##获取列坐标
63+
# if (rn==chanid):R[rm][rn]=0##将已经分配的信道对应其他用户的速率矩阵位置设置为0，表示此信道已经分配不能再分配其他人
64+
#
65+
# else: ###如果当前基站的信道已经分配完毕，暂时输出下面的字符串，后续会继续处理这种情况
66+
#
67+
# print "All channels are busy"
68+
# exit(0)
69+
# print "\n"
70+
# n = n + 1 ##当前基站的分配完毕，n+1进入下一个基站的额信道分配
71+
#
72+
# return BSchanAllocate

0 commit comments

Comments
 (0)