A Discrete-Event Network Simulator
API
lte-test-uplink-power-control.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
22
23#include "lte-ffr-simple.h"
24
25#include "ns3/lte-helper.h"
26#include "ns3/mobility-helper.h"
27#include <ns3/boolean.h>
28#include <ns3/callback.h>
29#include <ns3/config.h>
30#include <ns3/double.h>
31#include <ns3/enum.h>
32#include <ns3/ff-mac-scheduler.h>
33#include <ns3/integer.h>
34#include <ns3/log.h>
35#include <ns3/lte-common.h>
36#include <ns3/lte-enb-net-device.h>
37#include <ns3/lte-enb-phy.h>
38#include <ns3/lte-enb-rrc.h>
39#include <ns3/lte-rrc-sap.h>
40#include <ns3/lte-ue-net-device.h>
41#include <ns3/lte-ue-phy.h>
42#include <ns3/lte-ue-rrc.h>
43#include <ns3/pointer.h>
44#include <ns3/simulator.h>
45#include <ns3/string.h>
46
47using namespace ns3;
48
49NS_LOG_COMPONENT_DEFINE("LteUplinkPowerControlTest");
50
56 : TestSuite("lte-uplink-power-control", SYSTEM)
57{
58 // LogLevel logLevel = (LogLevel)(LOG_PREFIX_FUNC | LOG_PREFIX_TIME | LOG_LEVEL_DEBUG);
59 // LogComponentEnable ("LteUplinkPowerControlTest", logLevel);
60 NS_LOG_INFO("Creating LteUplinkPowerControlTestSuite");
61
62 AddTestCase(new LteUplinkOpenLoopPowerControlTestCase("OpenLoopTest1"), TestCase::QUICK);
64 new LteUplinkClosedLoopPowerControlAbsoluteModeTestCase("ClosedLoopAbsoluteModeTest1"),
65 TestCase::QUICK);
67 "ClosedLoopAccumulatedModeTest1"),
68 TestCase::QUICK);
69}
70
76
80void
82 uint16_t cellId,
83 uint16_t rnti,
84 double txPower)
85{
86 testcase->PuschTxPowerTrace(cellId, rnti, txPower);
87}
88
89void
91 uint16_t cellId,
92 uint16_t rnti,
93 double txPower)
94{
95 testcase->PucchTxPowerTrace(cellId, rnti, txPower);
96}
97
98void
100 uint16_t cellId,
101 uint16_t rnti,
102 double txPower)
103{
104 testcase->SrsTxPowerTrace(cellId, rnti, txPower);
105}
106
108 : TestCase(name)
109{
110 NS_LOG_INFO("Creating LteUplinkPowerControlTestCase");
111}
112
114{
115}
116
117void
119 uint32_t y,
120 double expectedPuschTxPower,
121 double expectedPucchTxPower,
122 double expectedSrsTxPower)
123{
124 NS_LOG_FUNCTION(this);
125 NS_LOG_DEBUG("Teleport UE to : (" << x << ", " << y << ", 0)");
126
127 m_ueMobility->SetPosition(Vector(x, y, 0.0));
129
130 m_expectedPuschTxPower = expectedPuschTxPower;
131 m_expectedPucchTxPower = expectedPucchTxPower;
132 m_expectedSrsTxPower = expectedSrsTxPower;
133}
134
135void
137 uint32_t tpcNum,
138 double expectedPuschTxPower,
139 double expectedPucchTxPower,
140 double expectedSrsTxPower)
141{
142 NS_LOG_FUNCTION(this);
143
145
146 m_expectedPuschTxPower = expectedPuschTxPower;
147 m_expectedPucchTxPower = expectedPucchTxPower;
148 m_expectedSrsTxPower = expectedSrsTxPower;
149
150 m_ffrSimple->SetTpc(tpc, tpcNum, m_accumulatedMode);
151}
152
153void
154LteUplinkPowerControlTestCase::PuschTxPowerTrace(uint16_t cellId, uint16_t rnti, double txPower)
155{
156 NS_LOG_FUNCTION(this);
157 NS_LOG_DEBUG("PuschTxPower : CellId: " << cellId << " RNTI: " << rnti
158 << " PuschTxPower: " << txPower);
159 // wait because of RSRP filtering
161 {
162 return;
163 }
164 NS_TEST_ASSERT_MSG_EQ_TOL(txPower, m_expectedPuschTxPower, 0.01, "Wrong Pusch Tx Power");
165}
166
167void
168LteUplinkPowerControlTestCase::PucchTxPowerTrace(uint16_t cellId, uint16_t rnti, double txPower)
169{
170 NS_LOG_FUNCTION(this);
171 NS_LOG_DEBUG("PucchTxPower : CellId: " << cellId << " RNTI: " << rnti
172 << " PuschTxPower: " << txPower);
173 // wait because of RSRP filtering
175 {
176 return;
177 }
178
179 NS_TEST_ASSERT_MSG_EQ_TOL(txPower, m_expectedPucchTxPower, 0.01, "Wrong Pucch Tx Power");
180}
181
182void
183LteUplinkPowerControlTestCase::SrsTxPowerTrace(uint16_t cellId, uint16_t rnti, double txPower)
184{
185 NS_LOG_FUNCTION(this);
186 NS_LOG_DEBUG("SrsTxPower : CellId: " << cellId << " RNTI: " << rnti
187 << " PuschTxPower: " << txPower);
188 // wait because of RSRP filtering
190 {
191 return;
192 }
193 NS_TEST_ASSERT_MSG_EQ_TOL(txPower, m_expectedSrsTxPower, 0.01, "Wrong Srs Tx Power");
194}
195
196void
198{
199}
200
202 : LteUplinkPowerControlTestCase("Uplink Open Loop Power Control: " + name)
203{
204 NS_LOG_INFO("Creating LteUplinkPowerControlTestCase");
205}
206
208{
209}
210
211void
213{
215 Config::SetDefault("ns3::LteHelper::UseIdealRrc", BooleanValue(false));
216
217 double eNbTxPower = 30;
218 Config::SetDefault("ns3::LteEnbPhy::TxPower", DoubleValue(eNbTxPower));
219 Config::SetDefault("ns3::LteUePhy::TxPower", DoubleValue(10.0));
220 Config::SetDefault("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue(true));
221
222 Config::SetDefault("ns3::LteUePowerControl::ClosedLoop", BooleanValue(false));
223 Config::SetDefault("ns3::LteUePowerControl::AccumulationEnabled", BooleanValue(false));
224 Config::SetDefault("ns3::LteUePowerControl::PoNominalPusch", IntegerValue(-90));
225 Config::SetDefault("ns3::LteUePowerControl::PsrsOffset", IntegerValue(9));
226
227 Ptr<LteHelper> lteHelper = CreateObject<LteHelper>();
228
229 uint16_t bandwidth = 25;
230 double d1 = 0;
231
232 // Create Nodes: eNodeB and UE
233 NodeContainer enbNodes;
234 NodeContainer ueNodes;
235 enbNodes.Create(1);
236 ueNodes.Create(1);
237 NodeContainer allNodes = NodeContainer(enbNodes, ueNodes);
238
239 /* the topology is the following:
240 *
241 * eNB1-------------------------UE
242 * d1
243 */
244
245 // Install Mobility Model
246 Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();
247 positionAlloc->Add(Vector(0.0, 0.0, 0.0)); // eNB1
248 positionAlloc->Add(Vector(d1, 0.0, 0.0)); // UE1
249
251 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
252 mobility.SetPositionAllocator(positionAlloc);
253 mobility.Install(allNodes);
254 m_ueMobility = ueNodes.Get(0)->GetObject<MobilityModel>();
255
256 // Create Devices and install them in the Nodes (eNB and UE)
257 NetDeviceContainer enbDevs;
258 NetDeviceContainer ueDevs;
259 lteHelper->SetSchedulerType("ns3::PfFfMacScheduler");
260
261 lteHelper->SetEnbDeviceAttribute("DlBandwidth", UintegerValue(bandwidth));
262 lteHelper->SetEnbDeviceAttribute("UlBandwidth", UintegerValue(bandwidth));
263
264 enbDevs = lteHelper->InstallEnbDevice(enbNodes);
265 ueDevs = lteHelper->InstallUeDevice(ueNodes);
266
267 Ptr<LteUePhy> uePhy =
268 DynamicCast<LteUePhy>(ueDevs.Get(0)->GetObject<LteUeNetDevice>()->GetPhy());
269 m_ueUpc = uePhy->GetUplinkPowerControl();
270
271 m_ueUpc->TraceConnectWithoutContext("ReportPuschTxPower",
273 m_ueUpc->TraceConnectWithoutContext("ReportPucchTxPower",
275 m_ueUpc->TraceConnectWithoutContext("ReportSrsTxPower",
277
278 // Attach a UE to a eNB
279 lteHelper->Attach(ueDevs, enbDevs.Get(0));
280
281 // Activate a data radio bearer
282 enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
283 EpsBearer bearer(q);
284 lteHelper->ActivateDataRadioBearer(ueDevs, bearer);
285
286 // Changing UE position
287 Simulator::Schedule(MilliSeconds(0),
289 this,
290 0,
291 0,
292 -40,
293 -40,
294 -40);
295 Simulator::Schedule(MilliSeconds(200),
297 this,
298 200,
299 0,
300 8.9745,
301 8.9745,
302 11.9745);
303 Simulator::Schedule(MilliSeconds(300),
305 this,
306 400,
307 0,
308 14.9951,
309 14.9951,
310 17.9951);
311 Simulator::Schedule(MilliSeconds(400),
313 this,
314 600,
315 0,
316 18.5169,
317 18.5169,
318 21.5169);
319 Simulator::Schedule(MilliSeconds(500),
321 this,
322 800,
323 0,
324 21.0157,
325 21.0157,
326 23);
327 Simulator::Schedule(MilliSeconds(600),
329 this,
330 1000,
331 0,
332 22.9539,
333 22.9539,
334 23);
335 Simulator::Schedule(MilliSeconds(700),
337 this,
338 1200,
339 0,
340 23,
341 10,
342 23);
343 Simulator::Schedule(MilliSeconds(800),
345 this,
346 400,
347 0,
348 14.9951,
349 14.9951,
350 17.9951);
351 Simulator::Schedule(MilliSeconds(900),
353 this,
354 800,
355 0,
356 21.0157,
357 21.0157,
358 23);
359 Simulator::Schedule(MilliSeconds(1000),
361 this,
362 0,
363 0,
364 -40,
365 -40,
366 -40);
367 Simulator::Schedule(MilliSeconds(1100),
369 this,
370 100,
371 0,
372 2.9539,
373 2.9539,
374 5.9539);
375 Simulator::Stop(Seconds(1.200));
376 Simulator::Run();
377
378 Simulator::Destroy();
379}
380
383 : LteUplinkPowerControlTestCase("Uplink Closed Loop Power Control: " + name)
384{
385 NS_LOG_INFO("Creating LteUplinkClosedLoopPowerControlAbsoluteModeTestCase");
386}
387
390{
391}
392
393void
395{
397 Config::SetDefault("ns3::LteHelper::UseIdealRrc", BooleanValue(false));
398
399 double eNbTxPower = 30;
400 Config::SetDefault("ns3::LteEnbPhy::TxPower", DoubleValue(eNbTxPower));
401 Config::SetDefault("ns3::LteUePhy::TxPower", DoubleValue(10.0));
402 Config::SetDefault("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue(true));
403
404 Config::SetDefault("ns3::LteUePowerControl::ClosedLoop", BooleanValue(true));
405 Config::SetDefault("ns3::LteUePowerControl::AccumulationEnabled", BooleanValue(false));
406 Config::SetDefault("ns3::LteUePowerControl::PoNominalPusch", IntegerValue(-90));
407 Config::SetDefault("ns3::LteUePowerControl::PsrsOffset", IntegerValue(9));
408
409 Ptr<LteHelper> lteHelper = CreateObject<LteHelper>();
410 lteHelper->SetFfrAlgorithmType("ns3::LteFfrSimple");
411
412 uint16_t bandwidth = 25;
413 double d1 = 100;
414
415 // Create Nodes: eNodeB and UE
416 NodeContainer enbNodes;
417 NodeContainer ueNodes;
418 enbNodes.Create(1);
419 ueNodes.Create(1);
420 NodeContainer allNodes = NodeContainer(enbNodes, ueNodes);
421
422 /* the topology is the following:
423 *
424 * eNB1-------------------------UE
425 * d1
426 */
427
428 // Install Mobility Model
429 Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();
430 positionAlloc->Add(Vector(0.0, 0.0, 0.0)); // eNB1
431 positionAlloc->Add(Vector(d1, 0.0, 0.0)); // UE1
432
434 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
435 mobility.SetPositionAllocator(positionAlloc);
436 mobility.Install(allNodes);
437 m_ueMobility = ueNodes.Get(0)->GetObject<MobilityModel>();
438
439 // Create Devices and install them in the Nodes (eNB and UE)
440 NetDeviceContainer enbDevs;
441 NetDeviceContainer ueDevs;
442 lteHelper->SetSchedulerType("ns3::PfFfMacScheduler");
443
444 lteHelper->SetEnbDeviceAttribute("DlBandwidth", UintegerValue(bandwidth));
445 lteHelper->SetEnbDeviceAttribute("UlBandwidth", UintegerValue(bandwidth));
446
447 enbDevs = lteHelper->InstallEnbDevice(enbNodes);
448 ueDevs = lteHelper->InstallUeDevice(ueNodes);
449
450 Ptr<LteUePhy> uePhy =
451 DynamicCast<LteUePhy>(ueDevs.Get(0)->GetObject<LteUeNetDevice>()->GetPhy());
452 m_ueUpc = uePhy->GetUplinkPowerControl();
453
454 m_ueUpc->TraceConnectWithoutContext("ReportPuschTxPower",
456 m_ueUpc->TraceConnectWithoutContext("ReportPucchTxPower",
458 m_ueUpc->TraceConnectWithoutContext("ReportSrsTxPower",
460
461 // Attach a UE to a eNB
462 lteHelper->Attach(ueDevs, enbDevs.Get(0));
463
464 // Activate a data radio bearer
465 enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
466 EpsBearer bearer(q);
467 lteHelper->ActivateDataRadioBearer(ueDevs, bearer);
468
469 PointerValue tmp;
470 enbDevs.Get(0)->GetAttribute("LteFfrAlgorithm", tmp);
471 m_ffrSimple = DynamicCast<LteFfrSimple>(tmp.GetObject());
472 m_accumulatedMode = false;
473
474 // Changing TPC value
475 Simulator::Schedule(MilliSeconds(0),
477 this,
478 1,
479 0,
480 1.9539,
481 1.9539,
482 4.9539);
483 Simulator::Schedule(MilliSeconds(100),
485 this,
486 0,
487 0,
488 -1.0461,
489 -1.0461,
490 1.9539);
491 Simulator::Schedule(MilliSeconds(200),
493 this,
494 2,
495 0,
496 3.9539,
497 3.9539,
498 6.9539);
499 Simulator::Schedule(MilliSeconds(300),
501 this,
502 3,
503 0,
504 6.9539,
505 6.9539,
506 9.9539);
507 Simulator::Schedule(MilliSeconds(400),
509 this,
510 0,
511 0,
512 -1.0461,
513 -1.0461,
514 1.9539);
515 Simulator::Schedule(MilliSeconds(500),
517 this,
518 1,
519 0,
520 1.9539,
521 1.9539,
522 4.9539);
523 Simulator::Schedule(MilliSeconds(600),
525 this,
526 3,
527 0,
528 6.9539,
529 6.9539,
530 9.9539);
531 Simulator::Schedule(MilliSeconds(800),
533 this,
534 2,
535 0,
536 3.9539,
537 3.9539,
538 6.9539);
539 Simulator::Stop(Seconds(1.000));
540 Simulator::Run();
541
542 Simulator::Destroy();
543}
544
547 : LteUplinkPowerControlTestCase("Uplink Closed Loop Power Control: " + name)
548{
549 NS_LOG_INFO("Creating LteUplinkClosedLoopPowerControlAccumulatedModeTestCase");
550}
551
554{
555}
556
557void
559{
561 Config::SetDefault("ns3::LteHelper::UseIdealRrc", BooleanValue(false));
562
563 double eNbTxPower = 30;
564 Config::SetDefault("ns3::LteEnbPhy::TxPower", DoubleValue(eNbTxPower));
565 Config::SetDefault("ns3::LteUePhy::TxPower", DoubleValue(10.0));
566 Config::SetDefault("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue(true));
567
568 Config::SetDefault("ns3::LteUePowerControl::ClosedLoop", BooleanValue(true));
569 Config::SetDefault("ns3::LteUePowerControl::AccumulationEnabled", BooleanValue(true));
570 Config::SetDefault("ns3::LteUePowerControl::PoNominalPusch", IntegerValue(-90));
571 Config::SetDefault("ns3::LteUePowerControl::PsrsOffset", IntegerValue(9));
572
573 Ptr<LteHelper> lteHelper = CreateObject<LteHelper>();
574 lteHelper->SetFfrAlgorithmType("ns3::LteFfrSimple");
575
576 uint16_t bandwidth = 25;
577 double d1 = 10;
578
579 // Create Nodes: eNodeB and UE
580 NodeContainer enbNodes;
581 NodeContainer ueNodes;
582 enbNodes.Create(1);
583 ueNodes.Create(1);
584 NodeContainer allNodes = NodeContainer(enbNodes, ueNodes);
585
586 /* the topology is the following:
587 *
588 * eNB1-------------------------UE
589 * d1
590 */
591
592 // Install Mobility Model
593 Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();
594 positionAlloc->Add(Vector(0.0, 0.0, 0.0)); // eNB1
595 positionAlloc->Add(Vector(d1, 0.0, 0.0)); // UE1
596
598 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
599 mobility.SetPositionAllocator(positionAlloc);
600 mobility.Install(allNodes);
601 m_ueMobility = ueNodes.Get(0)->GetObject<MobilityModel>();
602
603 // Create Devices and install them in the Nodes (eNB and UE)
604 NetDeviceContainer enbDevs;
605 NetDeviceContainer ueDevs;
606 lteHelper->SetSchedulerType("ns3::PfFfMacScheduler");
607
608 lteHelper->SetEnbDeviceAttribute("DlBandwidth", UintegerValue(bandwidth));
609 lteHelper->SetEnbDeviceAttribute("UlBandwidth", UintegerValue(bandwidth));
610
611 enbDevs = lteHelper->InstallEnbDevice(enbNodes);
612 ueDevs = lteHelper->InstallUeDevice(ueNodes);
613
614 Ptr<LteUePhy> uePhy =
615 DynamicCast<LteUePhy>(ueDevs.Get(0)->GetObject<LteUeNetDevice>()->GetPhy());
616 m_ueUpc = uePhy->GetUplinkPowerControl();
617
618 m_ueUpc->TraceConnectWithoutContext("ReportPuschTxPower",
620 m_ueUpc->TraceConnectWithoutContext("ReportPucchTxPower",
622 m_ueUpc->TraceConnectWithoutContext("ReportSrsTxPower",
624
625 // Attach a UE to a eNB
626 lteHelper->Attach(ueDevs, enbDevs.Get(0));
627
628 // Activate a data radio bearer
629 enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
630 EpsBearer bearer(q);
631 lteHelper->ActivateDataRadioBearer(ueDevs, bearer);
632
633 PointerValue tmp;
634 enbDevs.Get(0)->GetAttribute("LteFfrAlgorithm", tmp);
635 m_ffrSimple = DynamicCast<LteFfrSimple>(tmp.GetObject());
636 m_accumulatedMode = true;
637
638 // Changing TPC value
639 Simulator::Schedule(MilliSeconds(0),
641 this,
642 1,
643 0,
644 -17.0461,
645 -17.0461,
646 -14.0461);
647 Simulator::Schedule(MilliSeconds(100),
649 this,
650 0,
651 20,
652 -37.0461,
653 -37.0461,
654 -34.0461);
655 Simulator::Schedule(MilliSeconds(200),
657 this,
658 0,
659 20,
660 -40,
661 10,
662 -37.0461);
663 Simulator::Schedule(MilliSeconds(300),
665 this,
666 2,
667 1,
668 -39.0461,
669 -39.0461,
670 -36.0461);
671 Simulator::Schedule(MilliSeconds(400),
673 this,
674 3,
675 10,
676 -9.0461,
677 -9.0461,
678 -6.0461);
679 Simulator::Schedule(MilliSeconds(500),
681 this,
682 2,
683 15,
684 5.9539,
685 5.9539,
686 8.9539);
687 Simulator::Schedule(MilliSeconds(600),
689 this,
690 3,
691 1,
692 8.9539,
693 8.9539,
694 11.9539);
695 Simulator::Schedule(MilliSeconds(700),
697 this,
698 2,
699 10,
700 18.9539,
701 18.9539,
702 21.9539);
703 Simulator::Schedule(MilliSeconds(800),
705 this,
706 2,
707 20,
708 23,
709 23,
710 23);
711 Simulator::Schedule(MilliSeconds(900),
713 this,
714 0,
715 1,
716 22.9539,
717 22.9539,
718 23);
719 Simulator::Schedule(MilliSeconds(1000),
721 this,
722 0,
723 20,
724 2.9539,
725 2.9539,
726 5.9539);
727 Simulator::Schedule(MilliSeconds(1100),
729 this,
730 2,
731 5,
732 7.9539,
733 7.9539,
734 10.9539);
735 Simulator::Stop(Seconds(1.200));
736 Simulator::Run();
737
738 Simulator::Destroy();
739}
AttributeValue implementation for Boolean.
Definition: boolean.h:37
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition: double.h:42
This class contains the specification of EPS Bearers.
Definition: eps-bearer.h:91
Qci
QoS Class Indicator.
Definition: eps-bearer.h:106
Hold a signed integer type.
Definition: integer.h:45
void SetTpc(uint32_t tpc, uint32_t num, bool acculumatedMode)
Set transmission power control.
void SetFfrAlgorithmType(std::string type)
Set the type of FFR algorithm to be used by eNodeB devices.
Definition: lte-helper.cc:316
NetDeviceContainer InstallEnbDevice(NodeContainer c)
Create a set of eNodeB devices.
Definition: lte-helper.cc:482
void SetSchedulerType(std::string type)
Set the type of scheduler to be used by eNodeB devices.
Definition: lte-helper.cc:289
void Attach(NetDeviceContainer ueDevices)
Enables automatic attachment of a set of UE devices to a suitable cell using Idle mode initial cell s...
Definition: lte-helper.cc:1044
void SetEnbDeviceAttribute(std::string n, const AttributeValue &v)
Set an attribute for the eNodeB devices (LteEnbNetDevice) to be created.
Definition: lte-helper.cc:409
void ActivateDataRadioBearer(NetDeviceContainer ueDevices, EpsBearer bearer)
Activate a Data Radio Bearer on a given UE devices (for LTE-only simulation).
Definition: lte-helper.cc:1441
NetDeviceContainer InstallUeDevice(NodeContainer c)
Create a set of UE devices.
Definition: lte-helper.cc:497
The LteUeNetDevice class implements the UE net device.
Ptr< LteUePhy > GetPhy() const
Get the Phy.
Helper class used to assign positions and mobility models to nodes.
Keep track of the current position and velocity of an object.
void SetPosition(const Vector &position)
holds a vector of ns3::NetDevice pointers
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr<NetDevice> stored in this container at a given index.
keep track of a set of node pointers.
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
bool TraceConnectWithoutContext(std::string name, const CallbackBase &cb)
Connect a TraceSource to a Callback without a context.
Definition: object-base.cc:311
Ptr< T > GetObject() const
Get a pointer to the requested aggregated Object.
Definition: object.h:471
Hold objects of type Ptr<T>.
Definition: pointer.h:37
Ptr< Object > GetObject() const
Get the Object referenced by the PointerValue.
Definition: pointer.cc:57
Ptr< T > Get() const
Definition: pointer.h:206
encapsulates test code
Definition: test.h:1060
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:305
A suite of tests to run.
Definition: test.h:1256
Hold an unsigned integer type.
Definition: uinteger.h:45
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
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:891
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:268
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:275
static LteUplinkPowerControlTestSuite lteUplinkPowerControlTestSuite
Static variable for test initialization.
auto MakeBoundCallback(R(*fnPtr)(Args...), BArgs... bargs)
Make Callbacks with varying number of bound arguments.
Definition: callback.h:752
Time Now()
create an ns3::Time instance which contains the current simulation time.
Definition: simulator.cc:296
#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
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1336
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1348
Every class exported by the ns3 library is enclosed in the ns3 namespace.
mobility
Definition: third.py:96