用Python模拟一个区域广播通信网络

浅夏110

题干：
& k# n' Q. v  q  y考虑这样的一个无线网：每个通信节点都是低功率的发射器，并且在进行着空间上的低速连续运动 (无法预知运动方向及其改变的规律)，所以对一个节点而言，只有和它距离在一定范围之内的节点才能收到它的信号，而且节点会 (在未声明的情况下) 相互接近或远离。每个节点需要不定期地、断续地发送信息，但会时刻保持收听信息。发送和收听工作可以同时进行。在这个通信网络中，完全没有网络的基础设施，而且每个节点只需要把自己的信息广播出去，需要此条信息的节点只需要被动收听即可，并不需要点对点地持续交换信息。所有信息只能使用同一个频率发送，一旦有两个或多个节点的广播发生冲突，能同时收听到它们的节点就都能监听到冲突。
8 t# X" t0 Z0 N: v3 n
我们假设发送每条信息所占用的时间都是等长的。所有的节点都拥有同样的内置算法，并拥有一个校准过的高精度时钟。
0 Y/ a# J% a* }  i
分析：
我们可以模拟一个题干中所描述的无线网，由于广播的不定期、断续地发送，我们可以用概率p pp来对广播发送进行描述，同时规定广播的半径r rr和同一区域出现的通信节点个数(用户输入)和产生的位置(随机)。
7 x0 M5 D" u0 p3 a
需要注意的是，节点会在空间上的低速连续运动，同时无法预知运动方向及其改变的规律，这点要用随机取模拟。
5 i) ^- R% k# h' A, R
为了方便解题，我们可以在模拟的同时对一些参数进行计算，例如在我的这段代码中，计算了：

number of all node，所有节点的个数
1 P0 c1 a9 y/ K3 f4 unumber of broadcast node，当前正在广播的节点个数以及其比例(number of broadcast node / number of all node)
number of effective receipt node，当前有效接收到广播的节点个数以及其比例(number of effective receipt node / number of all node)
7 `, X+ U& P, M* O0 cnumber of conflict receipt node，当前冲突节点的个数以及其比例(num node conflict / num node receipt)
: r# L0 Y! }! R4 a1 s2 D" T演示：
6 u% A; c) K& k! a
& }: H7 B$ e+ I  _
! _) d! d& n3 Y$ D( f" Z. z对图中的图符进行解释：

9 {7 u! O7 Z5 W) Hbroadcast，当前正在广播的节点及其广播域
receipt，节点
effective receipt，当前有效接收到广播的节点
8 j; ?) W, Q& u, Iconflict receipt，当前接收发生冲突的节点
代码：
可以通过如下代码模拟，或者自己完善：
6 K( |% f, r+ I, a% K% i+ N
8 q, m/ d( }' p! `* A; R! Mimport datetime
import math
import random
import numpy
5 e+ m8 _9 T( @3 F# d2 ?import time
$ K. Y6 |  K! U7 m+ H: `
import matplotlib.pyplot as plt
import numpy as np
5 A& m. _6 ~9 i7 k; h/ {: X/ ]
. J6 {! W: S1 l. j* S6 }2 B1 Y# 可调参数
  s, y5 F# o, MN =200 # 节点个数
seed = datetime.datetime.now() # 点产生的随机种子
, a( M6 \& Z# I$ y2 H, @+ _; m0 x( w! kp = 0.2 # 某一时间点发送信号的概率
3 f0 o0 t6 K4 N0 r( M9 L  Dradius = 0.05 # 广播半径

plt.ion() # 循环开始
" s* B% g0 ]/ k, \4 b# P. z) eplt.show()

- g- h. ]0 k0 J8 t1 Q. M# 构造节点，全部存入一个列表
x_all = np.random.rand(N)
# F) T* m& U6 Zy_all = np.random.rand(N)
! g# `. I" ]9 V$ _0 N) m
list_node_broadcast = []
list_node_receipt = []
list_node_conflict = []
+ p6 u/ k' Q' P4 F
+ F2 ]' |( Q# jfor _ in range(50):
. E$ @( F3 h0 T0 _' g5 ~- e& U( g    # 结果参数
) x- H4 o" R; v: P    num_node_broadcast = 0 # 正在广播的节点的个数
& K* L1 N7 h* [, n, J3 ?    num_node_receipt = 0 # 有效接收的节点的个数
: x! L( ?! b; K    num_node_conflict = 0 # 发生冲突的节点个数

+ U0 I9 l; g! F; E    for each_index in range(len(x_all)):
) b* G& y. Y- ?* V1 p' K6 o) M' U        randonX = random.uniform(-0.01, 0.01)
        x_all[each_index] += randonX
# I5 k9 k/ s6 }$ x, |( A3 c2 a        randonY = random.uniform(-0.01, 0.01)
2 @5 u2 o1 V  P, w- |: y7 p% e        y_all[each_index] += randonY
, k/ H; l1 ^; n2 ^4 _
# Z8 I" e* N+ l  ?5 c! d) F( j; |    # 依概率构造广播节点和接收节点
1 U+ i8 g( E( t6 w    node_broadcast = [] # 广播节点
/ H4 b1 R( B* b; a5 n4 [# z! n1 Q    node_receipt = [] # 接收节点
3 A4 ~* e0 h1 ?8 T7 X    for i in range(len(x_all)):
        random_pro = random.uniform(0, 1)
& q" H, d6 g% a1 |/ a: ~" A        if random_pro <= 0.2:
            node_broadcast.append([x_all, y_all])
            num_node_broadcast += 1
' Z3 f# x. I/ N% ?# f4 g/ R        else:
0 \. m6 B: p4 H4 f0 ?& C- ^6 v" ?            node_receipt.append([x_all, y_all])
    list_node_broadcast.append(num_node_broadcast) # 记录一次循环的广播节点个数
2 Z0 h% ?4 F8 E8 K5 S
* L2 v) o, r% n2 I) r7 n    # 计算有效的接收节点
    effective_receipt_node = []
    conflict_receipt_node = []
    for each_receipt in node_receipt:
2 m# P  u5 ]2 d8 F! A1 F# ?6 Y! ?6 A        flag = 0 # 该变量用来指示某个接收节点是否处于多个广播节点的广播范围之内，0表示0个，1表示1个...以此类推
5 X, v4 \- a# ?4 h* d" ]3 `2 ]  f        for each_broadcast in node_broadcast:
            if math.sqrt((each_receipt[0]-each_broadcast[0])**2 + (each_receipt[1]-each_broadcast[1])**2) < radius:
                flag += 1
        if flag > 1:
' @. v* G& m7 R" ~2 l. i            num_node_conflict += 1
4 k. s6 l! R/ U3 m. w            conflict_receipt_node.append(each_receipt)
# V$ M3 f! l$ c  G1 J        if flag == 1:
            effective_receipt_node.append(each_receipt)
+ w. H# H# h: s* r. V% J5 L            num_node_receipt += 1
5 {4 d! b5 }5 Q% O3 `7 c    list_node_receipt.append(num_node_receipt) # 记录一次循环的有效节点接收个数
    list_node_conflict.append(num_node_conflict) # 记录一次循环的冲突节点个数
  R' J0 v% {2 c- K# K* y+ z2 `' G
, V% R6 o" @6 Z  u. D    # 提取广播节点、接收节点、有效接收节点的坐标
+ `; P3 J) {. U1 i& S1 C  @7 g    broadcast_x = [i[0] for i in node_broadcast]
3 \0 Z# Y8 N6 }' U  T    broadcast_y = [i[1] for i in node_broadcast]
$ B8 Z4 {, t" `/ Y1 \: P! m' u' R    receipt_x = [i[0] for i in node_receipt]
    receipt_y = [i[1] for i in node_receipt]
* n) z. {4 ?, f$ q" \) k    effective_receipt_x = [[i[0] for i in effective_receipt_node]]
' _6 N8 a- m& C    effective_receipt_y = [[i[1] for i in effective_receipt_node]]
    conflict_receipt_x = [[i[0] for i in conflict_receipt_node]]
    conflict_receipt_y = [[i[1] for i in conflict_receipt_node]]

4 t! n* [+ Q# S, }, z/ e% ]0 t    plt.cla()  # 清除当前绘图
/ b! l" M% r7 q
    # 绘制散点图
4 f' `& T2 M* p( Q1 G0 h+ H3 Z    plt.scatter(broadcast_x, broadcast_y, s=500, c='#ffffff', edgecolors='#000000', label='broadcast') # 绘制广播节点
( o' {  I% O# R6 c    plt.scatter(receipt_x, receipt_y, s=10, c='#000000', edgecolors='#000000', label='receipt') # 绘制全部接收节点
- e& \. m7 R; z8 u    plt.scatter(effective_receipt_x, effective_receipt_y, s=10, c='#32b16c', edgecolors='#32b16c', label='effective receipt') # 绘制有效接收节点
% f7 J/ C% w( k' p4 M+ l    plt.scatter(conflict_receipt_x, conflict_receipt_y, s=10, c='#e60012', edgecolors='#e60012', label='conflict receipt') # 绘制冲突接收节点
- A- N! M* R$ h2 a) B
    # 图中的文字说明
' V5 A% k+ ~7 _2 i$ o  C    plt.text(0.35, 0.1, 'number of all node: %d' % N, fontdict={'size': 10, 'color': 'red'})
. F' V# a4 C& D$ s' p, S    plt.text(0.35, 0.05, 'number of broadcast node: %d (%0.2f)' % (num_node_broadcast, num_node_broadcast/N), fontdict={'size':10, 'color':'red'})
    plt.text(0.35, 0, 'number of effective receipt node: %d (%0.2f)' % (num_node_receipt, num_node_receipt/(N-num_node_broadcast)), fontdict={'size':10, 'color':'red'})
    plt.text(0.35, -0.05, 'number of conflict receipt node: %d (%0.2f)' % (num_node_conflict, num_node_conflict/num_node_receipt), fontdict={'size':10, 'color':'red'})

    plt.axis('off')
    plt.xlim(-0.1, 1.1)
- s: n3 d* S! F& E; K+ l    plt.ylim(-0.1, 1.1)
% W, b$ v9 d- N5 ?0 ]; l( h/ {# p5 S- o3 N    plt.style.use('ggplot')
4 c2 @, w! n- W! Q# K    plt.legend(loc='lower left')
! _6 i3 j( I  u: F. Z& n    plt.pause(0.2)  # 保留绘图0.2s

) p) B& Q# h) C/ r, l: N8 L% l& Dplt.ioff() # 循环结束
plt.show()

) x+ V5 k5 X+ k& _+ I6 e  Uprint("有效发送" + str(numpy.mean(list_node_broadcast)))
' K7 m& e! X  mprint("有效接收" + str(numpy.mean(list_node_receipt)))
! \& j3 W5 p2 }2 g, A) P- vprint("冲突" + str(numpy.mean(list_node_conflict)))
2 Z5 R, E% |- Y0 kprint("Sy" + str(numpy.mean(list_node_conflict)/numpy.mean(list_node_broadcast)))
( L8 q, c: ?( e  j6 R; \- ]4 }: a
7 j. ~6 y# u' e1 m5 O- s. ]2 z5 Ux_axis = [str(i)+"t" for i in range(50)]
. ?( R; K) W" I
  d2 x: p3 O4 S9 q! L% {6 H; l, J5 ~& ?fig = plt.figure(figsize=(12,4))
plt.axis('on')
$ A; _: n- k3 r! u6 A4 v/ o0 g7 ]plt.subplot(facecolor='w')
plt.plot(x_axis, list_node_broadcast, color='black', linewidth=1.0, linestyle='-', label='广播节点')
3 e% s( {& Z4 [/ v; u. {# Gplt.plot(x_axis, list_node_receipt, color='green', linewidth=1.0, linestyle='-', label='接收节点')
% X) f. i$ X* H/ h4 ]plt.plot(x_axis, list_node_conflict, color='red', linewidth=1.0, linestyle='-', label='冲突节点')
; C( X- S4 Y" {9 e5 t" f" ?
4 r4 g; E' |1 Q5 c+ i3 }plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.xticks(rotation=-45)
plt.legend(loc='upper left')
plt.grid(axis="both")
  g5 {3 G+ w* A, h+ u1 D+ z% T# plt.show()

————————————————
# x5 `2 {7 x  s* Y" i6 ?- _( t& i6 d版权声明：本文为CSDN博主「白水偷偷画工图」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
8 T+ d! F: r9 Y5 l- l, X原文链接：https://blog.csdn.net/baishuiniyaonulia/article/details/106101280