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