A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
lte-test-phy-error-model.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2011-2013 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
3 *
4 * SPDX-License-Identifier: GPL-2.0-only
5 *
6 * Author: Marco Miozzo <marco.miozzo@cttc.es>
7 * Nicola Baldo <nbaldo@cttc.es>
8 */
9
10#include "lte-test-phy-error-model.h"
11
12#include "ns3/boolean.h"
13#include "ns3/buildings-helper.h"
14#include "ns3/config.h"
15#include "ns3/double.h"
16#include "ns3/enum.h"
17#include "ns3/eps-bearer.h"
18#include "ns3/ff-mac-scheduler.h"
19#include "ns3/hybrid-buildings-propagation-loss-model.h"
20#include "ns3/integer.h"
21#include "ns3/log.h"
22#include "ns3/lte-enb-net-device.h"
23#include "ns3/lte-enb-phy.h"
24#include "ns3/lte-helper.h"
25#include "ns3/lte-ue-net-device.h"
26#include "ns3/lte-ue-phy.h"
27#include "ns3/lte-ue-rrc.h"
28#include "ns3/mobility-building-info.h"
29#include "ns3/mobility-helper.h"
30#include "ns3/net-device-container.h"
31#include "ns3/node-container.h"
32#include "ns3/object.h"
33#include "ns3/packet.h"
34#include "ns3/ptr.h"
35#include "ns3/radio-bearer-stats-calculator.h"
36#include "ns3/simulator.h"
37#include "ns3/spectrum-error-model.h"
38#include "ns3/spectrum-interference.h"
39#include "ns3/string.h"
40#include "ns3/test.h"
41
42#include <iostream>
43
44using namespace ns3;
45
46NS_LOG_COMPONENT_DEFINE("LteTestPhyErrorModel");
47
48LenaTestPhyErrorModelSuite::LenaTestPhyErrorModelSuite()
49 : TestSuite("lte-phy-error-model", Type::SYSTEM)
50{
51 NS_LOG_INFO("creating LenaTestPhyErrorModelTestCase");
52
53 for (uint32_t rngRun = 1; rngRun <= 3; ++rngRun)
54 {
55 // Tests on DL Control Channels (PCFICH+PDCCH)
56 // the tolerance is calculated with the following octave code:
57 //
58 // n = 1000; # TX packets
59 // for p=1-[0.007 0.045 0.206 0.343]
60 // tol = n*p - binoinv(0.001, n, p)
61 // endfor
62
63 // This octave code calculates a 99.9% confidence level test (0.001 failure rate)
64 // for a binomial distribution. 'p' in this case comes from the PCFICH-PDCCH error
65 // curve in lte-mi-error-model.cc:75-91.
66 // SINR 2.0 dB corresponds to BLER of roughly 0.007, SINR 4.0 dB to BLER of 0.045
67 // SINR 6.0 dB to 0.206, and SINR 7.0 dB to 0.343.
68
69 // 1 interfering eNB SINR -2.0 BLER 0.007 TB size 217
70 AddTestCase(new LenaDlCtrlPhyErrorModelTestCase(2, 1078, 0.007, 9, rngRun),
71 (rngRun == 1) ? TestCase::Duration::QUICK : TestCase::Duration::TAKES_FOREVER);
72 // 2 interfering eNBs SINR -4.0 BLER 0.037 TB size 217
73 AddTestCase(new LenaDlCtrlPhyErrorModelTestCase(3, 1040, 0.045, 21, rngRun),
74 (rngRun == 1) ? TestCase::Duration::EXTENSIVE
75 : TestCase::Duration::TAKES_FOREVER);
76 // 3 interfering eNBs SINR -6.0 BLER 0.21 TB size 133
77 AddTestCase(new LenaDlCtrlPhyErrorModelTestCase(4, 1250, 0.206, 40, rngRun),
78 (rngRun == 1) ? TestCase::Duration::EXTENSIVE
79 : TestCase::Duration::TAKES_FOREVER);
80 // 4 interfering eNBs SINR -7.0 BLER 0.34 TB size 133
81 AddTestCase(new LenaDlCtrlPhyErrorModelTestCase(5, 1260, 0.343, 47, rngRun),
82 (rngRun == 1) ? TestCase::Duration::EXTENSIVE
83 : TestCase::Duration::TAKES_FOREVER);
84
85 // Tests on DL Data channels (PDSCH)
86 // the tolerance is calculated with the following octave code:
87 //
88 // n = 1000; # TX packets
89 // for p=1-[0.33 0.11 0.2 0.3 0.55 0.14]
90 // tol = n*p - binoinv(0.005, n, p)
91 // endfor
92
93 // MCS 2 TB size of 256 bits BLER 0.33 SINR -5.51
94 AddTestCase(new LenaDataPhyErrorModelTestCase(4, 1800, 0.33, 39, rngRun),
95 (rngRun == 1) ? TestCase::Duration::QUICK : TestCase::Duration::TAKES_FOREVER);
96 // MCS 2 TB size of 528 bits BLER 0.11 SINR -5.51
97 AddTestCase(new LenaDataPhyErrorModelTestCase(2, 1800, 0.11, 26, rngRun),
98 (rngRun == 1) ? TestCase::Duration::EXTENSIVE
99 : TestCase::Duration::TAKES_FOREVER);
100 // MCS 2 TB size of 1088 bits BLER 0.02 SINR -5.51
101 AddTestCase(new LenaDataPhyErrorModelTestCase(1, 1800, 0.02, 33, rngRun),
102 (rngRun == 1) ? TestCase::Duration::EXTENSIVE
103 : TestCase::Duration::TAKES_FOREVER);
104 // MCS 12 TB size of 4800 bits BLER 0.3 SINR 4.43
105 AddTestCase(new LenaDataPhyErrorModelTestCase(1, 600, 0.3, 38, rngRun),
106 (rngRun == 1) ? TestCase::Duration::EXTENSIVE
107 : TestCase::Duration::TAKES_FOREVER);
108 // MCS 12 TB size of 1632 bits BLER 0.55 SINR 4.43
109 AddTestCase(new LenaDataPhyErrorModelTestCase(3, 600, 0.55, 40, rngRun),
110 (rngRun == 1) ? TestCase::Duration::EXTENSIVE
111 : TestCase::Duration::TAKES_FOREVER);
112 // MCS 16 TB size of 7272 bits (3648 x 3584) BLER 0.14 SINR 8.48
113 // BLER 0.14 = 1 - ((1-0.075)*(1-0.075))
114 AddTestCase(new LenaDataPhyErrorModelTestCase(1, 470, 0.14, 29, rngRun),
115 (rngRun == 1) ? TestCase::Duration::EXTENSIVE
116 : TestCase::Duration::TAKES_FOREVER);
117 }
118}
119
120/**
121 * @ingroup lte-test
122 * Static variable for test initialization
123 */
124static LenaTestPhyErrorModelSuite lenaTestPhyErrorModelSuite;
125
126std::string
127LenaDataPhyErrorModelTestCase::BuildNameString(uint16_t nUser, uint16_t dist, uint32_t rngRun)
128{
129 std::ostringstream oss;
130 oss << "DataPhyErrorModel " << nUser << " UEs, distance " << dist << " m, RngRun " << rngRun;
131 return oss.str();
132}
133
134LenaDataPhyErrorModelTestCase::LenaDataPhyErrorModelTestCase(uint16_t nUser,
135 uint16_t dist,
136 double blerRef,
137 uint16_t toleranceRxPackets,
138 uint32_t rngRun)
139 : TestCase(BuildNameString(nUser, dist, rngRun)),
140 m_nUser(nUser),
141 m_dist(dist),
142 m_blerRef(blerRef),
143 m_toleranceRxPackets(toleranceRxPackets),
144 m_rngRun(rngRun)
145{
146}
147
151
152void
153LenaDataPhyErrorModelTestCase::DoRun()
154{
155 SetDataDir(NS_TEST_SOURCEDIR);
156 double ber = 0.03;
157 // Allow extra time in the beginning of simulation to allow RRC connection
158 // establishment + SRS. The random variable (m_random in LteSpectrumPhy) can
159 // cause the MIB reception to be corrupted on the first reception attempt,
160 // leading the connection to be delayed for an extra MIB period of 80 ms.
161 // Earlier versions of this test used 40 milliseconds for low interference
162 // configurations, and 120 milliseconds for high interference configurations
163 // (4 or 5 eNBs), but 120 milliseconds was found to be too low for at least
164 // one case, so 150 ms is more conservative.
165 Time statsStartTime = MilliSeconds(150);
166 Config::SetDefault("ns3::LteAmc::Ber", DoubleValue(ber));
167 Config::SetDefault("ns3::LteAmc::AmcModel", EnumValue(LteAmc::PiroEW2010));
168 Config::SetDefault("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue(false));
169 Config::SetDefault("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue(true));
170 Config::SetDefault("ns3::RrFfMacScheduler::HarqEnabled", BooleanValue(false));
171 Config::SetGlobal("RngRun", UintegerValue(m_rngRun));
172
173 Config::SetDefault("ns3::RadioBearerStatsCalculator::DlRlcOutputFilename",
174 StringValue(CreateTempDirFilename("DlRlcStats.txt")));
175 Config::SetDefault("ns3::RadioBearerStatsCalculator::UlRlcOutputFilename",
176 StringValue(CreateTempDirFilename("UlRlcStats.txt")));
177
178 // Disable Uplink Power Control
179 Config::SetDefault("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue(false));
180
181 /*
182 * Initialize Simulation Scenario: 1 eNB and m_nUser UEs
183 */
184
185 int64_t stream = 1;
186 Ptr<LteHelper> lena = CreateObject<LteHelper>();
187
188 // Create Nodes: eNodeB and UE
189 NodeContainer enbNodes;
190 NodeContainer ueNodes;
191 enbNodes.Create(1);
192 ueNodes.Create(m_nUser);
193
194 // Install Mobility Model
195 MobilityHelper mobility;
196 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
197 mobility.Install(enbNodes);
198 BuildingsHelper::Install(enbNodes);
199 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
200 mobility.Install(ueNodes);
201 BuildingsHelper::Install(ueNodes);
202
203 // remove random shadowing component
204 lena->SetAttribute("PathlossModel", StringValue("ns3::HybridBuildingsPropagationLossModel"));
205 lena->SetPathlossModelAttribute("ShadowSigmaOutdoor", DoubleValue(0.0));
206 lena->SetPathlossModelAttribute("ShadowSigmaIndoor", DoubleValue(0.0));
207 lena->SetPathlossModelAttribute("ShadowSigmaExtWalls", DoubleValue(0.0));
208
209 // Create Devices and install them in the Nodes (eNB and UE)
210 NetDeviceContainer enbDevs;
211 NetDeviceContainer ueDevs;
212 lena->SetSchedulerType("ns3::RrFfMacScheduler");
213 lena->SetSchedulerAttribute("UlCqiFilter", EnumValue(FfMacScheduler::PUSCH_UL_CQI));
214
215 enbDevs = lena->InstallEnbDevice(enbNodes);
216 // Call AssignStreams in the EpcHelper only once by setting 'assignEpcStreams' only once
217 // Then, increment the stream value by 1000 (a magic number that should ensure that there
218 // are no overlapping stream assignments) each time that AssignStreams is called,
219 // to lessen the possibility that random variable stream assignment changes propagate
220 // to other objects.
221 lena->AssignStreams(enbDevs, stream, false);
222 stream += 1000;
223 ueDevs = lena->InstallUeDevice(ueNodes);
224 lena->AssignStreams(ueDevs, stream, true);
225 stream += 1000;
226 lena->GetDownlinkSpectrumChannel()->AssignStreams(stream);
227 stream += 1000;
228 lena->GetUplinkSpectrumChannel()->AssignStreams(stream);
229 stream += 1000;
230
231 // Attach a UE to a eNB
232 lena->Attach(ueDevs, enbDevs.Get(0));
233
234 // Activate an EPS bearer. When ActivateDataRadioBearer is called without
235 // an EPC, it defaults to the saturation mode RLC (RLC_SM_ALWAYS), which
236 // causes one packet to be generated per TTI, which provides the traffic
237 // for this test.
238 EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
239 EpsBearer bearer(q);
240 lena->ActivateDataRadioBearer(ueDevs, bearer);
241
242 Ptr<LteEnbNetDevice> lteEnbDev = enbDevs.Get(0)->GetObject<LteEnbNetDevice>();
243 Ptr<LteEnbPhy> enbPhy = lteEnbDev->GetPhy();
244 enbPhy->SetAttribute("TxPower", DoubleValue(43.0));
245 enbPhy->SetAttribute("NoiseFigure", DoubleValue(5.0));
246 // place the HeNB over the default rooftop level (20 mt.)
247 Ptr<MobilityModel> mm = enbNodes.Get(0)->GetObject<MobilityModel>();
248 mm->SetPosition(Vector(0.0, 0.0, 30.0));
249
250 // Set UEs' position and power
251 for (int i = 0; i < m_nUser; i++)
252 {
253 Ptr<MobilityModel> mm1 = ueNodes.Get(i)->GetObject<MobilityModel>();
254 mm1->SetPosition(Vector(m_dist, 0.0, 1.0));
255 Ptr<LteUeNetDevice> lteUeDev = ueDevs.Get(i)->GetObject<LteUeNetDevice>();
256 Ptr<LteUePhy> uePhy = lteUeDev->GetPhy();
257 uePhy->SetAttribute("TxPower", DoubleValue(23.0));
258 uePhy->SetAttribute("NoiseFigure", DoubleValue(9.0));
259 }
260
261 Time statsDuration = Seconds(1);
262 Simulator::Stop(statsStartTime + statsDuration - Seconds(0.0001));
263
264 lena->EnableRlcTraces();
265 Ptr<RadioBearerStatsCalculator> rlcStats = lena->GetRlcStats();
266 rlcStats->SetAttribute("StartTime", TimeValue(statsStartTime));
267 rlcStats->SetAttribute("EpochDuration", TimeValue(statsDuration));
268
269 Simulator::Run();
270
271 NS_LOG_INFO("\tTest downlink data shared channels (PDSCH)");
272 NS_LOG_INFO("Test with " << m_nUser << " user(s) at distance " << m_dist << " expected BLER "
273 << m_blerRef);
274 for (int i = 0; i < m_nUser; i++)
275 {
276 // get the imsi
277 uint64_t imsi = ueDevs.Get(i)->GetObject<LteUeNetDevice>()->GetImsi();
278 uint8_t lcId = 3;
279
280 double dlRxPackets = rlcStats->GetDlRxPackets(imsi, lcId);
281 double dlTxPackets = rlcStats->GetDlTxPackets(imsi, lcId);
282 double dlBler [[maybe_unused]] = 1.0 - (dlRxPackets / dlTxPackets);
283 double expectedDlRxPackets = dlTxPackets - dlTxPackets * m_blerRef;
284 NS_LOG_INFO("\tUser " << i << " imsi " << imsi << " DOWNLINK"
285 << " pkts rx " << dlRxPackets << " tx " << dlTxPackets << " BLER "
286 << dlBler << " Err " << std::fabs(m_blerRef - dlBler)
287 << " expected rx " << expectedDlRxPackets << " difference "
288 << std::abs(expectedDlRxPackets - dlRxPackets) << " tolerance "
289 << m_toleranceRxPackets);
290
291 // sanity check for whether the tx packets reported by the stats are correct
292 // we expect one packet per TTI
293 auto expectedDlTxPackets = static_cast<double>(statsDuration.GetMilliSeconds());
294 NS_TEST_ASSERT_MSG_EQ_TOL(dlTxPackets,
295 expectedDlTxPackets,
296 expectedDlTxPackets * 0.005,
297 " too different DL TX packets reported");
298
299 // this is the main test condition: check that the RX packets are within the expected range
300 NS_TEST_ASSERT_MSG_EQ_TOL(dlRxPackets,
301 expectedDlRxPackets,
302 m_toleranceRxPackets,
303 " too different DL RX packets reported");
304 }
305
306 Simulator::Destroy();
307}
308
309std::string
310LenaDlCtrlPhyErrorModelTestCase::BuildNameString(uint16_t nEnb, uint16_t dist, uint32_t rngRun)
311{
312 std::ostringstream oss;
313 oss << "DlCtrlPhyErrorModel " << nEnb << " eNBs, distance " << dist << " m, RngRun " << rngRun;
314 return oss.str();
315}
316
317LenaDlCtrlPhyErrorModelTestCase::LenaDlCtrlPhyErrorModelTestCase(uint16_t nEnb,
318 uint16_t dist,
319 double blerRef,
320 uint16_t toleranceRxPackets,
321 uint32_t rngRun)
322 : TestCase(BuildNameString(nEnb, dist, rngRun)),
323 m_nEnb(nEnb),
324 m_dist(dist),
325 m_blerRef(blerRef),
326 m_toleranceRxPackets(toleranceRxPackets),
327 m_rngRun(rngRun)
328{
329}
330
334
335void
336LenaDlCtrlPhyErrorModelTestCase::DoRun()
337{
338 SetDataDir(NS_TEST_SOURCEDIR);
339
340 double ber = 0.03;
341 // Allow extra time in the beginning of simulation to allow RRC connection
342 // establishment + SRS. The random variable (m_random in LteSpectrumPhy) can
343 // cause the MIB reception to be corrupted on the first reception attempt,
344 // leading the connection to be delayed for an extra MIB period of 80 ms.
345 // Earlier versions of this test used 40 milliseconds for low interference
346 // configurations, and 120 milliseconds for high interference configurations
347 // (4 or 5 eNBs), but 120 milliseconds was found to be too low for at least
348 // one case, so 150 ms is more conservative.
349 Time statsStartTime = MilliSeconds(150);
350 Config::SetDefault("ns3::LteAmc::Ber", DoubleValue(ber));
351 Config::SetDefault("ns3::LteAmc::AmcModel", EnumValue(LteAmc::PiroEW2010));
352 Config::SetDefault("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue(true));
353 Config::SetDefault("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue(false));
354 Config::SetDefault("ns3::RrFfMacScheduler::HarqEnabled", BooleanValue(false));
355 Config::SetGlobal("RngRun", UintegerValue(m_rngRun));
356
357 Config::SetDefault("ns3::RadioBearerStatsCalculator::DlRlcOutputFilename",
358 StringValue(CreateTempDirFilename("DlRlcStats.txt")));
359 Config::SetDefault("ns3::RadioBearerStatsCalculator::UlRlcOutputFilename",
360 StringValue(CreateTempDirFilename("UlRlcStats.txt")));
361
362 // Disable Uplink Power Control
363 Config::SetDefault("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue(false));
364
365 /*
366 * Initialize Simulation Scenario: 1 eNB and m_nUser UEs
367 */
368
369 int64_t stream = 1;
370 Ptr<LteHelper> lena = CreateObject<LteHelper>();
371
372 // Create Nodes: eNodeB and UE
373 NodeContainer enbNodes;
374 NodeContainer ueNodes;
375 enbNodes.Create(m_nEnb);
376 ueNodes.Create(1);
377
378 // Install Mobility Model
379 MobilityHelper mobility;
380 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
381 mobility.Install(enbNodes);
382 BuildingsHelper::Install(enbNodes);
383 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
384 mobility.Install(ueNodes);
385 BuildingsHelper::Install(ueNodes);
386
387 // remove random shadowing component
388 lena->SetAttribute("PathlossModel", StringValue("ns3::HybridBuildingsPropagationLossModel"));
389 lena->SetPathlossModelAttribute("ShadowSigmaOutdoor", DoubleValue(0.0));
390 lena->SetPathlossModelAttribute("ShadowSigmaIndoor", DoubleValue(0.0));
391 lena->SetPathlossModelAttribute("ShadowSigmaExtWalls", DoubleValue(0.0));
392
393 // Create Devices and install them in the Nodes (eNB and UE)
394 NetDeviceContainer enbDevs;
395 NetDeviceContainer ueDevs;
396 lena->SetSchedulerType("ns3::RrFfMacScheduler");
397 lena->SetSchedulerAttribute("UlCqiFilter", EnumValue(FfMacScheduler::PUSCH_UL_CQI));
398
399 enbDevs = lena->InstallEnbDevice(enbNodes);
400 // Call AssignStreams in the EpcHelper only once by setting 'assignEpcStreams' only once
401 // Then, increment the stream value by 1000 (a magic number that should ensure that there
402 // are no overlapping stream assignments) each time that AssignStreams is called,
403 // to lessen the possibility that random variable stream assignment changes propagate
404 // to other objects.
405 lena->AssignStreams(enbDevs, stream, false);
406 stream += 1000;
407 ueDevs = lena->InstallUeDevice(ueNodes);
408 lena->AssignStreams(ueDevs, stream, true);
409 stream += 1000;
410 lena->GetDownlinkSpectrumChannel()->AssignStreams(stream);
411 stream += 1000;
412 lena->GetUplinkSpectrumChannel()->AssignStreams(stream);
413 stream += 1000;
414
415 // Attach a UE to one eNB (the others are interfering ones)
416 lena->Attach(ueDevs, enbDevs.Get(0));
417
418 // Activate an EPS bearer. When ActivateDataRadioBearer is called without
419 // an EPC, it defaults to the saturation mode RLC (RLC_SM_ALWAYS), which
420 // causes one packet to be generated per TTI, which provides the traffic
421 // for this test.
422 EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
423 EpsBearer bearer(q);
424 lena->ActivateDataRadioBearer(ueDevs, bearer);
425
426 // Set UEs' position and power
427 for (int i = 0; i < m_nEnb; i++)
428 {
429 // place the HeNB over the default rooftop level (20 mt.)
430 Ptr<MobilityModel> mm = enbNodes.Get(i)->GetObject<MobilityModel>();
431 mm->SetPosition(Vector(0.0, 0.0, 30.0));
432 Ptr<LteEnbNetDevice> lteEnbDev = enbDevs.Get(i)->GetObject<LteEnbNetDevice>();
433 Ptr<LteEnbPhy> enbPhy = lteEnbDev->GetPhy();
434 enbPhy->SetAttribute("TxPower", DoubleValue(43.0));
435 enbPhy->SetAttribute("NoiseFigure", DoubleValue(5.0));
436 }
437
438 // Set UEs' position and power
439 Ptr<MobilityModel> mm = ueNodes.Get(0)->GetObject<MobilityModel>();
440 mm->SetPosition(Vector(m_dist, 0.0, 1.0));
441 Ptr<LteUeNetDevice> lteUeDev = ueDevs.Get(0)->GetObject<LteUeNetDevice>();
442 Ptr<LteUePhy> uePhy = lteUeDev->GetPhy();
443 uePhy->SetAttribute("TxPower", DoubleValue(23.0));
444 uePhy->SetAttribute("NoiseFigure", DoubleValue(9.0));
445
446 Time statsDuration = Seconds(1);
447 Simulator::Stop(statsStartTime + statsDuration - Seconds(0.0001));
448
449 lena->EnableRlcTraces();
450 Ptr<RadioBearerStatsCalculator> rlcStats = lena->GetRlcStats();
451 rlcStats->SetAttribute("StartTime", TimeValue(statsStartTime));
452 rlcStats->SetAttribute("EpochDuration", TimeValue(statsDuration));
453
454 Simulator::Run();
455
456 NS_LOG_INFO("\tTest downlink control channels (PCFICH+PDCCH)");
457 NS_LOG_INFO("Test with " << m_nEnb << " eNB(s) at distance " << m_dist << " expected BLER "
458 << m_blerRef);
459 int nUser = 1;
460 for (int i = 0; i < nUser; i++)
461 {
462 // get the imsi
463 uint64_t imsi = ueDevs.Get(i)->GetObject<LteUeNetDevice>()->GetImsi();
464 uint8_t lcId = 3;
465 double dlRxPackets = rlcStats->GetDlRxPackets(imsi, lcId);
466 double dlTxPackets = rlcStats->GetDlTxPackets(imsi, lcId);
467 double dlBler [[maybe_unused]] = 1.0 - (dlRxPackets / dlTxPackets);
468 double expectedDlRxPackets = dlTxPackets - dlTxPackets * m_blerRef;
469 NS_LOG_INFO("\tUser " << i << " imsi " << imsi << " DOWNLINK"
470 << " pkts rx " << dlRxPackets << " tx " << dlTxPackets << " BLER "
471 << dlBler << " Err " << std::fabs(m_blerRef - dlBler)
472 << " expected rx " << expectedDlRxPackets << " difference "
473 << std::abs(expectedDlRxPackets - dlRxPackets) << " tolerance "
474 << m_toleranceRxPackets);
475
476 // sanity check for whether the tx packets reported by the stats are correct
477 // we expect one packet per TTI
478 auto expectedDlTxPackets = static_cast<double>(statsDuration.GetMilliSeconds());
479 NS_TEST_ASSERT_MSG_EQ_TOL(dlTxPackets,
480 expectedDlTxPackets,
481 expectedDlTxPackets * 0.005,
482 " too different DL TX packets reported");
483
484 // this is the main test condition: check that the RX packets are within the expected range
485 NS_TEST_ASSERT_MSG_EQ_TOL(dlRxPackets,
486 expectedDlRxPackets,
487 m_toleranceRxPackets,
488 "too different DL RX packets reported");
489 }
490
491 Simulator::Destroy();
492}
q
uint32_t q
Definition cairo-wideint.c:774
LenaDataPhyErrorModelTestCase
This system test program creates different test cases with a single eNB and several UEs,...
Definition lte-test-phy-error-model.h:28
LenaDataPhyErrorModelTestCase::BuildNameString
static std::string BuildNameString(uint16_t nUser, uint16_t dist, uint32_t rngRun)
Builds the test name string based on provided parameter values.
Definition lte-test-phy-error-model.cc:127
LenaDataPhyErrorModelTestCase::m_nUser
uint16_t m_nUser
number of UE nodes
Definition lte-test-phy-error-model.h:56
LenaDataPhyErrorModelTestCase::m_dist
double m_dist
the distance between nodes
Definition lte-test-phy-error-model.h:57
LenaDataPhyErrorModelTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition lte-test-phy-error-model.cc:153
LenaDataPhyErrorModelTestCase::LenaDataPhyErrorModelTestCase
LenaDataPhyErrorModelTestCase(uint16_t nUser, uint16_t dist, double blerRef, uint16_t toleranceRxPackets, uint32_t rngRun)
Constructor.
Definition lte-test-phy-error-model.cc:134
LenaDataPhyErrorModelTestCase::m_toleranceRxPackets
uint16_t m_toleranceRxPackets
receive packet tolerance loss
Definition lte-test-phy-error-model.h:59
LenaDlCtrlPhyErrorModelTestCase
Lena Dl Ctrl Phy Error Model Test Case.
Definition lte-test-phy-error-model.h:69
LenaDlCtrlPhyErrorModelTestCase::m_nEnb
uint16_t m_nEnb
the number of ENB nodes
Definition lte-test-phy-error-model.h:97
LenaDlCtrlPhyErrorModelTestCase::BuildNameString
static std::string BuildNameString(uint16_t nUser, uint16_t dist, uint32_t rngRun)
Build name string.
Definition lte-test-phy-error-model.cc:310
LenaDlCtrlPhyErrorModelTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition lte-test-phy-error-model.cc:336
LenaDlCtrlPhyErrorModelTestCase::m_dist
double m_dist
the distance between nodes
Definition lte-test-phy-error-model.h:98
LenaDlCtrlPhyErrorModelTestCase::m_toleranceRxPackets
uint16_t m_toleranceRxPackets
receive packet tolerance loss
Definition lte-test-phy-error-model.h:100
LenaDlCtrlPhyErrorModelTestCase::LenaDlCtrlPhyErrorModelTestCase
LenaDlCtrlPhyErrorModelTestCase(uint16_t nEnb, uint16_t dist, double blerRef, uint16_t toleranceRxPackets, uint32_t rngRun)
Constructor.
Definition lte-test-phy-error-model.cc:317
LenaTestPhyErrorModelSuite
Lena Test Phy Error Model Suite.
Definition lte-test-phy-error-model.h:110
ns3::BooleanValue
AttributeValue implementation for Boolean.
Definition boolean.h:26
ns3::BuildingsHelper::Install
static void Install(Ptr< Node > node)
Install the MobilityBuildingInfo to a node.
Definition buildings-helper.cc:34
ns3::DoubleValue
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition double.h:31
ns3::EnumValue
Hold variables of type enum.
Definition enum.h:52
ns3::EpsBearer
This class contains the specification of EPS Bearers.
Definition eps-bearer.h:80
ns3::EpsBearer::Qci
Qci
QoS Class Indicator.
Definition eps-bearer.h:95
ns3::EpsBearer::GBR_CONV_VOICE
@ GBR_CONV_VOICE
GBR Conversational Voice.
Definition eps-bearer.h:96
ns3::LteEnbNetDevice
The eNodeB device implementation.
Definition lte-enb-net-device.h:48
ns3::LteUeNetDevice
The LteUeNetDevice class implements the UE net device.
Definition lte-ue-net-device.h:46
ns3::MobilityHelper
Helper class used to assign positions and mobility models to nodes.
Definition mobility-helper.h:33
ns3::MobilityModel
Keep track of the current position and velocity of an object.
Definition mobility-model.h:30
ns3::NetDeviceContainer
holds a vector of ns3::NetDevice pointers
Definition net-device-container.h:32
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:56
ns3::NodeContainer
keep track of a set of node pointers.
Definition node-container.h:29
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:73
ns3::NodeContainer::Get
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
Definition node-container.cc:67
ns3::Object::GetObject
Ptr< T > GetObject() const
Get a pointer to the requested aggregated Object.
Definition object.h:518
ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition ptr.h:70
ns3::Simulator::Destroy
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
Definition simulator.cc:125
ns3::Simulator::Run
static void Run()
Run the simulation.
Definition simulator.cc:161
ns3::Simulator::Stop
static void Stop()
Tell the Simulator the calling event should be the last one executed.
Definition simulator.cc:169
ns3::StringValue
Hold variables of type string.
Definition string.h:45
ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, Duration duration=Duration::QUICK)
Add an individual child TestCase to this test suite.
Definition test.cc:296
ns3::TestCase::Duration::EXTENSIVE
@ EXTENSIVE
Medium length test.
Definition test.h:1058
ns3::TestCase::Duration::QUICK
@ QUICK
Fast test.
Definition test.h:1057
ns3::TestCase::Duration::TAKES_FOREVER
@ TAKES_FOREVER
Very long running test.
Definition test.h:1059
ns3::TestCase::CreateTempDirFilename
std::string CreateTempDirFilename(std::string filename)
Construct the full path to a file in a temporary directory.
Definition test.cc:436
ns3::TestCase::SetDataDir
void SetDataDir(std::string directory)
Set the data directory where reference trace files can be found.
Definition test.cc:476
ns3::TestCase::TestCase
TestCase(const TestCase &)=delete
Caller graph was not generated because of its size.
ns3::TestSuite::Type
Type
Type of test.
Definition test.h:1271
ns3::TestSuite::TestSuite
TestSuite(std::string name, Type type=Type::UNIT)
Construct a new test suite.
Definition test.cc:494
ns3::Time
Simulation virtual time values and global simulation resolution.
Definition nstime.h:95
ns3::Time::GetMilliSeconds
int64_t GetMilliSeconds() const
Get an approximation of the time stored in this instance in the indicated unit.
Definition nstime.h:403
ns3::TimeValue
AttributeValue implementation for Time.
Definition nstime.h:1375
ns3::UintegerValue
Hold an unsigned integer type.
Definition uinteger.h:34
uint32_t
ns3::Config::SetGlobal
void SetGlobal(std::string name, const AttributeValue &value)
Definition config.cc:932
ns3::Config::SetDefault
void SetDefault(std::string name, const AttributeValue &value)
Definition config.cc:886
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition log.h:194
NS_LOG_INFO
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition log.h:267
lenaTestPhyErrorModelSuite
static LenaTestPhyErrorModelSuite lenaTestPhyErrorModelSuite
Static variable for test initialization.
Definition lte-test-phy-error-model.cc:124
ns3::CreateObject
Ptr< T > CreateObject(Args &&... args)
Create an object by type, with varying number of constructor parameters.
Definition object.h:627
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:326
ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition nstime.h:1273
ns3::MilliSeconds
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition nstime.h:1290
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.