A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
lte-test-frequency-reuse.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-frequency-reuse.h"
22
23#include "lte-ffr-simple.h"
24#include "lte-simple-spectrum-phy.h"
25
26#include "ns3/internet-module.h"
27#include "ns3/lte-helper.h"
28#include "ns3/mobility-helper.h"
29#include "ns3/packet-sink-helper.h"
30#include "ns3/point-to-point-epc-helper.h"
31#include "ns3/point-to-point-module.h"
32#include "ns3/udp-client-server-helper.h"
33#include <ns3/boolean.h>
34#include <ns3/callback.h>
35#include <ns3/config.h>
36#include <ns3/double.h>
37#include <ns3/enum.h>
38#include <ns3/ff-mac-scheduler.h>
39#include <ns3/log.h>
40#include <ns3/lte-common.h>
41#include <ns3/lte-enb-net-device.h>
42#include <ns3/lte-enb-phy.h>
43#include <ns3/lte-enb-rrc.h>
44#include <ns3/lte-ue-net-device.h>
45#include <ns3/lte-ue-phy.h>
46#include <ns3/lte-ue-rrc.h>
47#include <ns3/pointer.h>
48#include <ns3/simulator.h>
49#include <ns3/string.h>
50
51using namespace ns3;
52
53NS_LOG_COMPONENT_DEFINE("LteFrequencyReuseTest");
54
59LteFrequencyReuseTestSuite::LteFrequencyReuseTestSuite()
60 : TestSuite("lte-frequency-reuse", SYSTEM)
61{
62 // LogLevel logLevel = (LogLevel)(LOG_PREFIX_FUNC | LOG_PREFIX_TIME | LOG_LEVEL_DEBUG);
63 // LogComponentEnable ("LteFrequencyReuseTest", logLevel);
64
65 std::vector<bool> availableDlRb;
66 std::vector<bool> availableUlRb;
67 for (uint32_t i = 0; i < 12; i++)
68 {
69 availableDlRb.push_back(true);
70 availableUlRb.push_back(true);
71 }
72 for (uint32_t i = 12; i < 25; i++)
73 {
74 availableDlRb.push_back(false);
75 availableUlRb.push_back(false);
76 }
77
78 AddTestCase(new LteHardFrTestCase("DownlinkHardFrPf1",
79 1,
80 "ns3::PfFfMacScheduler",
81 25,
82 25,
83 0,
84 12,
85 0,
86 12,
87 availableDlRb,
88 availableUlRb),
89 TestCase::QUICK);
90 AddTestCase(new LteHardFrTestCase("DownlinkHardFrPf2",
91 5,
92 "ns3::PfFfMacScheduler",
93 25,
94 25,
95 0,
96 12,
97 0,
98 12,
99 availableDlRb,
100 availableUlRb),
101 TestCase::QUICK);
102 AddTestCase(new LteHardFrTestCase("DownlinkHardFrPss1",
103 1,
104 "ns3::PssFfMacScheduler",
105 25,
106 25,
107 0,
108 12,
109 0,
110 12,
111 availableDlRb,
112 availableUlRb),
113 TestCase::QUICK);
114 AddTestCase(new LteHardFrTestCase("DownlinkHardFrPss2",
115 5,
116 "ns3::PssFfMacScheduler",
117 25,
118 25,
119 0,
120 12,
121 0,
122 12,
123 availableDlRb,
124 availableUlRb),
125 TestCase::QUICK);
126 AddTestCase(new LteHardFrTestCase("DownlinkHardFrCqa1",
127 1,
128 "ns3::CqaFfMacScheduler",
129 25,
130 25,
131 0,
132 12,
133 0,
134 12,
135 availableDlRb,
136 availableUlRb),
137 TestCase::QUICK);
138 AddTestCase(new LteHardFrTestCase("DownlinkHardFrCqa2",
139 5,
140 "ns3::CqaFfMacScheduler",
141 25,
142 25,
143 0,
144 12,
145 0,
146 12,
147 availableDlRb,
148 availableUlRb),
149 TestCase::QUICK);
150 AddTestCase(new LteHardFrTestCase("DownlinkHardFrFdTbfq1",
151 1,
152 "ns3::FdTbfqFfMacScheduler",
153 25,
154 25,
155 0,
156 12,
157 0,
158 12,
159 availableDlRb,
160 availableUlRb),
161 TestCase::QUICK);
162 AddTestCase(new LteHardFrTestCase("DownlinkHardFrFdTbfq2",
163 5,
164 "ns3::FdTbfqFfMacScheduler",
165 25,
166 25,
167 0,
168 12,
169 0,
170 12,
171 availableDlRb,
172 availableUlRb),
173 TestCase::QUICK);
174 AddTestCase(new LteHardFrTestCase("DownlinkHardFrTdTbfq1",
175 1,
176 "ns3::TdTbfqFfMacScheduler",
177 25,
178 25,
179 0,
180 12,
181 0,
182 12,
183 availableDlRb,
184 availableUlRb),
185 TestCase::QUICK);
186 AddTestCase(new LteHardFrTestCase("DownlinkHardFrTdTbfq2",
187 5,
188 "ns3::TdTbfqFfMacScheduler",
189 25,
190 25,
191 0,
192 12,
193 0,
194 12,
195 availableDlRb,
196 availableUlRb),
197 TestCase::QUICK);
198
199 availableDlRb.clear();
200 availableUlRb.clear();
201 for (uint32_t i = 0; i < 6; i++)
202 {
203 availableDlRb.push_back(true);
204 availableUlRb.push_back(true);
205 }
206 for (uint32_t i = 6; i < 12; i++)
207 {
208 availableDlRb.push_back(false);
209 availableUlRb.push_back(false);
210 }
211 for (uint32_t i = 12; i < 18; i++)
212 {
213 availableDlRb.push_back(true);
214 availableUlRb.push_back(true);
215 }
216 for (uint32_t i = 18; i < 25; i++)
217 {
218 availableDlRb.push_back(false);
219 availableUlRb.push_back(false);
220 }
221
222 AddTestCase(new LteStrictFrTestCase("DownlinkStrictFrPf1",
223 1,
224 "ns3::PfFfMacScheduler",
225 25,
226 25,
227 6,
228 6,
229 6,
230 6,
231 6,
232 6,
233 availableDlRb,
234 availableUlRb),
235 TestCase::QUICK);
236 AddTestCase(new LteStrictFrTestCase("DownlinkStrictFrPf2",
237 5,
238 "ns3::PfFfMacScheduler",
239 25,
240 25,
241 6,
242 6,
243 6,
244 6,
245 6,
246 6,
247 availableDlRb,
248 availableUlRb),
249 TestCase::QUICK);
250 AddTestCase(new LteStrictFrTestCase("DownlinkStrictFrPss1",
251 1,
252 "ns3::PssFfMacScheduler",
253 25,
254 25,
255 6,
256 6,
257 6,
258 6,
259 6,
260 6,
261 availableDlRb,
262 availableUlRb),
263 TestCase::QUICK);
264 AddTestCase(new LteStrictFrTestCase("DownlinkStrictFrPss2",
265 5,
266 "ns3::PssFfMacScheduler",
267 25,
268 25,
269 6,
270 6,
271 6,
272 6,
273 6,
274 6,
275 availableDlRb,
276 availableUlRb),
277 TestCase::QUICK);
278 AddTestCase(new LteStrictFrTestCase("DownlinkStrictFrCqa1",
279 1,
280 "ns3::CqaFfMacScheduler",
281 25,
282 25,
283 6,
284 6,
285 6,
286 6,
287 6,
288 6,
289 availableDlRb,
290 availableUlRb),
291 TestCase::QUICK);
292 AddTestCase(new LteStrictFrTestCase("DownlinkStrictFrCqa2",
293 5,
294 "ns3::CqaFfMacScheduler",
295 25,
296 25,
297 6,
298 6,
299 6,
300 6,
301 6,
302 6,
303 availableDlRb,
304 availableUlRb),
305 TestCase::QUICK);
306 AddTestCase(new LteStrictFrTestCase("DownlinkStrictFrCqaFdTbfq1",
307 1,
308 "ns3::FdTbfqFfMacScheduler",
309 25,
310 25,
311 6,
312 6,
313 6,
314 6,
315 6,
316 6,
317 availableDlRb,
318 availableUlRb),
319 TestCase::QUICK);
320 AddTestCase(new LteStrictFrTestCase("DownlinkStrictFrCqaFdTbfq2",
321 5,
322 "ns3::FdTbfqFfMacScheduler",
323 25,
324 25,
325 6,
326 6,
327 6,
328 6,
329 6,
330 6,
331 availableDlRb,
332 availableUlRb),
333 TestCase::QUICK);
334 AddTestCase(new LteStrictFrTestCase("DownlinkStrictFrCqaTdTbfq1",
335 1,
336 "ns3::TdTbfqFfMacScheduler",
337 25,
338 25,
339 6,
340 6,
341 6,
342 6,
343 6,
344 6,
345 availableDlRb,
346 availableUlRb),
347 TestCase::QUICK);
348 AddTestCase(new LteStrictFrTestCase("DownlinkStrictFrCqaTdTbfq2",
349 5,
350 "ns3::TdTbfqFfMacScheduler",
351 25,
352 25,
353 6,
354 6,
355 6,
356 6,
357 6,
358 6,
359 availableDlRb,
360 availableUlRb),
361 TestCase::QUICK);
362
363 AddTestCase(new LteStrictFrAreaTestCase("LteStrictFrAreaTestCasePf1", "ns3::PfFfMacScheduler"),
364 TestCase::QUICK);
365 AddTestCase(
366 new LteStrictFrAreaTestCase("LteStrictFrAreaTestCasePss1", "ns3::PssFfMacScheduler"),
367 TestCase::QUICK);
368 AddTestCase(
369 new LteStrictFrAreaTestCase("LteStrictFrAreaTestCaseCqa1", "ns3::CqaFfMacScheduler"),
370 TestCase::QUICK);
371 AddTestCase(
372 new LteStrictFrAreaTestCase("LteStrictFrAreaTestCaseFdTbfq1", "ns3::FdTbfqFfMacScheduler"),
373 TestCase::QUICK);
374 AddTestCase(
375 new LteStrictFrAreaTestCase("LteStrictFrAreaTestCaseTdTbfq1", "ns3::TdTbfqFfMacScheduler"),
376 TestCase::QUICK);
377
378 AddTestCase(new LteSoftFrAreaTestCase("LteSoftFrAreaTestCasePf1", "ns3::PfFfMacScheduler"),
379 TestCase::QUICK);
380 AddTestCase(new LteSoftFrAreaTestCase("LteSoftFrAreaTestCasePss1", "ns3::PssFfMacScheduler"),
381 TestCase::QUICK);
382 AddTestCase(new LteSoftFrAreaTestCase("LteSoftFrAreaTestCaseCqa1", "ns3::CqaFfMacScheduler"),
383 TestCase::QUICK);
384 AddTestCase(
385 new LteSoftFrAreaTestCase("LteSoftFrAreaTestCaseFdTbfq1", "ns3::FdTbfqFfMacScheduler"),
386 TestCase::QUICK);
387 AddTestCase(
388 new LteSoftFrAreaTestCase("LteSoftFrAreaTestCaseTdTbfq1", "ns3::TdTbfqFfMacScheduler"),
389 TestCase::QUICK);
390
391 AddTestCase(new LteSoftFfrAreaTestCase("LteSoftFfrAreaTestCasePf1", "ns3::PfFfMacScheduler"),
392 TestCase::QUICK);
393 AddTestCase(new LteSoftFfrAreaTestCase("LteSoftFfrAreaTestCasePss1", "ns3::PssFfMacScheduler"),
394 TestCase::QUICK);
395 AddTestCase(new LteSoftFfrAreaTestCase("LteSoftFfrAreaTestCaseCqa1", "ns3::CqaFfMacScheduler"),
396 TestCase::QUICK);
397 AddTestCase(
398 new LteSoftFfrAreaTestCase("LteSoftFfrAreaTestCaseFdTbfq1", "ns3::FdTbfqFfMacScheduler"),
399 TestCase::QUICK);
400 AddTestCase(
401 new LteSoftFfrAreaTestCase("LteSoftFfrAreaTestCaseTdTbfq1", "ns3::TdTbfqFfMacScheduler"),
402 TestCase::QUICK);
403
404 AddTestCase(
405 new LteEnhancedFfrAreaTestCase("LteEnhancedFfrAreaTestCasePf1", "ns3::PfFfMacScheduler"),
406 TestCase::QUICK);
407 AddTestCase(
408 new LteEnhancedFfrAreaTestCase("LteEnhancedFfrAreaTestCasePss1", "ns3::PssFfMacScheduler"),
409 TestCase::QUICK);
410 AddTestCase(
411 new LteEnhancedFfrAreaTestCase("LteEnhancedFfrAreaTestCaseCqa1", "ns3::CqaFfMacScheduler"),
412 TestCase::QUICK);
413 AddTestCase(new LteEnhancedFfrAreaTestCase("LteEnhancedFfrAreaTestCaseFdTbfq1",
414 "ns3::FdTbfqFfMacScheduler"),
415 TestCase::QUICK);
416 AddTestCase(new LteEnhancedFfrAreaTestCase("LteEnhancedFfrAreaTestCaseTdTbfq1",
417 "ns3::TdTbfqFfMacScheduler"),
418 TestCase::QUICK);
419
420 AddTestCase(new LteDistributedFfrAreaTestCase("LteDistributedFfrAreaTestCasePf1",
421 "ns3::PfFfMacScheduler"),
422 TestCase::QUICK);
423 AddTestCase(new LteDistributedFfrAreaTestCase("LteDistributedFfrAreaTestCasePss1",
424 "ns3::PssFfMacScheduler"),
425 TestCase::QUICK);
426 AddTestCase(new LteDistributedFfrAreaTestCase("LteDistributedFfrAreaTestCaseCqa1",
427 "ns3::CqaFfMacScheduler"),
428 TestCase::QUICK);
429 AddTestCase(new LteDistributedFfrAreaTestCase("LteDistributedFfrAreaTestCaseFdTbfq1",
430 "ns3::FdTbfqFfMacScheduler"),
431 TestCase::QUICK);
432 AddTestCase(new LteDistributedFfrAreaTestCase("LteDistributedFfrAreaTestCaseTdTbfq1",
433 "ns3::TdTbfqFfMacScheduler"),
434 TestCase::QUICK);
435}
436
441static LteFrequencyReuseTestSuite lteFrequencyReuseTestSuite;
442
446void
447DlDataRxStartNofitication(LteFrTestCase* testcase, Ptr<const SpectrumValue> spectrumValue)
448{
449 testcase->DlDataRxStart(spectrumValue);
450}
451
452void
453UlDataRxStartNofitication(LteFrTestCase* testcase, Ptr<const SpectrumValue> spectrumValue)
454{
455 testcase->UlDataRxStart(spectrumValue);
456}
457
458LteFrTestCase::LteFrTestCase(std::string name,
459 uint32_t userNum,
460 uint16_t dlBandwidth,
461 uint16_t ulBandwidth,
462 std::vector<bool> availableDlRb,
463 std::vector<bool> availableUlRb)
464 : TestCase("Test: " + name),
465 m_userNum(userNum),
466 m_dlBandwidth(dlBandwidth),
467 m_ulBandwidth(ulBandwidth),
468 m_availableDlRb(availableDlRb),
469 m_usedMutedDlRbg(false),
470 m_availableUlRb(availableUlRb),
471 m_usedMutedUlRbg(false)
472{
473}
474
475LteFrTestCase::~LteFrTestCase()
476{
477}
478
479void
480LteFrTestCase::DlDataRxStart(Ptr<const SpectrumValue> spectrumValue)
481{
482 NS_LOG_DEBUG("DL DATA Power allocation :");
483 uint32_t i = 0;
484 for (auto it = spectrumValue->ConstValuesBegin(); it != spectrumValue->ConstValuesEnd(); it++)
485 {
486 double power = (*it) * (m_dlBandwidth * 180000);
487 NS_LOG_DEBUG("RB " << i << " POWER: "
488 << " " << power << " isAvailable: " << m_availableDlRb[i]);
489
490 if (!m_availableDlRb[i] && power > 0)
491 {
492 m_usedMutedDlRbg = true;
493 }
494 i++;
495 }
496}
497
498void
499LteFrTestCase::UlDataRxStart(Ptr<const SpectrumValue> spectrumValue)
500{
501 NS_LOG_DEBUG("UL DATA Power allocation :");
502 uint32_t i = 0;
503 for (auto it = spectrumValue->ConstValuesBegin(); it != spectrumValue->ConstValuesEnd(); it++)
504 {
505 double power = (*it) * (m_ulBandwidth * 180000);
506 NS_LOG_DEBUG("RB " << i << " POWER: "
507 << " " << power << " isAvailable: " << m_availableUlRb[i]);
508
509 if (!m_availableUlRb[i] && power > 0)
510 {
511 m_usedMutedUlRbg = true;
512 }
513 i++;
514 }
515}
516
517void
518LteFrTestCase::DoRun()
519{
520}
521
522LteHardFrTestCase::LteHardFrTestCase(std::string name,
523 uint32_t userNum,
524 std::string schedulerType,
525 uint16_t dlBandwidth,
526 uint16_t ulBandwidth,
527 uint8_t dlSubBandOffset,
528 uint16_t dlSubBandwidth,
529 uint8_t ulSubBandOffset,
530 uint16_t ulSubBandwidth,
531 std::vector<bool> availableDlRb,
532 std::vector<bool> availableUlRb)
533 : LteFrTestCase(name, userNum, dlBandwidth, ulBandwidth, availableDlRb, availableUlRb),
534 m_schedulerType(schedulerType),
535 m_dlSubBandOffset(dlSubBandOffset),
536 m_dlSubBandwidth(dlSubBandwidth),
537 m_ulSubBandOffset(ulSubBandOffset),
538 m_ulSubBandwidth(ulSubBandwidth)
539{
540 NS_LOG_INFO("Creating LteDownlinkFrTestCase");
541}
542
543LteHardFrTestCase::~LteHardFrTestCase()
544{
545}
546
547void
548LteHardFrTestCase::DoRun()
549{
550 NS_LOG_DEBUG("LteFrTestCase");
551
552 Config::Reset();
553 Config::SetDefault("ns3::LteHelper::UseIdealRrc", BooleanValue(false));
554
559 Ptr<LteHelper> lteHelper = CreateObject<LteHelper>();
560 lteHelper->SetFfrAlgorithmType("ns3::LteFrHardAlgorithm");
561
562 lteHelper->SetFfrAlgorithmAttribute("DlSubBandOffset", UintegerValue(m_dlSubBandOffset));
563 lteHelper->SetFfrAlgorithmAttribute("DlSubBandwidth", UintegerValue(m_dlSubBandwidth));
564
565 lteHelper->SetFfrAlgorithmAttribute("UlSubBandOffset", UintegerValue(m_ulSubBandOffset));
566 lteHelper->SetFfrAlgorithmAttribute("UlSubBandwidth", UintegerValue(m_ulSubBandwidth));
567
568 // Create Nodes: eNodeB and UE
569 NodeContainer enbNodes;
570 NodeContainer ueNodes;
571 enbNodes.Create(1);
572 ueNodes.Create(m_userNum);
573 NodeContainer allNodes = NodeContainer(enbNodes, ueNodes);
574
575 // Install Mobility Model
576 MobilityHelper mobility;
577 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
578 mobility.Install(allNodes);
579
580 // Create Devices and install them in the Nodes (eNB and UE)
581 NetDeviceContainer enbDevs;
582 NetDeviceContainer ueDevs;
583 lteHelper->SetSchedulerType(m_schedulerType);
584 enbDevs = lteHelper->InstallEnbDevice(enbNodes);
585 ueDevs = lteHelper->InstallUeDevice(ueNodes);
586
587 // Attach a UE to a eNB
588 lteHelper->Attach(ueDevs, enbDevs.Get(0));
589
590 // Activate the default EPS bearer
591 // Since this test includes the Token Bank Fair Queue Scheduler
592 //(ns3::FdTbfqFfMacScheduler) we have to treat the default
593 // bearer as the dedicated bearer with QoS.
594 GbrQosInformation qos;
595 qos.mbrUl = 1e6;
596 qos.mbrDl = 1e6;
597 qos.gbrUl = 1e4;
598 qos.gbrDl = 1e4;
599
600 EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
601 EpsBearer bearer(q, qos);
602 lteHelper->ActivateDataRadioBearer(ueDevs, bearer);
603
604 // Test SpectrumPhy to get signals form DL channel
605 Ptr<LteSpectrumPhy> enbDlSpectrumPhy = enbDevs.Get(0)
606 ->GetObject<LteEnbNetDevice>()
607 ->GetPhy()
608 ->GetDownlinkSpectrumPhy()
609 ->GetObject<LteSpectrumPhy>();
610 Ptr<SpectrumChannel> dlChannel = enbDlSpectrumPhy->GetChannel();
611
612 Ptr<LteSimpleSpectrumPhy> testDlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy>();
613 Ptr<LteEnbNetDevice> eNbDev = enbDevs.Get(0)->GetObject<LteEnbNetDevice>();
614 testDlSpectrumPhy->SetRxSpectrumModel(
615 LteSpectrumValueHelper::GetSpectrumModel(eNbDev->GetDlEarfcn(), m_dlBandwidth));
616 dlChannel->AddRx(testDlSpectrumPhy);
617
618 testDlSpectrumPhy->TraceConnectWithoutContext(
619 "RxStart",
620 MakeBoundCallback(&DlDataRxStartNofitication, this));
621
622 // Test SpectrumPhy to get signals form UL channel
623 Ptr<LteSpectrumPhy> ueUlSpectrumPhy = ueDevs.Get(0)
624 ->GetObject<LteUeNetDevice>()
625 ->GetPhy()
626 ->GetUplinkSpectrumPhy()
627 ->GetObject<LteSpectrumPhy>();
628 Ptr<SpectrumChannel> ulChannel = ueUlSpectrumPhy->GetChannel();
629
630 Ptr<LteSimpleSpectrumPhy> testUlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy>();
631 testUlSpectrumPhy->SetRxSpectrumModel(
632 LteSpectrumValueHelper::GetSpectrumModel(eNbDev->GetUlEarfcn(), m_ulBandwidth));
633 ulChannel->AddRx(testUlSpectrumPhy);
634
635 testUlSpectrumPhy->TraceConnectWithoutContext(
636 "RxStart",
637 MakeBoundCallback(&UlDataRxStartNofitication, this));
638
639 Simulator::Stop(Seconds(0.500));
640 Simulator::Run();
641
642 NS_TEST_ASSERT_MSG_EQ(m_usedMutedDlRbg, false, "Scheduler used DL RBG muted by FFR Algorithm");
643
644 NS_TEST_ASSERT_MSG_EQ(m_usedMutedUlRbg, false, "Scheduler used UL RBG muted by FFR Algorithm");
645
646 Simulator::Destroy();
647}
648
649LteStrictFrTestCase::LteStrictFrTestCase(std::string name,
650 uint32_t userNum,
651 std::string schedulerType,
652 uint16_t dlBandwidth,
653 uint16_t ulBandwidth,
654 uint16_t dlCommonSubBandwidth,
655 uint8_t dlEdgeSubBandOffset,
656 uint16_t dlEdgeSubBandwidth,
657 uint16_t ulCommonSubBandwidth,
658 uint8_t ulEdgeSubBandOffset,
659 uint16_t ulEdgeSubBandwidth,
660 std::vector<bool> availableDlRb,
661 std::vector<bool> availableUlRb)
662 : LteFrTestCase(name, userNum, dlBandwidth, ulBandwidth, availableDlRb, availableUlRb),
663 m_schedulerType(schedulerType),
664 m_dlCommonSubBandwidth(dlCommonSubBandwidth),
665 m_dlEdgeSubBandOffset(dlEdgeSubBandOffset),
666 m_dlEdgeSubBandwidth(dlEdgeSubBandwidth),
667 m_ulCommonSubBandwidth(ulCommonSubBandwidth),
668 m_ulEdgeSubBandOffset(ulEdgeSubBandOffset),
669 m_ulEdgeSubBandwidth(ulEdgeSubBandwidth)
670{
671 NS_LOG_INFO("Creating LteFrTestCase");
672}
673
674LteStrictFrTestCase::~LteStrictFrTestCase()
675{
676}
677
678void
679LteStrictFrTestCase::DoRun()
680{
681 NS_LOG_DEBUG("LteFrTestCase");
682
683 Config::Reset();
684 Config::SetDefault("ns3::LteHelper::UseIdealRrc", BooleanValue(false));
685
690 Ptr<LteHelper> lteHelper = CreateObject<LteHelper>();
691 lteHelper->SetFfrAlgorithmType("ns3::LteFrStrictAlgorithm");
692
693 lteHelper->SetFfrAlgorithmAttribute("DlCommonSubBandwidth",
694 UintegerValue(m_dlCommonSubBandwidth));
695 lteHelper->SetFfrAlgorithmAttribute("DlEdgeSubBandOffset",
696 UintegerValue(m_dlEdgeSubBandOffset));
697 lteHelper->SetFfrAlgorithmAttribute("DlEdgeSubBandwidth", UintegerValue(m_dlEdgeSubBandwidth));
698
699 lteHelper->SetFfrAlgorithmAttribute("UlCommonSubBandwidth",
700 UintegerValue(m_ulCommonSubBandwidth));
701 lteHelper->SetFfrAlgorithmAttribute("UlEdgeSubBandOffset",
702 UintegerValue(m_ulEdgeSubBandOffset));
703 lteHelper->SetFfrAlgorithmAttribute("UlEdgeSubBandwidth", UintegerValue(m_ulEdgeSubBandwidth));
704
705 // Create Nodes: eNodeB and UE
706 NodeContainer enbNodes;
707 NodeContainer ueNodes;
708 enbNodes.Create(1);
709 ueNodes.Create(m_userNum);
710 NodeContainer allNodes = NodeContainer(enbNodes, ueNodes);
711
712 // Install Mobility Model
713 MobilityHelper mobility;
714 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
715 mobility.Install(allNodes);
716
717 // Create Devices and install them in the Nodes (eNB and UE)
718 NetDeviceContainer enbDevs;
719 NetDeviceContainer ueDevs;
720 lteHelper->SetSchedulerType(m_schedulerType);
721 enbDevs = lteHelper->InstallEnbDevice(enbNodes);
722 ueDevs = lteHelper->InstallUeDevice(ueNodes);
723
724 // Attach a UE to a eNB
725 lteHelper->Attach(ueDevs, enbDevs.Get(0));
726
727 // Activate the default EPS bearer
728 // Since this test includes the Token Bank Fair Queue Scheduler
729 //(ns3::FdTbfqFfMacScheduler) we have to treat the default
730 // bearer as the dedicated bearer with QoS.
731
732 GbrQosInformation qos;
733 qos.mbrUl = 1e6;
734 qos.mbrDl = 1e6;
735 qos.gbrUl = 1e4;
736 qos.gbrDl = 1e4;
737
738 EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
739 EpsBearer bearer(q, qos);
740 lteHelper->ActivateDataRadioBearer(ueDevs, bearer);
741
742 // Test SpectrumPhy to get signals form DL channel
743 Ptr<LteSpectrumPhy> enbDlSpectrumPhy = enbDevs.Get(0)
744 ->GetObject<LteEnbNetDevice>()
745 ->GetPhy()
746 ->GetDownlinkSpectrumPhy()
747 ->GetObject<LteSpectrumPhy>();
748 Ptr<SpectrumChannel> dlChannel = enbDlSpectrumPhy->GetChannel();
749
750 Ptr<LteSimpleSpectrumPhy> testDlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy>();
751 Ptr<LteEnbNetDevice> eNbDev = enbDevs.Get(0)->GetObject<LteEnbNetDevice>();
752 testDlSpectrumPhy->SetRxSpectrumModel(
753 LteSpectrumValueHelper::GetSpectrumModel(eNbDev->GetDlEarfcn(), m_dlBandwidth));
754 dlChannel->AddRx(testDlSpectrumPhy);
755
756 testDlSpectrumPhy->TraceConnectWithoutContext(
757 "RxStart",
758 MakeBoundCallback(&DlDataRxStartNofitication, this));
759
760 // Test SpectrumPhy to get signals form UL channel
761 Ptr<LteSpectrumPhy> ueUlSpectrumPhy = ueDevs.Get(0)
762 ->GetObject<LteUeNetDevice>()
763 ->GetPhy()
764 ->GetUplinkSpectrumPhy()
765 ->GetObject<LteSpectrumPhy>();
766 Ptr<SpectrumChannel> ulChannel = ueUlSpectrumPhy->GetChannel();
767
768 Ptr<LteSimpleSpectrumPhy> testUlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy>();
769 testUlSpectrumPhy->SetRxSpectrumModel(
770 LteSpectrumValueHelper::GetSpectrumModel(eNbDev->GetUlEarfcn(), m_ulBandwidth));
771 ulChannel->AddRx(testUlSpectrumPhy);
772
773 testUlSpectrumPhy->TraceConnectWithoutContext(
774 "RxStart",
775 MakeBoundCallback(&UlDataRxStartNofitication, this));
776
777 Simulator::Stop(Seconds(0.500));
778 Simulator::Run();
779
780 NS_TEST_ASSERT_MSG_EQ(m_usedMutedDlRbg, false, "Scheduler used DL RBG muted by FFR Algorithm");
781
782 NS_TEST_ASSERT_MSG_EQ(m_usedMutedUlRbg, false, "Scheduler used UL RBG muted by FFR Algorithm");
783
784 Simulator::Destroy();
785}
786
787void
788DlDataRxStartNofiticationArea(LteFrAreaTestCase* testcase, Ptr<const SpectrumValue> spectrumValue)
789{
790 testcase->DlDataRxStart(spectrumValue);
791}
792
793void
794UlDataRxStartNofiticationArea(LteFrAreaTestCase* testcase, Ptr<const SpectrumValue> spectrumValue)
795{
796 testcase->UlDataRxStart(spectrumValue);
797}
798
799LteFrAreaTestCase::LteFrAreaTestCase(std::string name, std::string schedulerType)
800 : TestCase("Test: " + name),
801 m_schedulerType(schedulerType)
802{
803 m_dlBandwidth = 25;
804 m_ulBandwidth = 25;
805 m_usedWrongDlRbg = false;
806 m_usedWrongUlRbg = false;
807}
808
809LteFrAreaTestCase::~LteFrAreaTestCase()
810{
811}
812
813void
814LteFrAreaTestCase::DlDataRxStart(Ptr<const SpectrumValue> spectrumValue)
815{
816 // need time to report new UE measurements, and wait because of filtering
817 if ((Simulator::Now() - m_teleportTime) < MilliSeconds(400))
818 {
819 return;
820 }
821
822 NS_LOG_DEBUG("DL DATA Power allocation :");
823 uint32_t i = 0;
824 for (auto it = spectrumValue->ConstValuesBegin(); it != spectrumValue->ConstValuesEnd(); it++)
825 {
826 double power = (*it) * (m_dlBandwidth * 180000);
827 NS_LOG_DEBUG("RB " << i << " POWER: "
828 << " " << power);
829 NS_LOG_DEBUG("RB " << i << " POWER: "
830 << " " << power << " Available: " << m_expectedDlRb[i]
831 << " Expected Power: " << m_expectedDlPower);
832
833 if (!m_expectedDlRb[i] && power > 0)
834 {
835 m_usedWrongDlRbg = true;
836 }
837 else if (m_expectedDlRb[i] && power > 0)
838 {
839 NS_TEST_ASSERT_MSG_EQ_TOL(power,
840 m_expectedDlPower,
841 0.1,
842 "Wrong Data Channel DL Power level");
843 }
844 i++;
845 }
846}
847
848void
849LteFrAreaTestCase::UlDataRxStart(Ptr<const SpectrumValue> spectrumValue)
850{
851 // need time to report new UE measurements, and wait because of filtering
852 if ((Simulator::Now() - m_teleportTime) < MilliSeconds(400))
853 {
854 return;
855 }
856
857 NS_LOG_DEBUG("UL DATA Power allocation :");
858 uint32_t i = 0;
859 uint32_t numActiveRbs = 0;
860
861 // At the moment I could not find a better way to find total number
862 // of active RBs. This method is independent of the bandwidth
863 // configuration done in a test scenario, thus, it requires
864 // minimum change to the script.
865 for (auto it = spectrumValue->ConstValuesBegin(); it != spectrumValue->ConstValuesEnd(); it++)
866 {
867 // Count the RB as active if it is part of
868 // the expected UL RBs and has Power Spectral Density (PSD) > 0
869 if (m_expectedUlRb[numActiveRbs] && (*it) > 0)
870 {
871 numActiveRbs++;
872 }
873 }
874 NS_LOG_DEBUG("Total number of active RBs = " << numActiveRbs);
875
876 // The uplink power control and the uplink PSD
877 // calculation only consider active resource blocks.
878 for (auto it = spectrumValue->ConstValuesBegin(); it != spectrumValue->ConstValuesEnd(); it++)
879 {
880 double power = (*it) * (numActiveRbs * 180000);
881 NS_LOG_DEBUG("RB " << i << " POWER: " << power
882 << " expectedUlPower: " << m_expectedUlPower);
883 if (!m_expectedUlRb[i] && power > 0)
884 {
885 m_usedWrongUlRbg = true;
886 }
887 else if (m_expectedUlRb[i] && power > 0)
888 {
889 NS_TEST_ASSERT_MSG_EQ_TOL(power,
890 m_expectedUlPower,
891 0.01,
892 "Wrong Data Channel UL Power level"
893 << Simulator::Now().As(Time::S));
894 }
895 i++;
896 }
897}
898
899void
900LteFrAreaTestCase::SimpleTeleportUe(uint32_t x, uint32_t y)
901{
902 NS_LOG_FUNCTION(this);
903 NS_LOG_DEBUG("Teleport UE to : (" << x << ", " << y << ", 0)");
904 m_teleportTime = Simulator::Now();
905 m_ueMobility->SetPosition(Vector(x, y, 0.0));
906}
907
908void
909LteFrAreaTestCase::TeleportUe(uint32_t x,
910 uint32_t y,
911 double expectedPower,
912 std::vector<bool> expectedDlRb)
913{
914 NS_LOG_FUNCTION(this);
915 NS_LOG_DEBUG("Teleport UE to : (" << x << ", " << y << ", 0)");
916 m_teleportTime = Simulator::Now();
917 m_ueMobility->SetPosition(Vector(x, y, 0.0));
918 m_expectedDlPower = expectedPower;
919 m_expectedDlRb = expectedDlRb;
920}
921
922void
923LteFrAreaTestCase::TeleportUe2(Ptr<Node> ueNode,
924 uint32_t x,
925 uint32_t y,
926 double expectedPower,
927 std::vector<bool> expectedDlRb)
928{
929 NS_LOG_FUNCTION(this);
930 NS_LOG_DEBUG("Teleport UE to : (" << x << ", " << y << ", 0)");
931
932 Ptr<MobilityModel> ueMobility = ueNode->GetObject<MobilityModel>();
933 ueMobility->SetPosition(Vector(x, y, 0.0));
934 m_teleportTime = Simulator::Now();
935 m_expectedDlPower = expectedPower;
936 m_expectedDlRb = expectedDlRb;
937}
938
939void
940LteFrAreaTestCase::SetDlExpectedValues(double expectedDlPower, std::vector<bool> expectedDlRb)
941{
942 NS_LOG_FUNCTION(this);
943 m_expectedDlPower = expectedDlPower;
944 m_expectedDlRb = expectedDlRb;
945}
946
947void
948LteFrAreaTestCase::SetUlExpectedValues(double expectedUlPower, std::vector<bool> expectedUlRb)
949{
950 NS_LOG_FUNCTION(this);
951 m_expectedUlPower = expectedUlPower;
952 m_expectedUlRb = expectedUlRb;
953}
954
955void
956LteFrAreaTestCase::DoRun()
957{
958}
959
960LteStrictFrAreaTestCase::LteStrictFrAreaTestCase(std::string name, std::string schedulerType)
961 : LteFrAreaTestCase(name, schedulerType)
962{
963 NS_LOG_INFO("Creating LteFrTestCase");
964}
965
966LteStrictFrAreaTestCase::~LteStrictFrAreaTestCase()
967{
968}
969
970void
971LteStrictFrAreaTestCase::DoRun()
972{
973 NS_LOG_DEBUG("LteStrictFrAreaTestCase");
974
975 Config::Reset();
976 Config::SetDefault("ns3::LteHelper::UseIdealRrc", BooleanValue(true));
977 Config::SetDefault("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue(false));
978 Config::SetDefault("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue(false));
979
980 double eNbTxPower = 30;
981 Config::SetDefault("ns3::LteEnbPhy::TxPower", DoubleValue(eNbTxPower));
982 Config::SetDefault("ns3::LteUePhy::TxPower", DoubleValue(10.0));
983 Config::SetDefault("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue(true));
984
985 Config::SetDefault("ns3::LteUePowerControl::ClosedLoop", BooleanValue(true));
986 Config::SetDefault("ns3::LteUePowerControl::AccumulationEnabled", BooleanValue(false));
987
988 Ptr<LteHelper> lteHelper = CreateObject<LteHelper>();
989
990 // Create Nodes: eNodeB and UE
991 NodeContainer enbNodes;
992 NodeContainer ueNodes1;
993 NodeContainer ueNodes2;
994 enbNodes.Create(2);
995 ueNodes1.Create(1);
996 ueNodes2.Create(1);
997 NodeContainer allNodes = NodeContainer(enbNodes, ueNodes1, ueNodes2);
998
999 /*
1000 * The topology is the following:
1001 *
1002 * eNB1 UE1 eNB2
1003 * | | |
1004 * x ------------ x ------------------------ x ------------ x----UE2
1005 * 200 m 600 m 200 m 20 m
1006 *
1007 */
1008
1009 Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();
1010 positionAlloc->Add(Vector(0.0, 0.0, 0.0)); // eNB1
1011 positionAlloc->Add(Vector(1000, 0.0, 0.0)); // eNB2
1012 positionAlloc->Add(Vector(0.0, 0.0, 0.0)); // UE1
1013 positionAlloc->Add(Vector(1020, 0.0, 0.0)); // UE2
1014 MobilityHelper mobility;
1015 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
1016 mobility.SetPositionAllocator(positionAlloc);
1017 mobility.Install(allNodes);
1018 m_ueMobility = ueNodes1.Get(0)->GetObject<MobilityModel>();
1019
1020 // Disable layer-3 filtering
1021 Config::SetDefault("ns3::LteEnbRrc::RsrpFilterCoefficient", UintegerValue(0));
1022 Config::SetDefault("ns3::LteEnbRrc::RsrqFilterCoefficient", UintegerValue(0));
1023
1024 // Create Devices and install them in the Nodes (eNB and UE)
1025 NetDeviceContainer enbDevs;
1026 NetDeviceContainer ueDevs1;
1027 NetDeviceContainer ueDevs2;
1028 lteHelper->SetSchedulerType(m_schedulerType);
1029
1030 lteHelper->SetFfrAlgorithmType("ns3::LteFrStrictAlgorithm");
1031 lteHelper->SetFfrAlgorithmAttribute("RsrqThreshold", UintegerValue(25));
1032 lteHelper->SetFfrAlgorithmAttribute("CenterPowerOffset",
1033 UintegerValue(LteRrcSap::PdschConfigDedicated::dB0));
1034 lteHelper->SetFfrAlgorithmAttribute("EdgePowerOffset",
1035 UintegerValue(LteRrcSap::PdschConfigDedicated::dB3));
1036
1037 lteHelper->SetFfrAlgorithmAttribute("DlCommonSubBandwidth", UintegerValue(6));
1038 lteHelper->SetFfrAlgorithmAttribute("DlEdgeSubBandOffset", UintegerValue(6));
1039 lteHelper->SetFfrAlgorithmAttribute("DlEdgeSubBandwidth", UintegerValue(6));
1040
1041 lteHelper->SetFfrAlgorithmAttribute("UlCommonSubBandwidth", UintegerValue(6));
1042 lteHelper->SetFfrAlgorithmAttribute("UlEdgeSubBandOffset", UintegerValue(6));
1043 lteHelper->SetFfrAlgorithmAttribute("UlEdgeSubBandwidth", UintegerValue(6));
1044 enbDevs.Add(lteHelper->InstallEnbDevice(enbNodes.Get(0)));
1045
1046 lteHelper->SetFfrAlgorithmType("ns3::LteFrNoOpAlgorithm");
1047 enbDevs.Add(lteHelper->InstallEnbDevice(enbNodes.Get(1)));
1048
1049 ueDevs1 = lteHelper->InstallUeDevice(ueNodes1);
1050 ueDevs2 = lteHelper->InstallUeDevice(ueNodes2);
1051
1052 // Attach a UE to a eNB
1053 lteHelper->Attach(ueDevs1, enbDevs.Get(0));
1054 lteHelper->Attach(ueDevs2, enbDevs.Get(1));
1055
1056 // Activate the default EPS bearer
1057 // Since this test includes the Token Bank Fair Queue Scheduler
1058 //(ns3::FdTbfqFfMacScheduler) we have to treat the default
1059 // bearer as the dedicated bearer with QoS.
1060 GbrQosInformation qos;
1061 qos.mbrUl = 1e6;
1062 qos.mbrDl = 1e6;
1063 qos.gbrUl = 1e4;
1064 qos.gbrDl = 1e4;
1065
1066 EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
1067 EpsBearer bearer(q, qos);
1068
1069 lteHelper->ActivateDataRadioBearer(ueDevs1, bearer);
1070 lteHelper->ActivateDataRadioBearer(ueDevs2, bearer);
1071
1072 // Test SpectrumPhy to get signals form DL channel
1073 Ptr<LteSpectrumPhy> enbDlSpectrumPhy = enbDevs.Get(0)
1074 ->GetObject<LteEnbNetDevice>()
1075 ->GetPhy()
1076 ->GetDownlinkSpectrumPhy()
1077 ->GetObject<LteSpectrumPhy>();
1078 Ptr<SpectrumChannel> dlChannel = enbDlSpectrumPhy->GetChannel();
1079
1080 Ptr<LteSimpleSpectrumPhy> testDlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy>();
1081 Ptr<LteEnbNetDevice> eNbDev = enbDevs.Get(0)->GetObject<LteEnbNetDevice>();
1082 testDlSpectrumPhy->SetRxSpectrumModel(
1083 LteSpectrumValueHelper::GetSpectrumModel(eNbDev->GetDlEarfcn(), m_dlBandwidth));
1084 dlChannel->AddRx(testDlSpectrumPhy);
1085
1086 testDlSpectrumPhy->SetCellId(1);
1087
1088 testDlSpectrumPhy->TraceConnectWithoutContext(
1089 "RxStart",
1090 MakeBoundCallback(&DlDataRxStartNofiticationArea, this));
1091
1092 // Test SpectrumPhy to get signals form UL channel
1093 Ptr<LteSpectrumPhy> ueUlSpectrumPhy = ueDevs1.Get(0)
1094 ->GetObject<LteUeNetDevice>()
1095 ->GetPhy()
1096 ->GetUplinkSpectrumPhy()
1097 ->GetObject<LteSpectrumPhy>();
1098 Ptr<SpectrumChannel> ulChannel = ueUlSpectrumPhy->GetChannel();
1099
1100 Ptr<LteSimpleSpectrumPhy> testUlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy>();
1101 testUlSpectrumPhy->SetRxSpectrumModel(
1102 LteSpectrumValueHelper::GetSpectrumModel(eNbDev->GetUlEarfcn(), m_ulBandwidth));
1103 ulChannel->AddRx(testUlSpectrumPhy);
1104
1105 testUlSpectrumPhy->SetCellId(1);
1106
1107 testUlSpectrumPhy->TraceConnectWithoutContext(
1108 "RxStart",
1109 MakeBoundCallback(&UlDataRxStartNofiticationArea, this));
1110
1111 std::vector<bool> expectedDlRbCenterArea;
1112 expectedDlRbCenterArea.resize(m_dlBandwidth, false);
1113 std::vector<bool> expectedUlRbCenterArea;
1114 expectedUlRbCenterArea.resize(m_ulBandwidth, false);
1115 for (uint32_t i = 0; i < 6; i++)
1116 {
1117 expectedDlRbCenterArea[i] = true;
1118 expectedUlRbCenterArea[i] = true;
1119 }
1120
1121 std::vector<bool> expectedDlRbEdgeArea;
1122 expectedDlRbEdgeArea.resize(m_dlBandwidth, false);
1123 std::vector<bool> expectedUlRbEdgeArea;
1124 expectedUlRbEdgeArea.resize(m_ulBandwidth, false);
1125 for (uint32_t i = 12; i < 18; i++)
1126 {
1127 expectedDlRbEdgeArea[i] = true;
1128 expectedUlRbEdgeArea[i] = true;
1129 }
1130
1131 Simulator::Schedule(MilliSeconds(1),
1132 &LteFrAreaTestCase::TeleportUe,
1133 this,
1134 200,
1135 0,
1136 1,
1137 expectedDlRbCenterArea);
1138 Simulator::Schedule(MilliSeconds(1),
1139 &LteFrAreaTestCase::SetUlExpectedValues,
1140 this,
1141 0.0150543,
1142 expectedUlRbCenterArea);
1143
1144 Simulator::Schedule(MilliSeconds(501),
1145 &LteFrAreaTestCase::TeleportUe,
1146 this,
1147 800,
1148 0,
1149 2,
1150 expectedDlRbEdgeArea);
1151 Simulator::Schedule(MilliSeconds(501),
1152 &LteFrAreaTestCase::SetUlExpectedValues,
1153 this,
1154 0.199526,
1155 expectedUlRbEdgeArea);
1156
1157 Simulator::Schedule(MilliSeconds(1001),
1158 &LteFrAreaTestCase::TeleportUe,
1159 this,
1160 200,
1161 0,
1162 1,
1163 expectedDlRbCenterArea);
1164 Simulator::Schedule(MilliSeconds(1001),
1165 &LteFrAreaTestCase::SetUlExpectedValues,
1166 this,
1167 0.0150543,
1168 expectedUlRbCenterArea);
1169
1170 Simulator::Stop(Seconds(1.500));
1171 Simulator::Run();
1172
1173 NS_TEST_ASSERT_MSG_EQ(m_usedWrongDlRbg, false, "Scheduler used DL RB muted by FFR Algorithm");
1174 NS_TEST_ASSERT_MSG_EQ(m_usedWrongUlRbg, false, "Scheduler used UL RB muted by FFR Algorithm");
1175
1176 Simulator::Destroy();
1177}
1178
1179LteSoftFrAreaTestCase::LteSoftFrAreaTestCase(std::string name, std::string schedulerType)
1180 : LteFrAreaTestCase(name, schedulerType)
1181{
1182 NS_LOG_INFO("Creating LteSoftFrAreaTestCase");
1183}
1184
1185LteSoftFrAreaTestCase::~LteSoftFrAreaTestCase()
1186{
1187}
1188
1189void
1190LteSoftFrAreaTestCase::DoRun()
1191{
1192 NS_LOG_DEBUG("LteSoftFrAreaTestCase");
1193
1194 Config::Reset();
1195 Config::SetDefault("ns3::LteHelper::UseIdealRrc", BooleanValue(true));
1196 Config::SetDefault("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue(false));
1197 Config::SetDefault("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue(false));
1198
1199 double eNbTxPower = 30;
1200 Config::SetDefault("ns3::LteEnbPhy::TxPower", DoubleValue(eNbTxPower));
1201 Config::SetDefault("ns3::LteUePhy::TxPower", DoubleValue(10.0));
1202 Config::SetDefault("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue(true));
1203
1204 Config::SetDefault("ns3::LteUePowerControl::ClosedLoop", BooleanValue(true));
1205 Config::SetDefault("ns3::LteUePowerControl::AccumulationEnabled", BooleanValue(false));
1206
1207 Ptr<LteHelper> lteHelper = CreateObject<LteHelper>();
1208
1209 // Create Nodes: eNodeB and UE
1210 NodeContainer enbNodes;
1211 NodeContainer ueNodes1;
1212 NodeContainer ueNodes2;
1213 enbNodes.Create(2);
1214 ueNodes1.Create(1);
1215 ueNodes2.Create(1);
1216 NodeContainer allNodes = NodeContainer(enbNodes, ueNodes1, ueNodes2);
1217
1218 /*
1219 * The topology is the following:
1220 *
1221 * eNB1 UE1 eNB2
1222 * | | |
1223 * x ------------ x ------------------------ x ------------ x----UE2
1224 * 200 m 600 m 200 m 20 m
1225 *
1226 */
1227
1228 Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();
1229 positionAlloc->Add(Vector(0.0, 0.0, 0.0)); // eNB1
1230 positionAlloc->Add(Vector(1000, 0.0, 0.0)); // eNB2
1231 positionAlloc->Add(Vector(0.0, 0.0, 0.0)); // UE1
1232 positionAlloc->Add(Vector(1020, 0.0, 0.0)); // UE2
1233 MobilityHelper mobility;
1234 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
1235 mobility.SetPositionAllocator(positionAlloc);
1236 mobility.Install(allNodes);
1237 m_ueMobility = ueNodes1.Get(0)->GetObject<MobilityModel>();
1238
1239 // Disable layer-3 filtering
1240 Config::SetDefault("ns3::LteEnbRrc::RsrpFilterCoefficient", UintegerValue(0));
1241 Config::SetDefault("ns3::LteEnbRrc::RsrqFilterCoefficient", UintegerValue(0));
1242
1243 // Create Devices and install them in the Nodes (eNB and UE)
1244 NetDeviceContainer enbDevs;
1245 NetDeviceContainer ueDevs1;
1246 NetDeviceContainer ueDevs2;
1247 lteHelper->SetSchedulerType(m_schedulerType);
1248
1249 lteHelper->SetFfrAlgorithmType("ns3::LteFrSoftAlgorithm");
1250 lteHelper->SetFfrAlgorithmAttribute("AllowCenterUeUseEdgeSubBand", BooleanValue(false));
1251 lteHelper->SetFfrAlgorithmAttribute("RsrqThreshold", UintegerValue(25));
1252 lteHelper->SetFfrAlgorithmAttribute("CenterPowerOffset",
1253 UintegerValue(LteRrcSap::PdschConfigDedicated::dB0));
1254 lteHelper->SetFfrAlgorithmAttribute("EdgePowerOffset",
1255 UintegerValue(LteRrcSap::PdschConfigDedicated::dB3));
1256
1257 lteHelper->SetFfrAlgorithmAttribute("DlEdgeSubBandOffset", UintegerValue(8));
1258 lteHelper->SetFfrAlgorithmAttribute("DlEdgeSubBandwidth", UintegerValue(8));
1259 lteHelper->SetFfrAlgorithmAttribute("UlEdgeSubBandOffset", UintegerValue(8));
1260 lteHelper->SetFfrAlgorithmAttribute("UlEdgeSubBandwidth", UintegerValue(8));
1261 enbDevs.Add(lteHelper->InstallEnbDevice(enbNodes.Get(0)));
1262
1263 lteHelper->SetFfrAlgorithmType("ns3::LteFrNoOpAlgorithm");
1264 enbDevs.Add(lteHelper->InstallEnbDevice(enbNodes.Get(1)));
1265
1266 ueDevs1 = lteHelper->InstallUeDevice(ueNodes1);
1267 ueDevs2 = lteHelper->InstallUeDevice(ueNodes2);
1268
1269 // Attach a UE to a eNB
1270 lteHelper->Attach(ueDevs1, enbDevs.Get(0));
1271 lteHelper->Attach(ueDevs2, enbDevs.Get(1));
1272
1273 // Activate the default EPS bearer
1274 // Since this test includes the Token Bank Fair Queue Scheduler
1275 //(ns3::FdTbfqFfMacScheduler) we have to treat the default
1276 // bearer as the dedicated bearer with QoS.
1277 GbrQosInformation qos;
1278 qos.mbrUl = 1e6;
1279 qos.mbrDl = 1e6;
1280 qos.gbrUl = 1e4;
1281 qos.gbrDl = 1e4;
1282
1283 EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
1284 EpsBearer bearer(q, qos);
1285 lteHelper->ActivateDataRadioBearer(ueDevs1, bearer);
1286 lteHelper->ActivateDataRadioBearer(ueDevs2, bearer);
1287
1288 // Test SpectrumPhy to get signals form DL channel
1289 Ptr<LteSpectrumPhy> enbDlSpectrumPhy = enbDevs.Get(0)
1290 ->GetObject<LteEnbNetDevice>()
1291 ->GetPhy()
1292 ->GetDownlinkSpectrumPhy()
1293 ->GetObject<LteSpectrumPhy>();
1294 Ptr<SpectrumChannel> dlChannel = enbDlSpectrumPhy->GetChannel();
1295
1296 Ptr<LteSimpleSpectrumPhy> testDlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy>();
1297 Ptr<LteEnbNetDevice> eNbDev = enbDevs.Get(0)->GetObject<LteEnbNetDevice>();
1298 testDlSpectrumPhy->SetRxSpectrumModel(
1299 LteSpectrumValueHelper::GetSpectrumModel(eNbDev->GetDlEarfcn(), m_dlBandwidth));
1300 dlChannel->AddRx(testDlSpectrumPhy);
1301
1302 testDlSpectrumPhy->SetCellId(1);
1303
1304 testDlSpectrumPhy->TraceConnectWithoutContext(
1305 "RxStart",
1306 MakeBoundCallback(&DlDataRxStartNofiticationArea, this));
1307
1308 // Test SpectrumPhy to get signals form UL channel
1309 Ptr<LteSpectrumPhy> ueUlSpectrumPhy = ueDevs1.Get(0)
1310 ->GetObject<LteUeNetDevice>()
1311 ->GetPhy()
1312 ->GetUplinkSpectrumPhy()
1313 ->GetObject<LteSpectrumPhy>();
1314 Ptr<SpectrumChannel> ulChannel = ueUlSpectrumPhy->GetChannel();
1315
1316 Ptr<LteSimpleSpectrumPhy> testUlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy>();
1317 testUlSpectrumPhy->SetRxSpectrumModel(
1318 LteSpectrumValueHelper::GetSpectrumModel(eNbDev->GetUlEarfcn(), m_ulBandwidth));
1319 ulChannel->AddRx(testUlSpectrumPhy);
1320
1321 testUlSpectrumPhy->SetCellId(1);
1322
1323 testUlSpectrumPhy->TraceConnectWithoutContext(
1324 "RxStart",
1325 MakeBoundCallback(&UlDataRxStartNofiticationArea, this));
1326
1327 std::vector<bool> expectedDlRbCenterArea;
1328 expectedDlRbCenterArea.resize(m_dlBandwidth, false);
1329 std::vector<bool> expectedUlRbCenterArea;
1330 expectedUlRbCenterArea.resize(m_ulBandwidth, false);
1331 for (uint32_t i = 0; i < 8; i++)
1332 {
1333 expectedDlRbCenterArea[i] = true;
1334 expectedUlRbCenterArea[i] = true;
1335 }
1336 for (uint32_t i = 16; i < 25; i++)
1337 {
1338 expectedDlRbCenterArea[i] = true;
1339 }
1340
1341 std::vector<bool> expectedDlRbEdgeArea;
1342 expectedDlRbEdgeArea.resize(m_dlBandwidth, false);
1343 std::vector<bool> expectedUlRbEdgeArea;
1344 expectedUlRbEdgeArea.resize(m_ulBandwidth, false);
1345 for (uint32_t i = 8; i < 16; i++)
1346 {
1347 expectedDlRbEdgeArea[i] = true;
1348 expectedUlRbEdgeArea[i] = true;
1349 }
1350
1351 Simulator::Schedule(MilliSeconds(1),
1352 &LteFrAreaTestCase::TeleportUe,
1353 this,
1354 200,
1355 0,
1356 1,
1357 expectedDlRbCenterArea);
1358 Simulator::Schedule(MilliSeconds(1),
1359 &LteFrAreaTestCase::SetUlExpectedValues,
1360 this,
1361 0.0150543,
1362 expectedUlRbCenterArea);
1363
1364 Simulator::Schedule(MilliSeconds(501),
1365 &LteFrAreaTestCase::TeleportUe,
1366 this,
1367 800,
1368 0,
1369 2,
1370 expectedDlRbEdgeArea);
1371 Simulator::Schedule(MilliSeconds(501),
1372 &LteFrAreaTestCase::SetUlExpectedValues,
1373 this,
1374 0.199526,
1375 expectedUlRbEdgeArea);
1376
1377 Simulator::Schedule(MilliSeconds(1001),
1378 &LteFrAreaTestCase::TeleportUe,
1379 this,
1380 200,
1381 0,
1382 1,
1383 expectedDlRbCenterArea);
1384 Simulator::Schedule(MilliSeconds(1001),
1385 &LteFrAreaTestCase::SetUlExpectedValues,
1386 this,
1387 0.0150543,
1388 expectedUlRbCenterArea);
1389
1390 Simulator::Stop(Seconds(1.500));
1391 Simulator::Run();
1392
1393#if 0
1394 NS_TEST_ASSERT_MSG_EQ (m_usedWrongDlRbg, false,
1395 "Scheduler used DL RBG muted by FFR Algorithm");
1396
1397#endif
1398 NS_TEST_ASSERT_MSG_EQ(m_usedWrongUlRbg, false, "Scheduler used UL RB muted by FFR Algorithm");
1399
1400 Simulator::Destroy();
1401}
1402
1403LteSoftFfrAreaTestCase::LteSoftFfrAreaTestCase(std::string name, std::string schedulerType)
1404 : LteFrAreaTestCase(name, schedulerType)
1405{
1406 NS_LOG_INFO("Creating LteSoftFfrAreaTestCase");
1407}
1408
1409LteSoftFfrAreaTestCase::~LteSoftFfrAreaTestCase()
1410{
1411}
1412
1413void
1414LteSoftFfrAreaTestCase::DoRun()
1415{
1416 NS_LOG_DEBUG("LteSoftFfrAreaTestCase");
1417
1418 Config::Reset();
1419 Config::SetDefault("ns3::LteHelper::UseIdealRrc", BooleanValue(true));
1420 Config::SetDefault("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue(false));
1421 Config::SetDefault("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue(false));
1422
1423 double eNbTxPower = 30;
1424 Config::SetDefault("ns3::LteEnbPhy::TxPower", DoubleValue(eNbTxPower));
1425 Config::SetDefault("ns3::LteUePhy::TxPower", DoubleValue(10.0));
1426 Config::SetDefault("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue(true));
1427
1428 Config::SetDefault("ns3::LteUePowerControl::ClosedLoop", BooleanValue(true));
1429 Config::SetDefault("ns3::LteUePowerControl::AccumulationEnabled", BooleanValue(false));
1430
1431 Ptr<LteHelper> lteHelper = CreateObject<LteHelper>();
1432
1433 // Create Nodes: eNodeB and UE
1434 NodeContainer enbNodes;
1435 NodeContainer ueNodes1;
1436 NodeContainer ueNodes2;
1437 enbNodes.Create(2);
1438 ueNodes1.Create(1);
1439 ueNodes2.Create(1);
1440 NodeContainer allNodes = NodeContainer(enbNodes, ueNodes1, ueNodes2);
1441
1442 /*
1443 * The topology is the following:
1444 *
1445 * eNB1 UE1 eNB2
1446 * | | |
1447 * x ------------ x ------------------------ x ------------ x----UE2
1448 * 200 m 600 m 200 m 20 m
1449 *
1450 */
1451
1452 Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();
1453 positionAlloc->Add(Vector(0.0, 0.0, 0.0)); // eNB1
1454 positionAlloc->Add(Vector(1000, 0.0, 0.0)); // eNB2
1455 positionAlloc->Add(Vector(0.0, 0.0, 0.0)); // UE1
1456 positionAlloc->Add(Vector(1020, 0.0, 0.0)); // UE2
1457 MobilityHelper mobility;
1458 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
1459 mobility.SetPositionAllocator(positionAlloc);
1460 mobility.Install(allNodes);
1461 m_ueMobility = ueNodes1.Get(0)->GetObject<MobilityModel>();
1462
1463 // Disable layer-3 filtering
1464 Config::SetDefault("ns3::LteEnbRrc::RsrpFilterCoefficient", UintegerValue(0));
1465 Config::SetDefault("ns3::LteEnbRrc::RsrqFilterCoefficient", UintegerValue(0));
1466
1467 // Create Devices and install them in the Nodes (eNB and UE)
1468 NetDeviceContainer enbDevs;
1469 NetDeviceContainer ueDevs1;
1470 NetDeviceContainer ueDevs2;
1471 lteHelper->SetSchedulerType(m_schedulerType);
1472
1473 lteHelper->SetFfrAlgorithmType("ns3::LteFfrSoftAlgorithm");
1474 lteHelper->SetFfrAlgorithmAttribute("CenterRsrqThreshold", UintegerValue(28));
1475 lteHelper->SetFfrAlgorithmAttribute("EdgeRsrqThreshold", UintegerValue(18));
1476 lteHelper->SetFfrAlgorithmAttribute("CenterAreaPowerOffset",
1477 UintegerValue(LteRrcSap::PdschConfigDedicated::dB_3));
1478 lteHelper->SetFfrAlgorithmAttribute("MediumAreaPowerOffset",
1479 UintegerValue(LteRrcSap::PdschConfigDedicated::dB0));
1480 lteHelper->SetFfrAlgorithmAttribute("EdgeAreaPowerOffset",
1481 UintegerValue(LteRrcSap::PdschConfigDedicated::dB3));
1482
1483 lteHelper->SetFfrAlgorithmAttribute("UlCommonSubBandwidth", UintegerValue(6));
1484 lteHelper->SetFfrAlgorithmAttribute("DlCommonSubBandwidth", UintegerValue(6));
1485
1486 lteHelper->SetFfrAlgorithmAttribute("DlEdgeSubBandOffset", UintegerValue(6));
1487 lteHelper->SetFfrAlgorithmAttribute("DlEdgeSubBandwidth", UintegerValue(6));
1488 lteHelper->SetFfrAlgorithmAttribute("UlEdgeSubBandOffset", UintegerValue(6));
1489 lteHelper->SetFfrAlgorithmAttribute("UlEdgeSubBandwidth", UintegerValue(6));
1490 enbDevs.Add(lteHelper->InstallEnbDevice(enbNodes.Get(0)));
1491
1492 lteHelper->SetFfrAlgorithmType("ns3::LteFrNoOpAlgorithm");
1493 enbDevs.Add(lteHelper->InstallEnbDevice(enbNodes.Get(1)));
1494
1495 ueDevs1 = lteHelper->InstallUeDevice(ueNodes1);
1496 ueDevs2 = lteHelper->InstallUeDevice(ueNodes2);
1497
1498 // Attach a UE to a eNB
1499 lteHelper->Attach(ueDevs1, enbDevs.Get(0));
1500 lteHelper->Attach(ueDevs2, enbDevs.Get(1));
1501
1502 // Activate the default EPS bearer
1503 // Since this test includes the Token Bank Fair Queue Scheduler
1504 //(ns3::FdTbfqFfMacScheduler) we have to treat the default
1505 // bearer as the dedicated bearer with QoS.
1506 GbrQosInformation qos;
1507 qos.mbrUl = 1e6;
1508 qos.mbrDl = 1e6;
1509 qos.gbrUl = 1e4;
1510 qos.gbrDl = 1e4;
1511
1512 EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
1513 EpsBearer bearer(q, qos);
1514 lteHelper->ActivateDataRadioBearer(ueDevs1, bearer);
1515 lteHelper->ActivateDataRadioBearer(ueDevs2, bearer);
1516
1517 // Test SpectrumPhy to get signals form DL channel
1518 Ptr<LteSpectrumPhy> enbDlSpectrumPhy = enbDevs.Get(0)
1519 ->GetObject<LteEnbNetDevice>()
1520 ->GetPhy()
1521 ->GetDownlinkSpectrumPhy()
1522 ->GetObject<LteSpectrumPhy>();
1523 Ptr<SpectrumChannel> dlChannel = enbDlSpectrumPhy->GetChannel();
1524
1525 Ptr<LteSimpleSpectrumPhy> testDlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy>();
1526 Ptr<LteEnbNetDevice> eNbDev = enbDevs.Get(0)->GetObject<LteEnbNetDevice>();
1527 testDlSpectrumPhy->SetRxSpectrumModel(
1528 LteSpectrumValueHelper::GetSpectrumModel(eNbDev->GetDlEarfcn(), m_dlBandwidth));
1529 dlChannel->AddRx(testDlSpectrumPhy);
1530
1531 testDlSpectrumPhy->SetCellId(1);
1532
1533 testDlSpectrumPhy->TraceConnectWithoutContext(
1534 "RxStart",
1535 MakeBoundCallback(&DlDataRxStartNofiticationArea, this));
1536
1537 // Test SpectrumPhy to get signals form UL channel
1538 Ptr<LteSpectrumPhy> ueUlSpectrumPhy = ueDevs1.Get(0)
1539 ->GetObject<LteUeNetDevice>()
1540 ->GetPhy()
1541 ->GetUplinkSpectrumPhy()
1542 ->GetObject<LteSpectrumPhy>();
1543 Ptr<SpectrumChannel> ulChannel = ueUlSpectrumPhy->GetChannel();
1544
1545 Ptr<LteSimpleSpectrumPhy> testUlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy>();
1546 testUlSpectrumPhy->SetRxSpectrumModel(
1547 LteSpectrumValueHelper::GetSpectrumModel(eNbDev->GetUlEarfcn(), m_ulBandwidth));
1548 ulChannel->AddRx(testUlSpectrumPhy);
1549
1550 testUlSpectrumPhy->SetCellId(1);
1551
1552 testUlSpectrumPhy->TraceConnectWithoutContext(
1553 "RxStart",
1554 MakeBoundCallback(&UlDataRxStartNofiticationArea, this));
1555
1556 double expectedDlPowerCenterArea = 0.5;
1557 std::vector<bool> expectedDlRbCenterArea;
1558 expectedDlRbCenterArea.resize(m_dlBandwidth, false);
1559 std::vector<bool> expectedUlRbCenterArea;
1560 expectedUlRbCenterArea.resize(m_ulBandwidth, false);
1561 for (uint32_t i = 6; i < 12; i++)
1562 {
1563 expectedDlRbCenterArea[i] = true;
1564 expectedUlRbCenterArea[i] = true;
1565 }
1566 for (uint32_t i = 18; i < 25; i++)
1567 {
1568 expectedDlRbCenterArea[i] = true;
1569 expectedUlRbCenterArea[i] = true;
1570 }
1571
1572 double expectedDlPowerMiddleArea = 1.0;
1573 std::vector<bool> expectedDlRbMiddleArea;
1574 expectedDlRbMiddleArea.resize(m_dlBandwidth, false);
1575 std::vector<bool> expectedUlRbMiddleArea;
1576 expectedUlRbMiddleArea.resize(m_ulBandwidth, false);
1577 for (uint32_t i = 0; i < 6; i++)
1578 {
1579 expectedDlRbMiddleArea[i] = true;
1580 expectedUlRbMiddleArea[i] = true;
1581 }
1582
1583 double expectedDlPowerEdgeArea = 2.0;
1584 std::vector<bool> expectedDlRbEdgeArea;
1585 expectedDlRbEdgeArea.resize(m_dlBandwidth, false);
1586 std::vector<bool> expectedUlRbEdgeArea;
1587 expectedUlRbEdgeArea.resize(m_ulBandwidth, false);
1588 for (uint32_t i = 12; i < 18; i++)
1589 {
1590 expectedDlRbEdgeArea[i] = true;
1591 expectedUlRbEdgeArea[i] = true;
1592 }
1593
1594 Simulator::Schedule(MilliSeconds(1),
1595 &LteFrAreaTestCase::TeleportUe,
1596 this,
1597 200,
1598 0,
1599 expectedDlPowerCenterArea,
1600 expectedDlRbCenterArea);
1601 Simulator::Schedule(MilliSeconds(1),
1602 &LteFrAreaTestCase::SetUlExpectedValues,
1603 this,
1604 0.0150543,
1605 expectedUlRbCenterArea);
1606
1607 Simulator::Schedule(MilliSeconds(501),
1608 &LteFrAreaTestCase::TeleportUe,
1609 this,
1610 600,
1611 0,
1612 expectedDlPowerMiddleArea,
1613 expectedDlRbMiddleArea);
1614 Simulator::Schedule(MilliSeconds(501),
1615 &LteFrAreaTestCase::SetUlExpectedValues,
1616 this,
1617 0.135489,
1618 expectedUlRbMiddleArea);
1619
1620 Simulator::Schedule(MilliSeconds(1001),
1621 &LteFrAreaTestCase::TeleportUe,
1622 this,
1623 800,
1624 0,
1625 expectedDlPowerEdgeArea,
1626 expectedDlRbEdgeArea);
1627 Simulator::Schedule(MilliSeconds(1001),
1628 &LteFrAreaTestCase::SetUlExpectedValues,
1629 this,
1630 0.199526,
1631 expectedUlRbEdgeArea);
1632
1633 Simulator::Schedule(MilliSeconds(1501),
1634 &LteFrAreaTestCase::TeleportUe,
1635 this,
1636 600,
1637 0,
1638 expectedDlPowerMiddleArea,
1639 expectedDlRbMiddleArea);
1640 Simulator::Schedule(MilliSeconds(1501),
1641 &LteFrAreaTestCase::SetUlExpectedValues,
1642 this,
1643 0.135489,
1644 expectedUlRbMiddleArea);
1645
1646 Simulator::Schedule(MilliSeconds(2001),
1647 &LteFrAreaTestCase::TeleportUe,
1648 this,
1649 200,
1650 0,
1651 expectedDlPowerCenterArea,
1652 expectedDlRbCenterArea);
1653 Simulator::Schedule(MilliSeconds(2001),
1654 &LteFrAreaTestCase::SetUlExpectedValues,
1655 this,
1656 0.0150543,
1657 expectedUlRbCenterArea);
1658
1659 Simulator::Stop(Seconds(2.500));
1660 Simulator::Run();
1661
1662 NS_TEST_ASSERT_MSG_EQ(m_usedWrongDlRbg, false, "Scheduler used DL RBG muted by FFR Algorithm");
1663
1664 NS_TEST_ASSERT_MSG_EQ(m_usedWrongUlRbg, false, "Scheduler used UL RB muted by FFR Algorithm");
1665
1666 Simulator::Destroy();
1667}
1668
1669LteEnhancedFfrAreaTestCase::LteEnhancedFfrAreaTestCase(std::string name, std::string schedulerType)
1670 : LteFrAreaTestCase(name, schedulerType)
1671{
1672 NS_LOG_INFO("Creating LteEnhancedFfrAreaTestCase");
1673}
1674
1675LteEnhancedFfrAreaTestCase::~LteEnhancedFfrAreaTestCase()
1676{
1677}
1678
1679void
1680LteEnhancedFfrAreaTestCase::DoRun()
1681{
1682 NS_LOG_DEBUG("LteEnhancedFfrAreaTestCase");
1683
1684 Config::Reset();
1685 Config::SetDefault("ns3::LteHelper::UseIdealRrc", BooleanValue(true));
1686 Config::SetDefault("ns3::LteHelper::UsePdschForCqiGeneration", BooleanValue(true));
1687 Config::SetDefault("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue(false));
1688 Config::SetDefault("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue(false));
1689
1690 double eNbTxPower = 30;
1691 Config::SetDefault("ns3::LteEnbPhy::TxPower", DoubleValue(eNbTxPower));
1692 Config::SetDefault("ns3::LteUePhy::TxPower", DoubleValue(10.0));
1693 Config::SetDefault("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue(true));
1694
1695 Config::SetDefault("ns3::LteUePowerControl::ClosedLoop", BooleanValue(true));
1696 Config::SetDefault("ns3::LteUePowerControl::AccumulationEnabled", BooleanValue(false));
1697
1698 Ptr<LteHelper> lteHelper = CreateObject<LteHelper>();
1699
1700 // Create Nodes: eNodeB and UE
1701 NodeContainer enbNodes;
1702 NodeContainer ueNodes1;
1703 NodeContainer ueNodes2;
1704 enbNodes.Create(2);
1705 ueNodes1.Create(1);
1706 ueNodes2.Create(1);
1707 NodeContainer allNodes = NodeContainer(enbNodes, ueNodes1, ueNodes2);
1708
1709 /*
1710 * The topology is the following:
1711 *
1712 * eNB1 UE1 eNB2
1713 * | | |
1714 * x ------------ x ------------------------ x ------------ x----UE2
1715 * 200 m 600 m 200 m 20 m
1716 *
1717 */
1718
1719 Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();
1720 positionAlloc->Add(Vector(0.0, 0.0, 0.0)); // eNB1
1721 positionAlloc->Add(Vector(1000, 0.0, 0.0)); // eNB2
1722 positionAlloc->Add(Vector(0.0, 0.0, 0.0)); // UE1
1723 positionAlloc->Add(Vector(1020, 0.0, 0.0)); // UE2
1724 MobilityHelper mobility;
1725 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
1726 mobility.SetPositionAllocator(positionAlloc);
1727 mobility.Install(allNodes);
1728 m_ueMobility = ueNodes1.Get(0)->GetObject<MobilityModel>();
1729
1730 // Disable layer-3 filtering
1731 Config::SetDefault("ns3::LteEnbRrc::RsrpFilterCoefficient", UintegerValue(0));
1732 Config::SetDefault("ns3::LteEnbRrc::RsrqFilterCoefficient", UintegerValue(0));
1733
1734 // Create Devices and install them in the Nodes (eNB and UE)
1735 NetDeviceContainer enbDevs;
1736 NetDeviceContainer ueDevs1;
1737 NetDeviceContainer ueDevs2;
1738 lteHelper->SetSchedulerType(m_schedulerType);
1739 lteHelper->SetSchedulerAttribute("HarqEnabled", BooleanValue(true));
1740
1741 lteHelper->SetEnbDeviceAttribute("DlBandwidth", UintegerValue(m_dlBandwidth));
1742 lteHelper->SetEnbDeviceAttribute("UlBandwidth", UintegerValue(m_ulBandwidth));
1743
1744 lteHelper->SetFfrAlgorithmType("ns3::LteFfrEnhancedAlgorithm");
1745 lteHelper->SetFfrAlgorithmAttribute("RsrqThreshold", UintegerValue(25));
1746 lteHelper->SetFfrAlgorithmAttribute("DlCqiThreshold", UintegerValue(10));
1747 lteHelper->SetFfrAlgorithmAttribute("UlCqiThreshold", UintegerValue(15));
1748 lteHelper->SetFfrAlgorithmAttribute("CenterAreaPowerOffset",
1749 UintegerValue(LteRrcSap::PdschConfigDedicated::dB_6));
1750 lteHelper->SetFfrAlgorithmAttribute("EdgeAreaPowerOffset",
1751 UintegerValue(LteRrcSap::PdschConfigDedicated::dB0));
1752
1753 lteHelper->SetFfrAlgorithmAttribute("UlSubBandOffset", UintegerValue(0));
1754 lteHelper->SetFfrAlgorithmAttribute("UlReuse3SubBandwidth", UintegerValue(4));
1755 lteHelper->SetFfrAlgorithmAttribute("UlReuse1SubBandwidth", UintegerValue(4));
1756
1757 lteHelper->SetFfrAlgorithmAttribute("DlSubBandOffset", UintegerValue(0));
1758 lteHelper->SetFfrAlgorithmAttribute("DlReuse3SubBandwidth", UintegerValue(4));
1759 lteHelper->SetFfrAlgorithmAttribute("DlReuse1SubBandwidth", UintegerValue(4));
1760
1761 enbDevs.Add(lteHelper->InstallEnbDevice(enbNodes.Get(0)));
1762
1763 lteHelper->SetFfrAlgorithmType("ns3::LteFrNoOpAlgorithm");
1764 enbDevs.Add(lteHelper->InstallEnbDevice(enbNodes.Get(1)));
1765
1766 ueDevs1 = lteHelper->InstallUeDevice(ueNodes1);
1767 ueDevs2 = lteHelper->InstallUeDevice(ueNodes2);
1768
1769 // Attach a UE to a eNB
1770 lteHelper->Attach(ueDevs1, enbDevs.Get(0));
1771 lteHelper->Attach(ueDevs2, enbDevs.Get(1));
1772
1773 // Activate the default EPS bearer
1774 // Since this test includes the Token Bank Fair Queue Scheduler
1775 //(ns3::FdTbfqFfMacScheduler) we have to treat the default
1776 // bearer as the dedicated bearer with QoS.
1777 GbrQosInformation qos;
1778 qos.mbrUl = 1e6;
1779 qos.mbrDl = 1e6;
1780 qos.gbrUl = 1e4;
1781 qos.gbrDl = 1e4;
1782
1783 EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
1784 EpsBearer bearer(q, qos);
1785 lteHelper->ActivateDataRadioBearer(ueDevs1, bearer);
1786 lteHelper->ActivateDataRadioBearer(ueDevs2, bearer);
1787
1788 // Test SpectrumPhy to get signals form DL channel
1789 Ptr<LteSpectrumPhy> enbDlSpectrumPhy = enbDevs.Get(0)
1790 ->GetObject<LteEnbNetDevice>()
1791 ->GetPhy()
1792 ->GetDownlinkSpectrumPhy()
1793 ->GetObject<LteSpectrumPhy>();
1794 Ptr<SpectrumChannel> dlChannel = enbDlSpectrumPhy->GetChannel();
1795
1796 Ptr<LteSimpleSpectrumPhy> testDlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy>();
1797 Ptr<LteEnbNetDevice> eNbDev = enbDevs.Get(0)->GetObject<LteEnbNetDevice>();
1798 testDlSpectrumPhy->SetRxSpectrumModel(
1799 LteSpectrumValueHelper::GetSpectrumModel(eNbDev->GetDlEarfcn(), m_dlBandwidth));
1800 dlChannel->AddRx(testDlSpectrumPhy);
1801
1802 testDlSpectrumPhy->SetCellId(1);
1803
1804 testDlSpectrumPhy->TraceConnectWithoutContext(
1805 "RxStart",
1806 MakeBoundCallback(&DlDataRxStartNofiticationArea, this));
1807
1808 // Test SpectrumPhy to get signals form UL channel
1809 Ptr<LteSpectrumPhy> ueUlSpectrumPhy = ueDevs1.Get(0)
1810 ->GetObject<LteUeNetDevice>()
1811 ->GetPhy()
1812 ->GetUplinkSpectrumPhy()
1813 ->GetObject<LteSpectrumPhy>();
1814 Ptr<SpectrumChannel> ulChannel = ueUlSpectrumPhy->GetChannel();
1815
1816 Ptr<LteSimpleSpectrumPhy> testUlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy>();
1817 testUlSpectrumPhy->SetRxSpectrumModel(
1818 LteSpectrumValueHelper::GetSpectrumModel(eNbDev->GetUlEarfcn(), m_ulBandwidth));
1819 ulChannel->AddRx(testUlSpectrumPhy);
1820
1821 testUlSpectrumPhy->SetCellId(1);
1822
1823 testUlSpectrumPhy->TraceConnectWithoutContext(
1824 "RxStart",
1825 MakeBoundCallback(&UlDataRxStartNofiticationArea, this));
1826
1827 double expectedDlPowerCenterArea = 0.251189;
1828 std::vector<bool> expectedDlRbCenterArea;
1829 expectedDlRbCenterArea.resize(m_dlBandwidth, false);
1830 std::vector<bool> expectedUlRbCenterArea;
1831 expectedUlRbCenterArea.resize(m_ulBandwidth, false);
1832 for (uint32_t i = 0; i < 8; i++)
1833 {
1834 expectedDlRbCenterArea[i] = true;
1835 expectedUlRbCenterArea[i] = true;
1836 }
1837 for (uint32_t i = 12; i < 16; i++)
1838 {
1839 expectedDlRbCenterArea[i] = true;
1840 expectedUlRbCenterArea[i] = true;
1841 }
1842 for (uint32_t i = 20; i < 24; i++)
1843 {
1844 expectedDlRbCenterArea[i] = true;
1845 expectedUlRbCenterArea[i] = true;
1846 }
1847
1848 double expectedDlPowerMiddleArea = 0.251189;
1849 std::vector<bool> expectedDlRbMiddleArea;
1850 expectedDlRbMiddleArea.resize(m_dlBandwidth, false);
1851 std::vector<bool> expectedUlRbMiddleArea;
1852 expectedUlRbMiddleArea.resize(m_ulBandwidth, false);
1853 for (uint32_t i = 4; i < 8; i++)
1854 {
1855 expectedDlRbMiddleArea[i] = true;
1856 expectedUlRbMiddleArea[i] = true;
1857 }
1858
1859 double expectedDlPowerEdgeArea = 1.0;
1860 std::vector<bool> expectedDlRbEdgeArea;
1861 expectedDlRbEdgeArea.resize(m_dlBandwidth, false);
1862 std::vector<bool> expectedUlRbEdgeArea;
1863 expectedUlRbEdgeArea.resize(m_ulBandwidth, false);
1864 for (uint32_t i = 0; i < 4; i++)
1865 {
1866 expectedDlRbEdgeArea[i] = true;
1867 expectedUlRbEdgeArea[i] = true;
1868 }
1869
1870 Simulator::Schedule(MilliSeconds(1),
1871 &LteEnhancedFfrAreaTestCase::TeleportUe,
1872 this,
1873 100,
1874 0,
1875 expectedDlPowerCenterArea,
1876 expectedDlRbCenterArea);
1877 Simulator::Schedule(MilliSeconds(1),
1878 &LteFrAreaTestCase::SetUlExpectedValues,
1879 this,
1880 0.00250905,
1881 expectedUlRbCenterArea);
1882
1883 Simulator::Schedule(MilliSeconds(501),
1884 &LteEnhancedFfrAreaTestCase::TeleportUe,
1885 this,
1886 300,
1887 0,
1888 expectedDlPowerMiddleArea,
1889 expectedDlRbMiddleArea);
1890 Simulator::Schedule(MilliSeconds(501),
1891 &LteFrAreaTestCase::SetUlExpectedValues,
1892 this,
1893 0.0225815,
1894 expectedUlRbMiddleArea);
1895
1896 Simulator::Schedule(MilliSeconds(1001),
1897 &LteEnhancedFfrAreaTestCase::TeleportUe,
1898 this,
1899 600,
1900 0,
1901 expectedDlPowerEdgeArea,
1902 expectedDlRbEdgeArea);
1903 Simulator::Schedule(MilliSeconds(1001),
1904 &LteFrAreaTestCase::SetUlExpectedValues,
1905 this,
1906 0.0903259,
1907 expectedUlRbEdgeArea);
1908
1909 Simulator::Schedule(MilliSeconds(1501),
1910 &LteEnhancedFfrAreaTestCase::TeleportUe,
1911 this,
1912 100,
1913 0,
1914 expectedDlPowerCenterArea,
1915 expectedDlRbCenterArea);
1916 Simulator::Schedule(MilliSeconds(1501),
1917 &LteFrAreaTestCase::SetUlExpectedValues,
1918 this,
1919 0.00250905,
1920 expectedUlRbCenterArea);
1921
1922 Simulator::Schedule(MilliSeconds(2001),
1923 &LteEnhancedFfrAreaTestCase::TeleportUe,
1924 this,
1925 300,
1926 0,
1927 expectedDlPowerMiddleArea,
1928 expectedDlRbMiddleArea);
1929 Simulator::Schedule(MilliSeconds(2001),
1930 &LteFrAreaTestCase::SetUlExpectedValues,
1931 this,
1932 0.0225815,
1933 expectedUlRbCenterArea);
1934
1935 Simulator::Stop(Seconds(2.500));
1936 Simulator::Run();
1937
1938 NS_TEST_ASSERT_MSG_EQ(m_usedWrongDlRbg, false, "Scheduler used DL RBG muted by FFR Algorithm");
1939
1940 NS_TEST_ASSERT_MSG_EQ(m_usedWrongUlRbg, false, "Scheduler used UL RB muted by FFR Algorithm");
1941
1942 Simulator::Destroy();
1943}
1944
1945LteDistributedFfrAreaTestCase::LteDistributedFfrAreaTestCase(std::string name,
1946 std::string schedulerType)
1947 : LteFrAreaTestCase(name, schedulerType)
1948{
1949 NS_LOG_INFO("Creating LteDistributedFfrAreaTestCase");
1950}
1951
1952LteDistributedFfrAreaTestCase::~LteDistributedFfrAreaTestCase()
1953{
1954}
1955
1956void
1957LteDistributedFfrAreaTestCase::DoRun()
1958{
1959 NS_LOG_DEBUG("LteDistributedFfrAreaTestCase");
1960
1961 Config::Reset();
1962 Config::SetDefault("ns3::LteHelper::UseIdealRrc", BooleanValue(true));
1963 Config::SetDefault("ns3::LteHelper::UsePdschForCqiGeneration", BooleanValue(true));
1964 Config::SetDefault("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue(false));
1965 Config::SetDefault("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue(false));
1966
1967 double eNbTxPower = 30;
1968 Config::SetDefault("ns3::LteEnbPhy::TxPower", DoubleValue(eNbTxPower));
1969 Config::SetDefault("ns3::LteUePhy::TxPower", DoubleValue(10.0));
1970 Config::SetDefault("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue(true));
1971
1972 Config::SetDefault("ns3::LteUePowerControl::ClosedLoop", BooleanValue(true));
1973 Config::SetDefault("ns3::LteUePowerControl::AccumulationEnabled", BooleanValue(false));
1974
1975 // Disable layer-3 filtering
1976 Config::SetDefault("ns3::LteEnbRrc::RsrpFilterCoefficient", UintegerValue(0));
1977 Config::SetDefault("ns3::LteEnbRrc::RsrqFilterCoefficient", UintegerValue(0));
1978
1979 uint16_t bandwidth = 25;
1980
1981 Ptr<LteHelper> lteHelper = CreateObject<LteHelper>();
1982 Ptr<PointToPointEpcHelper> epcHelper = CreateObject<PointToPointEpcHelper>();
1983 lteHelper->SetEpcHelper(epcHelper);
1984 lteHelper->SetHandoverAlgorithmType("ns3::NoOpHandoverAlgorithm"); // disable automatic handover
1985
1986 Ptr<Node> pgw = epcHelper->GetPgwNode();
1987
1988 // Create a single RemoteHost
1989 NodeContainer remoteHostContainer;
1990 remoteHostContainer.Create(1);
1991 Ptr<Node> remoteHost = remoteHostContainer.Get(0);
1992 InternetStackHelper internet;
1993 internet.Install(remoteHostContainer);
1994
1995 // Create the Internet
1996 PointToPointHelper p2ph;
1997 p2ph.SetDeviceAttribute("DataRate", DataRateValue(DataRate("100Gb/s")));
1998 p2ph.SetDeviceAttribute("Mtu", UintegerValue(1500));
1999 p2ph.SetChannelAttribute("Delay", TimeValue(Seconds(0.010)));
2000 NetDeviceContainer internetDevices = p2ph.Install(pgw, remoteHost);
2001 Ipv4AddressHelper ipv4h;
2002 ipv4h.SetBase("1.0.0.0", "255.0.0.0");
2003 Ipv4InterfaceContainer internetIpIfaces = ipv4h.Assign(internetDevices);
2004 Ipv4Address remoteHostAddr = internetIpIfaces.GetAddress(1);
2005
2006 // Routing of the Internet Host (towards the LTE network)
2007 Ipv4StaticRoutingHelper ipv4RoutingHelper;
2008 Ptr<Ipv4StaticRouting> remoteHostStaticRouting =
2009 ipv4RoutingHelper.GetStaticRouting(remoteHost->GetObject<Ipv4>());
2010 // interface 0 is localhost, 1 is the p2p device
2011 remoteHostStaticRouting->AddNetworkRouteTo(Ipv4Address("7.0.0.0"), Ipv4Mask("255.0.0.0"), 1);
2012
2013 // Create Nodes: eNodeB and UE
2014 NodeContainer enbNodes;
2015 NodeContainer ueNodes1;
2016 NodeContainer ueNodes2;
2017 enbNodes.Create(2);
2018 ueNodes1.Create(2);
2019 ueNodes2.Create(1);
2020 NodeContainer ueNodes = NodeContainer(ueNodes1, ueNodes2);
2021 NodeContainer allNodes = NodeContainer(enbNodes, ueNodes1, ueNodes2);
2022
2023 /*
2024 * The topology is the following:
2025 *
2026 * eNB1 UE1 UE2 eNB2
2027 * | | | |
2028 * x ------------ x ------------------------ x ------------ x
2029 * 200 m 600 m 200 m
2030 *
2031 */
2032
2033 // Install Mobility Model
2034 Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();
2035 positionAlloc->Add(Vector(0.0, 0.0, 0.0)); // eNB1
2036 positionAlloc->Add(Vector(1000, 0.0, 0.0)); // eNB2
2037
2038 positionAlloc->Add(Vector(200, 0.0, 0.0)); // UE1
2039 positionAlloc->Add(Vector(200, 0.0, 0.0)); // UE1
2040 positionAlloc->Add(Vector(800, 0.0, 0.0)); // UE2
2041
2042 MobilityHelper mobility;
2043 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
2044 mobility.SetPositionAllocator(positionAlloc);
2045 mobility.Install(allNodes);
2046 m_ueMobility = ueNodes2.Get(0)->GetObject<MobilityModel>();
2047
2048 // Create Devices and install them in the Nodes (eNB and UE)
2049 NetDeviceContainer enbDevs;
2050 NetDeviceContainer ueDevs1;
2051 NetDeviceContainer ueDevs2;
2052 lteHelper->SetSchedulerType(m_schedulerType);
2053
2054 lteHelper->SetEnbDeviceAttribute("DlBandwidth", UintegerValue(bandwidth));
2055 lteHelper->SetEnbDeviceAttribute("UlBandwidth", UintegerValue(bandwidth));
2056
2057 lteHelper->SetFfrAlgorithmType("ns3::LteFfrDistributedAlgorithm");
2058 lteHelper->SetFfrAlgorithmAttribute("CalculationInterval", TimeValue(MilliSeconds(10)));
2059 lteHelper->SetFfrAlgorithmAttribute("RsrqThreshold", UintegerValue(25));
2060 lteHelper->SetFfrAlgorithmAttribute("RsrpDifferenceThreshold", UintegerValue(5));
2061 lteHelper->SetFfrAlgorithmAttribute("EdgeRbNum", UintegerValue(6));
2062 lteHelper->SetFfrAlgorithmAttribute("CenterPowerOffset",
2063 UintegerValue(LteRrcSap::PdschConfigDedicated::dB0));
2064 lteHelper->SetFfrAlgorithmAttribute("EdgePowerOffset",
2065 UintegerValue(LteRrcSap::PdschConfigDedicated::dB3));
2066
2067 enbDevs = lteHelper->InstallEnbDevice(enbNodes);
2068 ueDevs1 = lteHelper->InstallUeDevice(ueNodes1);
2069 ueDevs2 = lteHelper->InstallUeDevice(ueNodes2);
2070
2071 NetDeviceContainer ueLteDevs;
2072 ueLteDevs.Add(ueDevs1);
2073 ueLteDevs.Add(ueDevs2);
2074
2075 // Add X2 interface
2076 lteHelper->AddX2Interface(enbNodes);
2077
2078 // Install the IP stack on the UEs
2079 internet.Install(ueNodes);
2080 Ipv4InterfaceContainer ueIpIfaces;
2081 ueIpIfaces = epcHelper->AssignUeIpv4Address(NetDeviceContainer(ueLteDevs));
2082 // Assign IP address to UEs, and install applications
2083 for (uint32_t u = 0; u < ueNodes.GetN(); ++u)
2084 {
2085 Ptr<Node> ueNode = ueNodes.Get(u);
2086 // Set the default gateway for the UE
2087 Ptr<Ipv4StaticRouting> ueStaticRouting =
2088 ipv4RoutingHelper.GetStaticRouting(ueNode->GetObject<Ipv4>());
2089 ueStaticRouting->SetDefaultRoute(epcHelper->GetUeDefaultGatewayAddress(), 1);
2090 }
2091
2092 // Attach a UE to a eNB
2093 lteHelper->Attach(ueDevs1, enbDevs.Get(0));
2094 lteHelper->Attach(ueDevs2, enbDevs.Get(1));
2095
2096 // Install and start applications on UEs and remote host
2097 uint16_t dlPort = 10000;
2098 uint16_t ulPort = 20000;
2099
2100 // randomize a bit start times to avoid simulation artifacts
2101 // (e.g., buffer overflows due to packet transmissions happening
2102 // exactly at the same time)
2103 Ptr<UniformRandomVariable> startTimeSeconds = CreateObject<UniformRandomVariable>();
2104 startTimeSeconds->SetAttribute("Min", DoubleValue(0));
2105 startTimeSeconds->SetAttribute("Max", DoubleValue(0.010));
2106
2107 for (uint32_t u = 0; u < ueNodes.GetN(); ++u)
2108 {
2109 Ptr<Node> ue = ueNodes.Get(u);
2110 // Set the default gateway for the UE
2111 Ptr<Ipv4StaticRouting> ueStaticRouting =
2112 ipv4RoutingHelper.GetStaticRouting(ue->GetObject<Ipv4>());
2113 ueStaticRouting->SetDefaultRoute(epcHelper->GetUeDefaultGatewayAddress(), 1);
2114
2115 for (uint32_t b = 0; b < 1; ++b)
2116 {
2117 ++dlPort;
2118 ++ulPort;
2119
2120 ApplicationContainer clientApps;
2121 ApplicationContainer serverApps;
2122
2123 NS_LOG_LOGIC("installing UDP DL app for UE " << u);
2124 UdpClientHelper dlClientHelper(ueIpIfaces.GetAddress(u), dlPort);
2125 dlClientHelper.SetAttribute("MaxPackets", UintegerValue(1000000));
2126 dlClientHelper.SetAttribute("Interval", TimeValue(MilliSeconds(1.0)));
2127 clientApps.Add(dlClientHelper.Install(remoteHost));
2128 PacketSinkHelper dlPacketSinkHelper("ns3::UdpSocketFactory",
2129 InetSocketAddress(Ipv4Address::GetAny(), dlPort));
2130 serverApps.Add(dlPacketSinkHelper.Install(ue));
2131
2132 NS_LOG_LOGIC("installing UDP UL app for UE " << u);
2133 UdpClientHelper ulClientHelper(remoteHostAddr, ulPort);
2134 ulClientHelper.SetAttribute("MaxPackets", UintegerValue(1000000));
2135 ulClientHelper.SetAttribute("Interval", TimeValue(MilliSeconds(1.0)));
2136 clientApps.Add(ulClientHelper.Install(ue));
2137 PacketSinkHelper ulPacketSinkHelper("ns3::UdpSocketFactory",
2138 InetSocketAddress(Ipv4Address::GetAny(), ulPort));
2139 serverApps.Add(ulPacketSinkHelper.Install(remoteHost));
2140
2141 Ptr<EpcTft> tft = Create<EpcTft>();
2142 EpcTft::PacketFilter dlpf;
2143 dlpf.localPortStart = dlPort;
2144 dlpf.localPortEnd = dlPort;
2145 tft->Add(dlpf);
2146 EpcTft::PacketFilter ulpf;
2147 ulpf.remotePortStart = ulPort;
2148 ulpf.remotePortEnd = ulPort;
2149 tft->Add(ulpf);
2150 // Since this test includes the Token Bank Fair Queue Scheduler
2151 //(ns3::FdTbfqFfMacScheduler) we have to use GBR bearer with
2152 // certain QoS.
2153 GbrQosInformation qos;
2154 qos.mbrUl = 1e6;
2155 qos.mbrDl = 1e6;
2156 qos.gbrUl = 1e4;
2157 qos.gbrDl = 1e4;
2158
2159 EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
2160 EpsBearer bearer(q, qos);
2161 lteHelper->ActivateDedicatedEpsBearer(ueLteDevs.Get(u), bearer, tft);
2162
2163 Time startTime = Seconds(startTimeSeconds->GetValue());
2164 serverApps.Start(startTime);
2165 clientApps.Start(startTime);
2166 }
2167 }
2168
2169 // Test SpectrumPhy to get signals form DL channel
2170 Ptr<LteSpectrumPhy> enbDlSpectrumPhy = enbDevs.Get(0)
2171 ->GetObject<LteEnbNetDevice>()
2172 ->GetPhy()
2173 ->GetDownlinkSpectrumPhy()
2174 ->GetObject<LteSpectrumPhy>();
2175 Ptr<SpectrumChannel> dlChannel = enbDlSpectrumPhy->GetChannel();
2176
2177 Ptr<LteSimpleSpectrumPhy> testDlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy>();
2178 Ptr<LteEnbNetDevice> eNbDev = enbDevs.Get(0)->GetObject<LteEnbNetDevice>();
2179 testDlSpectrumPhy->SetRxSpectrumModel(
2180 LteSpectrumValueHelper::GetSpectrumModel(eNbDev->GetDlEarfcn(), m_dlBandwidth));
2181 dlChannel->AddRx(testDlSpectrumPhy);
2182
2183 testDlSpectrumPhy->SetCellId(2);
2184
2185 testDlSpectrumPhy->TraceConnectWithoutContext(
2186 "RxStart",
2187 MakeBoundCallback(&DlDataRxStartNofiticationArea, this));
2188
2189 // Test SpectrumPhy to get signals form UL channel
2190 Ptr<LteSpectrumPhy> ueUlSpectrumPhy = ueDevs1.Get(0)
2191 ->GetObject<LteUeNetDevice>()
2192 ->GetPhy()
2193 ->GetUplinkSpectrumPhy()
2194 ->GetObject<LteSpectrumPhy>();
2195 Ptr<SpectrumChannel> ulChannel = ueUlSpectrumPhy->GetChannel();
2196
2197 Ptr<LteSimpleSpectrumPhy> testUlSpectrumPhy = CreateObject<LteSimpleSpectrumPhy>();
2198 testUlSpectrumPhy->SetRxSpectrumModel(
2199 LteSpectrumValueHelper::GetSpectrumModel(eNbDev->GetUlEarfcn(), m_ulBandwidth));
2200 ulChannel->AddRx(testUlSpectrumPhy);
2201
2202 testUlSpectrumPhy->SetCellId(2);
2203
2204 testUlSpectrumPhy->TraceConnectWithoutContext(
2205 "RxStart",
2206 MakeBoundCallback(&UlDataRxStartNofiticationArea, this));
2207
2208 double expectedDlPowerCenterArea = 1.0;
2209 std::vector<bool> expectedDlRbCenterArea;
2210 expectedDlRbCenterArea.resize(m_dlBandwidth, false);
2211 std::vector<bool> expectedUlRbCenterArea;
2212 expectedUlRbCenterArea.resize(m_ulBandwidth, false);
2213 for (uint32_t i = 0; i < m_dlBandwidth; i++)
2214 {
2215 expectedDlRbCenterArea[i] = true;
2216 expectedUlRbCenterArea[i] = true;
2217 }
2218
2219 double expectedDlPowerEdgeArea = 2.0;
2220 std::vector<bool> expectedDlRbEdgeArea;
2221 expectedDlRbEdgeArea.resize(m_dlBandwidth, false);
2222 std::vector<bool> expectedUlRbEdgeArea;
2223 expectedUlRbEdgeArea.resize(m_ulBandwidth, false);
2224 for (uint32_t i = 0; i < 6; i++)
2225 {
2226 expectedDlRbEdgeArea[i] = true;
2227 expectedUlRbEdgeArea[i] = true;
2228 }
2229
2230 std::vector<bool> expectedDlRbEdgeArea2;
2231 expectedDlRbEdgeArea2.resize(m_dlBandwidth, false);
2232 std::vector<bool> expectedUlRbEdgeArea2;
2233 expectedUlRbEdgeArea2.resize(m_dlBandwidth, false);
2234 for (uint32_t i = 6; i < 12; i++)
2235 {
2236 expectedDlRbEdgeArea2[i] = true;
2237 expectedUlRbEdgeArea2[i] = true;
2238 }
2239
2240 Simulator::Schedule(MilliSeconds(1),
2241 &LteFrAreaTestCase::TeleportUe,
2242 this,
2243 800,
2244 0,
2245 expectedDlPowerCenterArea,
2246 expectedDlRbCenterArea);
2247 Simulator::Schedule(MilliSeconds(1),
2248 &LteFrAreaTestCase::SetUlExpectedValues,
2249 this,
2250 0.0225815,
2251 expectedUlRbCenterArea);
2252
2253 Simulator::Schedule(MilliSeconds(501),
2254 &LteFrAreaTestCase::TeleportUe,
2255 this,
2256 400,
2257 0,
2258 expectedDlPowerEdgeArea,
2259 expectedDlRbEdgeArea);
2260 Simulator::Schedule(MilliSeconds(501),
2261 &LteFrAreaTestCase::SetUlExpectedValues,
2262 this,
2263 0.135489,
2264 expectedUlRbEdgeArea);
2265
2266 Simulator::Schedule(MilliSeconds(1001),
2267 &LteFrAreaTestCase::TeleportUe2,
2268 this,
2269 ueNodes1.Get(0),
2270 600,
2271 0,
2272 expectedDlPowerEdgeArea,
2273 expectedDlRbEdgeArea2);
2274 Simulator::Schedule(MilliSeconds(1001),
2275 &LteFrAreaTestCase::SetUlExpectedValues,
2276 this,
2277 0.135489,
2278 expectedUlRbEdgeArea2);
2279
2280 Simulator::Schedule(MilliSeconds(1501),
2281 &LteFrAreaTestCase::TeleportUe2,
2282 this,
2283 ueNodes1.Get(0),
2284 200,
2285 0,
2286 expectedDlPowerEdgeArea,
2287 expectedDlRbEdgeArea);
2288 Simulator::Schedule(MilliSeconds(1501),
2289 &LteFrAreaTestCase::SetUlExpectedValues,
2290 this,
2291 0.135489,
2292 expectedUlRbEdgeArea);
2293
2294 Simulator::Schedule(MilliSeconds(2001),
2295 &LteFrAreaTestCase::TeleportUe,
2296 this,
2297 800,
2298 0,
2299 expectedDlPowerCenterArea,
2300 expectedDlRbCenterArea);
2301 Simulator::Schedule(MilliSeconds(2001),
2302 &LteFrAreaTestCase::SetUlExpectedValues,
2303 this,
2304 0.0225815,
2305 expectedUlRbCenterArea);
2306
2307 Simulator::Stop(Seconds(2.500));
2308 Simulator::Run();
2309
2310#if 0
2311 NS_TEST_ASSERT_MSG_EQ (m_usedWrongDlRbg, false,
2312 "Scheduler used DL RBG muted by FFR Algorithm");
2313#endif
2314
2315 NS_TEST_ASSERT_MSG_EQ(m_usedWrongUlRbg, false, "Scheduler used UL RB muted by FFR Algorithm");
2316
2317 Simulator::Destroy();
2318}
LteDistributedFfrAreaTestCase
Lte Distributed Ffr Area Test Case.
Definition: lte-test-frequency-reuse.h:389
LteDistributedFfrAreaTestCase::LteDistributedFfrAreaTestCase
LteDistributedFfrAreaTestCase(std::string name, std::string schedulerType)
Constructor.
Definition: lte-test-frequency-reuse.cc:1945
LteDistributedFfrAreaTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: lte-test-frequency-reuse.cc:1957
LteEnhancedFfrAreaTestCase
Lte Enhanced Ffr Area Test Case.
Definition: lte-test-frequency-reuse.h:368
LteEnhancedFfrAreaTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: lte-test-frequency-reuse.cc:1680
LteEnhancedFfrAreaTestCase::LteEnhancedFfrAreaTestCase
LteEnhancedFfrAreaTestCase(std::string name, std::string schedulerType)
Constructor.
Definition: lte-test-frequency-reuse.cc:1669
LteFrAreaTestCase
Test frequency reuse algorithm by teleporting UEs to different parts of area and checking if the freq...
Definition: lte-test-frequency-reuse.h:214
LteFrAreaTestCase::m_teleportTime
Time m_teleportTime
the teleport time
Definition: lte-test-frequency-reuse.h:285
LteFrAreaTestCase::LteFrAreaTestCase
LteFrAreaTestCase(std::string name, std::string schedulerType)
Constructor.
Definition: lte-test-frequency-reuse.cc:799
LteFrAreaTestCase::m_usedWrongUlRbg
bool m_usedWrongUlRbg
used wrong UL RBG?
Definition: lte-test-frequency-reuse.h:295
LteFrAreaTestCase::m_expectedDlRb
std::vector< bool > m_expectedDlRb
the expected DL per RB
Definition: lte-test-frequency-reuse.h:289
LteFrAreaTestCase::SimpleTeleportUe
void SimpleTeleportUe(uint32_t x, uint32_t y)
Simple teleport UE function.
Definition: lte-test-frequency-reuse.cc:900
LteFrAreaTestCase::m_ulBandwidth
uint16_t m_ulBandwidth
the UL bandwidth
Definition: lte-test-frequency-reuse.h:283
LteFrAreaTestCase::m_dlBandwidth
uint16_t m_dlBandwidth
the DL bandwidth
Definition: lte-test-frequency-reuse.h:282
LteFrAreaTestCase::m_expectedUlRb
std::vector< bool > m_expectedUlRb
expected UL per RB
Definition: lte-test-frequency-reuse.h:294
LteFrAreaTestCase::UlDataRxStart
void UlDataRxStart(Ptr< const SpectrumValue > spectrumValue)
UL data receive start function.
Definition: lte-test-frequency-reuse.cc:849
LteFrAreaTestCase::TeleportUe2
void TeleportUe2(Ptr< Node > ueNode, uint32_t x, uint32_t y, double expectedPower, std::vector< bool > expectedDlRb)
Teleport UE 2 function.
Definition: lte-test-frequency-reuse.cc:923
LteFrAreaTestCase::DlDataRxStart
void DlDataRxStart(Ptr< const SpectrumValue > spectrumValue)
DL data receive start function.
Definition: lte-test-frequency-reuse.cc:814
LteFrAreaTestCase::m_expectedUlPower
double m_expectedUlPower
expected UL power
Definition: lte-test-frequency-reuse.h:293
LteFrAreaTestCase::m_schedulerType
std::string m_schedulerType
the scheduler type
Definition: lte-test-frequency-reuse.h:280
LteFrAreaTestCase::SetUlExpectedValues
void SetUlExpectedValues(double expectedPower, std::vector< bool > expectedDlRb)
Set UL expected values function.
Definition: lte-test-frequency-reuse.cc:948
LteFrAreaTestCase::m_expectedDlPower
double m_expectedDlPower
the expected DL power
Definition: lte-test-frequency-reuse.h:288
LteFrAreaTestCase::SetDlExpectedValues
void SetDlExpectedValues(double expectedPower, std::vector< bool > expectedDlRb)
Set DL expected values function.
Definition: lte-test-frequency-reuse.cc:940
LteFrAreaTestCase::m_usedWrongDlRbg
bool m_usedWrongDlRbg
used wrong DL RBG?
Definition: lte-test-frequency-reuse.h:290
LteFrAreaTestCase::TeleportUe
void TeleportUe(uint32_t x, uint32_t y, double expectedPower, std::vector< bool > expectedDlRb)
Teleport UE function.
Definition: lte-test-frequency-reuse.cc:909
LteFrAreaTestCase::m_ueMobility
Ptr< MobilityModel > m_ueMobility
the UE mobility model
Definition: lte-test-frequency-reuse.h:286
LteFrAreaTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: lte-test-frequency-reuse.cc:956
LteFrTestCase
Test frequency reuse algorithm.
Definition: lte-test-frequency-reuse.h:56
LteFrTestCase::DlDataRxStart
void DlDataRxStart(Ptr< const SpectrumValue > spectrumValue)
DL data receive start function.
Definition: lte-test-frequency-reuse.cc:480
LteFrTestCase::m_userNum
uint32_t m_userNum
the number of UE nodes
Definition: lte-test-frequency-reuse.h:90
LteFrTestCase::UlDataRxStart
void UlDataRxStart(Ptr< const SpectrumValue > spectrumValue)
UL data receive start function.
Definition: lte-test-frequency-reuse.cc:499
LteFrTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: lte-test-frequency-reuse.cc:518
LteFrTestCase::m_dlBandwidth
uint16_t m_dlBandwidth
the DL bandwidth
Definition: lte-test-frequency-reuse.h:91
LteFrTestCase::LteFrTestCase
LteFrTestCase(std::string name, uint32_t userNum, uint16_t dlBandwidth, uint16_t ulBandwidth, std::vector< bool > availableDlRb, std::vector< bool > availableUlRb)
Constructor.
Definition: lte-test-frequency-reuse.cc:458
LteFrTestCase::m_ulBandwidth
uint16_t m_ulBandwidth
the UL bandwidth
Definition: lte-test-frequency-reuse.h:92
LteFrTestCase::m_usedMutedDlRbg
bool m_usedMutedDlRbg
used muted DL RBG?
Definition: lte-test-frequency-reuse.h:95
LteFrTestCase::m_availableDlRb
std::vector< bool > m_availableDlRb
the available DL for each RB
Definition: lte-test-frequency-reuse.h:94
LteFrTestCase::m_availableUlRb
std::vector< bool > m_availableUlRb
the available UL for each RB
Definition: lte-test-frequency-reuse.h:97
LteFrTestCase::m_usedMutedUlRbg
bool m_usedMutedUlRbg
used muted UL RBG?
Definition: lte-test-frequency-reuse.h:98
LteFrequencyReuseTestSuite
Test the fractional frequency reuse algorithms.
Definition: lte-test-frequency-reuse.h:44
LteHardFrTestCase
Test hard frequency reuse algorithm.
Definition: lte-test-frequency-reuse.h:108
LteHardFrTestCase::LteHardFrTestCase
LteHardFrTestCase(std::string name, uint32_t userNum, std::string schedulerType, uint16_t dlBandwidth, uint16_t ulBandwidth, uint8_t dlSubBandOffset, uint16_t dlSubBandwidth, uint8_t ulSubBandOffset, uint16_t ulSubBandwidth, std::vector< bool > availableDlRb, std::vector< bool > availableUlRb)
Constructor.
Definition: lte-test-frequency-reuse.cc:522
LteHardFrTestCase::m_dlSubBandOffset
uint8_t m_dlSubBandOffset
the DL subband offset
Definition: lte-test-frequency-reuse.h:143
LteHardFrTestCase::m_ulSubBandwidth
uint8_t m_ulSubBandwidth
UL subband offset.
Definition: lte-test-frequency-reuse.h:147
LteHardFrTestCase::m_ulSubBandOffset
uint8_t m_ulSubBandOffset
UL subband offset.
Definition: lte-test-frequency-reuse.h:146
LteHardFrTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: lte-test-frequency-reuse.cc:548
LteHardFrTestCase::m_dlSubBandwidth
uint8_t m_dlSubBandwidth
the DL subband width
Definition: lte-test-frequency-reuse.h:144
LteHardFrTestCase::m_schedulerType
std::string m_schedulerType
the scheduler type
Definition: lte-test-frequency-reuse.h:141
LteSoftFfrAreaTestCase
Lte Soft Ffr Area Test Case.
Definition: lte-test-frequency-reuse.h:347
LteSoftFfrAreaTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: lte-test-frequency-reuse.cc:1414
LteSoftFfrAreaTestCase::LteSoftFfrAreaTestCase
LteSoftFfrAreaTestCase(std::string name, std::string schedulerType)
Constructor.
Definition: lte-test-frequency-reuse.cc:1403
LteSoftFrAreaTestCase
Lte Soft Fr Area Test Case.
Definition: lte-test-frequency-reuse.h:326
LteSoftFrAreaTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: lte-test-frequency-reuse.cc:1190
LteSoftFrAreaTestCase::LteSoftFrAreaTestCase
LteSoftFrAreaTestCase(std::string name, std::string schedulerType)
Constructor.
Definition: lte-test-frequency-reuse.cc:1179
LteStrictFrAreaTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: lte-test-frequency-reuse.cc:971
LteStrictFrAreaTestCase::LteStrictFrAreaTestCase
LteStrictFrAreaTestCase(std::string name, std::string schedulerType)
Constructor.
Definition: lte-test-frequency-reuse.cc:960
LteStrictFrTestCase
Test strict frequency reuse algorithm.
Definition: lte-test-frequency-reuse.h:157
LteStrictFrTestCase::m_ulCommonSubBandwidth
uint16_t m_ulCommonSubBandwidth
UL common subbandwidth.
Definition: lte-test-frequency-reuse.h:200
LteStrictFrTestCase::DoRun
void DoRun() override
Implementation to actually run this TestCase.
Definition: lte-test-frequency-reuse.cc:679
LteStrictFrTestCase::m_dlCommonSubBandwidth
uint16_t m_dlCommonSubBandwidth
DL common subbandwidth.
Definition: lte-test-frequency-reuse.h:196
LteStrictFrTestCase::m_dlEdgeSubBandOffset
uint8_t m_dlEdgeSubBandOffset
DL edge subband offset.
Definition: lte-test-frequency-reuse.h:197
LteStrictFrTestCase::m_ulEdgeSubBandOffset
uint8_t m_ulEdgeSubBandOffset
UL edge subband offset.
Definition: lte-test-frequency-reuse.h:201
LteStrictFrTestCase::m_schedulerType
std::string m_schedulerType
scheduler type
Definition: lte-test-frequency-reuse.h:194
LteStrictFrTestCase::LteStrictFrTestCase
LteStrictFrTestCase(std::string name, uint32_t userNum, std::string schedulerType, uint16_t dlBandwidth, uint16_t ulBandwidth, uint16_t dlCommonSubBandwidth, uint8_t dlEdgeSubBandOffset, uint16_t dlEdgeSubBandwidth, uint16_t ulCommonSubBandwidth, uint8_t ulEdgeSubBandOffset, uint16_t ulEdgeSubBandwidth, std::vector< bool > availableDlRb, std::vector< bool > availableUlRb)
Constructor.
Definition: lte-test-frequency-reuse.cc:649
LteStrictFrTestCase::m_dlEdgeSubBandwidth
uint16_t m_dlEdgeSubBandwidth
DL edge subbandwidth.
Definition: lte-test-frequency-reuse.h:198
LteStrictFrTestCase::m_ulEdgeSubBandwidth
uint16_t m_ulEdgeSubBandwidth
UL edge subbandwidth.
Definition: lte-test-frequency-reuse.h:202
ns3::ApplicationContainer
holds a vector of ns3::Application pointers.
Definition: application-container.h:44
ns3::BooleanValue
AttributeValue implementation for Boolean.
Definition: boolean.h:37
ns3::DataRate
Class for representing data rates.
Definition: data-rate.h:89
DataRateValue
AttributeValue implementation for DataRate.
ns3::DoubleValue
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition: double.h:42
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::EpsBearer::GBR_CONV_VOICE
@ GBR_CONV_VOICE
GBR Conversational Voice.
Definition: eps-bearer.h:107
ns3::InetSocketAddress
an Inet address class
Definition: inet-socket-address.h:42
ns3::InternetStackHelper
aggregate IP/TCP/UDP functionality to existing Nodes.
Definition: internet-stack-helper.h:92
ns3::Ipv4AddressHelper
A helper class to make life easier while doing simple IPv4 address assignment in scripts.
Definition: ipv4-address-helper.h:49
ns3::Ipv4AddressHelper::SetBase
void SetBase(Ipv4Address network, Ipv4Mask mask, Ipv4Address base="0.0.0.1")
Set the base network number, network mask and base address.
Definition: ipv4-address-helper.cc:64
ns3::Ipv4AddressHelper::Assign
Ipv4InterfaceContainer Assign(const NetDeviceContainer &c)
Assign IP addresses to the net devices specified in the container based on the current network prefix...
Definition: ipv4-address-helper.cc:132
ns3::Ipv4Address
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:42
ns3::Ipv4Address::GetAny
static Ipv4Address GetAny()
Definition: ipv4-address.cc:378
ns3::Ipv4
Access to the IPv4 forwarding table, interfaces, and configuration.
Definition: ipv4.h:79
ns3::Ipv4InterfaceContainer
holds a vector of std::pair of Ptr<Ipv4> and interface index.
Definition: ipv4-interface-container.h:56
ns3::Ipv4InterfaceContainer::GetAddress
Ipv4Address GetAddress(uint32_t i, uint32_t j=0) const
Definition: ipv4-interface-container.cc:60
ns3::Ipv4Mask
a class to represent an Ipv4 address mask
Definition: ipv4-address.h:257
ns3::Ipv4StaticRoutingHelper
Helper class that adds ns3::Ipv4StaticRouting objects.
Definition: ipv4-static-routing-helper.h:44
ns3::Ipv4StaticRoutingHelper::GetStaticRouting
Ptr< Ipv4StaticRouting > GetStaticRouting(Ptr< Ipv4 > ipv4) const
Try and find the static routing protocol as either the main routing protocol or in the list of routin...
Definition: ipv4-static-routing-helper.cc:59
ns3::LteEnbNetDevice
The eNodeB device implementation.
Definition: lte-enb-net-device.h:59
ns3::LteSpectrumPhy
The LteSpectrumPhy models the physical layer of LTE.
Definition: lte-spectrum-phy.h:150
ns3::LteSpectrumValueHelper::GetSpectrumModel
static Ptr< SpectrumModel > GetSpectrumModel(uint32_t earfcn, uint16_t bandwidth)
Definition: lte-spectrum-value-helper.cc:250
ns3::LteUeNetDevice
The LteUeNetDevice class implements the UE net device.
Definition: lte-ue-net-device.h:57
ns3::MobilityHelper
Helper class used to assign positions and mobility models to nodes.
Definition: mobility-helper.h:44
ns3::MobilityModel
Keep track of the current position and velocity of an object.
Definition: mobility-model.h:40
ns3::MobilityModel::SetPosition
void SetPosition(const Vector &position)
Definition: mobility-model.cc:92
ns3::NetDeviceContainer
holds a vector of ns3::NetDevice pointers
Definition: net-device-container.h:43
ns3::NetDeviceContainer::Add
void Add(NetDeviceContainer other)
Append the contents of another NetDeviceContainer to the end of this container.
Definition: net-device-container.cc:73
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::GetN
uint32_t GetN() const
Get the number of Ptr<Node> stored in this container.
Definition: node-container.cc:72
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::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:78
ns3::Object::GetObject
Ptr< T > GetObject() const
Get a pointer to the requested aggregated Object.
Definition: object.h:471
ns3::PacketSinkHelper
A helper to make it easier to instantiate an ns3::PacketSinkApplication on a set of nodes.
Definition: packet-sink-helper.h:36
ns3::PacketSinkHelper::Install
ApplicationContainer Install(NodeContainer c) const
Install an ns3::PacketSinkApplication on each node of the input container configured with all the att...
Definition: packet-sink-helper.cc:56
ns3::PointToPointHelper
Build a set of PointToPointNetDevice objects.
Definition: point-to-point-helper.h:44
ns3::PointToPointHelper::SetDeviceAttribute
void SetDeviceAttribute(std::string name, const AttributeValue &value)
Set an attribute value to be propagated to each NetDevice created by the helper.
Definition: point-to-point-helper.cc:54
ns3::PointToPointHelper::SetChannelAttribute
void SetChannelAttribute(std::string name, const AttributeValue &value)
Set an attribute value to be propagated to each Channel created by the helper.
Definition: point-to-point-helper.cc:60
ns3::PointToPointHelper::Install
NetDeviceContainer Install(NodeContainer c)
Definition: point-to-point-helper.cc:231
ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:78
ns3::Simulator::Schedule
static EventId Schedule(const Time &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
Definition: simulator.h:558
ns3::Simulator::Destroy
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
Definition: simulator.cc:140
ns3::Simulator::Now
static Time Now()
Return the current simulation virtual time.
Definition: simulator.cc:199
ns3::Simulator::Run
static void Run()
Run the simulation.
Definition: simulator.cc:176
ns3::Simulator::Stop
static void Stop()
Tell the Simulator the calling event should be the last one executed.
Definition: simulator.cc:184
ns3::TestCase
encapsulates test code
Definition: test.h:1060
ns3::TestCase::QUICK
@ QUICK
Fast test.
Definition: test.h:1065
ns3::TestCase::AddTestCase
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:301
ns3::TestSuite
A suite of tests to run.
Definition: test.h:1256
ns3::Time
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:105
ns3::Time::S
@ S
second
Definition: nstime.h:116
ns3::TimeValue
AttributeValue implementation for Time.
Definition: nstime.h:1412
ns3::UdpClientHelper
Create a client application which sends UDP packets carrying a 32bit sequence number and a 64 bit tim...
Definition: udp-client-server-helper.h:97
ns3::UdpClientHelper::SetAttribute
void SetAttribute(std::string name, const AttributeValue &value)
Record an attribute to be set in each Application after it is is created.
Definition: udp-client-server-helper.cc:87
ns3::UdpClientHelper::Install
ApplicationContainer Install(NodeContainer c)
Definition: udp-client-server-helper.cc:93
ns3::UintegerValue
Hold an unsigned integer type.
Definition: uinteger.h:45
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:855
ns3::Config::SetDefault
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:890
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_LOGIC
#define NS_LOG_LOGIC(msg)
Use NS_LOG to output a message of level LOG_LOGIC.
Definition: log.h:282
NS_LOG_FUNCTION
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
Definition: log-macros-enabled.h:238
NS_LOG_INFO
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:275
lteFrequencyReuseTestSuite
static LteFrequencyReuseTestSuite lteFrequencyReuseTestSuite
Static variable for test initialization.
Definition: lte-test-frequency-reuse.cc:441
ns3::MakeBoundCallback
auto MakeBoundCallback(R(*fnPtr)(Args...), BArgs &&... bargs)
Make Callbacks with varying number of bound arguments.
Definition: callback.h:765
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:1325
ns3::MilliSeconds
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1337
UlDataRxStartNofiticationArea
void UlDataRxStartNofiticationArea(LteFrAreaTestCase *testcase, Ptr< const SpectrumValue > spectrumValue)
Definition: lte-test-frequency-reuse.cc:794
DlDataRxStartNofiticationArea
void DlDataRxStartNofiticationArea(LteFrAreaTestCase *testcase, Ptr< const SpectrumValue > spectrumValue)
Definition: lte-test-frequency-reuse.cc:788
DlDataRxStartNofitication
void DlDataRxStartNofitication(LteFrTestCase *testcase, Ptr< const SpectrumValue > spectrumValue)
TestCase Data.
Definition: lte-test-frequency-reuse.cc:447
UlDataRxStartNofitication
void UlDataRxStartNofitication(LteFrTestCase *testcase, Ptr< const SpectrumValue > spectrumValue)
Definition: lte-test-frequency-reuse.cc:453
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::EpcTft::PacketFilter
Implement the data structure representing a TrafficFlowTemplate Packet Filter.
Definition: epc-tft.h:71
ns3::EpcTft::PacketFilter::localPortEnd
uint16_t localPortEnd
end of the port number range of the UE
Definition: epc-tft.h:132
ns3::EpcTft::PacketFilter::remotePortEnd
uint16_t remotePortEnd
end of the port number range of the remote host
Definition: epc-tft.h:130
ns3::EpcTft::PacketFilter::remotePortStart
uint16_t remotePortStart
start of the port number range of the remote host
Definition: epc-tft.h:129
ns3::EpcTft::PacketFilter::localPortStart
uint16_t localPortStart
start of the port number range of the UE
Definition: epc-tft.h:131
ns3::GbrQosInformation
3GPP TS 36.413 9.2.1.18 GBR QoS Information
Definition: eps-bearer.h:36
ns3::GbrQosInformation::gbrDl
uint64_t gbrDl
Guaranteed Bit Rate (bit/s) in downlink.
Definition: eps-bearer.h:42
ns3::GbrQosInformation::gbrUl
uint64_t gbrUl
Guaranteed Bit Rate (bit/s) in uplink.
Definition: eps-bearer.h:43
ns3::GbrQosInformation::mbrDl
uint64_t mbrDl
Maximum Bit Rate (bit/s) in downlink.
Definition: eps-bearer.h:44
ns3::GbrQosInformation::mbrUl
uint64_t mbrUl
Maximum Bit Rate (bit/s) in uplink.
Definition: eps-bearer.h:45