├── chanGainFSPL.m ├── chanRank.m ├── README.md ├── chanGain.m ├── experiment0_main.m ├── M3_prototype.m ├── M3_prototype_SCA.m ├── experiment0_OMA.m ├── M3_OMA.m ├── experiment0_NOMA.m └── M3_Joint_RA_TS.m /chanGainFSPL.m: -------------------------------------------------------------------------------- 1 | % This function computes the channel gain of the link between the user and the UAV. 2 | % rUser is a 1*3 vector denoting 3-D coordinates of the user. 3 | % rUAV is a 1*3 vector denoting 3-D coordinates of the UAV. 4 | 5 | function [g, L] = chanGainFSPL(rUAV, rUser) 6 | fc = 2e9; % Carrier frequency (Hz) 7 | c = 3e8; % Speed of light (m/sec) 8 | alpha = 2; % Path loss exponent 9 | 10 | % LoS distance between UAV and user 11 | d = sqrt((rUAV(1)-rUser(1))^2+(rUAV(2)-rUser(2))^2+(rUAV(3)-rUser(3))^2); 12 | L = (4*pi*fc*d/c)^alpha; 13 | g = 1/L; % Channel gain of the link 14 | end 15 | 16 | -------------------------------------------------------------------------------- /chanRank.m: -------------------------------------------------------------------------------- 1 | % This function ranks the user in ascending order of their channel gains. 2 | function [gRank, rank, Psi] = chanRank(g, U, N) 3 | % g is a U*N matrix denoting the channel gains for all links throughout the interval. 4 | gRank = zeros(U, N); 5 | rank = zeros(U, N); 6 | Psi = zeros(U, N); 7 | for n = 1:N 8 | [gRank(:, n), rank(:, n)] = sort(g(:, n)); 9 | % rank gives a list of user index. Its value denotes the user index with that ranking, 10 | % i.e. rank(k, n) means the index of user with the k-th smallest channel gain at time n. 11 | [B2, Psi(:, n)] = sort(rank(:, n)); 12 | % Psi helps track the rankings of users, 13 | % i.e. Psi(i, n) denotes the ranking of user i at time n. 14 | end 15 | end -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # multi-uav-mec 2 | Code implementation of our paper [Energy-Efficient Multi-UAV-Enabled Multiaccess Edge Computing Incorporating NOMA](https://ieeexplore.ieee.org/document/9032145/) on *IEEE Internet of Things Journal*. 3 | 4 | We are most happy if you find our work helpful to you research. If you use this repo, please cite our work: 5 | 6 | ```tex 7 | @ARTICLE{9032145, 8 | author={Zhang, Xiaochen and Zhang, Jiao and Xiong, Jun and Zhou, Li and Wei, Jibo}, 9 | journal={IEEE Internet of Things Journal}, 10 | title={Energy-Efficient Multi-UAV-Enabled Multiaccess Edge Computing Incorporating NOMA}, 11 | year={2020}, 12 | volume={7}, 13 | number={6}, 14 | pages={5613-5627}, 15 | doi={10.1109/JIOT.2020.2980035} 16 | } 17 | ``` 18 | 19 | Contact zhangxiaochen14@nudt.edu.cn if you have any issues. 20 | -------------------------------------------------------------------------------- /chanGain.m: -------------------------------------------------------------------------------- 1 | % This function computes the channel gain of the link between the user and the UAV. 2 | % rUser is a 1*3 vector denoting 3-D coordinates of the user. 3 | % rUAV is a 1*3 vector denoting 3-D coordinates of the UAV. 4 | 5 | function [g, L] = chanGain(rUAV, rUser) 6 | fc = 2e9; % Carrier frequency (Hz) 7 | c = 3e8; % Speed of light (m/sec) 8 | alpha = 2; % Path loss exponent 9 | % Consider the urban scenario 10 | % The coefficients below are based on 11 | a = 11.95; 12 | b = 0.14; 13 | etaLoS = 10^(1/10); 14 | etaNLoS = 10^(20/10); 15 | 16 | % LoS distance between UAV and user 17 | d = sqrt((rUAV(1)-rUser(1))^2+(rUAV(2)-rUser(2))^2+(rUAV(3)-rUser(3))^2); 18 | % Elevation angle of UAV respective to the user. 19 | theta = 180/pi*asin(abs(rUAV(3)-rUser(3))/d); 20 | 21 | % Compute the probability of LoS and NLoS 22 | pLoS = 1/(1+a*exp(-b*(theta-a))); 23 | pNLoS = 1-pLoS; 24 | 25 | % Average path loss 26 | L = pLoS*etaLoS*(4*pi*fc*d/c)^alpha+pNLoS*etaNLoS*(4*pi*fc*d/c)^alpha; 27 | g = 1/L; % Channel gain of the link 28 | end 29 | 30 | -------------------------------------------------------------------------------- /experiment0_main.m: -------------------------------------------------------------------------------- 1 | % clear all 2 | % close all 3 | % lengthArea = 1000; 4 | % widthArea = 1000; 5 | % U = 8; 6 | % rUser = [0.3*lengthArea+0.7*lengthArea*rand(U, 1),0.3*widthArea+0.7*widthArea*rand(U, 1), zeros(U, 1)]; 7 | 8 | % rUser = [kron(100*(2:2:8).',ones(2,1)), ... 9 | % repmat([600, 800].', 4, 1),... 10 | % zeros(U, 1)]; 11 | 12 | % [power_OMA, rUAV_OMA, utility_OMA, fUAV_OMA, fUser_OMA] = experiment0_OMA(rUser); 13 | [power_NOMA, rUAV_NOMA, utility_NOMA, fUAV_NOMA, fUser_NOMA] = experiment0_NOMA(rUser); 14 | 15 | E_user_offload_NOMA = utility_NOMA(1); 16 | E_user_comp_NOMA = utility_NOMA(2); 17 | E_uav_comp_NOMA = utility_NOMA(3); 18 | E_uav_move_NOMA = utility_NOMA(4); 19 | 20 | E_user_offload_OMA = utility_OMA(1); 21 | E_user_comp_OMA = utility_OMA(2); 22 | E_uav_comp_OMA = utility_OMA(3); 23 | E_uav_move_OMA = utility_OMA(4); 24 | 25 | omegaUser = 0.8; % Weight factor of users 26 | omegaUAV = 1-omegaUser; % Weight factor of UAVs 27 | 28 | 29 | y = [E_user_offload_NOMA/omegaUser, E_user_offload_OMA/omegaUser;... 30 | E_user_comp_NOMA/omegaUser, E_user_comp_OMA/omegaUser;... 31 | E_uav_comp_NOMA/omegaUAV, E_uav_comp_OMA/omegaUAV;... 32 | E_uav_move_NOMA/omegaUAV, E_uav_move_OMA/omegaUAV]; 33 | 34 | E_total_NOMA = sum(utility_NOMA) 35 | E_total_OMA = sum(utility_OMA) 36 | 37 | N = 20; 38 | 39 | figure(1) 40 | scatter(rUser(:, 1), rUser(:, 2)); 41 | hold on 42 | scatter(rUAV_NOMA(:, 1, 1), rUAV_NOMA(:, 2, 1)); 43 | hold on 44 | scatter(rUAV_NOMA(:, 1, 2), rUAV_NOMA(:, 2, 2)); 45 | hold on 46 | scatter(rUAV_OMA(:, 1, 1), rUAV_OMA(:, 2, 1)); 47 | hold on 48 | scatter(rUAV_OMA(:, 1, 2), rUAV_OMA(:, 2, 2)); 49 | legend('Users', 'UAV 1 for NOMA', 'UAV 2 for NOMA', 'UAV 1 for OMA', 'UAV 2 for OMA') 50 | 51 | title('Location of SMDs and Trajectories of UAVs') 52 | xlabel('Length/m') 53 | ylabel('Width/m') 54 | axis([0 lengthArea 0 widthArea]) 55 | 56 | figure(2) 57 | for i = 1:U 58 | stem3(i*ones(N, 1), (1:N), power_NOMA(i, :)); 59 | hold on 60 | end 61 | xlabel('User Index') 62 | ylabel('Time Slot') 63 | zlabel('Offloading Power') 64 | title('Record of offloading power of each user for NOMA') 65 | 66 | figure(3) 67 | for i = 1:U 68 | stem3(i*ones(N, 1), (1:N), power_OMA(i, :)); 69 | hold on 70 | end 71 | xlabel('User Index') 72 | ylabel('Time Slot') 73 | zlabel('Offloading Power') 74 | title('Record of offloading power of each user for OMA') 75 | 76 | figure(4) 77 | bar(y); 78 | 79 | 80 | 81 | -------------------------------------------------------------------------------- /M3_prototype.m: -------------------------------------------------------------------------------- 1 | clear all 2 | close all 3 | % This script describes a NOMA-assisted MEC system on UAV according to doc 'Model 1.pages'. 4 | % Created and copyrighted by ZHANG Xiaochen at 10:22 a.m., Apr. 12, 2019. 5 | 6 | %% Setup of the Model 7 | 8 | % Consider U terrestrial users located in a area 9 | U = 8; % Number of users/SMDs 10 | 11 | % The size of the area is defined by: 12 | lengthArea = 1000; % Length of the coverage area (m) 13 | widthArea = 1000; % Width of the coverage area (m) 14 | 15 | % U SMDs are uniformly distributed in the rectangular coverage area. 16 | % rUser = [lengthArea*rand(U, 1),widthArea*rand(U, 1), zeros(U, 1)]; 17 | % rUser = [100*(2:2:8).', 100*8*ones(U, 1), zeros(U, 1)]; 18 | % rUser = [[400,400,600,600].', [600,800,600,800].',zeros(U, 1)]; 19 | % rUser = [[100,500,800,600].', [600,600,600,800].',zeros(U, 1)]; 20 | rUser = [kron(100*(2:2:8).',ones(2,1)), ... 21 | repmat([600, 800].', 4, 1),... 22 | zeros(U, 1)]; 23 | 24 | 25 | 26 | % Divide the time interval into N tme slots. 27 | T = 100; % Length of interval 28 | N = 20; % Number of time slots 29 | tau = T/N; % Duration of each time slot 30 | 31 | % Set the initial trajectory of UAV 32 | M = 2; 33 | hUAV = 20; % Flying altitude of UAV 34 | rI = [0, 0, hUAV; 0, 0, hUAV]; % Intial position of the UAV (M*3) 35 | rF = [lengthArea, 0, hUAV; 0, widthArea, hUAV]; % Final position of the UAV 36 | 37 | rUAV = zeros(N, 3, M); % Trajectory vector of the UAV 38 | 39 | % rUAV is a N*3 matrix of which each describes the 3-D coordinates of UAV 40 | % at each time slot. 41 | for m = 1:M 42 | rUAV(N, :, m) = rF(m, :); 43 | end 44 | for n = 1:N-1 45 | for m = 1:M 46 | rUAV(n, :, m) = rI(m, :)+n/N*(rF(m, :)-rI(m, :)); 47 | end 48 | end 49 | 50 | % Plot the configuration of the model 51 | figure(1) 52 | scatter(rUser(:, 1), rUser(:, 2)); 53 | hold on 54 | stem(rUAV(:, 1, 1), rUAV(:, 2, 1)); 55 | hold on 56 | stem(rUAV(:, 1, 2), rUAV(:, 2, 2)); 57 | 58 | title('Location of SMDs and Trajectory of the UAV') 59 | xlabel('Length/m') 60 | ylabel('Width/m') 61 | axis([0 lengthArea 0 widthArea]) 62 | 63 | % Find the channel gain for each user in each time slot 64 | g = zeros(U, N, M); % Channel gain matrix 65 | L = zeros(U, N, M); % Path loss matrix 66 | % g is a U*N matrix denoting the channel gains for all links throughout the interval. 67 | 68 | for i = 1:U 69 | for n = 1:N 70 | for m = 1:M 71 | [g(i, n, m), L(i, n, m)] = chanGainFSPL(rUAV(n, :, m), rUser(i, :)); 72 | end 73 | end 74 | end 75 | 76 | omegaUser = 0.8; 77 | omegaUAV = 1-omegaUser; 78 | 79 | N0 = 1e-17; % Power spectral density of AWGN (W/Hz) 80 | B = 4e6; % System bandwidth (Hz) 81 | 82 | D = 120*ones(U, 1); % Number of bits for each SMDs to finish (Mbit) 83 | kappa = 1e-28; % Effective swiched capacitance of CPU 84 | 85 | fmaxUAV = 20; % Maximum CPU frequency of MEC server (GHz) 86 | fminUAV = 0; % Minimum CPU frequency of SMDs (GHz) 87 | CUAV = 1e3; % Processing density of MEC server (Hz/bit) 88 | 89 | fmaxUser = 1; % Maximum CPU frequency of SMDs (GHz) 90 | fminUser = 0; % Minimum CPU frequency of SMDs (GHz) 91 | CUser = 1e3; % Processing density of SMD (Hz/bit) 92 | 93 | %% Resource Allocation (RA) for Offloading and Computation 94 | gRank = zeros(U, N, M); 95 | rank = zeros(U, N, M); 96 | Psi = zeros(U, N, M); 97 | beta = zeros(U+2, N, M); 98 | mu = zeros(U+1, N, M); 99 | 100 | for m = 1:M 101 | [gRank(:, :, m), rank(:, :, m), Psi(:, :, m)] = chanRank(g(:, :, m), U, N); 102 | 103 | beta(2:(U+1), :, m) = 1./gRank(:, :, m); 104 | 105 | for k = 1:U+1 106 | mu(k, :, m) = -beta(k+1, :, m)+beta(k, :, m); 107 | end 108 | end 109 | % rank gives a list of user index. Its value denotes the user index with that ranking, 110 | % i.e. rank(k, n) means the index of user with the k-th smallest channel gain at time n. 111 | % Psi helps track the rankings of users, 112 | % i.e. Psi(i, n) denotes the ranking of user i at time n. 113 | 114 | % beta is a (U+2)*N matrix. 115 | 116 | mu = mu/(1e9); 117 | J = log(2)/(B*tau); 118 | J = J*1e6; 119 | c1 = omegaUser*kappa*tau*1e27; 120 | c2 = omegaUser*B*N0*1e9; 121 | c3 = omegaUAV*kappa*tau*1e27; 122 | 123 | % Solve the convex optimization problem: Posynomial + Sum of exp 124 | 125 | xmin = 0; 126 | cvx_begin 127 | variable x(U, N, M) nonnegative 128 | variable fUser(U, N) nonnegative 129 | variable fUAV(U, N, M) nonnegative 130 | variable threshold 131 | variable userRate(U, N, M) 132 | eta = 0; 133 | for i = 1:U 134 | for n = 1:N 135 | for m = 1:M 136 | if Psi(i, n, m) > 1 137 | userRate(i, n, m) == x(Psi(i, n, m), n, m)-x(Psi(i, n, m)-1, n, m); 138 | elseif Psi(i, n, m) == 1 139 | userRate(i, n, m) == x(Psi(i, n, m), n, m); 140 | end 141 | end 142 | end 143 | end 144 | 145 | for m = 1:M 146 | eta = eta+c2*sum(sum(mu(2:end, :, m).*exp(J*x(:, :, m)))) +... 147 | c2*sum(mu(1, :, m)); 148 | end 149 | eta = eta+c1*sum(sum(pow_p(fUser, 3))) +... 150 | c3*sum(sum(sum(pow_p(fUAV, 3)))); 151 | minimize( threshold ) 152 | subject to 153 | % C0: Objective function 154 | eta<= threshold; 155 | % C1: CPU frequency constraint on SMDs 156 | fminUser <= fUser; 157 | fUser <= fmaxUser; 158 | 159 | % C2: CPU frequency constraint on MEC server 160 | for m = 1:M 161 | fminUAV <= sum(fUAV(:, :, m), 1); 162 | sum(fUAV(:, :, m), 1) <= fmaxUAV; 163 | end 164 | 165 | % C3: Offloading rate constraint on SMDs 166 | xmin <= x; 167 | 168 | for k = 2:U 169 | for n = 1:N 170 | for m = 1:M 171 | x(k, n, m) >= x(k-1, n, m); 172 | end 173 | end 174 | end 175 | 176 | % C4: Accomplishment of computation tasks 177 | D <= 1000*tau/CUser*sum(fUser, 2)+1000*tau/CUAV*sum(sum(fUAV(:, 2:end, :), 3), 2); 178 | 179 | % C5&C6: Causal constraint on offloading and edge computing 180 | 181 | for i = 1:U 182 | for n = 2:N 183 | for m = 1:M 184 | sum(userRate(i, (1:n-1), m)) >= tau/CUAV*1000*sum(fUAV(i, (2:n), m)); 185 | end 186 | end 187 | end 188 | 189 | cvx_end 190 | 191 | % Record the offloading power of each user in each time slot. 192 | recordPowerOffload = zeros(U, N, M); 193 | for i = 1:U 194 | for n = 1:N 195 | for m = 1:M 196 | if Psi(i, n, m) > 1 197 | recordPowerOffload(i, n, m) = B*N0/g(Psi(i, n, m))*(exp(J*x(Psi(i, n, m), n, m))-exp(J*x(Psi(i, n, m)-1, n, m))); 198 | elseif Psi(i, n, m) == 1 199 | recordPowerOffload(i, n, m) = B*N0/g(Psi(i, n, m))*(exp(J*x(Psi(i), n, m))-1); 200 | end 201 | end 202 | end 203 | end 204 | 205 | figure(2) 206 | for i = 1:U 207 | for m = 1:M 208 | stem3(i*ones(N, 1), (1:N), recordPowerOffload(i, :, m)); 209 | hold on 210 | end 211 | end 212 | xlabel('User Index') 213 | ylabel('Time Slot') 214 | zlabel('Offloading Power') 215 | 216 | -------------------------------------------------------------------------------- /M3_prototype_SCA.m: -------------------------------------------------------------------------------- 1 | clear all 2 | close all 3 | % This script describes a NOMA-assisted MEC system on UAV according to doc 'Model 1.pages'. 4 | % Created and copyrighted by ZHANG Xiaochen at 10:22 a.m., Apr. 12, 2019. 5 | 6 | %% Setup of the Model 7 | 8 | % Consider U terrestrial users located in a area 9 | U = 8; % Number of users/SMDs 10 | 11 | % The size of the area is defined by: 12 | lengthArea = 1000; % Length of the coverage area (m) 13 | widthArea = 1000; % Width of the coverage area (m) 14 | 15 | % U SMDs are uniformly distributed in the rectangular coverage area. 16 | % rUser = [lengthArea*rand(U, 1),widthArea*rand(U, 1), zeros(U, 1)]; 17 | % rUser = [100*(2:2:8).', 100*8*ones(U, 1), zeros(U, 1)]; 18 | % rUser = [[400,400,600,600].', [600,800,600,800].',zeros(U, 1)]; 19 | % rUser = [[100,500,800,600].', [600,600,600,800].',zeros(U, 1)]; 20 | rUser = [kron(100*(2:2:8).',ones(2,1)), ... 21 | repmat([600, 800].', 4, 1),... 22 | zeros(U, 1)]; 23 | 24 | 25 | 26 | % Divide the time interval into N tme slots. 27 | T = 100; % Length of interval 28 | N = 20; % Number of time slots 29 | tau = T/N; % Duration of each time slot 30 | 31 | % Set the initial trajectory of UAV 32 | M = 2; 33 | hUAV = 20; % Flying altitude of UAV 34 | rI = [0, 0, hUAV; 0, 0, hUAV]; % Intial position of the UAV (M*3) 35 | rF = [lengthArea, 0, hUAV; 0, widthArea, hUAV]; % Final position of the UAV 36 | 37 | rUAV = zeros(N, 3, M); % Trajectory vector of the UAV 38 | 39 | % rUAV is a N*3 matrix of which each describes the 3-D coordinates of UAV 40 | % at each time slot. 41 | for m = 1:M 42 | rUAV(N, :, m) = rF(m, :); 43 | end 44 | for n = 1:N-1 45 | for m = 1:M 46 | rUAV(n, :, m) = rI(m, :)+n/N*(rF(m, :)-rI(m, :)); 47 | end 48 | end 49 | 50 | % Plot the configuration of the model 51 | figure(1) 52 | scatter(rUser(:, 1), rUser(:, 2)); 53 | hold on 54 | stem(rUAV(:, 1, 1), rUAV(:, 2, 1)); 55 | hold on 56 | stem(rUAV(:, 1, 2), rUAV(:, 2, 2)); 57 | 58 | title('Location of SMDs and Trajectory of the UAV') 59 | xlabel('Length/m') 60 | ylabel('Width/m') 61 | axis([0 lengthArea 0 widthArea]) 62 | 63 | % Find the channel gain for each user in each time slot 64 | g = zeros(U, N, M); % Channel gain matrix 65 | L = zeros(U, N, M); % Path loss matrix 66 | % g is a U*N matrix denoting the channel gains for all links throughout the interval. 67 | 68 | for i = 1:U 69 | for n = 1:N 70 | for m = 1:M 71 | [g(i, n, m), L(i, n, m)] = chanGainFSPL(rUAV(n, :, m), rUser(i, :)); 72 | end 73 | end 74 | end 75 | 76 | omegaUser = 0.8; 77 | omegaUAV = 1-omegaUser; 78 | 79 | N0 = 1e-17; % Power spectral density of AWGN (W/Hz) 80 | B = 4e6; % System bandwidth (Hz) 81 | 82 | D = 120*ones(U, 1); % Number of bits for each SMDs to finish (Mbit) 83 | kappa = 1e-28; % Effective swiched capacitance of CPU 84 | 85 | fmaxUAV = 20; % Maximum CPU frequency of MEC server (GHz) 86 | fminUAV = 0; % Minimum CPU frequency of SMDs (GHz) 87 | CUAV = 1e3; % Processing density of MEC server (Hz/bit) 88 | 89 | fmaxUser = 1; % Maximum CPU frequency of SMDs (GHz) 90 | fminUser = 0; % Minimum CPU frequency of SMDs (GHz) 91 | CUser = 1e3; % Processing density of SMD (Hz/bit) 92 | 93 | %% Resource Allocation (RA) for Offloading and Computation 94 | gRank = zeros(U, N, M); 95 | rank = zeros(U, N, M); 96 | Psi = zeros(U, N, M); 97 | beta = zeros(U+2, N, M); 98 | mu = zeros(U+1, N, M); 99 | 100 | for m = 1:M 101 | [gRank(:, :, m), rank(:, :, m), Psi(:, :, m)] = chanRank(g(:, :, m), U, N); 102 | 103 | beta(2:(U+1), :, m) = 1./gRank(:, :, m); 104 | 105 | for k = 1:U+1 106 | mu(k, :, m) = -beta(k+1, :, m)+beta(k, :, m); 107 | end 108 | end 109 | % rank gives a list of user index. Its value denotes the user index with that ranking, 110 | % i.e. rank(k, n) means the index of user with the k-th smallest channel gain at time n. 111 | % Psi helps track the rankings of users, 112 | % i.e. Psi(i, n) denotes the ranking of user i at time n. 113 | 114 | % beta is a (U+2)*N matrix. 115 | 116 | mu = mu/(1e9); 117 | J = log(2)/(B*tau); 118 | J = J*1e6; 119 | c1 = omegaUser*kappa*tau*1e27; 120 | c2 = omegaUser*B*N0*1e9; 121 | c3 = omegaUAV*kappa*tau*1e27; 122 | 123 | % Solve the convex optimization problem: Posynomial + Sum of exp 124 | 125 | xmin = 0; 126 | x0 = zeros(U, N, M); 127 | pmax = 10; 128 | pmin = 0; 129 | eta0 = 0; 130 | 131 | while 1 132 | 133 | cvx_begin 134 | variable x(U, N, M) nonnegative 135 | variable fUser(U, N) nonnegative 136 | variable fUAV(U, N, M) nonnegative 137 | variable threshold 138 | variable userRate(U, N, M) 139 | eta = 0; 140 | expressions pUser(U, N) 141 | 142 | for i = 1:U 143 | for n = 1:N 144 | pUser(i, n) = 0; 145 | end 146 | end 147 | 148 | 149 | for i = 1:U 150 | for n = 1:N 151 | for m = 1:M 152 | if Psi(i, n, m) == 1 153 | pUser(i, n) = pUser(i, n)+B*N0/g(i, n, m)*(exp(J*x(Psi(i, n, m), n, m))-1); 154 | elseif Psi(i, n, m) > 1 155 | pUser(i, n) = pUser(i, n)+B*N0/g(i, n, m)*(... 156 | exp(J*x(Psi(i, n, m), n, m))-... 157 | (... 158 | exp(J*x0(Psi(i, n, m)-1, n, m))+J*exp(J*x0(Psi(i, n, m)-1, n, m))*(x(Psi(i, n, m)-1, n, m)-x0(Psi(i, n, m)-1, n, m))... 159 | )... 160 | ); 161 | end 162 | end 163 | end 164 | end 165 | 166 | for i = 1:U 167 | for n = 1:N 168 | for m = 1:M 169 | if Psi(i, n, m) > 1 170 | userRate(i, n, m) == x(Psi(i, n, m), n, m)-x(Psi(i, n, m)-1, n, m); 171 | elseif Psi(i, n, m) == 1 172 | userRate(i, n, m) == x(Psi(i, n, m), n, m); 173 | end 174 | end 175 | end 176 | end 177 | 178 | for m = 1:M 179 | eta = eta+c2*sum(sum(mu(2:end, :, m).*exp(J*x(:, :, m)))) +... 180 | c2*sum(mu(1, :, m)); 181 | end 182 | eta = eta+c1*sum(sum(pow_p(fUser, 3))) +... 183 | c3*sum(sum(sum(pow_p(fUAV, 3)))); 184 | minimize( threshold ) 185 | subject to 186 | % C0: Objective function 187 | eta<= threshold; 188 | % C1: CPU frequency constraint on SMDs 189 | fminUser <= fUser; 190 | fUser <= fmaxUser; 191 | 192 | % C2: CPU frequency constraint on MEC server 193 | for m = 1:M 194 | fminUAV <= sum(fUAV(:, :, m), 1); 195 | sum(fUAV(:, :, m), 1) <= fmaxUAV; 196 | end 197 | 198 | % C3: Offloading rate/power constraint on SMDs 199 | for k = 2:U 200 | for n = 1:N 201 | for m = 1:M 202 | x(k, n, m) >= x(k-1, n, m); 203 | end 204 | end 205 | end 206 | 207 | pUser <= pmax; 208 | 209 | % C4: Accomplishment of computation tasks 210 | D <= 1000*tau/CUser*sum(fUser, 2)+1000*tau/CUAV*sum(sum(fUAV(:, 2:end, :), 3), 2); 211 | 212 | % C5&C6: Causal constraint on offloading and edge computing 213 | 214 | for i = 1:U 215 | for n = 2:N 216 | for m = 1:M 217 | sum(userRate(i, (1:n-1), m)) >= tau/CUAV*1000*sum(fUAV(i, (2:n), m)); 218 | end 219 | end 220 | end 221 | 222 | cvx_end 223 | 224 | if abs(eta-eta0) <= 1e-3 225 | break 226 | end 227 | 228 | x0 = x; 229 | eta0 = eta; 230 | end 231 | 232 | % Record the offloading power of each user in each time slot. 233 | recordPowerOffload = zeros(U, N, M); 234 | for i = 1:U 235 | for n = 1:N 236 | for m = 1:M 237 | if Psi(i, n, m) > 1 238 | recordPowerOffload(i, n, m) = B*N0/g(i, n, m)*(exp(J*x(Psi(i, n, m), n, m))-exp(J*x(Psi(i, n, m)-1, n, m))); 239 | elseif Psi(i, n, m) == 1 240 | recordPowerOffload(i, n, m) = B*N0/g(i, n, m)*(exp(J*x(Psi(i), n, m))-1); 241 | end 242 | end 243 | end 244 | end 245 | 246 | figure(2) 247 | for i = 1:U 248 | stem3(i*ones(N, 1), (1:N), recordPowerOffload(i, :)); 249 | hold on 250 | end 251 | xlabel('User Index') 252 | ylabel('Time Slot') 253 | zlabel('Offloading Power') 254 | 255 | figure(3) 256 | for i = 1:U 257 | stem3(i*ones(N, 1), (1:N), pUser(i, :)); 258 | hold on 259 | end 260 | xlabel('User Index') 261 | ylabel('Time Slot') 262 | zlabel('Offloading Power') 263 | -------------------------------------------------------------------------------- /experiment0_OMA.m: -------------------------------------------------------------------------------- 1 | function [power_OMA, rUAV_OMA, utility_OMA, fUAV_OMA, fUser_OMA] = experiment0_OMA(rUser) 2 | 3 | %% Setup of the Model 4 | 5 | % Consider U terrestrial users located in a area 6 | U = 8; % Number of users/SMDs 7 | 8 | % The size of the area is defined by: 9 | lengthArea = 1000; % Length of the coverage area (m) 10 | widthArea = 1000; % Width of the coverage area (m) 11 | 12 | % U SMDs are uniformly distributed in the rectangular coverage area. 13 | 14 | 15 | % Divide the time interval into N tme slots. 16 | T = 100; % Length of interval 17 | N = 20; % Number of time slots 18 | tau = T/N; % Duration of each time slot 19 | 20 | % Set the initial trajectory of UAV 21 | M = 2; 22 | hUAV = 50; % Flying altitude of UAV 23 | rI = [0, 0, hUAV; 0, 0, hUAV]; % Intial position of the UAV (M*3) 24 | rF = [lengthArea, 0, hUAV; 0, widthArea, hUAV]; % Final position of the UAV 25 | 26 | rUAV = zeros(N, 3, M); % Trajectory vector of the UAV 27 | 28 | % rUAV(time, dimension, UAV index) is a N*3*M matrix of which each describes the 3-D coordinates of UAVs 29 | % at each time slot. 30 | 31 | for m = 1:M 32 | rUAV(N, :, m) = rF(m, :); 33 | end 34 | for n = 1:N-1 35 | for m = 1:M 36 | rUAV(n, :, m) = rI(m, :)+n/N*(rF(m, :)-rI(m, :)); 37 | end 38 | end 39 | 40 | % Other parameters involved in the model. 41 | 42 | omegaUser = 0.8; % Weight factor of users 43 | omegaUAV = 1-omegaUser; % Weight factor of UAVs 44 | 45 | N0 = 1e-17; % Power spectral density of AWGN (W/Hz) 46 | B = 4e6; % System bandwidth (Hz) 47 | 48 | D = 120*ones(U, 1); % Number of bits for each SMDs to finish (Mbit) 49 | kappa = 1e-28; % Effective swiched capacitance of CPU 50 | 51 | fmaxUAV = 20; % Maximum CPU frequency of MEC server (GHz) 52 | fminUAV = 0; % Minimum CPU frequency of SMDs (GHz) 53 | CUAV = 1e3; % Processing density of MEC server (Hz/bit) 54 | 55 | fmaxUser = 1; % Maximum CPU frequency of SMDs (GHz) 56 | fminUser = 0; % Minimum CPU frequency of SMDs (GHz) 57 | CUser = 1e3; % Processing density of SMD (Hz/bit) 58 | 59 | J = log(2)/(B*tau); 60 | J = J*1e6; 61 | 62 | vmax = 15; % Maximum flying speed of UAV (m/sec) 63 | alpha = 2; % Path loss factor 64 | fc = 2e9; % Carrier frequency (Hz) 65 | c = 3e8; % Speed of light (m/sec) 66 | Q = (4*pi*fc/c)^alpha; 67 | gamma = 1e-4; 68 | W = 10; % Mass of UAV (kg) 69 | 70 | c1 = omegaUser*kappa*tau*1e27; 71 | c2 = omegaUser*B*N0*1e9; 72 | c3 = omegaUAV*kappa*tau*1e27; 73 | 74 | %% Approximation of channel gain by curve fitting 75 | a = 11.95; 76 | b = 0.14; 77 | 78 | etaLoS = 10^(1/10); 79 | etaNLoS = 10^(20/10); 80 | 81 | d = hUAV:1000; 82 | L = (... 83 | 1./(... 84 | 1+a*exp(... 85 | -180*b/pi*asin(hUAV./d)+a*b... 86 | )... 87 | )*(etaLoS-etaNLoS)+etaNLoS... 88 | )... 89 | .*(4*pi*fc*d/c).^2; 90 | 91 | [curvePoly, goodness, output] = fit(d.', L.', 'poly2'); 92 | 93 | p1 = curvePoly.p1; 94 | p2 = curvePoly.p2; 95 | p3 = curvePoly.p3; 96 | 97 | %% Joint Optimization of Resource Allocation and Trajectory Scheduling 98 | 99 | maxIteration = 15; 100 | utilitySeq = zeros(maxIteration, 1); 101 | numIteration = 1; % Number of iteration 102 | 103 | pmax = 10; % Maximum offloading power for SMDs. 104 | pmin = 0; 105 | xmin = 0; 106 | 107 | %% Find the channel gain for each link between UAVs and users in each time slot 108 | g = zeros(U, N, M); % Channel gain matrix 109 | L = zeros(U, N, M); % Path loss matrix 110 | % g is a U*N matrix denoting the channel gains for all links throughout the interval. 111 | 112 | for i = 1:U 113 | for n = 1:N 114 | for m = 1:M 115 | [g(i, n, m), L(i, n, m)] = chanGain(rUAV(n, :, m), rUser(i, :)); 116 | end 117 | end 118 | end 119 | 120 | %% Resource Allocation (RA) for Offloading and Computation 121 | 122 | cvx_begin 123 | variable fUser(U, N) nonnegative 124 | variable fUAV(U, N, M) nonnegative 125 | variable threshold 126 | variable userRate(U, N, M) 127 | expressions offloadPower(U, N M) 128 | for m = 1:M 129 | for n = 1:N 130 | for i = 1:U 131 | offloadPower(i, n, m) = B*N0/(g(i, n, m)*U)*(exp(U*J*userRate(i, n, m))-1); 132 | end 133 | end 134 | end 135 | 136 | eta = omegaUser*sum(sum(sum(offloadPower, 3)))+c1*sum(sum(pow_p(fUser, 3))) +... 137 | c3*sum(sum(sum(pow_p(fUAV, 3)))); 138 | minimize( threshold ) 139 | subject to 140 | % C0: Objective function 141 | eta<= threshold; 142 | % C1: CPU frequency constraint on SMDs 143 | fminUser <= fUser; 144 | fUser <= fmaxUser; 145 | 146 | % C2: CPU frequency constraint on MEC server 147 | for m = 1:M 148 | fminUAV <= sum(fUAV(:, :, m), 1); 149 | sum(fUAV(:, :, m), 1) <= fmaxUAV; 150 | end 151 | 152 | % C3: Offloading rate/power constraint on SMDs 153 | sum(offloadPower, 3) <= pmax; 154 | userRate>=0; 155 | 156 | % C4: Accomplishment of computation tasks 157 | D <= 1000*tau/CUser*sum(fUser, 2)+1000*tau/CUAV*sum(sum(fUAV(:, 2:end, :), 3), 2); 158 | 159 | % C5&C6: Causal constraint on offloading and edge computing 160 | 161 | for i = 1:U 162 | for n = 2:N 163 | for m = 1:M 164 | sum(userRate(i, (1:n-1), m)) >= tau/CUAV*1000*sum(fUAV(i, (2:n), m)); 165 | end 166 | end 167 | end 168 | 169 | cvx_end 170 | 171 | %% Iteration begins 172 | while 1 173 | %% Optimization of UAV Trajectory Scheduling 174 | chi = zeros(U, N, M); 175 | % chi is an U*N*M matrix. 176 | for m= 1:M 177 | for i = 1:U 178 | for n = 1:N 179 | chi(i, n, m) = omegaUser*1e10*B*N0/U*(exp(U*J*userRate(i, n, m))-1); 180 | end 181 | end 182 | end 183 | 184 | for k = 1:U 185 | for n = 1:N 186 | for m = 1:M 187 | if chi(k, n, m) <= 1e-6 188 | chi(k, n, m) = 0; 189 | end 190 | end 191 | end 192 | end 193 | 194 | cvx_begin 195 | variable r1(N, M) 196 | variable r2(N, M) 197 | variable threshold2 198 | Emove = 0; 199 | for m = 1:M 200 | Emove = Emove + square_pos((r1(1, m)-rI(m, 1))/tau)+square_pos((r2(1, m)-rI(m, 2))/tau); 201 | for n = 2:N 202 | Emove = Emove+square_pos((r1(n, m)-r1(n-1 ,m))/tau)+square_pos((r2(n, m)-r2(n-1 ,m))/tau); 203 | end 204 | end 205 | Emove = omegaUAV*gamma*tau*W/2*Emove; 206 | 207 | Eoffload = 0; 208 | for n = 1:N 209 | for i = 1:U 210 | for m = 1:M 211 | Eoffload = Eoffload+chi(k, n, m).*... 212 | (... 213 | p1*square_pos... 214 | (... 215 | norm([r1(n, m),r2(n, m),hUAV]-[rUser(i, 1), rUser(i, 2), 0])... 216 | )... 217 | +p2*norm([r1(n, m),r2(n, m),hUAV]-[rUser(i, 1), rUser(i, 2), 0])... 218 | +p3... 219 | )/(1e10); 220 | end 221 | end 222 | end 223 | 224 | 225 | minimize threshold2 226 | subject to 227 | 228 | Emove + Eoffload <= threshold2; 229 | 230 | 0 <= r1 <= lengthArea; 231 | 0 <= r2 <= widthArea; 232 | 233 | 234 | for m = 1:M 235 | r1(N, m) == rF(m, 1); 236 | r2(N, m) == rF(m, 2); 237 | (r1(1, m)-rI(m, 1))^2+(r2(1, m)-rI(m, 2))^2 <= (vmax*tau)^2; 238 | for n = 2:N 239 | (r1(n, m)-r1(n-1, m))^2+(r2(n, m)-r2(n-1, m))^2 <= (vmax*tau)^2; 240 | end 241 | end 242 | 243 | 244 | cvx_end 245 | 246 | % Update the UAV trajectory. 247 | for m = 1:M 248 | rUAV(:, 1, m) = r1(:, m); 249 | rUAV(:, 2, m) = r2(:, m); 250 | end 251 | 252 | %% Find the channel gain for each link between UAVs and users in each time slot 253 | g = zeros(U, N, M); % Channel gain matrix 254 | L = zeros(U, N, M); % Path loss matrix 255 | % g is a U*N matrix denoting the channel gains for all links throughout the interval. 256 | 257 | for i = 1:U 258 | for n = 1:N 259 | for m = 1:M 260 | [g(i, n, m), L(i, n, m)] = chanGain(rUAV(n, :, m), rUser(i, :)); 261 | end 262 | end 263 | end 264 | 265 | 266 | %% Resource Allocation (RA) for Offloading and Computation 267 | cvx_begin 268 | variable fUser(U, N) nonnegative 269 | variable fUAV(U, N, M) nonnegative 270 | variable threshold 271 | variable userRate(U, N, M) 272 | expressions offloadPower(U, N M) 273 | for m = 1:M 274 | for n = 1:N 275 | for i = 1:U 276 | offloadPower(i, n, m) = B*N0/(g(i, n, m)*U)*(exp(U*J*userRate(i, n, m))-1); 277 | end 278 | end 279 | end 280 | 281 | eta = omegaUser*sum(sum(sum(offloadPower, 3)))+c1*sum(sum(pow_p(fUser, 3))) +... 282 | c3*sum(sum(sum(pow_p(fUAV, 3)))); 283 | minimize( threshold ) 284 | subject to 285 | % C0: Objective function 286 | eta<= threshold; 287 | % C1: CPU frequency constraint on SMDs 288 | fminUser <= fUser; 289 | fUser <= fmaxUser; 290 | 291 | % C2: CPU frequency constraint on MEC server 292 | for m = 1:M 293 | fminUAV <= sum(fUAV(:, :, m), 1); 294 | sum(fUAV(:, :, m), 1) <= fmaxUAV; 295 | end 296 | 297 | % C3: Offloading rate/power constraint on SMDs 298 | sum(offloadPower, 3) <= pmax; 299 | userRate>=0; 300 | 301 | % C4: Accomplishment of computation tasks 302 | D <= 1000*tau/CUser*sum(fUser, 2)+1000*tau/CUAV*sum(sum(fUAV(:, 2:end, :), 3), 2); 303 | 304 | % C5&C6: Causal constraint on offloading and edge computing 305 | 306 | for i = 1:U 307 | for n = 2:N 308 | for m = 1:M 309 | sum(userRate(i, (1:n-1), m)) >= tau/CUAV*1000*sum(fUAV(i, (2:n), m)); 310 | end 311 | end 312 | end 313 | 314 | cvx_end 315 | 316 | %% Update the weighted system 317 | % Update the each term of weighted system utility. 318 | E_user_offload = omegaUser*sum(sum(sum(offloadPower))); 319 | 320 | E_user_comp = c1*sum(sum(fUser.^3)); 321 | E_uav_comp = c3*sum(sum(sum(fUAV.^3))); 322 | E_uav_move = Emove; 323 | 324 | % Update the weighted system utility. 325 | utilitySeq(numIteration) = E_user_comp+E_user_offload+E_uav_comp+E_uav_move; 326 | 327 | % Check the convergence of the algorithm to break the 'while' loop. 328 | if numIteration > 1 329 | if abs(utilitySeq(numIteration)-utilitySeq(numIteration-1)) <= 1 330 | break 331 | end 332 | end 333 | 334 | if numIteration == maxIteration 335 | break 336 | end 337 | 338 | numIteration = numIteration+1 339 | end 340 | 341 | recordOffloadPower = sum(offloadPower, 3); 342 | power_OMA = recordOffloadPower; 343 | rUAV_OMA = rUAV; 344 | % utilitySeq_OMA = utilitySeq(1: numIteration); 345 | fUAV_OMA = fUAV; 346 | fUser_OMA = fUser; 347 | utility_OMA = [E_user_offload, E_user_comp, E_uav_comp, E_uav_move]; 348 | 349 | end 350 | -------------------------------------------------------------------------------- /M3_OMA.m: -------------------------------------------------------------------------------- 1 | clear all 2 | close all 3 | % This script describes a NOMA-assisted MEC system on UAV according to doc 'Model 1.pages'. 4 | % Created and copyrighted by ZHANG Xiaochen at 10:22 a.m., Apr. 12, 2019. 5 | 6 | %% Setup of the Model 7 | 8 | % Consider U terrestrial users located in a area 9 | U = 8; % Number of users/SMDs 10 | 11 | % The size of the area is defined by: 12 | lengthArea = 1000; % Length of the coverage area (m) 13 | widthArea = 1000; % Width of the coverage area (m) 14 | 15 | % U SMDs are uniformly distributed in the rectangular coverage area. 16 | rUser = [lengthArea*rand(U, 1),widthArea*rand(U, 1), zeros(U, 1)]; 17 | % rUser = [100*(2:2:8).', 100*8*ones(U, 1), zeros(U, 1)]; 18 | % rUser = [[400,400,600,600].', [600,800,600,800].',zeros(U, 1)]; 19 | % rUser = [[100,500,800,600].', [600,600,600,800].',zeros(U, 1)]; 20 | rUser = [kron(100*(2:2:8).',ones(2,1)), ... 21 | repmat([600, 800].', 4, 1),... 22 | zeros(U, 1)]; 23 | 24 | 25 | 26 | % Divide the time interval into N tme slots. 27 | T = 100; % Length of interval 28 | N = 20; % Number of time slots 29 | tau = T/N; % Duration of each time slot 30 | 31 | % Set the initial trajectory of UAV 32 | M = 2; 33 | hUAV = 50; % Flying altitude of UAV 34 | rI = [0, 0, hUAV; 0, 0, hUAV]; % Intial position of the UAV (M*3) 35 | rF = [lengthArea, 0, hUAV; 0, widthArea, hUAV]; % Final position of the UAV 36 | 37 | rUAV = zeros(N, 3, M); % Trajectory vector of the UAV 38 | 39 | % rUAV(time, dimension, UAV index) is a N*3*M matrix of which each describes the 3-D coordinates of UAVs 40 | % at each time slot. 41 | 42 | for m = 1:M 43 | rUAV(N, :, m) = rF(m, :); 44 | end 45 | for n = 1:N-1 46 | for m = 1:M 47 | rUAV(n, :, m) = rI(m, :)+n/N*(rF(m, :)-rI(m, :)); 48 | end 49 | end 50 | 51 | % Other parameters involved in the model. 52 | 53 | omegaUser = 0.8; % Weight factor of users 54 | omegaUAV = 1-omegaUser; % Weight factor of UAVs 55 | 56 | N0 = 1e-17; % Power spectral density of AWGN (W/Hz) 57 | B = 4e6; % System bandwidth (Hz) 58 | 59 | D = 120*ones(U, 1); % Number of bits for each SMDs to finish (Mbit) 60 | kappa = 1e-28; % Effective swiched capacitance of CPU 61 | 62 | fmaxUAV = 20; % Maximum CPU frequency of MEC server (GHz) 63 | fminUAV = 0; % Minimum CPU frequency of SMDs (GHz) 64 | CUAV = 1e3; % Processing density of MEC server (Hz/bit) 65 | 66 | fmaxUser = 1; % Maximum CPU frequency of SMDs (GHz) 67 | fminUser = 0; % Minimum CPU frequency of SMDs (GHz) 68 | CUser = 1e3; % Processing density of SMD (Hz/bit) 69 | 70 | J = log(2)/(B*tau); 71 | J = J*1e6; 72 | 73 | vmax = 15; % Maximum flying speed of UAV (m/sec) 74 | alpha = 2; % Path loss factor 75 | fc = 2e9; % Carrier frequency (Hz) 76 | c = 3e8; % Speed of light (m/sec) 77 | Q = (4*pi*fc/c)^alpha; 78 | gamma = 1e-4; 79 | W = 10; % Mass of UAV (kg) 80 | 81 | c1 = omegaUser*kappa*tau*1e27; 82 | c2 = omegaUser*B*N0*1e9; 83 | c3 = omegaUAV*kappa*tau*1e27; 84 | 85 | %% Approximation of channel gain by curve fitting 86 | a = 11.95; 87 | b = 0.14; 88 | 89 | etaLoS = 10^(1/10); 90 | etaNLoS = 10^(20/10); 91 | 92 | d = hUAV:1000; 93 | L = (... 94 | 1./(... 95 | 1+a*exp(... 96 | -180*b/pi*asin(hUAV./d)+a*b... 97 | )... 98 | )*(etaLoS-etaNLoS)+etaNLoS... 99 | )... 100 | .*(4*pi*fc*d/c).^2; 101 | 102 | [curvePoly, goodness, output] = fit(d.', L.', 'poly2'); 103 | 104 | p1 = curvePoly.p1; 105 | p2 = curvePoly.p2; 106 | p3 = curvePoly.p3; 107 | 108 | %% Joint Optimization of Resource Allocation and Trajectory Scheduling 109 | 110 | maxIteration = 15; 111 | utilitySeq = zeros(maxIteration, 1); 112 | numIteration = 1; % Number of iteration 113 | 114 | pmax = 10; % Maximum offloading power for SMDs. 115 | pmin = 0; 116 | xmin = 0; 117 | 118 | %% Find the channel gain for each link between UAVs and users in each time slot 119 | g = zeros(U, N, M); % Channel gain matrix 120 | L = zeros(U, N, M); % Path loss matrix 121 | % g is a U*N matrix denoting the channel gains for all links throughout the interval. 122 | 123 | for i = 1:U 124 | for n = 1:N 125 | for m = 1:M 126 | [g(i, n, m), L(i, n, m)] = chanGain(rUAV(n, :, m), rUser(i, :)); 127 | end 128 | end 129 | end 130 | 131 | %% Resource Allocation (RA) for Offloading and Computation 132 | 133 | cvx_begin 134 | variable fUser(U, N) nonnegative 135 | variable fUAV(U, N, M) nonnegative 136 | variable threshold 137 | variable userRate(U, N, M) 138 | expressions offloadPower(U, N M) 139 | for m = 1:M 140 | for n = 1:N 141 | for i = 1:U 142 | offloadPower(i, n, m) = B*N0/(g(i, n, m)*U)*(exp(U*J*userRate(i, n, m))-1); 143 | end 144 | end 145 | end 146 | 147 | eta = omegaUser*sum(sum(sum(offloadPower, 3)))+c1*sum(sum(pow_p(fUser, 3))) +... 148 | c3*sum(sum(sum(pow_p(fUAV, 3)))); 149 | minimize( threshold ) 150 | subject to 151 | % C0: Objective function 152 | eta<= threshold; 153 | % C1: CPU frequency constraint on SMDs 154 | fminUser <= fUser; 155 | fUser <= fmaxUser; 156 | 157 | % C2: CPU frequency constraint on MEC server 158 | for m = 1:M 159 | fminUAV <= sum(fUAV(:, :, m), 1); 160 | sum(fUAV(:, :, m), 1) <= fmaxUAV; 161 | end 162 | 163 | % C3: Offloading rate/power constraint on SMDs 164 | sum(offloadPower, 3) <= pmax; 165 | userRate>=0; 166 | 167 | % C4: Accomplishment of computation tasks 168 | D <= 1000*tau/CUser*sum(fUser, 2)+1000*tau/CUAV*sum(sum(fUAV(:, 2:end, :), 3), 2); 169 | 170 | % C5&C6: Causal constraint on offloading and edge computing 171 | 172 | for i = 1:U 173 | for n = 2:N 174 | for m = 1:M 175 | sum(userRate(i, (1:n-1), m)) >= tau/CUAV*1000*sum(fUAV(i, (2:n), m)); 176 | end 177 | end 178 | end 179 | 180 | cvx_end 181 | 182 | %% Iteration begins 183 | while 1 184 | %% Optimization of UAV Trajectory Scheduling 185 | chi = zeros(U, N, M); 186 | % chi is an U*N*M matrix. 187 | for m= 1:M 188 | for i = 1:U 189 | for n = 1:N 190 | chi(i, n, m) = omegaUser*1e10*B*N0/U*(exp(U*J*userRate(i, n, m))-1); 191 | end 192 | end 193 | end 194 | 195 | for k = 1:U 196 | for n = 1:N 197 | for m = 1:M 198 | if chi(k, n, m) <= 1e-6 199 | chi(k, n, m) = 0; 200 | end 201 | end 202 | end 203 | end 204 | 205 | cvx_begin 206 | variable r1(N, M) 207 | variable r2(N, M) 208 | variable threshold2 209 | Emove = 0; 210 | for m = 1:M 211 | Emove = Emove + square_pos((r1(1, m)-rI(m, 1))/tau)+square_pos((r2(1, m)-rI(m, 2))/tau); 212 | for n = 2:N 213 | Emove = Emove+square_pos((r1(n, m)-r1(n-1 ,m))/tau)+square_pos((r2(n, m)-r2(n-1 ,m))/tau); 214 | end 215 | end 216 | Emove = omegaUAV*gamma*tau*W/2*Emove; 217 | 218 | Eoffload = 0; 219 | for n = 1:N 220 | for i = 1:U 221 | for m = 1:M 222 | Eoffload = Eoffload+chi(k, n, m).*... 223 | (... 224 | p1*square_pos... 225 | (... 226 | norm([r1(n, m),r2(n, m),hUAV]-[rUser(i, 1), rUser(i, 2), 0])... 227 | )... 228 | +p2*norm([r1(n, m),r2(n, m),hUAV]-[rUser(i, 1), rUser(i, 2), 0])... 229 | +p3... 230 | )/(1e10); 231 | end 232 | end 233 | end 234 | 235 | 236 | minimize threshold2 237 | subject to 238 | 239 | Emove + Eoffload <= threshold2; 240 | 241 | 0 <= r1 <= lengthArea; 242 | 0 <= r2 <= widthArea; 243 | 244 | 245 | for m = 1:M 246 | r1(N, m) == rF(m, 1); 247 | r2(N, m) == rF(m, 2); 248 | (r1(1, m)-rI(m, 1))^2+(r2(1, m)-rI(m, 2))^2 <= (vmax*tau)^2; 249 | for n = 2:N 250 | (r1(n, m)-r1(n-1, m))^2+(r2(n, m)-r2(n-1, m))^2 <= (vmax*tau)^2; 251 | end 252 | end 253 | 254 | 255 | cvx_end 256 | 257 | % Update the UAV trajectory. 258 | for m = 1:M 259 | rUAV(:, 1, m) = r1(:, m); 260 | rUAV(:, 2, m) = r2(:, m); 261 | end 262 | 263 | %% Find the channel gain for each link between UAVs and users in each time slot 264 | g = zeros(U, N, M); % Channel gain matrix 265 | L = zeros(U, N, M); % Path loss matrix 266 | % g is a U*N matrix denoting the channel gains for all links throughout the interval. 267 | 268 | for i = 1:U 269 | for n = 1:N 270 | for m = 1:M 271 | [g(i, n, m), L(i, n, m)] = chanGain(rUAV(n, :, m), rUser(i, :)); 272 | end 273 | end 274 | end 275 | 276 | 277 | %% Resource Allocation (RA) for Offloading and Computation 278 | cvx_begin 279 | variable fUser(U, N) nonnegative 280 | variable fUAV(U, N, M) nonnegative 281 | variable threshold 282 | variable userRate(U, N, M) 283 | expressions offloadPower(U, N M) 284 | for m = 1:M 285 | for n = 1:N 286 | for i = 1:U 287 | offloadPower(i, n, m) = B*N0/(g(i, n, m)*U)*(exp(U*J*userRate(i, n, m))-1); 288 | end 289 | end 290 | end 291 | 292 | eta = omegaUser*sum(sum(sum(offloadPower, 3)))+c1*sum(sum(pow_p(fUser, 3))) +... 293 | c3*sum(sum(sum(pow_p(fUAV, 3)))); 294 | minimize( threshold ) 295 | subject to 296 | % C0: Objective function 297 | eta<= threshold; 298 | % C1: CPU frequency constraint on SMDs 299 | fminUser <= fUser; 300 | fUser <= fmaxUser; 301 | 302 | % C2: CPU frequency constraint on MEC server 303 | for m = 1:M 304 | fminUAV <= sum(fUAV(:, :, m), 1); 305 | sum(fUAV(:, :, m), 1) <= fmaxUAV; 306 | end 307 | 308 | % C3: Offloading rate/power constraint on SMDs 309 | sum(offloadPower, 3) <= pmax; 310 | userRate>=0; 311 | 312 | % C4: Accomplishment of computation tasks 313 | D <= 1000*tau/CUser*sum(fUser, 2)+1000*tau/CUAV*sum(sum(fUAV(:, 2:end, :), 3), 2); 314 | 315 | % C5&C6: Causal constraint on offloading and edge computing 316 | 317 | for i = 1:U 318 | for n = 2:N 319 | for m = 1:M 320 | sum(userRate(i, (1:n-1), m)) >= tau/CUAV*1000*sum(fUAV(i, (2:n), m)); 321 | end 322 | end 323 | end 324 | 325 | cvx_end 326 | 327 | %% Update the weighted system 328 | % Update the each term of weighted system utility. 329 | E_user_offload = omegaUser*sum(sum(sum(offloadPower))); 330 | 331 | E_user_comp = c1*sum(sum(fUser.^3)); 332 | E_uav_comp = c3*sum(sum(sum(fUAV.^3))); 333 | E_uav_move = Emove; 334 | 335 | % Update the weighted system utility. 336 | utilitySeq(numIteration) = E_user_comp+E_user_offload+E_uav_comp+E_uav_move; 337 | 338 | % Check the convergence of the algorithm to break the 'while' loop. 339 | if numIteration > 1 340 | if abs(utilitySeq(numIteration)-utilitySeq(numIteration-1)) <= 1 341 | break 342 | end 343 | end 344 | 345 | if numIteration == maxIteration 346 | break 347 | end 348 | 349 | numIteration = numIteration+1 350 | end 351 | 352 | % Plot the configuration of the model 353 | figure(1) 354 | scatter(rUser(:, 1), rUser(:, 2)); 355 | hold on 356 | stem(rUAV(:, 1, 1), rUAV(:, 2, 1)); 357 | hold on 358 | stem(rUAV(:, 1, 2), rUAV(:, 2, 2)); 359 | 360 | title('Location of SMDs and Trajectory of the UAV') 361 | xlabel('Length/m') 362 | ylabel('Width/m') 363 | axis([0 lengthArea 0 widthArea]) 364 | 365 | figure(2) 366 | recordOffloadPower = sum(offloadPower, 3); 367 | 368 | for i = 1:U 369 | stem3(i*ones(N, 1), (1:N), recordOffloadPower(i, :)); 370 | hold on 371 | end 372 | xlabel('User Index') 373 | ylabel('Time Slot') 374 | zlabel('Offloading Power') 375 | title('Record of ffloading power of each user') 376 | 377 | figure(3) 378 | plot(utilitySeq(1:numIteration)) 379 | xlabel('Number Of Iteration') 380 | ylabel('Weighted System Utility') 381 | 382 | -------------------------------------------------------------------------------- /experiment0_NOMA.m: -------------------------------------------------------------------------------- 1 | function [power_NOMA, rUAV_NOMA, utility_NOMA, fUAV_NOMA, fUser_NOMA] = experiment0_NOMA(rUser) 2 | 3 | %% Setup of the Model 4 | 5 | % Consider U terrestrial users located in a area 6 | U = 8; % Number of users/SMDs 7 | 8 | % The size of the area is defined by: 9 | lengthArea = 1000; % Length of the coverage area (m) 10 | widthArea = 1000; % Width of the coverage area (m) 11 | 12 | % U SMDs are uniformly distributed in the rectangular coverage area. 13 | 14 | % Divide the time interval into N tme slots. 15 | T = 100; % Length of interval 16 | N = 20; % Number of time slots 17 | tau = T/N; % Duration of each time slot 18 | 19 | % Set the initial trajectory of UAV 20 | M = 2; 21 | hUAV = 50; % Flying altitude of UAV 22 | rI = [0, 0, hUAV; 0, 0, hUAV]; % Intial position of the UAV (M*3) 23 | rF = [lengthArea, 0, hUAV; 0, widthArea, hUAV]; % Final position of the UAV 24 | 25 | rUAV = zeros(N, 3, M); % Trajectory vector of the UAV 26 | 27 | % rUAV(time, dimension, UAV index) is a N*3*M matrix of which each describes the 3-D coordinates of UAVs 28 | % at each time slot. 29 | 30 | for m = 1:M 31 | rUAV(N, :, m) = rF(m, :); 32 | end 33 | for n = 1:N-1 34 | for m = 1:M 35 | rUAV(n, :, m) = rI(m, :)+n/N*(rF(m, :)-rI(m, :)); 36 | end 37 | end 38 | 39 | % Other parameters involved in the model. 40 | 41 | omegaUser = 0.8; % Weight factor of users 42 | omegaUAV = 1-omegaUser; % Weight factor of UAVs 43 | 44 | N0 = 1e-17; % Power spectral density of AWGN (W/Hz) 45 | B = 4e6; % System bandwidth (Hz) 46 | 47 | D = 120*ones(U, 1); % Number of bits for each SMDs to finish (Mbit) 48 | kappa = 1e-28; % Effective swiched capacitance of CPU 49 | 50 | fmaxUAV = 20; % Maximum CPU frequency of MEC server (GHz) 51 | fminUAV = 0; % Minimum CPU frequency of SMDs (GHz) 52 | CUAV = 1e3; % Processing density of MEC server (Hz/bit) 53 | 54 | fmaxUser = 1; % Maximum CPU frequency of SMDs (GHz) 55 | fminUser = 0; % Minimum CPU frequency of SMDs (GHz) 56 | CUser = 1e3; % Processing density of SMD (Hz/bit) 57 | 58 | J = log(2)/(B*tau); 59 | J = J*1e6; 60 | c1 = omegaUser*kappa*tau*1e27; 61 | c2 = omegaUser*B*N0*1e9; 62 | c3 = omegaUAV*kappa*tau*1e27; 63 | 64 | vmax = 15; % Maximum flying speed of UAV (m/sec) 65 | alpha = 2; % Path loss factor 66 | fc = 2e9; % Carrier frequency (Hz) 67 | c = 3e8; % Speed of light (m/sec) 68 | Q = (4*pi*fc/c)^alpha; 69 | gamma = 1e-4; 70 | W = 10; % Mass of UAV (kg) 71 | 72 | c4 = omegaUser*B*N0; 73 | 74 | %% Approximation of channel gain by curve fitting 75 | a = 11.95; 76 | b = 0.14; 77 | 78 | etaLoS = 10^(1/10); 79 | etaNLoS = 10^(20/10); 80 | 81 | d = hUAV:1000; 82 | L = (... 83 | 1./(... 84 | 1+a*exp(... 85 | -180*b/pi*asin(hUAV./d)+a*b... 86 | )... 87 | )*(etaLoS-etaNLoS)+etaNLoS... 88 | )... 89 | .*(4*pi*fc*d/c).^2; 90 | 91 | [curvePoly, goodness, output] = fit(d.', L.', 'poly2'); 92 | 93 | p1 = curvePoly.p1; 94 | p2 = curvePoly.p2; 95 | p3 = curvePoly.p3; 96 | 97 | %% Joint Optimization of Resource Allocation and Trajectory Scheduling 98 | 99 | maxIteration = 15; 100 | utilitySeq = zeros(maxIteration, 1); 101 | numIteration = 1; % Number of iteration 102 | 103 | pmax = 10; % Maximum offloading power for SMDs. 104 | pmin = 0; 105 | xmin = 0; 106 | 107 | %% Find the channel gain for each link between UAVs and users in each time slot 108 | g = zeros(U, N, M); % Channel gain matrix 109 | L = zeros(U, N, M); % Path loss matrix 110 | % g is a U*N matrix denoting the channel gains for all links throughout the interval. 111 | 112 | for i = 1:U 113 | for n = 1:N 114 | for m = 1:M 115 | [g(i, n, m), L(i, n, m)] = chanGain(rUAV(n, :, m), rUser(i, :)); 116 | end 117 | end 118 | end 119 | 120 | gRank = zeros(U, N, M); 121 | rank = zeros(U, N, M); 122 | Psi = zeros(U, N, M); 123 | beta = zeros(U+2, N, M); 124 | mu = zeros(U+1, N, M); 125 | 126 | for m = 1:M 127 | [gRank(:, :, m), rank(:, :, m), Psi(:, :, m)] = chanRank(g(:, :, m), U, N); 128 | 129 | beta(2:(U+1), :, m) = 1./gRank(:, :, m); 130 | 131 | for k = 1:U+1 132 | mu(k, :, m) = -beta(k+1, :, m)+beta(k, :, m); 133 | end 134 | end 135 | % rank gives a list of user index. Its value denotes the user index with that ranking, 136 | % i.e. rank(k, n) means the index of user with the k-th smallest channel gain at time n. 137 | % Psi helps track the rankings of users, 138 | % i.e. Psi(i, n) denotes the ranking of user i at time n. 139 | % beta is a (U+2)*N matrix. 140 | mu = mu/(1e9); 141 | 142 | % Set initial values for iteration. 143 | x0 = zeros(U, N, M); 144 | eta0 = 0; 145 | %% Resource Allocation (RA) for Offloading and Computation 146 | while 1 147 | 148 | cvx_begin 149 | variable x(U, N, M) nonnegative 150 | variable fUser(U, N) nonnegative 151 | variable fUAV(U, N, M) nonnegative 152 | variable threshold 153 | variable userRate(U, N, M) 154 | eta = 0; 155 | expressions pUser(U, N) 156 | 157 | for i = 1:U 158 | for n = 1:N 159 | pUser(i, n) = 0; 160 | end 161 | end 162 | 163 | 164 | for i = 1:U 165 | for n = 1:N 166 | for m = 1:M 167 | if Psi(i, n, m) == 1 168 | pUser(i, n) = pUser(i, n)+B*N0/g(i, n, m)*(exp(J*x(Psi(i, n, m), n, m))-1); 169 | elseif Psi(i, n, m) > 1 170 | pUser(i, n) = pUser(i, n)+B*N0/g(i, n, m)*(... 171 | exp(J*x(Psi(i, n, m), n, m))-... 172 | (... 173 | exp(J*x0(Psi(i, n, m)-1, n, m))+J*exp(J*x0(Psi(i, n, m)-1, n, m))*(x(Psi(i, n, m)-1, n, m)-x0(Psi(i, n, m)-1, n, m))... 174 | )... 175 | ); 176 | end 177 | end 178 | end 179 | end 180 | 181 | for i = 1:U 182 | for n = 1:N 183 | for m = 1:M 184 | if Psi(i, n, m) > 1 185 | userRate(i, n, m) == x(Psi(i, n, m), n, m)-x(Psi(i, n, m)-1, n, m); 186 | elseif Psi(i, n, m) == 1 187 | userRate(i, n, m) == x(Psi(i, n, m), n, m); 188 | end 189 | end 190 | end 191 | end 192 | 193 | for m = 1:M 194 | eta = eta+c2*sum(sum(mu(2:end, :, m).*exp(J*x(:, :, m)))) +... 195 | c2*sum(mu(1, :, m)); 196 | end 197 | eta = eta+c1*sum(sum(pow_p(fUser, 3))) +... 198 | c3*sum(sum(sum(pow_p(fUAV, 3)))); 199 | minimize( threshold ) 200 | subject to 201 | % C0: Objective function 202 | eta<= threshold; 203 | % C1: CPU frequency constraint on SMDs 204 | fminUser <= fUser; 205 | fUser <= fmaxUser; 206 | 207 | % C2: CPU frequency constraint on MEC server 208 | for m = 1:M 209 | fminUAV <= sum(fUAV(:, :, m), 1); 210 | sum(fUAV(:, :, m), 1) <= fmaxUAV; 211 | end 212 | 213 | % C3: Offloading rate/power constraint on SMDs 214 | for k = 2:U 215 | for n = 1:N 216 | for m = 1:M 217 | x(k, n, m) >= x(k-1, n, m); 218 | end 219 | end 220 | end 221 | 222 | pUser <= pmax; 223 | 224 | % C4: Accomplishment of computation tasks 225 | D <= 1000*tau/CUser*sum(fUser, 2)+1000*tau/CUAV*sum(sum(fUAV(:, 2:end, :), 3), 2); 226 | 227 | % C5&C6: Causal constraint on offloading and edge computing 228 | 229 | for i = 1:U 230 | for n = 2:N 231 | for m = 1:M 232 | sum(userRate(i, (1:n-1), m)) >= tau/CUAV*1000*sum(fUAV(i, (2:n), m)); 233 | end 234 | end 235 | end 236 | 237 | cvx_end 238 | break 239 | 240 | if abs(eta-eta0) <= 1 241 | break 242 | end 243 | 244 | x0 = x; 245 | eta0 = eta; 246 | end 247 | 248 | %% Iteration begins 249 | while 1 250 | %% Optimization of UAV Trajectory Scheduling 251 | for m = 1:M 252 | A(:, :, m) = exp(J*x(:, :, m)); 253 | end 254 | chi = zeros(U, N, M); 255 | for m= 1:M 256 | chi(1, :, m) = A(1, :, m)-ones(1, N); 257 | for k = 2:U 258 | chi(k, :, m) = A(k, :, m)-A(k-1, :, m); 259 | end 260 | end 261 | 262 | for k = 1:U 263 | for n = 1:N 264 | for m = 1:M 265 | if chi(k, n, m) <= 1e-6 266 | chi(k, n, m) = 0; 267 | end 268 | end 269 | end 270 | end 271 | chi = chi*c4; 272 | 273 | % nu is a U*N*2 matrix. 274 | % nu(k, n, :) gives coordinates of SMD with k-th smallest channel at time n. 275 | nu = zeros(U, N, 2); 276 | for n = 1:N 277 | for k = 1:U 278 | nu(k, n, :) = rUser(rank(k, n), 1:2); 279 | end 280 | end 281 | 282 | cvx_begin 283 | variable r1(N, M) 284 | variable r2(N, M) 285 | variable threshold2 286 | Emove = 0; 287 | for m = 1:M 288 | Emove = Emove + square_pos((r1(1, m)-rI(m, 1))/tau)+square_pos((r2(1, m)-rI(m, 2))/tau); 289 | for n = 2:N 290 | Emove = Emove+square_pos((r1(n, m)-r1(n-1 ,m))/tau)+square_pos((r2(n, m)-r2(n-1 ,m))/tau); 291 | end 292 | end 293 | Emove = omegaUAV*gamma*tau*W/2*Emove; 294 | 295 | 296 | Eoffload = 0; 297 | for n = 1:N 298 | for k = 1:U 299 | for m = 1:M 300 | Eoffload = Eoffload+chi(k, n, m).*... 301 | (... 302 | p1*square_pos... 303 | (... 304 | norm([r1(n, m),r2(n, m),hUAV]-[nu(k, n, 1), nu(k, n, 2), 0])... 305 | )... 306 | +p2*norm([r1(n, m),r2(n, m),hUAV]-[nu(k, n, 1), nu(k, n, 2), 0])... 307 | +p3... 308 | ); 309 | end 310 | end 311 | end 312 | 313 | 314 | minimize threshold2 315 | subject to 316 | 317 | Emove + Eoffload <= threshold2; 318 | 319 | 0 <= r1 <= lengthArea; 320 | 0 <= r2 <= widthArea; 321 | 322 | 323 | for m = 1:M 324 | r1(N, m) == rF(m, 1); 325 | r2(N, m) == rF(m, 2); 326 | (r1(1, m)-rI(m, 1))^2+(r2(1, m)-rI(m, 2))^2 <= (vmax*tau)^2; 327 | for n = 2:N 328 | (r1(n, m)-r1(n-1, m))^2+(r2(n, m)-r2(n-1, m))^2 <= (vmax*tau)^2; 329 | end 330 | end 331 | 332 | 333 | cvx_end 334 | 335 | % Update the UAV trajectory. 336 | for m = 1:M 337 | rUAV(:, 1, m) = r1(:, m); 338 | rUAV(:, 2, m) = r2(:, m); 339 | end 340 | 341 | %% Find the channel gain for each link between UAVs and users in each time slot 342 | g = zeros(U, N, M); % Channel gain matrix 343 | L = zeros(U, N, M); % Path loss matrix 344 | % g is a U*N matrix denoting the channel gains for all links throughout the interval. 345 | 346 | for i = 1:U 347 | for n = 1:N 348 | for m = 1:M 349 | [g(i, n, m), L(i, n, m)] = chanGain(rUAV(n, :, m), rUser(i, :)); 350 | end 351 | end 352 | end 353 | 354 | gRank = zeros(U, N, M); 355 | rank = zeros(U, N, M); 356 | Psi = zeros(U, N, M); 357 | beta = zeros(U+2, N, M); 358 | mu = zeros(U+1, N, M); 359 | 360 | for m = 1:M 361 | [gRank(:, :, m), rank(:, :, m), Psi(:, :, m)] = chanRank(g(:, :, m), U, N); 362 | 363 | beta(2:(U+1), :, m) = 1./gRank(:, :, m); 364 | 365 | for k = 1:U+1 366 | mu(k, :, m) = -beta(k+1, :, m)+beta(k, :, m); 367 | end 368 | end 369 | % rank gives a list of user index. Its value denotes the user index with that ranking, 370 | % i.e. rank(k, n) means the index of user with the k-th smallest channel gain at time n. 371 | % Psi helps track the rankings of users, 372 | % i.e. Psi(i, n) denotes the ranking of user i at time n. 373 | % beta is a (U+2)*N matrix. 374 | mu = mu/(1e9); 375 | 376 | % Set initial values for iteration. 377 | x0 = zeros(U, N, M); 378 | eta0 = 0; 379 | 380 | %% Resource Allocation (RA) for Offloading and Computation 381 | while 1 382 | 383 | cvx_begin 384 | variable x(U, N, M) nonnegative 385 | variable fUser(U, N) nonnegative 386 | variable fUAV(U, N, M) nonnegative 387 | variable threshold 388 | variable userRate(U, N, M) 389 | eta = 0; 390 | expressions pUser(U, N) 391 | 392 | for i = 1:U 393 | for n = 1:N 394 | pUser(i, n) = 0; 395 | end 396 | end 397 | 398 | 399 | for i = 1:U 400 | for n = 1:N 401 | for m = 1:M 402 | if Psi(i, n, m) == 1 403 | pUser(i, n) = pUser(i, n)+B*N0/g(i, n, m)*(exp(J*x(Psi(i, n, m), n, m))-1); 404 | elseif Psi(i, n, m) > 1 405 | pUser(i, n) = pUser(i, n)+B*N0/g(i, n, m)*(... 406 | exp(J*x(Psi(i, n, m), n, m))-... 407 | (... 408 | exp(J*x0(Psi(i, n, m)-1, n, m))+J*exp(J*x0(Psi(i, n, m)-1, n, m))*(x(Psi(i, n, m)-1, n, m)-x0(Psi(i, n, m)-1, n, m))... 409 | )... 410 | ); 411 | end 412 | end 413 | end 414 | end 415 | 416 | for i = 1:U 417 | for n = 1:N 418 | for m = 1:M 419 | if Psi(i, n, m) > 1 420 | userRate(i, n, m) == x(Psi(i, n, m), n, m)-x(Psi(i, n, m)-1, n, m); 421 | elseif Psi(i, n, m) == 1 422 | userRate(i, n, m) == x(Psi(i, n, m), n, m); 423 | end 424 | end 425 | end 426 | end 427 | 428 | for m = 1:M 429 | eta = eta+c2*sum(sum(mu(2:end, :, m).*exp(J*x(:, :, m)))) +... 430 | c2*sum(mu(1, :, m)); 431 | end 432 | eta = eta+c1*sum(sum(pow_p(fUser, 3))) +... 433 | c3*sum(sum(sum(pow_p(fUAV, 3)))); 434 | minimize( threshold ) 435 | subject to 436 | % C0: Objective function 437 | eta<= threshold; 438 | % C1: CPU frequency constraint on SMDs 439 | fminUser <= fUser; 440 | fUser <= fmaxUser; 441 | 442 | % C2: CPU frequency constraint on MEC server 443 | for m = 1:M 444 | fminUAV <= sum(fUAV(:, :, m), 1); 445 | sum(fUAV(:, :, m), 1) <= fmaxUAV; 446 | end 447 | 448 | % C3: Offloading rate/power constraint on SMDs 449 | for k = 2:U 450 | for n = 1:N 451 | for m = 1:M 452 | x(k, n, m) >= x(k-1, n, m); 453 | end 454 | end 455 | end 456 | 457 | pUser <= pmax; 458 | 459 | % C4: Accomplishment of computation tasks 460 | D <= 1000*tau/CUser*sum(fUser, 2)+1000*tau/CUAV*sum(sum(fUAV(:, 2:end, :), 3), 2); 461 | 462 | % C5&C6: Causal constraint on offloading and edge computing 463 | 464 | for i = 1:U 465 | for n = 2:N 466 | for m = 1:M 467 | sum(userRate(i, (1:n-1), m)) >= tau/CUAV*1000*sum(fUAV(i, (2:n), m)); 468 | end 469 | end 470 | end 471 | 472 | cvx_end 473 | 474 | if abs(eta-eta0) <= 1 475 | break 476 | end 477 | 478 | x0 = x; 479 | eta0 = eta; 480 | end 481 | 482 | %% Update the weighted system 483 | % Update the each term of weighted system utility. 484 | E_user_offload = 0; 485 | for m = 1:M 486 | E_user_offload = E_user_offload+c2*sum(sum(mu(2:end, :, m).*exp(J*x(:, :, m)))) +... 487 | c2*sum(mu(1, :, m)); 488 | end 489 | 490 | E_user_comp = c1*sum(sum(fUser.^3)); 491 | E_uav_comp = c3*sum(sum(sum(fUAV.^3))); 492 | E_uav_move = Emove; 493 | 494 | % Update the weighted system utility. 495 | utilitySeq(numIteration) = E_user_comp+E_user_offload+E_uav_comp+E_uav_move; 496 | 497 | % Check the convergence of the algorithm to break the 'while' loop. 498 | if numIteration > 1 499 | if abs(utilitySeq(numIteration)-utilitySeq(numIteration-1)) <= 1 500 | break 501 | end 502 | end 503 | 504 | if numIteration == maxIteration 505 | break 506 | end 507 | 508 | numIteration = numIteration+1 509 | end 510 | 511 | % Record the offloading power of each user in each time slot. 512 | recordOffloadPower = zeros(U, N); 513 | for i = 1:U 514 | for n = 1:N 515 | for m = 1:M 516 | if Psi(i, n, m) > 1 517 | recordOffloadPower(i, n) = recordOffloadPower(i, n)+... 518 | B*N0/g(i, n, m)*(exp(J*x(Psi(i, n, m), n, m))-exp(J*x(Psi(i, n, m)-1, n, m))); 519 | elseif Psi(i, n, m) == 1 520 | recordOffloadPower(i, n) = recordOffloadPower(i, n)+... 521 | B*N0/g(i, n, m)*(exp(J*x(Psi(i, n, m), n, m))-1); 522 | end 523 | end 524 | end 525 | end 526 | 527 | power_NOMA = recordOffloadPower; 528 | rUAV_NOMA = rUAV; 529 | % utilitySeq_NOMA = utilitySeq(1: numIteration); 530 | fUAV_NOMA = fUAV; 531 | fUser_NOMA = fUser; 532 | utility_NOMA = [E_user_offload, E_user_comp, E_uav_comp, E_uav_move]; 533 | 534 | 535 | end 536 | -------------------------------------------------------------------------------- /M3_Joint_RA_TS.m: -------------------------------------------------------------------------------- 1 | clear all 2 | close all 3 | % This script describes a NOMA-assisted MEC system on UAV according to doc 'Model 1.pages'. 4 | % Created and copyrighted by ZHANG Xiaochen at 10:22 a.m., Apr. 12, 2019. 5 | 6 | %% Setup of the Model 7 | 8 | % Consider U terrestrial users located in a area 9 | U = 8; % Number of users/SMDs 10 | 11 | % The size of the area is defined by: 12 | lengthArea = 1000; % Length of the coverage area (m) 13 | widthArea = 1000; % Width of the coverage area (m) 14 | 15 | % U SMDs are uniformly distributed in the rectangular coverage area. 16 | % rUser = [lengthArea*rand(U, 1),widthArea*rand(U, 1), zeros(U, 1)]; 17 | % rUser = [100*(2:2:8).', 100*8*ones(U, 1), zeros(U, 1)]; 18 | % rUser = [[400,400,600,600].', [600,800,600,800].',zeros(U, 1)]; 19 | % rUser = [[100,500,800,600].', [600,600,600,800].',zeros(U, 1)]; 20 | rUser = [kron(100*(2:2:8).',ones(2,1)), ... 21 | repmat([600, 800].', 4, 1),... 22 | zeros(U, 1)]; 23 | 24 | 25 | 26 | % Divide the time interval into N tme slots. 27 | T = 100; % Length of interval 28 | N = 20; % Number of time slots 29 | tau = T/N; % Duration of each time slot 30 | 31 | % Set the initial trajectory of UAV 32 | M = 2; 33 | hUAV = 50; % Flying altitude of UAV 34 | rI = [0, 0, hUAV; 0, 0, hUAV]; % Intial position of the UAV (M*3) 35 | rF = [lengthArea, 0, hUAV; 0, widthArea, hUAV]; % Final position of the UAV 36 | 37 | rUAV = zeros(N, 3, M); % Trajectory vector of the UAV 38 | 39 | % rUAV(time, dimension, UAV index) is a N*3*M matrix of which each describes the 3-D coordinates of UAVs 40 | % at each time slot. 41 | 42 | for m = 1:M 43 | rUAV(N, :, m) = rF(m, :); 44 | end 45 | for n = 1:N-1 46 | for m = 1:M 47 | rUAV(n, :, m) = rI(m, :)+n/N*(rF(m, :)-rI(m, :)); 48 | end 49 | end 50 | 51 | % Other parameters involved in the model. 52 | 53 | omegaUser = 0.8; % Weight factor of users 54 | omegaUAV = 1-omegaUser; % Weight factor of UAVs 55 | 56 | N0 = 1e-17; % Power spectral density of AWGN (W/Hz) 57 | B = 4e6; % System bandwidth (Hz) 58 | 59 | D = 120*ones(U, 1); % Number of bits for each SMDs to finish (Mbit) 60 | kappa = 1e-28; % Effective swiched capacitance of CPU 61 | 62 | fmaxUAV = 20; % Maximum CPU frequency of MEC server (GHz) 63 | fminUAV = 0; % Minimum CPU frequency of SMDs (GHz) 64 | CUAV = 1e3; % Processing density of MEC server (Hz/bit) 65 | 66 | fmaxUser = 1; % Maximum CPU frequency of SMDs (GHz) 67 | fminUser = 0; % Minimum CPU frequency of SMDs (GHz) 68 | CUser = 1e3; % Processing density of SMD (Hz/bit) 69 | 70 | J = log(2)/(B*tau); 71 | J = J*1e6; 72 | c1 = omegaUser*kappa*tau*1e27; 73 | c2 = omegaUser*B*N0*1e9; 74 | c3 = omegaUAV*kappa*tau*1e27; 75 | 76 | vmax = 15; % Maximum flying speed of UAV (m/sec) 77 | alpha = 2; % Path loss factor 78 | fc = 2e9; % Carrier frequency (Hz) 79 | c = 3e8; % Speed of light (m/sec) 80 | Q = (4*pi*fc/c)^alpha; 81 | gamma = 1e-4; 82 | W = 10; % Mass of UAV (kg) 83 | 84 | c4 = omegaUser*B*N0; 85 | 86 | %% Approximation of channel gain by curve fitting 87 | a = 11.95; 88 | b = 0.14; 89 | 90 | etaLoS = 10^(1/10); 91 | etaNLoS = 10^(20/10); 92 | 93 | d = hUAV:1000; 94 | L = (... 95 | 1./(... 96 | 1+a*exp(... 97 | -180*b/pi*asin(hUAV./d)+a*b... 98 | )... 99 | )*(etaLoS-etaNLoS)+etaNLoS... 100 | )... 101 | .*(4*pi*fc*d/c).^2; 102 | 103 | [curvePoly, goodness, output] = fit(d.', L.', 'poly2'); 104 | 105 | p1 = curvePoly.p1; 106 | p2 = curvePoly.p2; 107 | p3 = curvePoly.p3; 108 | 109 | %% Joint Optimization of Resource Allocation and Trajectory Scheduling 110 | 111 | maxIteration = 15; 112 | utilitySeq = zeros(maxIteration, 1); 113 | numIteration = 1; % Number of iteration 114 | 115 | pmax = 10; % Maximum offloading power for SMDs. 116 | pmin = 0; 117 | xmin = 0; 118 | 119 | %% Find the channel gain for each link between UAVs and users in each time slot 120 | g = zeros(U, N, M); % Channel gain matrix 121 | L = zeros(U, N, M); % Path loss matrix 122 | % g is a U*N matrix denoting the channel gains for all links throughout the interval. 123 | 124 | for i = 1:U 125 | for n = 1:N 126 | for m = 1:M 127 | [g(i, n, m), L(i, n, m)] = chanGain(rUAV(n, :, m), rUser(i, :)); 128 | end 129 | end 130 | end 131 | 132 | gRank = zeros(U, N, M); 133 | rank = zeros(U, N, M); 134 | Psi = zeros(U, N, M); 135 | beta = zeros(U+2, N, M); 136 | mu = zeros(U+1, N, M); 137 | 138 | for m = 1:M 139 | [gRank(:, :, m), rank(:, :, m), Psi(:, :, m)] = chanRank(g(:, :, m), U, N); 140 | 141 | beta(2:(U+1), :, m) = 1./gRank(:, :, m); 142 | 143 | for k = 1:U+1 144 | mu(k, :, m) = -beta(k+1, :, m)+beta(k, :, m); 145 | end 146 | end 147 | % rank gives a list of user index. Its value denotes the user index with that ranking, 148 | % i.e. rank(k, n) means the index of user with the k-th smallest channel gain at time n. 149 | % Psi helps track the rankings of users, 150 | % i.e. Psi(i, n) denotes the ranking of user i at time n. 151 | % beta is a (U+2)*N matrix. 152 | mu = mu/(1e9); 153 | 154 | % Set initial values for iteration. 155 | x0 = zeros(U, N, M); 156 | eta0 = 0; 157 | %% Resource Allocation (RA) for Offloading and Computation 158 | while 1 159 | 160 | cvx_begin 161 | variable x(U, N, M) nonnegative 162 | variable fUser(U, N) nonnegative 163 | variable fUAV(U, N, M) nonnegative 164 | variable threshold 165 | variable userRate(U, N, M) 166 | eta = 0; 167 | expressions pUser(U, N) 168 | 169 | for i = 1:U 170 | for n = 1:N 171 | pUser(i, n) = 0; 172 | end 173 | end 174 | 175 | 176 | for i = 1:U 177 | for n = 1:N 178 | for m = 1:M 179 | if Psi(i, n, m) == 1 180 | pUser(i, n) = pUser(i, n)+B*N0/g(i, n, m)*(exp(J*x(Psi(i, n, m), n, m))-1); 181 | elseif Psi(i, n, m) > 1 182 | pUser(i, n) = pUser(i, n)+B*N0/g(i, n, m)*(... 183 | exp(J*x(Psi(i, n, m), n, m))-... 184 | (... 185 | exp(J*x0(Psi(i, n, m)-1, n, m))+J*exp(J*x0(Psi(i, n, m)-1, n, m))*(x(Psi(i, n, m)-1, n, m)-x0(Psi(i, n, m)-1, n, m))... 186 | )... 187 | ); 188 | end 189 | end 190 | end 191 | end 192 | 193 | for i = 1:U 194 | for n = 1:N 195 | for m = 1:M 196 | if Psi(i, n, m) > 1 197 | userRate(i, n, m) == x(Psi(i, n, m), n, m)-x(Psi(i, n, m)-1, n, m); 198 | elseif Psi(i, n, m) == 1 199 | userRate(i, n, m) == x(Psi(i, n, m), n, m); 200 | end 201 | end 202 | end 203 | end 204 | 205 | for m = 1:M 206 | eta = eta+c2*sum(sum(mu(2:end, :, m).*exp(J*x(:, :, m)))) +... 207 | c2*sum(mu(1, :, m)); 208 | end 209 | eta = eta+c1*sum(sum(pow_p(fUser, 3))) +... 210 | c3*sum(sum(sum(pow_p(fUAV, 3)))); 211 | minimize( threshold ) 212 | subject to 213 | % C0: Objective function 214 | eta<= threshold; 215 | % C1: CPU frequency constraint on SMDs 216 | fminUser <= fUser; 217 | fUser <= fmaxUser; 218 | 219 | % C2: CPU frequency constraint on MEC server 220 | for m = 1:M 221 | fminUAV <= sum(fUAV(:, :, m), 1); 222 | sum(fUAV(:, :, m), 1) <= fmaxUAV; 223 | end 224 | 225 | % C3: Offloading rate/power constraint on SMDs 226 | for k = 2:U 227 | for n = 1:N 228 | for m = 1:M 229 | x(k, n, m) >= x(k-1, n, m); 230 | end 231 | end 232 | end 233 | 234 | pUser <= pmax; 235 | 236 | % C4: Accomplishment of computation tasks 237 | D <= 1000*tau/CUser*sum(fUser, 2)+1000*tau/CUAV*sum(sum(fUAV(:, 2:end, :), 3), 2); 238 | 239 | % C5&C6: Causal constraint on offloading and edge computing 240 | 241 | for i = 1:U 242 | for n = 2:N 243 | for m = 1:M 244 | sum(userRate(i, (1:n-1), m)) >= tau/CUAV*1000*sum(fUAV(i, (2:n), m)); 245 | end 246 | end 247 | end 248 | 249 | cvx_end 250 | break 251 | 252 | if abs(eta-eta0) <= 1 253 | break 254 | end 255 | 256 | x0 = x; 257 | eta0 = eta; 258 | end 259 | 260 | %% Iteration begins 261 | while 1 262 | %% Optimization of UAV Trajectory Scheduling 263 | for m = 1:M 264 | A(:, :, m) = exp(J*x(:, :, m)); 265 | end 266 | chi = zeros(U, N, M); 267 | for m= 1:M 268 | chi(1, :, m) = A(1, :, m)-ones(1, N); 269 | for k = 2:U 270 | chi(k, :, m) = A(k, :, m)-A(k-1, :, m); 271 | end 272 | end 273 | 274 | for k = 1:U 275 | for n = 1:N 276 | for m = 1:M 277 | if chi(k, n, m) <= 1e-6 278 | chi(k, n, m) = 0; 279 | end 280 | end 281 | end 282 | end 283 | chi = chi*c4; 284 | 285 | % nu is a U*N*2 matrix. 286 | % nu(k, n, :) gives coordinates of SMD with k-th smallest channel at time n. 287 | nu = zeros(U, N, 2); 288 | for n = 1:N 289 | for k = 1:U 290 | nu(k, n, :) = rUser(rank(k, n), 1:2); 291 | end 292 | end 293 | 294 | cvx_begin 295 | variable r1(N, M) 296 | variable r2(N, M) 297 | variable threshold2 298 | Emove = 0; 299 | for m = 1:M 300 | Emove = Emove + square_pos((r1(1, m)-rI(m, 1))/tau)+square_pos((r2(1, m)-rI(m, 2))/tau); 301 | for n = 2:N 302 | Emove = Emove+square_pos((r1(n, m)-r1(n-1 ,m))/tau)+square_pos((r2(n, m)-r2(n-1 ,m))/tau); 303 | end 304 | end 305 | Emove = omegaUAV*gamma*tau*W/2*Emove; 306 | 307 | 308 | Eoffload = 0; 309 | for n = 1:N 310 | for k = 1:U 311 | for m = 1:M 312 | Eoffload = Eoffload+chi(k, n, m).*... 313 | (... 314 | p1*square_pos... 315 | (... 316 | norm([r1(n, m),r2(n, m),hUAV]-[nu(k, n, 1), nu(k, n, 2), 0])... 317 | )... 318 | +p2*norm([r1(n, m),r2(n, m),hUAV]-[nu(k, n, 1), nu(k, n, 2), 0])... 319 | +p3... 320 | ); 321 | end 322 | end 323 | end 324 | 325 | 326 | minimize threshold2 327 | subject to 328 | 329 | Emove + Eoffload <= threshold2; 330 | 331 | 0 <= r1 <= lengthArea; 332 | 0 <= r2 <= widthArea; 333 | 334 | 335 | for m = 1:M 336 | r1(N, m) == rF(m, 1); 337 | r2(N, m) == rF(m, 2); 338 | (r1(1, m)-rI(m, 1))^2+(r2(1, m)-rI(m, 2))^2 <= (vmax*tau)^2; 339 | for n = 2:N 340 | (r1(n, m)-r1(n-1, m))^2+(r2(n, m)-r2(n-1, m))^2 <= (vmax*tau)^2; 341 | end 342 | end 343 | 344 | 345 | cvx_end 346 | 347 | % Update the UAV trajectory. 348 | for m = 1:M 349 | rUAV(:, 1, m) = r1(:, m); 350 | rUAV(:, 2, m) = r2(:, m); 351 | end 352 | 353 | %% Find the channel gain for each link between UAVs and users in each time slot 354 | g = zeros(U, N, M); % Channel gain matrix 355 | L = zeros(U, N, M); % Path loss matrix 356 | % g is a U*N matrix denoting the channel gains for all links throughout the interval. 357 | 358 | for i = 1:U 359 | for n = 1:N 360 | for m = 1:M 361 | [g(i, n, m), L(i, n, m)] = chanGain(rUAV(n, :, m), rUser(i, :)); 362 | end 363 | end 364 | end 365 | 366 | gRank = zeros(U, N, M); 367 | rank = zeros(U, N, M); 368 | Psi = zeros(U, N, M); 369 | beta = zeros(U+2, N, M); 370 | mu = zeros(U+1, N, M); 371 | 372 | for m = 1:M 373 | [gRank(:, :, m), rank(:, :, m), Psi(:, :, m)] = chanRank(g(:, :, m), U, N); 374 | 375 | beta(2:(U+1), :, m) = 1./gRank(:, :, m); 376 | 377 | for k = 1:U+1 378 | mu(k, :, m) = -beta(k+1, :, m)+beta(k, :, m); 379 | end 380 | end 381 | % rank gives a list of user index. Its value denotes the user index with that ranking, 382 | % i.e. rank(k, n) means the index of user with the k-th smallest channel gain at time n. 383 | % Psi helps track the rankings of users, 384 | % i.e. Psi(i, n) denotes the ranking of user i at time n. 385 | % beta is a (U+2)*N matrix. 386 | mu = mu/(1e9); 387 | 388 | % Set initial values for iteration. 389 | x0 = zeros(U, N, M); 390 | eta0 = 0; 391 | 392 | %% Resource Allocation (RA) for Offloading and Computation 393 | while 1 394 | 395 | cvx_begin 396 | variable x(U, N, M) nonnegative 397 | variable fUser(U, N) nonnegative 398 | variable fUAV(U, N, M) nonnegative 399 | variable threshold 400 | variable userRate(U, N, M) 401 | eta = 0; 402 | expressions pUser(U, N) 403 | 404 | for i = 1:U 405 | for n = 1:N 406 | pUser(i, n) = 0; 407 | end 408 | end 409 | 410 | 411 | for i = 1:U 412 | for n = 1:N 413 | for m = 1:M 414 | if Psi(i, n, m) == 1 415 | pUser(i, n) = pUser(i, n)+B*N0/g(i, n, m)*(exp(J*x(Psi(i, n, m), n, m))-1); 416 | elseif Psi(i, n, m) > 1 417 | pUser(i, n) = pUser(i, n)+B*N0/g(i, n, m)*(... 418 | exp(J*x(Psi(i, n, m), n, m))-... 419 | (... 420 | exp(J*x0(Psi(i, n, m)-1, n, m))+J*exp(J*x0(Psi(i, n, m)-1, n, m))*(x(Psi(i, n, m)-1, n, m)-x0(Psi(i, n, m)-1, n, m))... 421 | )... 422 | ); 423 | end 424 | end 425 | end 426 | end 427 | 428 | for i = 1:U 429 | for n = 1:N 430 | for m = 1:M 431 | if Psi(i, n, m) > 1 432 | userRate(i, n, m) == x(Psi(i, n, m), n, m)-x(Psi(i, n, m)-1, n, m); 433 | elseif Psi(i, n, m) == 1 434 | userRate(i, n, m) == x(Psi(i, n, m), n, m); 435 | end 436 | end 437 | end 438 | end 439 | 440 | for m = 1:M 441 | eta = eta+c2*sum(sum(mu(2:end, :, m).*exp(J*x(:, :, m)))) +... 442 | c2*sum(mu(1, :, m)); 443 | end 444 | eta = eta+c1*sum(sum(pow_p(fUser, 3))) +... 445 | c3*sum(sum(sum(pow_p(fUAV, 3)))); 446 | minimize( threshold ) 447 | subject to 448 | % C0: Objective function 449 | eta<= threshold; 450 | % C1: CPU frequency constraint on SMDs 451 | fminUser <= fUser; 452 | fUser <= fmaxUser; 453 | 454 | % C2: CPU frequency constraint on MEC server 455 | for m = 1:M 456 | fminUAV <= sum(fUAV(:, :, m), 1); 457 | sum(fUAV(:, :, m), 1) <= fmaxUAV; 458 | end 459 | 460 | % C3: Offloading rate/power constraint on SMDs 461 | for k = 2:U 462 | for n = 1:N 463 | for m = 1:M 464 | x(k, n, m) >= x(k-1, n, m); 465 | end 466 | end 467 | end 468 | 469 | pUser <= pmax; 470 | 471 | % C4: Accomplishment of computation tasks 472 | D <= 1000*tau/CUser*sum(fUser, 2)+1000*tau/CUAV*sum(sum(fUAV(:, 2:end, :), 3), 2); 473 | 474 | % C5&C6: Causal constraint on offloading and edge computing 475 | 476 | for i = 1:U 477 | for n = 2:N 478 | for m = 1:M 479 | sum(userRate(i, (1:n-1), m)) >= tau/CUAV*1000*sum(fUAV(i, (2:n), m)); 480 | end 481 | end 482 | end 483 | 484 | cvx_end 485 | 486 | if abs(eta-eta0) <= 1 487 | break 488 | end 489 | 490 | x0 = x; 491 | eta0 = eta; 492 | end 493 | 494 | %% Update the weighted system 495 | % Update the each term of weighted system utility. 496 | E_user_offload = 0; 497 | for m = 1:M 498 | E_user_offload = E_user_offload+c2*sum(sum(mu(2:end, :, m).*exp(J*x(:, :, m)))) +... 499 | c2*sum(mu(1, :, m)); 500 | end 501 | 502 | E_user_comp = c1*sum(sum(fUser.^3)); 503 | E_uav_comp = c3*sum(sum(sum(fUAV.^3))); 504 | E_uav_move = Emove; 505 | 506 | % Update the weighted system utility. 507 | utilitySeq(numIteration) = E_user_comp+E_user_offload+E_uav_comp+E_uav_move; 508 | 509 | % Check the convergence of the algorithm to break the 'while' loop. 510 | if numIteration > 1 511 | if abs(utilitySeq(numIteration)-utilitySeq(numIteration-1)) <= 1 512 | break 513 | end 514 | end 515 | 516 | if numIteration == maxIteration 517 | break 518 | end 519 | 520 | numIteration = numIteration+1 521 | end 522 | 523 | % Record the offloading power of each user in each time slot. 524 | recordOffloadPower = zeros(U, N); 525 | for i = 1:U 526 | for n = 1:N 527 | for m = 1:M 528 | if Psi(i, n, m) > 1 529 | recordOffloadPower(i, n) = recordOffloadPower(i, n)+... 530 | B*N0/g(i, n, m)*(exp(J*x(Psi(i, n, m), n, m))-exp(J*x(Psi(i, n, m)-1, n, m))); 531 | elseif Psi(i, n, m) == 1 532 | recordOffloadPower(i, n) = recordOffloadPower(i, n)+... 533 | B*N0/g(i, n, m)*(exp(J*x(Psi(i, n, m), n, m))-1); 534 | end 535 | end 536 | end 537 | end 538 | 539 | % Plot the configuration of the model 540 | figure(1) 541 | scatter(rUser(:, 1), rUser(:, 2)); 542 | hold on 543 | stem(rUAV(:, 1, 1), rUAV(:, 2, 1)); 544 | hold on 545 | stem(rUAV(:, 1, 2), rUAV(:, 2, 2)); 546 | 547 | title('Location of SMDs and Trajectory of the UAV') 548 | xlabel('Length/m') 549 | ylabel('Width/m') 550 | axis([0 lengthArea 0 widthArea]) 551 | 552 | figure(2) 553 | for i = 1:U 554 | stem3(i*ones(N, 1), (1:N), recordOffloadPower(i, :)); 555 | hold on 556 | end 557 | xlabel('User Index') 558 | ylabel('Time Slot') 559 | zlabel('Offloading Power') 560 | title('Record of ffloading power of each user') 561 | 562 | figure(3) 563 | for i = 1:U 564 | stem3(i*ones(N, 1), (1:N), pUser(i, :)); 565 | hold on 566 | end 567 | xlabel('User Index') 568 | ylabel('Time Slot') 569 | zlabel('Offloading Power') 570 | title('pUser: Offloading power of each user') 571 | 572 | figure(4) 573 | plot(utilitySeq(1:numIteration)) 574 | xlabel('Number Of Iteration') 575 | ylabel('Weighted System Utility') 576 | 577 | --------------------------------------------------------------------------------