A Discrete-Event Network Simulator
API
lte-test-downlink-power-control.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2014 Piotr Gawlowicz
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation;
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 *
17 * Author: Piotr Gawlowicz <gawlowicz.p@gmail.com>
18 *
19 */
20
21#include "lte-test-downlink-power-control.h"
22
23#include "lte-ffr-simple.h"
24
25#include "ns3/lte-helper.h"
26#include "ns3/mobility-helper.h"
27#include <ns3/boolean.h>
28#include <ns3/callback.h>
29#include <ns3/config.h>
30#include <ns3/double.h>
31#include <ns3/enum.h>
32#include <ns3/ff-mac-scheduler.h>
33#include <ns3/log.h>
34#include <ns3/lte-chunk-processor.h>
35#include <ns3/lte-common.h>
36#include <ns3/lte-enb-net-device.h>
37#include <ns3/lte-enb-phy.h>
38#include <ns3/lte-enb-rrc.h>
39#include <ns3/lte-rrc-sap.h>
40#include <ns3/lte-ue-net-device.h>
41#include <ns3/lte-ue-phy.h>
42#include <ns3/lte-ue-rrc.h>
43#include <ns3/pointer.h>
44#include <ns3/simulator.h>
45#include <ns3/string.h>
46
47using namespace ns3;
48
49NS_LOG_COMPONENT_DEFINE("LteDownlinkPowerControlTest");
50
55LteDownlinkPowerControlTestSuite::LteDownlinkPowerControlTestSuite()
56 : TestSuite("lte-downlink-power-control", SYSTEM)
57{
58 // LogLevel logLevel = (LogLevel)(LOG_PREFIX_FUNC | LOG_PREFIX_TIME | LOG_LEVEL_DEBUG);
59 // LogComponentEnable ("LteDownlinkPowerControlTest", logLevel);
60 NS_LOG_INFO("Creating LteDownlinkPowerControlTestSuite");
61
62 // Spectrum helper test
63 {
64 std::vector<int> activeRbs_txpowdB30nrb6run1earfcn500(4);
65 activeRbs_txpowdB30nrb6run1earfcn500[0] = 0;
66 activeRbs_txpowdB30nrb6run1earfcn500[1] = 2;
67 activeRbs_txpowdB30nrb6run1earfcn500[2] = 3;
68 activeRbs_txpowdB30nrb6run1earfcn500[3] = 5;
69
70 uint16_t earfcn = 500;
71 uint8_t bw = 6;
72 double powerTx = 30;
73
74 std::map<int, double> powerTxMap;
75 double rbTxPower = powerTx;
76
77 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB_6);
78 powerTxMap.insert(std::pair<int, double>(0, rbTxPower));
79
80 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB_3);
81 powerTxMap.insert(std::pair<int, double>(2, rbTxPower));
82
83 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB0);
84 powerTxMap.insert(std::pair<int, double>(3, rbTxPower));
85
86 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB2);
87 powerTxMap.insert(std::pair<int, double>(5, rbTxPower));
88
89 SpectrumValue spectrumValue_txpowdB30nrb6run1earfcn500(
90 LteSpectrumValueHelper::GetSpectrumModel(500, 6));
91 spectrumValue_txpowdB30nrb6run1earfcn500[0] = 2.325820769916e-07;
92 spectrumValue_txpowdB30nrb6run1earfcn500[1] = 0.000000000000e+00;
93 spectrumValue_txpowdB30nrb6run1earfcn500[2] = 4.640622533585e-07;
94 spectrumValue_txpowdB30nrb6run1earfcn500[3] = 9.259259259259e-07;
95 spectrumValue_txpowdB30nrb6run1earfcn500[4] = 0.000000000000e+00;
96 spectrumValue_txpowdB30nrb6run1earfcn500[5] = 1.467493696723e-06;
97
98 AddTestCase(new LteDownlinkPowerControlSpectrumValueTestCase(
99 "txpowdB30nrb6run1earfcn500_allRbPower",
100 earfcn,
101 bw,
102 powerTx,
103 powerTxMap,
104 activeRbs_txpowdB30nrb6run1earfcn500,
105 spectrumValue_txpowdB30nrb6run1earfcn500),
106 TestCase::QUICK);
107 }
108 {
109 // if power for RB not present, but RB is active, use powerTx
110 std::vector<int> activeRbs_txpowdB30nrb6run1earfcn500(4);
111 activeRbs_txpowdB30nrb6run1earfcn500[0] = 0;
112 activeRbs_txpowdB30nrb6run1earfcn500[1] = 2;
113 activeRbs_txpowdB30nrb6run1earfcn500[2] = 3;
114 activeRbs_txpowdB30nrb6run1earfcn500[3] = 5;
115
116 uint16_t earfcn = 500;
117 uint8_t bw = 6;
118 double powerTx = 30;
119
120 std::map<int, double> powerTxMap;
121 double rbTxPower = powerTx;
122
123 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB_3);
124 powerTxMap.insert(std::pair<int, double>(2, rbTxPower));
125
126 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB0);
127 powerTxMap.insert(std::pair<int, double>(3, rbTxPower));
128
129 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB2);
130 powerTxMap.insert(std::pair<int, double>(5, rbTxPower));
131
132 SpectrumValue spectrumValue_txpowdB30nrb6run1earfcn500(
133 LteSpectrumValueHelper::GetSpectrumModel(500, 6));
134 spectrumValue_txpowdB30nrb6run1earfcn500[0] = 9.259259259259e-07;
135 spectrumValue_txpowdB30nrb6run1earfcn500[1] = 0.000000000000e+00;
136 spectrumValue_txpowdB30nrb6run1earfcn500[2] = 4.640622533585e-07;
137 spectrumValue_txpowdB30nrb6run1earfcn500[3] = 9.259259259259e-07;
138 spectrumValue_txpowdB30nrb6run1earfcn500[4] = 0.000000000000e+00;
139 spectrumValue_txpowdB30nrb6run1earfcn500[5] = 1.467493696723e-06;
140
141 AddTestCase(new LteDownlinkPowerControlSpectrumValueTestCase(
142 "txpowdB30nrb6run1earfcn500",
143 earfcn,
144 bw,
145 powerTx,
146 powerTxMap,
147 activeRbs_txpowdB30nrb6run1earfcn500,
148 spectrumValue_txpowdB30nrb6run1earfcn500),
149 TestCase::QUICK);
150 }
151 {
152 std::vector<int> activeRbs_txpowdB30nrb25run1earfcn500(15);
153 activeRbs_txpowdB30nrb25run1earfcn500[0] = 0;
154 activeRbs_txpowdB30nrb25run1earfcn500[1] = 1;
155 activeRbs_txpowdB30nrb25run1earfcn500[2] = 2;
156 activeRbs_txpowdB30nrb25run1earfcn500[3] = 3;
157 activeRbs_txpowdB30nrb25run1earfcn500[4] = 7;
158 activeRbs_txpowdB30nrb25run1earfcn500[5] = 8;
159 activeRbs_txpowdB30nrb25run1earfcn500[6] = 9;
160 activeRbs_txpowdB30nrb25run1earfcn500[7] = 11;
161 activeRbs_txpowdB30nrb25run1earfcn500[8] = 13;
162 activeRbs_txpowdB30nrb25run1earfcn500[9] = 14;
163 activeRbs_txpowdB30nrb25run1earfcn500[10] = 18;
164 activeRbs_txpowdB30nrb25run1earfcn500[11] = 19;
165 activeRbs_txpowdB30nrb25run1earfcn500[12] = 20;
166 activeRbs_txpowdB30nrb25run1earfcn500[13] = 21;
167 activeRbs_txpowdB30nrb25run1earfcn500[14] = 24;
168
169 uint16_t earfcn = 500;
170 uint8_t bw = 25;
171 double powerTx = 30;
172
173 std::map<int, double> powerTxMap;
174 double rbTxPower = powerTx;
175 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB_3);
176 powerTxMap.insert(std::pair<int, double>(0, rbTxPower));
177 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB_4dot77);
178 powerTxMap.insert(std::pair<int, double>(1, rbTxPower));
179 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB_6);
180 powerTxMap.insert(std::pair<int, double>(2, rbTxPower));
181 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB1);
182 powerTxMap.insert(std::pair<int, double>(3, rbTxPower));
183 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB2);
184 powerTxMap.insert(std::pair<int, double>(7, rbTxPower));
185 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB2);
186 powerTxMap.insert(std::pair<int, double>(8, rbTxPower));
187 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB2);
188 powerTxMap.insert(std::pair<int, double>(9, rbTxPower));
189 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB_1dot77);
190 powerTxMap.insert(std::pair<int, double>(11, rbTxPower));
191 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB2);
192 powerTxMap.insert(std::pair<int, double>(13, rbTxPower));
193 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB_3);
194 powerTxMap.insert(std::pair<int, double>(14, rbTxPower));
195 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB0);
196 powerTxMap.insert(std::pair<int, double>(18, rbTxPower));
197 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB_3);
198 powerTxMap.insert(std::pair<int, double>(19, rbTxPower));
199 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB_3);
200 powerTxMap.insert(std::pair<int, double>(20, rbTxPower));
201 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB_4dot77);
202 powerTxMap.insert(std::pair<int, double>(21, rbTxPower));
203 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB3);
204 powerTxMap.insert(std::pair<int, double>(24, rbTxPower));
205
206 SpectrumValue spectrumValue_txpowdB30nrb25run1earfcn500(
207 LteSpectrumValueHelper::GetSpectrumModel(500, bw));
208 spectrumValue_txpowdB30nrb25run1earfcn500[0] = 1.113749408060e-07;
209 spectrumValue_txpowdB30nrb25run1earfcn500[1] = 7.409475839182e-08;
210 spectrumValue_txpowdB30nrb25run1earfcn500[2] = 5.581969847799e-08;
211 spectrumValue_txpowdB30nrb25run1earfcn500[3] = 2.797612026209e-07;
212 spectrumValue_txpowdB30nrb25run1earfcn500[4] = 0.000000000000e+00;
213 spectrumValue_txpowdB30nrb25run1earfcn500[5] = 0.000000000000e+00;
214 spectrumValue_txpowdB30nrb25run1earfcn500[6] = 0.000000000000e+00;
215 spectrumValue_txpowdB30nrb25run1earfcn500[7] = 3.521984872135e-07;
216 spectrumValue_txpowdB30nrb25run1earfcn500[8] = 3.521984872135e-07;
217 spectrumValue_txpowdB30nrb25run1earfcn500[9] = 3.521984872135e-07;
218 spectrumValue_txpowdB30nrb25run1earfcn500[10] = 0.000000000000e+00;
219 spectrumValue_txpowdB30nrb25run1earfcn500[11] = 1.478384791559e-07;
220 spectrumValue_txpowdB30nrb25run1earfcn500[12] = 0.000000000000e+00;
221 spectrumValue_txpowdB30nrb25run1earfcn500[13] = 3.521984872135e-07;
222 spectrumValue_txpowdB30nrb25run1earfcn500[14] = 1.113749408060e-07;
223 spectrumValue_txpowdB30nrb25run1earfcn500[15] = 0.000000000000e+00;
224 spectrumValue_txpowdB30nrb25run1earfcn500[16] = 0.000000000000e+00;
225 spectrumValue_txpowdB30nrb25run1earfcn500[17] = 0.000000000000e+00;
226 spectrumValue_txpowdB30nrb25run1earfcn500[18] = 2.222222222222e-07;
227 spectrumValue_txpowdB30nrb25run1earfcn500[19] = 1.113749408060e-07;
228 spectrumValue_txpowdB30nrb25run1earfcn500[20] = 1.113749408060e-07;
229 spectrumValue_txpowdB30nrb25run1earfcn500[21] = 7.409475839182e-08;
230 spectrumValue_txpowdB30nrb25run1earfcn500[22] = 0.000000000000e+00;
231 spectrumValue_txpowdB30nrb25run1earfcn500[23] = 0.000000000000e+00;
232 spectrumValue_txpowdB30nrb25run1earfcn500[24] = 4.433916255486e-07;
233
234 AddTestCase(new LteDownlinkPowerControlSpectrumValueTestCase(
235 "txpowdB30nrb25run1earfcn500_allRbPower",
236 earfcn,
237 bw,
238 powerTx,
239 powerTxMap,
240 activeRbs_txpowdB30nrb25run1earfcn500,
241 spectrumValue_txpowdB30nrb25run1earfcn500),
242 TestCase::QUICK);
243 }
244 {
245 // if power for RB not present, but RB is active, use powerTx
246 std::vector<int> activeRbs_txpowdB30nrb25run1earfcn500(15);
247 activeRbs_txpowdB30nrb25run1earfcn500[0] = 0;
248 activeRbs_txpowdB30nrb25run1earfcn500[1] = 1;
249 activeRbs_txpowdB30nrb25run1earfcn500[2] = 2;
250 activeRbs_txpowdB30nrb25run1earfcn500[3] = 3;
251 activeRbs_txpowdB30nrb25run1earfcn500[4] = 7;
252 activeRbs_txpowdB30nrb25run1earfcn500[5] = 8;
253 activeRbs_txpowdB30nrb25run1earfcn500[6] = 9;
254 activeRbs_txpowdB30nrb25run1earfcn500[7] = 11;
255 activeRbs_txpowdB30nrb25run1earfcn500[8] = 13;
256 activeRbs_txpowdB30nrb25run1earfcn500[9] = 14;
257 activeRbs_txpowdB30nrb25run1earfcn500[10] = 18;
258 activeRbs_txpowdB30nrb25run1earfcn500[11] = 19;
259 activeRbs_txpowdB30nrb25run1earfcn500[12] = 20;
260 activeRbs_txpowdB30nrb25run1earfcn500[13] = 21;
261 activeRbs_txpowdB30nrb25run1earfcn500[14] = 24;
262
263 uint16_t earfcn = 500;
264 uint8_t bw = 25;
265 double powerTx = 30;
266
267 std::map<int, double> powerTxMap;
268 double rbTxPower = powerTx;
269 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB_3);
270 powerTxMap.insert(std::pair<int, double>(0, rbTxPower));
271 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB_6);
272 powerTxMap.insert(std::pair<int, double>(2, rbTxPower));
273 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB1);
274 powerTxMap.insert(std::pair<int, double>(3, rbTxPower));
275 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB2);
276 powerTxMap.insert(std::pair<int, double>(7, rbTxPower));
277 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB2);
278 powerTxMap.insert(std::pair<int, double>(8, rbTxPower));
279 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB2);
280 powerTxMap.insert(std::pair<int, double>(13, rbTxPower));
281 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB_3);
282 powerTxMap.insert(std::pair<int, double>(14, rbTxPower));
283 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB0);
284 powerTxMap.insert(std::pair<int, double>(18, rbTxPower));
285 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB_3);
286 powerTxMap.insert(std::pair<int, double>(19, rbTxPower));
287 rbTxPower = CalculateRbTxPower(powerTx, LteRrcSap::PdschConfigDedicated::dB3);
288 powerTxMap.insert(std::pair<int, double>(24, rbTxPower));
289
290 SpectrumValue spectrumValue_txpowdB30nrb25run1earfcn500(
291 LteSpectrumValueHelper::GetSpectrumModel(500, bw));
292 spectrumValue_txpowdB30nrb25run1earfcn500[0] = 1.113749408060e-07;
293 spectrumValue_txpowdB30nrb25run1earfcn500[1] = 2.222222222222e-07;
294 spectrumValue_txpowdB30nrb25run1earfcn500[2] = 5.581969847799e-08;
295 spectrumValue_txpowdB30nrb25run1earfcn500[3] = 2.797612026209e-07;
296 spectrumValue_txpowdB30nrb25run1earfcn500[4] = 0.000000000000e+00;
297 spectrumValue_txpowdB30nrb25run1earfcn500[5] = 0.000000000000e+00;
298 spectrumValue_txpowdB30nrb25run1earfcn500[6] = 0.000000000000e+00;
299 spectrumValue_txpowdB30nrb25run1earfcn500[7] = 3.521984872135e-07;
300 spectrumValue_txpowdB30nrb25run1earfcn500[8] = 3.521984872135e-07;
301 spectrumValue_txpowdB30nrb25run1earfcn500[9] = 2.222222222222e-07;
302 spectrumValue_txpowdB30nrb25run1earfcn500[10] = 0.000000000000e+00;
303 spectrumValue_txpowdB30nrb25run1earfcn500[11] = 2.222222222222e-07;
304 spectrumValue_txpowdB30nrb25run1earfcn500[12] = 0.000000000000e+00;
305 spectrumValue_txpowdB30nrb25run1earfcn500[13] = 3.521984872135e-07;
306 spectrumValue_txpowdB30nrb25run1earfcn500[14] = 1.113749408060e-07;
307 spectrumValue_txpowdB30nrb25run1earfcn500[15] = 0.000000000000e+00;
308 spectrumValue_txpowdB30nrb25run1earfcn500[16] = 0.000000000000e+00;
309 spectrumValue_txpowdB30nrb25run1earfcn500[17] = 0.000000000000e+00;
310 spectrumValue_txpowdB30nrb25run1earfcn500[18] = 2.222222222222e-07;
311 spectrumValue_txpowdB30nrb25run1earfcn500[19] = 1.113749408060e-07;
312 spectrumValue_txpowdB30nrb25run1earfcn500[20] = 2.222222222222e-07;
313 spectrumValue_txpowdB30nrb25run1earfcn500[21] = 2.222222222222e-07;
314 spectrumValue_txpowdB30nrb25run1earfcn500[22] = 0.000000000000e+00;
315 spectrumValue_txpowdB30nrb25run1earfcn500[23] = 0.000000000000e+00;
316 spectrumValue_txpowdB30nrb25run1earfcn500[24] = 4.433916255486e-07;
317
318 AddTestCase(new LteDownlinkPowerControlSpectrumValueTestCase(
319 "txpowdB30nrb25run1earfcn500",
320 earfcn,
321 bw,
322 powerTx,
323 powerTxMap,
324 activeRbs_txpowdB30nrb25run1earfcn500,
325 spectrumValue_txpowdB30nrb25run1earfcn500),
326 TestCase::QUICK);
327 }
328
329 // Downlink DATA and CONTROL channels power comparison
330 AddTestCase(new LteDownlinkPowerControlTestCase(false,
331 LteRrcSap::PdschConfigDedicated::dB0,
332 "DataCtrlPowerDifference_noChange"),
333 TestCase::QUICK);
334 AddTestCase(new LteDownlinkPowerControlTestCase(true,
335 LteRrcSap::PdschConfigDedicated::dB_6,
336 "DataCtrlPowerDifference_dB_6"),
337 TestCase::QUICK);
338 AddTestCase(new LteDownlinkPowerControlTestCase(true,
339 LteRrcSap::PdschConfigDedicated::dB_4dot77,
340 "DataCtrlPowerDifference_dB_4dot77"),
341 TestCase::QUICK);
342 AddTestCase(new LteDownlinkPowerControlTestCase(true,
343 LteRrcSap::PdschConfigDedicated::dB_3,
344 "DataCtrlPowerDifference_dB_3"),
345 TestCase::QUICK);
346 AddTestCase(new LteDownlinkPowerControlTestCase(true,
347 LteRrcSap::PdschConfigDedicated::dB_1dot77,
348 "DataCtrlPowerDifference_dB_1dot77"),
349 TestCase::QUICK);
350 AddTestCase(new LteDownlinkPowerControlTestCase(true,
351 LteRrcSap::PdschConfigDedicated::dB0,
352 "DataCtrlPowerDifference_dB0"),
353 TestCase::QUICK);
354 AddTestCase(new LteDownlinkPowerControlTestCase(true,
355 LteRrcSap::PdschConfigDedicated::dB1,
356 "DataCtrlPowerDifference_dB1"),
357 TestCase::QUICK);
358 AddTestCase(new LteDownlinkPowerControlTestCase(true,
359 LteRrcSap::PdschConfigDedicated::dB2,
360 "DataCtrlPowerDifference_dB2"),
361 TestCase::QUICK);
362 AddTestCase(new LteDownlinkPowerControlTestCase(true,
363 LteRrcSap::PdschConfigDedicated::dB3,
364 "DataCtrlPowerDifference_dB3"),
365 TestCase::QUICK);
366
367 // RrcConnectionReconfiguration test
368 AddTestCase(
369 new LteDownlinkPowerControlRrcConnectionReconfigurationTestCase(false,
370 "RrcConnReconf-IdealRrc"),
371 TestCase::QUICK);
372 AddTestCase(
373 new LteDownlinkPowerControlRrcConnectionReconfigurationTestCase(true,
374 "RrcConnReconf-RealRrc"),
375 TestCase::QUICK);
376}
377
378double
379LteDownlinkPowerControlTestSuite::CalculateRbTxPower(double txPower, uint8_t pa)
380{
381 LteRrcSap::PdschConfigDedicated pdschConfigDedicated;
382 pdschConfigDedicated.pa = pa;
383 double rbTxpower =
384 txPower + LteRrcSap::ConvertPdschConfigDedicated2Double(pdschConfigDedicated);
385
386 return rbTxpower;
387}
388
389static LteDownlinkPowerControlTestSuite lteDownlinkPowerControlTestSuite;
390
395LteDownlinkPowerControlSpectrumValueTestCase::LteDownlinkPowerControlSpectrumValueTestCase(
396 std::string name,
397 uint16_t earfcn,
398 uint16_t bw,
399 double powerTx,
400 std::map<int, double> powerTxMap,
401 std::vector<int> activeRbs,
402 SpectrumValue& expected)
403 : TestCase("Downlink Power Control: " + name),
404 m_actual(LteSpectrumValueHelper::CreateTxPowerSpectralDensity(earfcn,
405 bw,
406 powerTx,
407 powerTxMap,
408 activeRbs)),
409 m_expected(Create<SpectrumValue>(expected))
410{
411 NS_LOG_INFO("Creating LteDownlinkPowerControlTestCase");
412}
413
414LteDownlinkPowerControlSpectrumValueTestCase::~LteDownlinkPowerControlSpectrumValueTestCase()
415{
416}
417
418void
419LteDownlinkPowerControlSpectrumValueTestCase::DoRun()
420{
421 NS_LOG_INFO("Creating LteDownlinkPowerControlSpectrumValueTestCase");
422 NS_TEST_ASSERT_MSG_EQ(m_actual->GetSpectrumModelUid(),
423 m_expected->GetSpectrumModelUid(),
424 "SpectrumModel UID mismatch");
425 NS_TEST_ASSERT_MSG_SPECTRUM_VALUE_EQ_TOL((*m_actual),
426 (*m_expected),
427 0.0000001,
428 "SpectrumValues not equal");
429}
430
431LteDownlinkPowerControlTestCase::LteDownlinkPowerControlTestCase(bool changePower,
432 uint8_t pa,
433 std::string name)
434 : TestCase("Downlink Power Control: " + name)
435{
436 m_changePdschConfigDedicated = changePower;
437 m_pdschConfigDedicated.pa = pa;
438 m_expectedPowerDiff = LteRrcSap::ConvertPdschConfigDedicated2Double(m_pdschConfigDedicated);
439 NS_LOG_INFO("Creating LteDownlinkPowerControlTestCase");
440}
441
442LteDownlinkPowerControlTestCase::~LteDownlinkPowerControlTestCase()
443{
444}
445
446void
447LteDownlinkPowerControlTestCase::DoRun()
448{
449 Config::Reset();
450 Config::SetDefault("ns3::LteHelper::UseIdealRrc", BooleanValue(false));
451
456 Ptr<LteHelper> lteHelper = CreateObject<LteHelper>();
457 lteHelper->SetFfrAlgorithmType("ns3::LteFfrSimple");
458
459 // Create Nodes: eNodeB and UE
460 NodeContainer enbNodes;
461 NodeContainer ueNodes;
462 enbNodes.Create(1);
463 ueNodes.Create(1);
464 NodeContainer allNodes = NodeContainer(enbNodes, ueNodes);
465
466 // Install Mobility Model
467 MobilityHelper mobility;
468 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
469 mobility.Install(allNodes);
470
471 // Create Devices and install them in the Nodes (eNB and UE)
472 NetDeviceContainer enbDevs;
473 NetDeviceContainer ueDevs;
474 lteHelper->SetSchedulerType("ns3::PfFfMacScheduler");
475 enbDevs = lteHelper->InstallEnbDevice(enbNodes);
476 ueDevs = lteHelper->InstallUeDevice(ueNodes);
477
478 // Attach a UE to a eNB
479 lteHelper->Attach(ueDevs, enbDevs.Get(0));
480
481 PointerValue tmp;
482 enbDevs.Get(0)->GetAttribute("LteFfrAlgorithm", tmp);
483 Ptr<LteFfrSimple> simpleFfrAlgorithm = DynamicCast<LteFfrSimple>(tmp.GetObject());
484 simpleFfrAlgorithm->ChangePdschConfigDedicated(m_changePdschConfigDedicated);
485 simpleFfrAlgorithm->SetPdschConfigDedicated(m_pdschConfigDedicated);
486
487 // Activate the default EPS bearer
488 enum EpsBearer::Qci q = EpsBearer::NGBR_VIDEO_TCP_DEFAULT;
489 EpsBearer bearer(q);
490 lteHelper->ActivateDataRadioBearer(ueDevs, bearer);
491
492 // Use testing chunk processor in the PHY layer
493 // It will be used to calculate data and ctrl power in downlink
494
495 Ptr<LtePhy> ue1Phy = ueDevs.Get(0)->GetObject<LteUeNetDevice>()->GetPhy()->GetObject<LtePhy>();
496
497 Ptr<LteChunkProcessor> testDlDataPowerReceived = Create<LteChunkProcessor>();
498 LteSpectrumValueCatcher dlDataPowerReceivedCatcher;
499 testDlDataPowerReceived->AddCallback(
500 MakeCallback(&LteSpectrumValueCatcher::ReportValue, &dlDataPowerReceivedCatcher));
501 ue1Phy->GetDownlinkSpectrumPhy()->AddDataPowerChunkProcessor(testDlDataPowerReceived);
502
503 Ptr<LteChunkProcessor> testDlCtrlPowerReceived = Create<LteChunkProcessor>();
504 LteSpectrumValueCatcher dlCtrlPowerReceivedCatcher;
505 testDlCtrlPowerReceived->AddCallback(
506 MakeCallback(&LteSpectrumValueCatcher::ReportValue, &dlCtrlPowerReceivedCatcher));
507 ue1Phy->GetDownlinkSpectrumPhy()->AddRsPowerChunkProcessor(testDlCtrlPowerReceived);
508
509 Simulator::Stop(Seconds(0.400));
510 Simulator::Run();
511
512 double dataPower = 10.0 * std::log10(dlDataPowerReceivedCatcher.GetValue()->operator[](0));
513 double ctrlPower = 10.0 * std::log10(dlCtrlPowerReceivedCatcher.GetValue()->operator[](0));
514 double powerDiff = (-1.0) * ctrlPower + dataPower;
515
516 NS_LOG_DEBUG("DataPower: " << dataPower);
517 NS_LOG_DEBUG("CtrlPower: " << ctrlPower);
518 NS_LOG_DEBUG("PowerDifference: " << powerDiff);
519 NS_LOG_DEBUG("ExpectedPowerDifference: " << m_expectedPowerDiff);
520
521 NS_TEST_ASSERT_MSG_EQ_TOL(
522 powerDiff,
523 m_expectedPowerDiff,
524 0.001,
525 "Downlink Data and Ctrl Power Difference are not equal within tolerance");
526
527 Simulator::Destroy();
528}
529
530void
531NotifyConnectionReconfigurationUe(
532 LteDownlinkPowerControlRrcConnectionReconfigurationTestCase* testcase,
533 std::string context,
534 uint64_t imsi,
535 uint16_t cellId,
536 uint16_t rnti)
537{
538 testcase->ConnectionReconfigurationUe(context, imsi, cellId, rnti);
539}
540
541void
542NotifyConnectionReconfigurationEnb(
543 LteDownlinkPowerControlRrcConnectionReconfigurationTestCase* testcase,
544 std::string context,
545 uint64_t imsi,
546 uint16_t cellId,
547 uint16_t rnti)
548{
549 testcase->ConnectionReconfigurationEnb(context, imsi, cellId, rnti);
550}
551
552void
553ChangePdschConfigDedicatedCallback(
554 LteDownlinkPowerControlRrcConnectionReconfigurationTestCase* testcase,
555 std::string context,
556 uint16_t rnti,
557 uint8_t pa)
558{
559 testcase->ChangePdschConfigDedicated(rnti, pa);
560}
561
562LteDownlinkPowerControlRrcConnectionReconfigurationTestCase::
563 LteDownlinkPowerControlRrcConnectionReconfigurationTestCase(bool useIdealRrc, std::string name)
564 : TestCase("Downlink Power Control: " + name),
565 m_useIdealRrc(useIdealRrc),
566 m_changePdschConfigDedicatedTriggered(false),
567 m_connectionReconfigurationUeReceived(false),
568 m_connectionReconfigurationEnbCompleted(false)
569{
570}
571
572LteDownlinkPowerControlRrcConnectionReconfigurationTestCase::
573 ~LteDownlinkPowerControlRrcConnectionReconfigurationTestCase()
574{
575}
576
577void
578LteDownlinkPowerControlRrcConnectionReconfigurationTestCase::ConnectionReconfigurationEnb(
579 std::string context,
580 uint64_t imsi,
581 uint16_t cellid,
582 uint16_t rnti)
583{
584 if (Simulator::Now() > MilliSeconds(100))
585 {
586 NS_LOG_DEBUG("eNb ConnectionReconfigurationCompleted");
587 m_connectionReconfigurationEnbCompleted = true;
588 }
589}
590
591void
592LteDownlinkPowerControlRrcConnectionReconfigurationTestCase::ConnectionReconfigurationUe(
593 std::string context,
594 uint64_t imsi,
595 uint16_t cellid,
596 uint16_t rnti)
597{
598 if (Simulator::Now() > MilliSeconds(100))
599 {
600 NS_LOG_DEBUG("Ue ConnectionReconfiguration");
601 m_connectionReconfigurationUeReceived = true;
602 }
603}
604
605void
606LteDownlinkPowerControlRrcConnectionReconfigurationTestCase::ChangePdschConfigDedicated(
607 uint16_t rnti,
608 uint8_t pa)
609{
610 NS_LOG_DEBUG("FFR Algorithm ChangePdschConfigDedicated");
611 m_changePdschConfigDedicatedTriggered = true;
612}
613
614void
615LteDownlinkPowerControlRrcConnectionReconfigurationTestCase::DoRun()
616{
617 Config::Reset();
618 Config::SetDefault("ns3::LteHelper::UseIdealRrc", BooleanValue(m_useIdealRrc));
619
624 Ptr<LteHelper> lteHelper = CreateObject<LteHelper>();
625 lteHelper->SetFfrAlgorithmType("ns3::LteFfrSimple");
626
627 // Create Nodes: eNodeB and UE
628 NodeContainer enbNodes;
629 NodeContainer ueNodes;
630 enbNodes.Create(1);
631 ueNodes.Create(1);
632 NodeContainer allNodes = NodeContainer(enbNodes, ueNodes);
633
634 // Install Mobility Model
635 MobilityHelper mobility;
636 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
637 mobility.Install(allNodes);
638
639 // Create Devices and install them in the Nodes (eNB and UE)
640 NetDeviceContainer enbDevs;
641 NetDeviceContainer ueDevs;
642 lteHelper->SetSchedulerType("ns3::PfFfMacScheduler");
643 enbDevs = lteHelper->InstallEnbDevice(enbNodes);
644 ueDevs = lteHelper->InstallUeDevice(ueNodes);
645
646 // Attach a UE to a eNB
647 lteHelper->Attach(ueDevs, enbDevs.Get(0));
648
649 PointerValue tmp;
650 enbDevs.Get(0)->GetAttribute("LteFfrAlgorithm", tmp);
651 Ptr<LteFfrSimple> simpleFfrAlgorithm = DynamicCast<LteFfrSimple>(tmp.GetObject());
652 LteRrcSap::PdschConfigDedicated pdschConfigDedicated;
653 pdschConfigDedicated.pa = LteRrcSap::PdschConfigDedicated::dB_6;
654 simpleFfrAlgorithm->ChangePdschConfigDedicated(true);
655 simpleFfrAlgorithm->SetPdschConfigDedicated(pdschConfigDedicated);
656
657 // Activate the default EPS bearer
658 enum EpsBearer::Qci q = EpsBearer::NGBR_VIDEO_TCP_DEFAULT;
659 EpsBearer bearer(q);
660 lteHelper->ActivateDataRadioBearer(ueDevs, bearer);
661
662 Config::Connect("/NodeList/0/DeviceList/0/LteFfrAlgorithm/ChangePdschConfigDedicated",
663 MakeBoundCallback(&ChangePdschConfigDedicatedCallback, this));
664 Config::Connect("/NodeList/1/DeviceList/0/LteUeRrc/ConnectionReconfiguration",
665 MakeBoundCallback(&NotifyConnectionReconfigurationUe, this));
666 Config::Connect("/NodeList/0/DeviceList/0/LteEnbRrc/ConnectionReconfiguration",
667 MakeBoundCallback(&NotifyConnectionReconfigurationEnb, this));
668
669 Simulator::Stop(Seconds(0.400));
670 Simulator::Run();
671
672 NS_TEST_ASSERT_MSG_EQ(m_changePdschConfigDedicatedTriggered,
673 true,
674 "Ffr have not changed PdschConfigDedicated for UE");
675 NS_TEST_ASSERT_MSG_EQ(m_connectionReconfigurationUeReceived,
676 true,
677 "Ue have not received RrcConnectionReconfiguration");
678 NS_TEST_ASSERT_MSG_EQ(m_connectionReconfigurationEnbCompleted,
679 true,
680 "Enb have not received RrcConnectionReconfigurationCompleted");
681
682 Simulator::Destroy();
683}
ns3::BooleanValue
AttributeValue implementation for Boolean.
Definition: boolean.h:37
ns3::EpsBearer
This class contains the specification of EPS Bearers.
Definition: eps-bearer.h:91
ns3::EpsBearer::Qci
Qci
QoS Class Indicator.
Definition: eps-bearer.h:106
ns3::LteFfrSimple::ChangePdschConfigDedicated
void ChangePdschConfigDedicated(bool change)
Callback function that is used to be connected to trace ChangePdschConfigDedicated.
Definition: lte-ffr-simple.cc:156
ns3::LteFfrSimple::SetPdschConfigDedicated
void SetPdschConfigDedicated(LteRrcSap::PdschConfigDedicated pdschConfigDedicated)
Set PDSCH config dedicated function.
Definition: lte-ffr-simple.cc:162
ns3::LteHelper::SetFfrAlgorithmType
void SetFfrAlgorithmType(std::string type)
Set the type of FFR algorithm to be used by eNodeB devices.
Definition: lte-helper.cc:316
ns3::LteHelper::InstallEnbDevice
NetDeviceContainer InstallEnbDevice(NodeContainer c)
Create a set of eNodeB devices.
Definition: lte-helper.cc:482
ns3::LteHelper::SetSchedulerType
void SetSchedulerType(std::string type)
Set the type of scheduler to be used by eNodeB devices.
Definition: lte-helper.cc:289
ns3::LteHelper::Attach
void Attach(NetDeviceContainer ueDevices)
Enables automatic attachment of a set of UE devices to a suitable cell using Idle mode initial cell s...
Definition: lte-helper.cc:1044
ns3::LteHelper::ActivateDataRadioBearer
void ActivateDataRadioBearer(NetDeviceContainer ueDevices, EpsBearer bearer)
Activate a Data Radio Bearer on a given UE devices (for LTE-only simulation).
Definition: lte-helper.cc:1441
ns3::LteHelper::InstallUeDevice
NetDeviceContainer InstallUeDevice(NodeContainer c)
Create a set of UE devices.
Definition: lte-helper.cc:497
ns3::LtePhy
The LtePhy models the physical layer of LTE.
Definition: lte-phy.h:50
ns3::LteSpectrumValueCatcher
A sink to be plugged to the callback of LteChunkProcessor allowing to save and later retrieve the lat...
Definition: lte-chunk-processor.h:103
ns3::LteSpectrumValueCatcher::GetValue
Ptr< SpectrumValue > GetValue()
Definition: lte-chunk-processor.cc:95
ns3::LteSpectrumValueHelper
This class defines all functions to create spectrum model for lte.
Definition: lte-spectrum-value-helper.h:37
ns3::LteUeNetDevice
The LteUeNetDevice class implements the UE net device.
Definition: lte-ue-net-device.h:58
ns3::MobilityHelper
Helper class used to assign positions and mobility models to nodes.
Definition: mobility-helper.h:44
ns3::NetDeviceContainer
holds a vector of ns3::NetDevice pointers
Definition: net-device-container.h:43
ns3::NetDeviceContainer::Get
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr<NetDevice> stored in this container at a given index.
Definition: net-device-container.cc:67
ns3::NodeContainer
keep track of a set of node pointers.
Definition: node-container.h:40
ns3::NodeContainer::Create
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
Definition: node-container.cc:84
ns3::Object::GetObject
Ptr< T > GetObject() const
Get a pointer to the requested aggregated Object.
Definition: object.h:471
ns3::PointerValue
Hold objects of type Ptr<T>.
Definition: pointer.h:37
ns3::PointerValue::GetObject
Ptr< Object > GetObject() const
Get the Object referenced by the PointerValue.
Definition: pointer.cc:57
ns3::SpectrumValue
Set of values corresponding to a given SpectrumModel.
Definition: spectrum-value.h:60
ns3::SpectrumValue::GetSpectrumModelUid
SpectrumModelUid_t GetSpectrumModelUid() const
Definition: spectrum-value.cc:53
ns3::TestCase
encapsulates test code
Definition: test.h:1060
ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:305
ns3::TestSuite
A suite of tests to run.
Definition: test.h:1256
ns3::Config::Reset
void Reset()
Reset the initial value of every attribute as well as the value of every global to what they were bef...
Definition: config.cc:856
ns3::Config::SetDefault
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:891
ns3::Config::Connect
void Connect(std::string path, const CallbackBase &cb)
Definition: config.cc:975
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
NS_LOG_DEBUG
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:268
NS_LOG_INFO
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:275
ns3::MakeBoundCallback
auto MakeBoundCallback(R(*fnPtr)(Args...), BArgs... bargs)
Make Callbacks with varying number of bound arguments.
Definition: callback.h:752
ns3::Create
Ptr< T > Create(Ts &&... args)
Create class instances by constructors with varying numbers of arguments and return them by Ptr.
Definition: ptr.h:481
ns3::Now
Time Now()
create an ns3::Time instance which contains the current simulation time.
Definition: simulator.cc:296
NS_TEST_ASSERT_MSG_SPECTRUM_VALUE_EQ_TOL
#define NS_TEST_ASSERT_MSG_SPECTRUM_VALUE_EQ_TOL(actual, expected, tol, msg)
Test if two SpectrumValue instances are equal within a given tolerance.
Definition: spectrum-test.h:110
NS_TEST_ASSERT_MSG_EQ
#define NS_TEST_ASSERT_MSG_EQ(actual, limit, msg)
Test that an actual and expected (limit) value are equal and report and abort if not.
Definition: test.h:144
NS_TEST_ASSERT_MSG_EQ_TOL
#define NS_TEST_ASSERT_MSG_EQ_TOL(actual, limit, tol, msg)
Test that actual and expected (limit) values are equal to plus or minus some tolerance and report and...
Definition: test.h:337
ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1338
ns3::MilliSeconds
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1350
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::MakeCallback
Callback< R, Args... > MakeCallback(R(T::*memPtr)(Args...), OBJ objPtr)
Build Callbacks for class method members which take varying numbers of arguments and potentially retu...
Definition: callback.h:691
third.mobility
mobility
Definition: third.py:96
ns3::LteRrcSap::PdschConfigDedicated
PdschConfigDedicated structure.
Definition: lte-rrc-sap.h:157