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