5-3.2

grasscoder · grasscoder · commit a5a3381a9c20 · 2017-05-03T22:29:28.000+08:00
5-3.2
diff --git a/CAPalloction.py b/CAPalloction.py
@@ -35,6 +35,7 @@
 RelayNum = 2
 TotalNum =  MacroNum+PicoNum+FemtoNum+RelayNum
 usernum = np.random.randint(20,50)
+print "usernum=%d"%usernum
 
 macroR = 500.0     ##宏基站的覆盖半径/m
 microR = 100.0     ##微基站的覆盖半径/m
@@ -105,7 +106,7 @@ def interfere(n,s,chanlist,BSX,BSY):
     '''
     ##不同基站相同信道才会产生干扰，除此之外只有噪声,基站BS_n 在信道chan_s上的干扰,不同基站只要分配了相同编号的信道，
     ##无论是否给同一个用户都会相互干扰，只是相同编号的信道分配给同一个用户干扰最大
-    chanlist 是信道的分配列表 等同于下面的BSchanAllocate，已分配信道是用用户坐标表示的，未分配信道值值为-1
+    chanlist 是信道的分配列表 等同于下面的BSchanAllocate，已分配信道是用用户坐标表示的，未分配信道值为-1
     '''
     interf = 0
     for i in xrange(len(chanlist)):#循环基站数量次
@@ -127,12 +128,7 @@ def interfere(n,s,chanlist,BSX,BSY):
 """
     BSCover 一行代表一个基站 下的所有用户
 """
-BSCover = classifyUser(UserX,UserY,BSX,BSY, r=100)
 
-##将用户按照基站的覆盖范围分类之后，将宏基站的坐标加入到基站坐标列表中去
-BSX = BSX + [0]
-BSY = BSY + [0]
-   
 '''
         #初始化一个信道分配矩阵，每一行代表一个基站的信道的分配，未分配的信道记为-1,如果某个信道分配给用户了，则标记为 用户   坐标 
         BSchanAllocate = [        
@@ -144,74 +140,82 @@ def interfere(n,s,chanlist,BSX,BSY):
         BS5 : [-1,-1,....,-1]
         ]
         '''
-
-BSchanAllocate = [[-1]*channelnum]*TotalNum  ####定义一个信道分配的矩阵，行代表一个基站，列代表基站的信道
-userRateDict = {}##用户速率表，记录的是用户当前信道分配条件下获得的速率值
-
-n = 0##由于list会出现多个相同值(基站范围内不一定总是存在用户)取下标得到第一此出现的值，故循环n,作为全局的控制变量
-for bs in BSCover:##bs表示当前循环的基站下所有用户的集合bs = [user(0),user(1),user(1),...,user(n)]
-#     n = BSCover.index(bs)##获取当前基站对应的下标值，以定位当前基站(BSX[n],BSY[n]),问题是：当出现多个空集时，index()的值是第一次出的下标值
+def channelAllocate(BSCover):
+    """
     
-    if len(bs) > 0 : ##判断bs中如果有用户的话,且不是最有一个基站，最后一个基站是宏基站
-        ##初始化计算基站信息的数据
-        if n!=(len(BSCover)-1): 
-            pt = microAveragePower###微基站的平均信道功率
-            P = picoPower  ##基站总共功率
-            radius = 100##m
-        else:
-            pt = macroAveragePower##宏基站的平均信道功率
-            P = macroPower
-            radius = 500##m
-#         Interf = 0 ##干扰
-        AvgBand = channelbandwidth##每个信道的平均带宽
-        
-        ##求当前基站范围内的用户与当前基站的距离
-        D = []
-        for useri in bs:#循环当前基站中用户数量次
-            d = distance(useri[0],useri[1],BSX[n],BSY[n])
-            D.append(d)##得到当前基站下的用户与当前基站距离的列表
-        
-        ##利用循环求当前基站下：每一个用户与所有信道连接条件下可获得的用户速率
-        R = []#初始化一个速度矩阵，一行代表当前基站下用户与所有信道的链接所获得速率值列表，列代表信道
-        for user in bs:
-#             R = []#初始化一个速度列表，当前循环的基站下覆盖的各个用户：假设信道分配给每一个用户的情形下得到的速率
-            r = []
-            for j in xrange(channelnum):
-                
-                Interf = interfere(n, j, BSchanAllocate, BSX, BSY)##n表示的是基站，j 是信道，chanlist是信道分配的列表
-                sinr = pt*(D[bs.index(user)])**(-4)/(Interf + P*radius**(-4)/alpha)##求sinr
-                rate = AvgBand*log2(1+sinr)
-                ##将得到的速率值r，追加到当前 用户速度一维列表中,
-                #每一个速率值对应一个信道:R =[r0,r1,r2,..]
-                r.append(rate)
-            R.append(r)
-        print R
-        print len(R[0])
-        
-            ##下一步进行信道的分配，使用的贪心算法，用户选择(或者说基站分配)当前速率值最大的信道
-        
-        for userj in bs:
-            j = bs.index(userj)##获取当前用户的下标(用户坐标不会存在重复)
+    """
+    BSchanAllocate = [[-1]*channelnum]*TotalNum  ####定义一个信道分配的矩阵，行代表一个基站，列代表基站的信道
+    n = 0##由于list会出现多个相同值(基站范围内不一定总是存在用户)取下标得到第一此出现的值，故循环n,作为全局的控制变量
+    for bs in BSCover:##bs表示当前循环的基站下所有用户的集合bs = [user(0),user(1),user(1),...,user(n)]
+    
+        if len(bs) > 0 : ##判断bs中如果有用户的话,且不是最有一个基站，最后一个基站是宏基站
+            ##初始化计算基站信息的数据
+            if n!=(len(BSCover)-1): 
+                pt = microAveragePower###微基站的平均信道功率
+                P = picoPower  ##基站总共功率
+                radius = 100##m
+            else:
+                pt = macroAveragePower##宏基站的平均信道功率
+                P = macroPower
+                radius = 500##m
+    
+            AvgBand = channelbandwidth##每个信道的平均带宽
+
+            """第一步：获得当前前基站下：每一个用户与所有信道连接条件下得到的用户速率"""
+            R = []#初始化一个速度矩阵，一行代表当前基站下用户与所有信道的链接所获得速率值列表，列代表信道
+            for user in bs:
+                d = distance(user[0],user[1],BSX[n],BSY[n])## 用户与当前基站的距离
+                r = []
+                for j in xrange(channelnum):
+                    
+                    Interf = interfere(n, j, BSchanAllocate, BSX, BSY)##n表示的是基站，j 是信道，chanlist是信道分配的列表
+#                     sinr = pt*(D[bs.index(user)])**(-4)/(Interf + P*radius**(-4)/alpha)##求sinr
+                    sinr = pt*(d)**(-4)/(Interf + P*radius**(-4)/alpha)##求sinr
+                    rate = AvgBand*log2(1+sinr)
+                    r.append(rate)
+                    ##将得到的速率值r，追加到当前 用户速度一维列表中,
+                    #每一个速率值对应一个信道:R =[r0,r1,r2,..]
+                    
+                R.append(r)
+            print len(R)
             
-            Rnow=0##表示用户当下的速率，这样做是有问题的!!!!？？？？？？？
-            while(Rnow < Rmin):##用户速率大于最低速率，
-                if BSchanAllocate[n].count(-1)>0:#当前基站还有未分配的信道
-                    Rnow += max(R[j])
-                    chanid = R[j].index(max(R[j]))##将当前用户速率值最大值对应的第一个(可能会出现速率并列最大的)信道标号赋值给chanid
-                    for rm in R:##循环速率矩阵行
-                        row = R.index(rm)#获取行坐标
-                        for rn in rm:
-                            col = rm.index(rn)##获取列坐标
-                            if (row!=j and col!=chanid):R[row][col]=0
-                    BSchanAllocate[n][chanid]=userj##在基站n的信道s对应位置写入用户坐标
-                else: 
-                    print "All channels are busy"
-                    exit(0)
-    n=n+1    
-        
+            """第二步：进行信道的分配，使用的贪心算法，用户选择(或者说基站分配)当前速率值最大的信道"""
+            for userj in bs:
+                j = bs.index(userj)##获取当前用户的下标(用户坐标不存在两个相同的)
+    
+                Rnow=0##表示用户当下的速率，这样做是有问题的!!!!？？？？？？？
+                while(Rnow < Rmin):##用户速率大于最低速率，
+                    if BSchanAllocate[n].count(-1)>0:#当前基站还有未分配的信道，还有一个else，如果当前基站的信道数量不够该如何处理
+                        Rnow += max(R[j])
+                        chanid = R[j].index(max(R[j]))##将当前用户速率值最大值对应的第一个(可能会出现速率并列最大的)信道标号赋值给chanid
+                        BSchanAllocate[n][chanid]=userj##在基站n的信道s对应位置写入用户坐标
+                        
+                        for rm in xrange(len(R)):##循环速率矩阵行，将本基站其他用户对应这条信道的速率设置为0
+    #                         row = R.index(rm)#获取行坐标
+                            for rn in xrange(len(R[j])):
+    #                             col = rm.index(rn)##获取列坐标
+                                if (rm!=j and rn==chanid):R[rm][rn]=0##将已经分配的信道对应其他用户的速率矩阵位置设置为0，表示此信道已经分配不能再分配其他人
+    #                     
+                    else: ###如果当前基站的信道已经分配完毕，暂时输出下面的字符串，后续会继续处理这种情况
+                        
+                        print "All channels are busy"
+                        exit(0)
+        n=n+1 ##当前基站的分配完毕，n+1进入下一个基站的额信道分配
+           
+    return BSchanAllocate    
 
 if __name__=="__main__":
-    print "\n"
-#     for i in BSchanAllocate:
-#         print i
+    
+    BSCover = classifyUser(UserX,UserY,BSX,BSY, r=100)
+    ##将用户按照基站的覆盖范围分类之后，将宏基站的坐标加入到基站坐标列表中去
+    BSX = BSX + [0]
+    BSY = BSY + [0]
+#     for i in xrange(len(BSX)):
+#         print (BSX[i],BSY[i])
+#         print "\n"
+#     
+    BSchanAllocate = channelAllocate(BSCover)
+    for i in BSchanAllocate:
+        print i
+                
     
