A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
lte-test-interference-fr.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2014 Piotr Gawlowicz
3 *
4 * SPDX-License-Identifier: GPL-2.0-only
5 *
6 * Author: Piotr Gawlowicz <gawlowicz.p@gmail.com>
7 * Based on lte-test-interference.{h,cc} by:
8 * Manuel Requena <manuel.requena@cttc.es>
9 * Nicola Baldo <nbaldo@cttc.es>
10 */
11
12#include "lte-test-interference-fr.h"
13
14#include "lte-simple-spectrum-phy.h"
15
16#include "ns3/boolean.h"
17#include "ns3/double.h"
18#include "ns3/ff-mac-scheduler.h"
19#include "ns3/log.h"
20#include "ns3/lte-enb-net-device.h"
21#include "ns3/lte-enb-phy.h"
22#include "ns3/lte-helper.h"
23#include "ns3/lte-spectrum-value-helper.h"
24#include "ns3/lte-ue-net-device.h"
25#include "ns3/lte-ue-phy.h"
26#include "ns3/mobility-helper.h"
27#include "ns3/simulator.h"
28#include "ns3/spectrum-value.h"
29#include "ns3/string.h"
30#include <ns3/enum.h>
31#include <ns3/lte-chunk-processor.h>
32#include <ns3/pointer.h>
33
34using namespace ns3;
35
36NS_LOG_COMPONENT_DEFINE("LteInterferenceFrTest");
37
38/**
39 * TestSuite
40 */
41
42LteInterferenceFrTestSuite::LteInterferenceFrTestSuite()
43 : TestSuite("lte-interference-fr", Type::SYSTEM)
44{
45 // LogLevel logLevel = (LogLevel)(LOG_PREFIX_FUNC | LOG_PREFIX_TIME | LOG_LEVEL_DEBUG);
46 // LogComponentEnable ("LteInterferenceFrTest", logLevel);
47
48 AddTestCase(new LteInterferenceHardFrTestCase("d1=50, d2=20",
49 50.000000,
50 20.000000,
51 356449.932732,
52 10803.280215),
53 TestCase::Duration::QUICK);
54 AddTestCase(new LteInterferenceHardFrTestCase("d1=50, d2=50",
55 50.000000,
56 50.000000,
57 356449.932732,
58 10803.280215),
59 TestCase::Duration::QUICK);
60 AddTestCase(new LteInterferenceHardFrTestCase("d1=50, d2=200",
61 50.000000,
62 200.000000,
63 356449.932732,
64 10803.280215),
65 TestCase::Duration::QUICK);
66 AddTestCase(new LteInterferenceHardFrTestCase("d1=50, d2=500",
67 50.000000,
68 500.000000,
69 356449.932732,
70 10803.280215),
71 TestCase::Duration::QUICK);
72
73 AddTestCase(new LteInterferenceStrictFrTestCase("d1=50, d2=20",
74 50.000000,
75 20.000000,
76 0.160000,
77 0.159998,
78 356449.932732,
79 10803.280215,
80 18),
81 TestCase::Duration::QUICK);
82 AddTestCase(new LteInterferenceStrictFrTestCase("d1=50, d2=50",
83 50.000000,
84 50.000000,
85 0.999997,
86 0.999907,
87 356449.932732,
88 10803.280215,
89 28),
90 TestCase::Duration::QUICK);
91 AddTestCase(new LteInterferenceStrictFrTestCase("d1=50, d2=200",
92 50.000000,
93 200.000000,
94 15.999282,
95 15.976339,
96 356449.932732,
97 10803.280215,
98 30),
99 TestCase::Duration::QUICK);
100 AddTestCase(new LteInterferenceStrictFrTestCase("d1=50, d2=500",
101 50.000000,
102 500.000000,
103 99.971953,
104 99.082845,
105 356449.932732,
106 10803.280215,
107 30),
108 TestCase::Duration::QUICK);
109}
110
111/**
112 * \ingroup lte-test
113 * Static variable for test initialization
114 */
115static LteInterferenceFrTestSuite LteInterferenceFrTestSuite;
116
117/**
118 * TestCase Data
119 */
120LteInterferenceHardFrTestCase::LteInterferenceHardFrTestCase(std::string name,
121 double d1,
122 double d2,
123 double dlSinr,
124 double ulSinr)
125 : TestCase("Test: " + name),
126 m_d1(d1),
127 m_d2(d2),
128 m_expectedDlSinrDb(10 * std::log10(dlSinr))
129{
130 NS_LOG_INFO("Creating LteInterferenceFrTestCase");
131}
132
136
137void
138LteInterferenceHardFrTestCase::DoRun()
139{
140 NS_LOG_INFO(this << GetName());
141 NS_LOG_DEBUG("LteInterferenceHardFrTestCase");
142
143 Config::Reset();
144 Config::SetDefault("ns3::LteHelper::UseIdealRrc", BooleanValue(false));
145
146 Config::SetDefault("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue(false));
147 Config::SetDefault("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue(false));
148 Config::SetDefault("ns3::LteAmc::AmcModel", EnumValue(LteAmc::PiroEW2010));
149 Config::SetDefault("ns3::LteAmc::Ber", DoubleValue(0.00005));
150
151 Ptr<LteHelper> lteHelper = CreateObject<LteHelper>();
152 lteHelper->SetFfrAlgorithmType("ns3::LteFrHardAlgorithm");
153
154 lteHelper->SetAttribute("PathlossModel", StringValue("ns3::FriisSpectrumPropagationLossModel"));
155
156 // Create Nodes: eNodeB and UE
157 NodeContainer enbNodes;
158 NodeContainer ueNodes1;
159 NodeContainer ueNodes2;
160 enbNodes.Create(2);
161 ueNodes1.Create(1);
162 ueNodes2.Create(1);
163 NodeContainer allNodes = NodeContainer(enbNodes, ueNodes1, ueNodes2);
164
165 // the topology is the following:
166 // d2
167 // UE1-----------eNB2
168 // | |
169 // d1| |d1
170 // | d2 |
171 // eNB1----------UE2
172 //
173 Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();
174 positionAlloc->Add(Vector(0.0, 0.0, 0.0)); // eNB1
175 positionAlloc->Add(Vector(m_d2, m_d1, 0.0)); // eNB2
176 positionAlloc->Add(Vector(0.0, m_d1, 0.0)); // UE1
177 positionAlloc->Add(Vector(m_d2, 0.0, 0.0)); // UE2
178 MobilityHelper mobility;
179 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
180 mobility.SetPositionAllocator(positionAlloc);
181 mobility.Install(allNodes);
182
183 // Create Devices and install them in the Nodes (eNB and UE)
184 NetDeviceContainer enbDevs;
185 NetDeviceContainer ueDevs1;
186 NetDeviceContainer ueDevs2;
187 lteHelper->SetSchedulerType("ns3::PfFfMacScheduler");
188 lteHelper->SetSchedulerAttribute("UlCqiFilter", EnumValue(FfMacScheduler::PUSCH_UL_CQI));
189
190 lteHelper->SetFfrAlgorithmAttribute("DlSubBandOffset", UintegerValue(0));
191 lteHelper->SetFfrAlgorithmAttribute("DlSubBandwidth", UintegerValue(12));
192 lteHelper->SetFfrAlgorithmAttribute("UlSubBandOffset", UintegerValue(0));
193 lteHelper->SetFfrAlgorithmAttribute("UlSubBandwidth", UintegerValue(25));
194 enbDevs.Add(lteHelper->InstallEnbDevice(enbNodes.Get(0)));
195
196 lteHelper->SetFfrAlgorithmAttribute("DlSubBandOffset", UintegerValue(12));
197 lteHelper->SetFfrAlgorithmAttribute("DlSubBandwidth", UintegerValue(12));
198 lteHelper->SetFfrAlgorithmAttribute("UlSubBandOffset", UintegerValue(0));
199 lteHelper->SetFfrAlgorithmAttribute("UlSubBandwidth", UintegerValue(25));
200 enbDevs.Add(lteHelper->InstallEnbDevice(enbNodes.Get(1)));
201
202 ueDevs1 = lteHelper->InstallUeDevice(ueNodes1);
203 ueDevs2 = lteHelper->InstallUeDevice(ueNodes2);
204
205 lteHelper->Attach(ueDevs1, enbDevs.Get(0));
206 lteHelper->Attach(ueDevs2, enbDevs.Get(1));
207
208 // Activate an EPS bearer
209 EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
210 EpsBearer bearer(q);
211 lteHelper->ActivateDataRadioBearer(ueDevs1, bearer);
212 lteHelper->ActivateDataRadioBearer(ueDevs2, bearer);
213
214 // Use testing chunk processor in the PHY layer
215 // It will be used to test that the SNR is as intended
216 // we plug in two instances, one for DL and one for UL
217
218 Ptr<LtePhy> ue1Phy = ueDevs1.Get(0)->GetObject<LteUeNetDevice>()->GetPhy()->GetObject<LtePhy>();
219 Ptr<LteChunkProcessor> testDlSinr1 = Create<LteChunkProcessor>();
220 LteSpectrumValueCatcher dlSinr1Catcher;
221 testDlSinr1->AddCallback(MakeCallback(&LteSpectrumValueCatcher::ReportValue, &dlSinr1Catcher));
222 ue1Phy->GetDownlinkSpectrumPhy()->AddDataSinrChunkProcessor(testDlSinr1);
223
224 Ptr<LtePhy> enb1phy =
225 enbDevs.Get(0)->GetObject<LteEnbNetDevice>()->GetPhy()->GetObject<LtePhy>();
226 Ptr<LteChunkProcessor> testUlSinr1 = Create<LteChunkProcessor>();
227 LteSpectrumValueCatcher ulSinr1Catcher;
228 testUlSinr1->AddCallback(MakeCallback(&LteSpectrumValueCatcher::ReportValue, &ulSinr1Catcher));
229 enb1phy->GetUplinkSpectrumPhy()->AddDataSinrChunkProcessor(testUlSinr1);
230
231 // same as above for eNB2 and UE2
232
233 Ptr<LtePhy> ue2Phy = ueDevs2.Get(0)->GetObject<LteUeNetDevice>()->GetPhy()->GetObject<LtePhy>();
234 Ptr<LteChunkProcessor> testDlSinr2 = Create<LteChunkProcessor>();
235 LteSpectrumValueCatcher dlSinr2Catcher;
236 testDlSinr2->AddCallback(MakeCallback(&LteSpectrumValueCatcher::ReportValue, &dlSinr2Catcher));
237 ue2Phy->GetDownlinkSpectrumPhy()->AddDataSinrChunkProcessor(testDlSinr2);
238
239 Ptr<LtePhy> enb2phy =
240 enbDevs.Get(1)->GetObject<LteEnbNetDevice>()->GetPhy()->GetObject<LtePhy>();
241 Ptr<LteChunkProcessor> testUlSinr2 = Create<LteChunkProcessor>();
242 LteSpectrumValueCatcher ulSinr2Catcher;
243 testUlSinr2->AddCallback(MakeCallback(&LteSpectrumValueCatcher::ReportValue, &ulSinr2Catcher));
244 enb1phy->GetUplinkSpectrumPhy()->AddDataSinrChunkProcessor(testUlSinr2);
245
246 // need to allow for RRC connection establishment + SRS
247 Simulator::Stop(Seconds(0.200));
248 Simulator::Run();
249
250 for (uint32_t i = 0; i < 12; i++)
251 {
252 double dlSinr1 = dlSinr1Catcher.GetValue()->operator[](i);
253 double dlSinr1Db = 10.0 * std::log10(dlSinr1);
254 NS_TEST_ASSERT_MSG_EQ_TOL(dlSinr1Db,
255 m_expectedDlSinrDb,
256 0.01,
257 "Wrong SINR in DL! (eNB1 --> UE1)");
258
259 double dlSinr2 = dlSinr2Catcher.GetValue()->operator[](i);
260 NS_TEST_ASSERT_MSG_EQ_TOL(dlSinr2, 0, 0.01, "Wrong SINR in DL! (eNB2 --> UE2)");
261 }
262
263 for (uint32_t i = 12; i < 24; i++)
264 {
265 double dlSinr1 = dlSinr1Catcher.GetValue()->operator[](i);
266 NS_TEST_ASSERT_MSG_EQ_TOL(dlSinr1, 0, 0.01, "Wrong SINR in DL! (eNB1 --> UE1)");
267
268 double dlSinr2 = dlSinr2Catcher.GetValue()->operator[](i);
269 double dlSinr2Db = 10.0 * std::log10(dlSinr2);
270 NS_TEST_ASSERT_MSG_EQ_TOL(dlSinr2Db,
271 m_expectedDlSinrDb,
272 0.01,
273 "Wrong SINR in DL! (eNB2 --> UE2)");
274 }
275
276 // FR algorithms do not operate in uplink now, so we do not test it
277 // double ulSinr1Db = 10.0 * std::log10 (testUlSinr1->GetValue ()->operator[] (0));
278 // NS_LOG_DEBUG("ulSinr1Db: "<< ulSinr1Db);
279 // NS_TEST_ASSERT_MSG_EQ_TOL (ulSinr1Db, m_expectedUlSinrDb, 0.01, "Wrong SINR in UL! (UE1 -->
280 // eNB1)");
281 //
282 // double ulSinr2Db = 10.0 * std::log10 (testUlSinr2->GetValue ()->operator[] (0));
283 // NS_LOG_DEBUG("ulSinr2Db: "<< ulSinr2Db);
284 // NS_TEST_ASSERT_MSG_EQ_TOL (ulSinr2Db, m_expectedUlSinrDb, 0.01, "Wrong SINR in UL! (UE2 -->
285 // eNB2)");
286
287 Simulator::Destroy();
288}
289
290LteInterferenceStrictFrTestCase::LteInterferenceStrictFrTestCase(std::string name,
291 double d1,
292 double d2,
293 double commonDlSinr,
294 double commonUlSinr,
295 double edgeDlSinr,
296 double edgeUlSinr,
297 uint32_t rspqThreshold)
298 : TestCase("Test: " + name),
299 m_d1(d1),
300 m_d2(d2),
301 m_commonDlSinrDb(10 * std::log10(commonDlSinr)),
302 m_edgeDlSinrDb(10 * std::log10(edgeDlSinr)),
303 m_rspqThreshold(rspqThreshold)
304{
305 NS_LOG_INFO("Creating LteInterferenceFrTestCase");
306}
307
311
312void
313LteInterferenceStrictFrTestCase::DoRun()
314{
315 NS_LOG_INFO(this << GetName());
316 NS_LOG_DEBUG("LteInterferenceStrictFrTestCase");
317
318 Config::Reset();
319 Config::SetDefault("ns3::LteHelper::UseIdealRrc", BooleanValue(true));
320
321 Config::SetDefault("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue(false));
322 Config::SetDefault("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue(false));
323 Config::SetDefault("ns3::LteAmc::AmcModel", EnumValue(LteAmc::PiroEW2010));
324 Config::SetDefault("ns3::LteAmc::Ber", DoubleValue(0.00005));
325
326 Ptr<LteHelper> lteHelper = CreateObject<LteHelper>();
327 lteHelper->SetFfrAlgorithmType("ns3::LteFrStrictAlgorithm");
328 lteHelper->SetFfrAlgorithmAttribute("RsrqThreshold", UintegerValue(m_rspqThreshold));
329 lteHelper->SetFfrAlgorithmAttribute("CenterPowerOffset",
330 UintegerValue(LteRrcSap::PdschConfigDedicated::dB0));
331 lteHelper->SetFfrAlgorithmAttribute("EdgePowerOffset",
332 UintegerValue(LteRrcSap::PdschConfigDedicated::dB0));
333
334 lteHelper->SetAttribute("PathlossModel", StringValue("ns3::FriisSpectrumPropagationLossModel"));
335
336 // Create Nodes: eNodeB and UE
337 NodeContainer enbNodes;
338 NodeContainer ueNodes1;
339 NodeContainer ueNodes2;
340 enbNodes.Create(2);
341 ueNodes1.Create(2);
342 ueNodes2.Create(2);
343 NodeContainer allNodes = NodeContainer(enbNodes, ueNodes1, ueNodes2);
344
345 // the topology is the following:
346 // d2
347 // UE1-----------eNB2
348 // | |
349 // d1| |d1
350 // | d2 |
351 // eNB1----------UE2
352 //
353 Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();
354 positionAlloc->Add(Vector(0.0, 0.0, 0.0)); // eNB1
355 positionAlloc->Add(Vector(m_d2, m_d1, 0.0)); // eNB2
356
357 positionAlloc->Add(Vector(0.0, m_d1, 0.0)); // UE1-eNB1
358 positionAlloc->Add(Vector(0.5 * m_d2, 0.0, 0.0)); // UE2-eNB1
359
360 positionAlloc->Add(Vector(m_d2, 0.0, 0.0)); // UE1-eNB2
361 positionAlloc->Add(Vector(0.5 * m_d2, m_d1, 0.0)); // UE2-eNB2
362
363 MobilityHelper mobility;
364 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
365 mobility.SetPositionAllocator(positionAlloc);
366 mobility.Install(allNodes);
367
368 // Create Devices and install them in the Nodes (eNB and UE)
369 NetDeviceContainer enbDevs;
370 NetDeviceContainer ueDevs1;
371 NetDeviceContainer ueDevs2;
372 lteHelper->SetSchedulerType("ns3::PfFfMacScheduler");
373 lteHelper->SetSchedulerAttribute("UlCqiFilter", EnumValue(FfMacScheduler::PUSCH_UL_CQI));
374
375 lteHelper->SetFfrAlgorithmAttribute("DlCommonSubBandwidth", UintegerValue(12));
376 lteHelper->SetFfrAlgorithmAttribute("DlEdgeSubBandOffset", UintegerValue(0));
377 lteHelper->SetFfrAlgorithmAttribute("DlEdgeSubBandwidth", UintegerValue(6));
378 lteHelper->SetFfrAlgorithmAttribute("UlCommonSubBandwidth", UintegerValue(25));
379 lteHelper->SetFfrAlgorithmAttribute("UlEdgeSubBandOffset", UintegerValue(0));
380 lteHelper->SetFfrAlgorithmAttribute("UlEdgeSubBandwidth", UintegerValue(0));
381
382 enbDevs.Add(lteHelper->InstallEnbDevice(enbNodes.Get(0)));
383
384 lteHelper->SetFfrAlgorithmAttribute("DlCommonSubBandwidth", UintegerValue(12));
385 lteHelper->SetFfrAlgorithmAttribute("DlEdgeSubBandOffset", UintegerValue(6));
386 lteHelper->SetFfrAlgorithmAttribute("DlEdgeSubBandwidth", UintegerValue(6));
387 enbDevs.Add(lteHelper->InstallEnbDevice(enbNodes.Get(1)));
388
389 ueDevs1 = lteHelper->InstallUeDevice(ueNodes1);
390 ueDevs2 = lteHelper->InstallUeDevice(ueNodes2);
391
392 lteHelper->Attach(ueDevs1, enbDevs.Get(0));
393 lteHelper->Attach(ueDevs2, enbDevs.Get(1));
394
395 // Activate an EPS bearer
396 EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
397 EpsBearer bearer(q);
398 lteHelper->ActivateDataRadioBearer(ueDevs1, bearer);
399 lteHelper->ActivateDataRadioBearer(ueDevs2, bearer);
400
401 // Use testing chunk processor in the PHY layer
402 // It will be used to test that the SNR is as intended
403 // we plug in two instances, one for DL and one for UL
404
405 Ptr<LtePhy> ue1Phy = ueDevs1.Get(0)->GetObject<LteUeNetDevice>()->GetPhy()->GetObject<LtePhy>();
406 Ptr<LteChunkProcessor> testDlSinr1 = Create<LteChunkProcessor>();
407 LteSpectrumValueCatcher dlSinr1Catcher;
408 testDlSinr1->AddCallback(MakeCallback(&LteSpectrumValueCatcher::ReportValue, &dlSinr1Catcher));
409 ue1Phy->GetDownlinkSpectrumPhy()->AddDataSinrChunkProcessor(testDlSinr1);
410
411 Ptr<LtePhy> enb1phy =
412 enbDevs.Get(0)->GetObject<LteEnbNetDevice>()->GetPhy()->GetObject<LtePhy>();
413 Ptr<LteChunkProcessor> testUlSinr1 = Create<LteChunkProcessor>();
414 LteSpectrumValueCatcher ulSinr1Catcher;
415 testUlSinr1->AddCallback(MakeCallback(&LteSpectrumValueCatcher::ReportValue, &ulSinr1Catcher));
416 enb1phy->GetUplinkSpectrumPhy()->AddDataSinrChunkProcessor(testUlSinr1);
417
418 // same as above for eNB2 and UE2
419
420 Ptr<LtePhy> ue2Phy = ueDevs2.Get(0)->GetObject<LteUeNetDevice>()->GetPhy()->GetObject<LtePhy>();
421 Ptr<LteChunkProcessor> testDlSinr2 = Create<LteChunkProcessor>();
422 LteSpectrumValueCatcher dlSinr2Catcher;
423 testDlSinr2->AddCallback(MakeCallback(&LteSpectrumValueCatcher::ReportValue, &dlSinr2Catcher));
424 ue2Phy->GetDownlinkSpectrumPhy()->AddDataSinrChunkProcessor(testDlSinr2);
425
426 Ptr<LtePhy> enb2phy =
427 enbDevs.Get(1)->GetObject<LteEnbNetDevice>()->GetPhy()->GetObject<LtePhy>();
428 Ptr<LteChunkProcessor> testUlSinr2 = Create<LteChunkProcessor>();
429 LteSpectrumValueCatcher ulSinr2Catcher;
430 testUlSinr2->AddCallback(MakeCallback(&LteSpectrumValueCatcher::ReportValue, &ulSinr2Catcher));
431 enb1phy->GetUplinkSpectrumPhy()->AddDataSinrChunkProcessor(testUlSinr2);
432
433 // need to allow for UE Measurement report
434 Simulator::Stop(Seconds(2.000));
435 Simulator::Run();
436
437 for (uint32_t i = 0; i < 12; i++)
438 {
439 double dlSinr1 = dlSinr1Catcher.GetValue()->operator[](i);
440 double dlSinr1Db = 10.0 * std::log10(dlSinr1);
441 NS_TEST_ASSERT_MSG_EQ_TOL(dlSinr1Db,
442 m_commonDlSinrDb,
443 0.01,
444 "Wrong SINR in DL! (eNB1 --> UE1)");
445
446 double dlSinr2 = dlSinr2Catcher.GetValue()->operator[](i);
447 double dlSinr2Db = 10.0 * std::log10(dlSinr2);
448 NS_TEST_ASSERT_MSG_EQ_TOL(dlSinr2Db,
449 m_commonDlSinrDb,
450 0.01,
451 "Wrong SINR in DL! (eNB2 --> UE2)");
452 }
453
454 for (uint32_t i = 12; i < 18; i++)
455 {
456 double dlSinr1 = dlSinr1Catcher.GetValue()->operator[](i);
457 double dlSinr1Db = 10.0 * std::log10(dlSinr1);
458 NS_TEST_ASSERT_MSG_EQ_TOL(dlSinr1Db,
459 m_edgeDlSinrDb,
460 0.01,
461 "Wrong SINR in DL! (eNB1 --> UE1)");
462
463 double dlSinr2 = dlSinr2Catcher.GetValue()->operator[](i);
464 NS_TEST_ASSERT_MSG_EQ_TOL(dlSinr2, 0, 0.01, "Wrong SINR in DL! (eNB2 --> UE2)");
465 }
466
467 for (uint32_t i = 18; i < 24; i++)
468 {
469 double dlSinr1 = dlSinr1Catcher.GetValue()->operator[](i);
470 NS_TEST_ASSERT_MSG_EQ_TOL(dlSinr1, 0, 0.01, "Wrong SINR in DL! (eNB1 --> UE1)");
471
472 double dlSinr2 = dlSinr2Catcher.GetValue()->operator[](i);
473 double dlSinr2Db = 10.0 * std::log10(dlSinr2);
474 NS_TEST_ASSERT_MSG_EQ_TOL(dlSinr2Db,
475 m_edgeDlSinrDb,
476 0.01,
477 "Wrong SINR in DL! (eNB2 --> UE2)");
478 }
479
480 // FR algorithms do not operate in uplink now, so we do not test it
481 // double ulSinr1Db = 10.0 * std::log10 (testUlSinr1->GetValue ()->operator[] (0));
482 // NS_LOG_DEBUG("ulSinr1Db: "<< ulSinr1Db);
483 // NS_TEST_ASSERT_MSG_EQ_TOL (ulSinr1Db, m_expectedUlSinrDb, 0.01, "Wrong SINR in UL! (UE1 -->
484 // eNB1)");
485 //
486 // double ulSinr2Db = 10.0 * std::log10 (testUlSinr2->GetValue ()->operator[] (0));
487 // NS_LOG_DEBUG("ulSinr2Db: "<< ulSinr2Db);
488 // NS_TEST_ASSERT_MSG_EQ_TOL (ulSinr2Db, m_expectedUlSinrDb, 0.01, "Wrong SINR in UL! (UE2 -->
489 // eNB2)");
490
491 Simulator::Destroy();
492}
LteInterferenceFrTestSuite
Test suite for the interference test when using different frequency reuse algorithms....
Definition lte-test-interference-fr.h:27
LteInterferenceHardFrTestCase
Lte interference test when using hard frequency reuse algorithm.
Definition lte-test-interference-fr.h:39
LteInterferenceHardFrTestCase::m_expectedDlSinrDb
double m_expectedDlSinrDb
expected DL SINR in dB
Definition lte-test-interference-fr.h:62
LteInterferenceHardFrTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition lte-test-interference-fr.cc:138
LteInterferenceHardFrTestCase::m_d2
double m_d2
distance between UE and other ENB
Definition lte-test-interference-fr.h:61
LteInterferenceHardFrTestCase::m_d1
double m_d1
distance between UE and ENB
Definition lte-test-interference-fr.h:60
LteInterferenceHardFrTestCase::LteInterferenceHardFrTestCase
LteInterferenceHardFrTestCase(std::string name, double d1, double d2, double dlSinr, double ulSinr)
Constructor.
Definition lte-test-interference-fr.cc:120
LteInterferenceStrictFrTestCase
Lte interference test when using strict frequency reuse algorithm.
Definition lte-test-interference-fr.h:71
LteInterferenceStrictFrTestCase::m_d1
double m_d1
distance between UE and ENB
Definition lte-test-interference-fr.h:98
LteInterferenceStrictFrTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition lte-test-interference-fr.cc:313
LteInterferenceStrictFrTestCase::m_commonDlSinrDb
double m_commonDlSinrDb
expected common DL SINR in dB
Definition lte-test-interference-fr.h:100
LteInterferenceStrictFrTestCase::m_edgeDlSinrDb
double m_edgeDlSinrDb
expected edge DL SINR in dB
Definition lte-test-interference-fr.h:101
LteInterferenceStrictFrTestCase::LteInterferenceStrictFrTestCase
LteInterferenceStrictFrTestCase(std::string name, double d1, double d2, double commonDlSinr, double commonUlSinr, double edgeDlSinr, double edgeUlSinr, uint32_t rspqThreshold)
Constructor.
Definition lte-test-interference-fr.cc:290
LteInterferenceStrictFrTestCase::m_d2
double m_d2
distance between UE and other ENB
Definition lte-test-interference-fr.h:99
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::LtePhy
The LtePhy models the physical layer of LTE.
Definition lte-phy.h:40
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:92
ns3::LteSpectrumValueCatcher::GetValue
Ptr< SpectrumValue > GetValue()
Definition lte-chunk-processor.cc:84
ns3::LteSpectrumValueCatcher::ReportValue
void ReportValue(const SpectrumValue &value)
function to be plugged to LteChunkProcessor::AddCallback ()
Definition lte-chunk-processor.cc:78
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::NetDeviceContainer
holds a vector of ns3::NetDevice pointers
Definition net-device-container.h:32
ns3::NetDeviceContainer::Add
void Add(NetDeviceContainer other)
Append the contents of another NetDeviceContainer to the end of this container.
Definition net-device-container.cc:62
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:511
ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition mpi-test-fixtures.h:37
ns3::Simulator::Destroy
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
Definition simulator.cc:131
ns3::Simulator::Run
static void Run()
Run the simulation.
Definition simulator.cc:167
ns3::Simulator::Stop
static void Stop()
Tell the Simulator the calling event should be the last one executed.
Definition simulator.cc:175
ns3::StringValue
Hold variables of type string.
Definition string.h:45
ns3::TestCase
encapsulates test code
Definition test.h:1050
ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, Duration duration=Duration::QUICK)
Add an individual child TestCase to this test suite.
Definition test.cc:292
ns3::TestCase::GetName
std::string GetName() const
Definition test.cc:367
ns3::TestSuite
A suite of tests to run.
Definition test.h:1267
ns3::TestSuite::Type
Type
Type of test.
Definition test.h:1274
ns3::UintegerValue
Hold an unsigned integer type.
Definition uinteger.h:34
uint32_t
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:848
ns3::Config::SetDefault
void SetDefault(std::string name, const AttributeValue &value)
Definition config.cc:883
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition log.h:191
NS_LOG_DEBUG
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition log.h:257
NS_LOG_INFO
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition log.h:264
LteInterferenceFrTestSuite
static LteInterferenceFrTestSuite LteInterferenceFrTestSuite
Static variable for test initialization.
Definition lte-test-interference-fr.cc:115
ns3::CreateObject
Ptr< T > CreateObject(Args &&... args)
Create an object by type, with varying number of constructor parameters.
Definition object.h:619
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:436
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:327
ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition nstime.h:1308
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:684
std
STL namespace.