Power control in LTE based on heuristic game theory for interference management

Figures & data

Table

Algorithm

Initialization: Fix the users $\eta \in \text{P}$ at random positions in the cells.

while (1)

for each $\eta$ do

Assign a β value initially as 0≤β≤1.0, and Δ ƕ = 0.2    //Sort the UEs in descending order according to the interference power level and path loss.//

i.e. $a=max(\mathrm{Pathlos}{s}_1,\mathrm{pathlos}{s}_2\dots .\mathrm{pathlos}{s}_{\eta })$and

$b=min(\mathrm{Pathlos}{s}_1,\mathrm{pathlos}{s}_2\dots .\mathrm{pathlos}{s}_{\eta })$

if

PL> $(\frac{a+b}{2}+\frac{a}{2})\ast \frac{1}{1.5}$ then PL>>min && β =  β+Δ ƕ;

//where Δ ƕ = 0.2//

end

else if

PL$\cong \left(\frac{a+b}{2}\right)$ then

PL∼‘Strategic choice’&& β = 0

end

else

PL<$\left(\frac{a+b}{2}+\frac{b}{2}\right)\ast \frac{1}{1.5}$ then PL > min && β =  β-Δ ƕ;

end

end if

Adjust P0 and hence ptx using eqns (6), (7), (8)

if

$\{U_n{\}}_{n\in p}=\mathrm{\Phi }$, continue with the same β value.

else

β =  0.5

end

end for

Table 1. Dependent and independent simulation parameters.

Simulation parameters	Description
Total no. of users, $\eta$	45
Cell radius, r	67m
Cell layout	Hexagonal, cells:5, 3-sectors, 15 sectors in total
Power contained in one PRB, P0	−50 dBm
Noise PSD, NoisePowerdB	−174 dBm Hz
System Bandwidth, BW	10 MHz
Resource block allocation for different BW options, m	1.4 MHz = 6; 3 MHz = 15; 5 MHz = 25; 10 MHz = 50; 15 MHz = 75; 20 MHz = 100;
Path loss, PL	PL = 35.3 + 37.6·log(d), distance in m
UE power class, Pmax	250 Mw (Max UE output Power)
Maximum antenna gain, G	15 dBi
Modulation and coding, δmcs	QPSK & 16QAM, continuous coding
No. Receiver Antenna	2 for diversity in Rayleigh fading
SNR	Target SNR, SNR0: 5 dB SNRmax: 20 dB
Path loss compensation factor, α	0.7
Convergence rate, CLBoostRatio	0.3

Figure 1. Created network map.

Figure 2. Each users’ (a) channel gain, (b) path loss, (c) shadow loss and (d) interference power measured in dB.

Figure 3. Uplink SINR for both open and closed loop.

Figure 4. Effective SINR for different target SNRs in dB.

Figure 5. Interference power and path loss measured in dB arranged in descending order and allocation of β value.

Figure 6. SNR and power variations of each user.

Figure 7. Users bit rate comparison of proposed power control scheme with the existing conventional power control scheme and power control scheme with convex pricing.

Figure 8. Throughput at the cell edge and cell centre.

Table

1.	Initialize simulation parameters and constants
2.	for each iteration:
3.	Generate network map with cells and sectors
4.	for each user in sector:
5.	Generate random user positions within the sector
6.	Calculate users' distances, angles, and path loss for each user in sectors:
7.	usersPathlossdB = pathloss_func(usersDistance)
8.	usersShadowdB = shadowStddB * rectpulse(rand(usersNumber, cellsNumber).', 3).'
9.	totalPathLossdB = zeros(usersNumber, sectorsNumber, ResourceblockNumber)
10.	Perform resource allocation based on scheduling algorithm
11.	AllocMatrix = zeros(sectorsNumber, ResourceblockNumber)
12.	if strcmpi(schedulingAlg, 'roundrobin'):
13.	if usersPerSector ≤ ResourceblockNumber:
14.	for cnt = 1: sectorsNumber:
15.	usersIndex = (cnt-1) * usersPerSector+(1:usersPerSector)
16.	userCnt = 1
17.	for cnt2 = 1: ResourceblockNumber:
18.	AllocMatrix(cnt, cnt2) = usersIndex(userCnt)
19.	if userCnt < usersPerSector:
	userCnt = userCnt + 1
20.	else
	userCnt = 1
21.	end
22.	end
23.	end
24.	end
25.	Generate random or fixed SNR values for each resource block
26.	if strcmpi(requiredSNRdB, 'random') || strcmpi(requiredSNRdB, 'fixed'):
27.	elseif strcmpi(requiredSNRdB, 'adaptive'):
28.	end
29.	end
30.	Determine the UE transmit power and calculating SINR for each resource block and sector
31.	for rb = 1: ResourceblockNumber
32.	if alpha  = = 1
33.	RequiredTxPowdB = maxUEOutPow * ones(ResourceblockNumber, 1)
34.	else
35.	RequiredTxPowdB = noisePowdB - 10 * log10(ResourceblockNumber) + alpha * CurrenttotalPathLossdBdB(:) + RequiredSNRdB(:)
36.	end
37.	for rb = 1: ResourceblockNumber
38.	CurrenttotalPathLossdBdB(rb) = totalPathLossdB(userIndex(rb), cnt, rb)
39.	end
40.	Determine the Receiver power and CL UE transmit power
41.	RxPowdB = closedLoopUETransmitPower(cnt,:) - CurrenttotalPathLossdBdB(:).'
42.	InterferePow = InterferePow + 10 .∧ (0.1 * (UETransmitPower(cnt2,:).' - CurrenttotalPathLossdBdB2(rb))
43.	closedLoopUETransmitPower(cnt, :) = min(RequiredTxPowdB, 10 * log10(maxUEOutPow)).’
44.	Heuristic Algorithm
45.	usersPathlossdB = usersPathlossdB(:, 1);
46.	PL = sort(usersPathlossdB);
47.	SortedInterferePow = InterferePow(:, 1);
48.	IntPower = sort(SortedInterferePow);
49.	A = max(PL);
50.	B = min(PL);
51.	High_PL = ((((A + B) / 2) + (A / 2))) * (1 / 1.5);
52.	Low_PL = ((((A + B) / 2) + (B / 2))) * (1 / 1.5);
53.	Medium_PL = (A + B) / 2;
54.	beta = 0.1 + (1 - 0.1) * rand();
55.	for upl = 1: userIndex
56.	if usersPathlossdB(upl) > High_PL
57.	beta = beta + 0.2;
58.	end
59.	elsif usersPathlossdB(upl) < Low_PL
60.	beta = beta – 0.2;
61.	end
62.	else usersPathlossdB(upl) > Medium_PL
63.	beta = beta + 0;
64.	end
65.	end
66.	Adjust closed-loop SINR based on the calculated beta and interference
67.	closedLoopRbSINRdB = UETransmitPower – UETransmitPower – 10 * log10(beta * 10 .∧ (InterferePow / 10));
68.	if nI ∼ =  closedLoopNumOfIterations + 1
69.	//Calculate the difference between required SNR and calculated SINR//
70.	closedLoopPowerBoostdB = closedLoopRequiredSNRdB – closedLoopRbSINRdB;
71.	//Adjust the transmit power based on the boost ratio//
72.	closedLoopUETransmitPower = closedLoopUETransmitPower + closedLoopPowerBoostdB * closedLoopBoostRatio;
73.	//Ensure the transmit power does not exceed the maximum allowed power//
74.	closedLoopUETransmitPower = min(closedLoopUETransmit Power, 10 * log10(maxUEOutPow));
75.	End