5G-LENA nr-v3.3-120-gdac69c56
The 5G/NR module for the ns-3 simulator
Loading...
Searching...
No Matches
nr-uplink-power-control-test.cc
1// Copyright (c) Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
2//
3// SPDX-License-Identifier: GPL-2.0-only
4
5#include "ns3/antenna-module.h"
6#include "ns3/applications-module.h"
7#include "ns3/boolean.h"
8#include "ns3/callback.h"
9#include "ns3/config.h"
10#include "ns3/double.h"
11#include "ns3/integer.h"
12#include "ns3/internet-module.h"
13#include "ns3/log.h"
14#include "ns3/mobility-helper.h"
15#include "ns3/nr-module.h"
16#include "ns3/point-to-point-module.h"
17#include "ns3/pointer.h"
18#include "ns3/rng-seed-manager.h"
19#include "ns3/simulator.h"
20#include "ns3/test.h"
21
22using namespace ns3;
23NS_LOG_COMPONENT_DEFINE("NrUplinkPowerControlTestCase");
24
32class NrUplinkPowerControlTestSuite : public TestSuite
33{
34 public:
35 NrUplinkPowerControlTestSuite();
36};
37
47class NrUplinkPowerControlTestCase : public TestCase
48{
49 public:
57 NrUplinkPowerControlTestCase(std::string name, bool closedLoop, bool accumulatedMode);
61 ~NrUplinkPowerControlTestCase() override;
62
71 void MoveUe(uint32_t distance, double expectedPuschTxPower, double expectedPucchTxPower);
72
79 void PuschTxPowerTrace(uint16_t cellId, uint16_t rnti, double txPower);
86 void PucchTxPowerTrace(uint16_t cellId, uint16_t rnti, double txPower);
87
88 protected:
89 void DoRun() override;
90
91 Ptr<MobilityModel> m_ueMobility;
92 Ptr<NrUePowerControl> m_ueUpc;
93 Time m_movingTime;
94 double m_expectedPuschTxPower{0.0};
95 double m_expectedPucchTxPower{0.0};
96 bool m_closedLoop{true};
97 bool m_accumulatedMode{true};
99 bool m_puschTxPowerTraceFired{
100 true};
101 bool m_pucchTxPowerTraceFired{
102 true};
103};
104
105NrUplinkPowerControlTestSuite::NrUplinkPowerControlTestSuite()
106 : TestSuite("nr-uplink-power-control-test", Type::SYSTEM)
107{
108 // LogLevel logLevel = (LogLevel)(LOG_PREFIX_FUNC | LOG_PREFIX_TIME | LOG_LEVEL_DEBUG);
109 // LogComponentEnable ("NrUplinkPowerControlTestSuite", logLevel);
110 NS_LOG_INFO("Creating NrUplinkPowerControlTestSuite");
111 AddTestCase(new NrUplinkPowerControlTestCase("OpenLoopPowerControlTest", false, false),
112 Duration::QUICK);
113 AddTestCase(
114 new NrUplinkPowerControlTestCase("ClosedLoopPowerControlAbsoluteModeTest", true, false),
115 Duration::QUICK);
116 AddTestCase(
117 new NrUplinkPowerControlTestCase("ClosedLoopPowerControlAccumulatedModeTest", true, true),
118 Duration::QUICK);
119}
120
121static NrUplinkPowerControlTestSuite lteUplinkPowerControlTestSuite;
122
123void
124PuschTxPowerReport(NrUplinkPowerControlTestCase* testcase,
125 uint16_t cellId,
126 uint16_t rnti,
127 double txPower)
128{
129 testcase->PuschTxPowerTrace(cellId, rnti, txPower);
130}
131
132void
133PucchTxPowerReport(NrUplinkPowerControlTestCase* testcase,
134 uint16_t cellId,
135 uint16_t rnti,
136 double txPower)
137{
138 testcase->PucchTxPowerTrace(cellId, rnti, txPower);
139}
140
141NrUplinkPowerControlTestCase::NrUplinkPowerControlTestCase(std::string name,
142 bool closedLoop,
143 bool accumulatedMode)
144 : TestCase(name)
145{
146 NS_LOG_INFO("Creating NrUplinkPowerControlTestCase");
147 m_closedLoop = closedLoop;
148 m_accumulatedMode =
149 accumulatedMode; // if closed loop is configured, this would indicate the type of a TPC mode
150 // to be used for the closed loop power control.
151}
152
153NrUplinkPowerControlTestCase::~NrUplinkPowerControlTestCase()
154{
155}
156
157void
158NrUplinkPowerControlTestCase::MoveUe(uint32_t distance,
159 double expectedPuschTxPower,
160 double expectedPucchTxPower)
161{
162 NS_LOG_FUNCTION(this);
163
164 NS_TEST_ASSERT_MSG_EQ(m_pucchTxPowerTraceFired,
165 true,
166 "Power trace for PUCCH did not get triggered. Test check for PUCCH did "
167 "not execute as expected. ");
168 m_pucchTxPowerTraceFired = false; // reset
169 NS_TEST_ASSERT_MSG_EQ(m_puschTxPowerTraceFired,
170 true,
171 "Power trace for PUSCH did not get triggered. Test check did PUSCH not "
172 "execute as expected. ");
173 m_puschTxPowerTraceFired = false; // reset
174 Vector newPosition = m_ueMobility->GetPosition();
175 newPosition.x = distance;
176 m_ueMobility->SetPosition(newPosition);
177 NS_LOG_DEBUG("Move UE to : " << m_ueMobility->GetPosition());
178 m_movingTime = Simulator::Now();
179 m_expectedPuschTxPower = expectedPuschTxPower;
180 m_expectedPucchTxPower = expectedPucchTxPower;
181}
182
183void
184NrUplinkPowerControlTestCase::PuschTxPowerTrace(uint16_t cellId, uint16_t rnti, double txPower)
185{
186 NS_LOG_FUNCTION(this);
187 NS_LOG_DEBUG("PuschTxPower for CellId: " << cellId << " RNTI: " << rnti
188 << " PuschTxPower: " << txPower);
189 // wait because of RSRP filtering
190 if ((Simulator::Now() - m_movingTime) < MilliSeconds(50))
191 {
192 return;
193 }
194 else
195 {
196 if (!m_puschTxPowerTraceFired)
197 {
198 m_puschTxPowerTraceFired = true;
199 }
200 }
201
202 // we allow some tolerance because of layer 3 filtering
203 NS_TEST_ASSERT_MSG_EQ_TOL(txPower,
204 m_expectedPuschTxPower,
205 1 + std::fabs(m_expectedPuschTxPower * 0.1),
206 "Wrong Pusch Tx Power");
207}
208
209void
210NrUplinkPowerControlTestCase::PucchTxPowerTrace(uint16_t cellId, uint16_t rnti, double txPower)
211{
212 NS_LOG_FUNCTION(this);
213 NS_LOG_DEBUG("PucchTxPower : CellId: " << cellId << " RNTI: " << rnti
214 << " PuschTxPower: " << txPower);
215 // wait because of RSRP filtering
216 if ((Simulator::Now() - m_movingTime) < MilliSeconds(50))
217 {
218 return;
219 }
220 else
221 {
222 if (!m_pucchTxPowerTraceFired)
223 {
224 m_pucchTxPowerTraceFired = true;
225 }
226 }
227
228 // we allow some tolerance because of layer 3 filtering
229 NS_TEST_ASSERT_MSG_EQ_TOL(txPower,
230 m_expectedPucchTxPower,
231 1 + std::fabs(m_expectedPucchTxPower * 0.1),
232 "Wrong Pucch Tx Power");
233}
234
235void
236NrUplinkPowerControlTestCase::DoRun()
237{
238 std::string scenario = "InH-OfficeMixed"; // scenario
239 double frequency = 2e9; // central frequency
240 double bandwidth = 4.6e6; // bandwidth
241 double hBS = 1.5; // base station antenna height in meters, and
242 double hUT = 1.5; // user antenna height in meters
243 double gNBTxPower = 30; // gNb tx power
244 double ueTxPower = 10; // ue tx power
245 std::string condition = "LOS";
246 uint16_t numerology = 0; // numerology to be used
247 uint16_t numCcPerBand = 1; // number of component carrier in the assigned band
248 Time udpAppStartTime = MilliSeconds(50);
249 Time simTime = MilliSeconds(2500);
250
251 Config::Reset();
252
253 RngSeedManager::SetSeed(1);
254 RngSeedManager::SetRun(1);
255
256 Config::SetDefault("ns3::NrUePhy::EnableUplinkPowerControl", BooleanValue(true));
257 Config::SetDefault("ns3::NrUePowerControl::ClosedLoop", BooleanValue(m_closedLoop));
258 Config::SetDefault("ns3::NrUePowerControl::AccumulationEnabled",
259 BooleanValue(m_accumulatedMode));
260 Config::SetDefault("ns3::NrUePowerControl::PoNominalPusch", IntegerValue(-90));
261 Config::SetDefault("ns3::NrUePowerControl::PoNominalPucch", IntegerValue(-80));
262 Config::SetDefault("ns3::NrUePowerControl::PsrsOffset", IntegerValue(9));
263 Config::SetDefault("ns3::ThreeGppPropagationLossModel::ShadowingEnabled", BooleanValue(false));
264
265 Ptr<NrPointToPointEpcHelper> nrEpcHelper = CreateObject<NrPointToPointEpcHelper>();
266 Ptr<IdealBeamformingHelper> idealBeamformingHelper = CreateObject<IdealBeamformingHelper>();
267 Ptr<NrHelper> nrHelper = CreateObject<NrHelper>();
268 Ptr<NrChannelHelper> channelHelper = CreateObject<NrChannelHelper>();
269 // Configure the spectrum channel
270 channelHelper->ConfigureFactories(scenario, condition, "ThreeGpp");
271 // Disable shadowing
272 channelHelper->SetPathlossAttribute("ShadowingEnabled", BooleanValue(false));
273 nrHelper->SetBeamformingHelper(idealBeamformingHelper);
274 nrHelper->SetEpcHelper(nrEpcHelper);
275
276 // Create Nodes: eNodeB and UE
277 NodeContainer gnbNodes;
278 NodeContainer ueNodes;
279 gnbNodes.Create(1);
280 ueNodes.Create(1);
281 NodeContainer allNodes = NodeContainer(gnbNodes, ueNodes);
282
283 // Install Mobility Model
284 Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();
285 positionAlloc->Add(Vector(0.1, 0.0, hBS)); // gNB
286 positionAlloc->Add(Vector(0, 0.0, hUT)); // UE
287
288 MobilityHelper mobility;
289 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
290 mobility.SetPositionAllocator(positionAlloc);
291 mobility.Install(allNodes);
292 m_ueMobility = ueNodes.Get(0)->GetObject<MobilityModel>();
293
294 // Create Devices and install them in the Nodes (eNB and UE)
295 NetDeviceContainer gnbDevs;
296 NetDeviceContainer ueDevs;
297 nrHelper->SetGnbPhyAttribute("Numerology", UintegerValue(numerology));
298 nrHelper->SetGnbPhyAttribute("TxPower", DoubleValue(gNBTxPower));
299 nrHelper->SetUePhyAttribute("TxPower", DoubleValue(ueTxPower));
300 nrHelper->SetUePhyAttribute("EnableUplinkPowerControl", BooleanValue(true));
301
302 CcBwpCreator::SimpleOperationBandConf bandConf(frequency, bandwidth, numCcPerBand);
303 CcBwpCreator ccBwpCreator;
304 OperationBandInfo band = ccBwpCreator.CreateOperationBandContiguousCc(bandConf);
305 channelHelper->AssignChannelsToBands({band}, NrChannelHelper::INIT_PROPAGATION);
306
307 BandwidthPartInfoPtrVector allBwps = CcBwpCreator::GetAllBwps({band});
308
309 // Configure ideal beamforming method
310 idealBeamformingHelper->SetAttribute("BeamformingMethod",
311 TypeIdValue(DirectPathBeamforming::GetTypeId()));
312
313 // Antennas for the UEs
314 nrHelper->SetUeAntennaAttribute("NumRows", UintegerValue(1));
315 nrHelper->SetUeAntennaAttribute("NumColumns", UintegerValue(1));
316 nrHelper->SetUeAntennaAttribute("AntennaElement",
317 PointerValue(CreateObject<IsotropicAntennaModel>()));
318
319 // Antennas for the gNbs
320 nrHelper->SetGnbAntennaAttribute("NumRows", UintegerValue(1));
321 nrHelper->SetGnbAntennaAttribute("NumColumns", UintegerValue(1));
322 nrHelper->SetGnbAntennaAttribute("AntennaElement",
323 PointerValue(CreateObject<IsotropicAntennaModel>()));
324
325 gnbDevs = nrHelper->InstallGnbDevice(gnbNodes, allBwps);
326 ueDevs = nrHelper->InstallUeDevice(ueNodes, allBwps);
327
328 Ptr<NrUePhy> uePhy = nrHelper->GetUePhy(ueDevs.Get(0), 0);
329
330 m_ueUpc = uePhy->GetUplinkPowerControl();
331
332 m_ueUpc->TraceConnectWithoutContext("ReportPuschTxPower",
333 MakeBoundCallback(&PuschTxPowerReport, this));
334 m_ueUpc->TraceConnectWithoutContext("ReportPucchTxPower",
335 MakeBoundCallback(&PucchTxPowerReport, this));
336
337 Ptr<const NrSpectrumPhy> txSpectrumPhy =
338 nrHelper->GetGnbPhy(gnbDevs.Get(0), 0)->GetSpectrumPhy();
339 Ptr<SpectrumChannel> txSpectrumChannel = txSpectrumPhy->GetSpectrumChannel();
340 Ptr<ThreeGppPropagationLossModel> propagationLossModel =
341 DynamicCast<ThreeGppPropagationLossModel>(txSpectrumChannel->GetPropagationLossModel());
342 NS_ASSERT(propagationLossModel != nullptr);
343 propagationLossModel->AssignStreams(1);
344 Ptr<ChannelConditionModel> channelConditionModel =
345 propagationLossModel->GetChannelConditionModel();
346 channelConditionModel->AssignStreams(1);
347 Ptr<ThreeGppSpectrumPropagationLossModel> spectrumLossModel =
348 DynamicCast<ThreeGppSpectrumPropagationLossModel>(
349 txSpectrumChannel->GetPhasedArraySpectrumPropagationLossModel());
350 NS_ASSERT_MSG(
351 spectrumLossModel == nullptr,
352 "3GPP spectrum model should be disabled in this test to have deterministic behaviour.");
353
354 // traffic configuration
355 Ptr<Node> pgw = nrEpcHelper->GetPgwNode();
356 NodeContainer remoteHostContainer;
357 remoteHostContainer.Create(1);
358 Ptr<Node> remoteHost = remoteHostContainer.Get(0);
359 InternetStackHelper internet;
360 internet.Install(remoteHostContainer);
361
362 // connect a remoteHost to pgw. Setup routing too
363 PointToPointHelper p2ph;
364 p2ph.SetDeviceAttribute("DataRate", DataRateValue(DataRate("100Gb/s")));
365 p2ph.SetDeviceAttribute("Mtu", UintegerValue(2500));
366 p2ph.SetChannelAttribute("Delay", TimeValue(Seconds(0.000)));
367 NetDeviceContainer internetDevices = p2ph.Install(pgw, remoteHost);
368 Ipv4AddressHelper ipv4h;
369 Ipv4StaticRoutingHelper ipv4RoutingHelper;
370 ipv4h.SetBase("1.0.0.0", "255.0.0.0");
371 Ipv4InterfaceContainer internetIpIfaces = ipv4h.Assign(internetDevices);
372 Ptr<Ipv4StaticRouting> remoteHostStaticRouting =
373 ipv4RoutingHelper.GetStaticRouting(remoteHost->GetObject<Ipv4>());
374 remoteHostStaticRouting->AddNetworkRouteTo(Ipv4Address("7.0.0.0"), Ipv4Mask("255.0.0.0"), 1);
375 internet.Install(ueNodes);
376
377 Ipv4InterfaceContainer ueIpIface = nrEpcHelper->AssignUeIpv4Address(ueDevs);
378 // Set the default gateway for the UE
379 Ptr<Ipv4StaticRouting> ueStaticRouting =
380 ipv4RoutingHelper.GetStaticRouting(ueNodes.Get(0)->GetObject<Ipv4>());
381 ueStaticRouting->SetDefaultRoute(nrEpcHelper->GetUeDefaultGatewayAddress(), 1);
382
383 // Attach a UE to a gNB
384 nrHelper->AttachToGnb(ueDevs.Get(0), gnbDevs.Get(0));
385
386 /*
387 * Traffic part. Install two kinds of traffic: low-latency and voice, each
388 * identified by a particular source port.
389 */
390 uint16_t dlPort = 1234;
391 uint16_t ulPort = 1236;
392
393 ApplicationContainer serverApps;
394 // The sink will always listen to the specified ports
395 UdpServerHelper dlPacketSink(dlPort);
396 UdpServerHelper ulPacketSink(ulPort);
397
398 // The server, that is the application which is listening, is installed in the UE
399 // for the DL traffic, and in the remote host for the UL traffic
400 serverApps.Add(dlPacketSink.Install(ueNodes.Get(0)));
401 serverApps.Add(ulPacketSink.Install(remoteHost));
402
403 UdpClientHelper dlClient;
404 dlClient.SetAttribute("RemotePort", UintegerValue(dlPort));
405 dlClient.SetAttribute("MaxPackets", UintegerValue(0xFFFFFFFF));
406 dlClient.SetAttribute("PacketSize", UintegerValue(100));
407 dlClient.SetAttribute("Interval", TimeValue(MilliSeconds(1)));
408 NrEpsBearer dlBearer(NrEpsBearer::GBR_CONV_VIDEO);
409 Ptr<NrEpcTft> dlTft = Create<NrEpcTft>();
410 NrEpcTft::PacketFilter dlpf;
411 dlpf.localPortStart = dlPort;
412 dlpf.localPortEnd = dlPort;
413 dlTft->Add(dlpf);
414
415 UdpClientHelper ulClient;
416 ulClient.SetAttribute("RemotePort", UintegerValue(ulPort));
417 ulClient.SetAttribute("MaxPackets", UintegerValue(0xFFFFFFFF));
418 ulClient.SetAttribute("PacketSize", UintegerValue(100));
419 ulClient.SetAttribute("Interval", TimeValue(MilliSeconds(1)));
420 NrEpsBearer ulBearer(NrEpsBearer::GBR_CONV_VIDEO);
421 Ptr<NrEpcTft> ulTft = Create<NrEpcTft>();
422 NrEpcTft::PacketFilter ulpf;
423 ulpf.remotePortStart = ulPort;
424 ulpf.remotePortEnd = ulPort;
425 ulpf.direction = NrEpcTft::UPLINK;
426 ulTft->Add(ulpf);
427
428 ApplicationContainer clientApps;
429 // set and add downlink app to container
430 Address ueAddress = ueIpIface.GetAddress(0);
431 dlClient.SetAttribute("RemoteAddress", AddressValue(ueAddress));
432 clientApps.Add(dlClient.Install(remoteHost));
433 nrHelper->ActivateDedicatedEpsBearer(ueDevs.Get(0), dlBearer, dlTft);
434 // set and add uplink app to container
435 ulClient.SetAttribute("RemoteAddress", AddressValue(internetIpIfaces.GetAddress(1)));
436 clientApps.Add(ulClient.Install(ueNodes.Get(0)));
437 nrHelper->ActivateDedicatedEpsBearer(ueDevs.Get(0), ulBearer, ulTft);
438
439 // start UDP server and client apps
440 serverApps.Start(udpAppStartTime);
441 clientApps.Start(udpAppStartTime);
442 serverApps.Stop(simTime);
443 clientApps.Stop(simTime);
444
473 // Changing UE position
474 if (!m_closedLoop)
475 {
476 Simulator::Schedule(MilliSeconds(0),
477 &NrUplinkPowerControlTestCase::MoveUe,
478 this,
479 10,
480 -21,
481 -11);
482 Simulator::Schedule(MilliSeconds(200),
483 &NrUplinkPowerControlTestCase::MoveUe,
484 this,
485 100,
486 -3,
487 7);
488 Simulator::Schedule(MilliSeconds(400),
489 &NrUplinkPowerControlTestCase::MoveUe,
490 this,
491 200,
492 2,
493 12);
494 Simulator::Schedule(MilliSeconds(600),
495 &NrUplinkPowerControlTestCase::MoveUe,
496 this,
497 300,
498 5,
499 15);
500 Simulator::Schedule(MilliSeconds(800),
501 &NrUplinkPowerControlTestCase::MoveUe,
502 this,
503 400,
504 7,
505 17);
506 Simulator::Schedule(MilliSeconds(1000),
507 &NrUplinkPowerControlTestCase::MoveUe,
508 this,
509 600,
510 10,
511 20);
512 Simulator::Schedule(MilliSeconds(1200),
513 &NrUplinkPowerControlTestCase::MoveUe,
514 this,
515 800,
516 12,
517 22);
518 Simulator::Schedule(MilliSeconds(1400),
519 &NrUplinkPowerControlTestCase::MoveUe,
520 this,
521 1000,
522 14,
523 23);
524 Simulator::Schedule(MilliSeconds(1600),
525 &NrUplinkPowerControlTestCase::MoveUe,
526 this,
527 10,
528 -20,
529 -10);
530 Simulator::Schedule(MilliSeconds(1800),
531 &NrUplinkPowerControlTestCase::MoveUe,
532 this,
533 100,
534 -3,
535 7);
536 Simulator::Schedule(MilliSeconds(2000),
537 &NrUplinkPowerControlTestCase::MoveUe,
538 this,
539 1000,
540 14,
541 23);
542 }
543 else
544 {
549 if (m_accumulatedMode)
550 {
551 Simulator::Schedule(MilliSeconds(0),
552 &NrUplinkPowerControlTestCase::MoveUe,
553 this,
554 10,
555 -21,
556 -11);
557 Simulator::Schedule(MilliSeconds(200),
558 &NrUplinkPowerControlTestCase::MoveUe,
559 this,
560 100,
561 -3,
562 7);
563 Simulator::Schedule(MilliSeconds(400),
564 &NrUplinkPowerControlTestCase::MoveUe,
565 this,
566 200,
567 2,
568 12);
569 Simulator::Schedule(MilliSeconds(600),
570 &NrUplinkPowerControlTestCase::MoveUe,
571 this,
572 300,
573 5,
574 15);
575 Simulator::Schedule(MilliSeconds(800),
576 &NrUplinkPowerControlTestCase::MoveUe,
577 this,
578 400,
579 7,
580 17);
581 Simulator::Schedule(MilliSeconds(1000),
582 &NrUplinkPowerControlTestCase::MoveUe,
583 this,
584 600,
585 10,
586 20);
587 Simulator::Schedule(MilliSeconds(1200),
588 &NrUplinkPowerControlTestCase::MoveUe,
589 this,
590 800,
591 12,
592 22);
593 Simulator::Schedule(MilliSeconds(1400),
594 &NrUplinkPowerControlTestCase::MoveUe,
595 this,
596 1000,
597 14,
598 23);
599 Simulator::Schedule(MilliSeconds(1600),
600 &NrUplinkPowerControlTestCase::MoveUe,
601 this,
602 10,
603 -20,
604 -10);
605 Simulator::Schedule(MilliSeconds(1800),
606 &NrUplinkPowerControlTestCase::MoveUe,
607 this,
608 100,
609 -3,
610 7);
611 Simulator::Schedule(MilliSeconds(2000),
612 &NrUplinkPowerControlTestCase::MoveUe,
613 this,
614 1000,
615 14,
616 23);
617 }
618 else
619 {
620 Simulator::Schedule(MilliSeconds(0),
621 &NrUplinkPowerControlTestCase::MoveUe,
622 this,
623 10,
624 -22,
625 -12);
626 Simulator::Schedule(MilliSeconds(200),
627 &NrUplinkPowerControlTestCase::MoveUe,
628 this,
629 100,
630 -4,
631 6);
632 Simulator::Schedule(MilliSeconds(400),
633 &NrUplinkPowerControlTestCase::MoveUe,
634 this,
635 200,
636 1,
637 11);
638 Simulator::Schedule(MilliSeconds(600),
639 &NrUplinkPowerControlTestCase::MoveUe,
640 this,
641 300,
642 4,
643 14);
644 Simulator::Schedule(MilliSeconds(800),
645 &NrUplinkPowerControlTestCase::MoveUe,
646 this,
647 400,
648 6,
649 16);
650 Simulator::Schedule(MilliSeconds(1000),
651 &NrUplinkPowerControlTestCase::MoveUe,
652 this,
653 600,
654 9,
655 19);
656 Simulator::Schedule(MilliSeconds(1200),
657 &NrUplinkPowerControlTestCase::MoveUe,
658 this,
659 800,
660 11,
661 21);
662 Simulator::Schedule(MilliSeconds(1400),
663 &NrUplinkPowerControlTestCase::MoveUe,
664 this,
665 1000,
666 13,
667 23);
668 Simulator::Schedule(MilliSeconds(1600),
669 &NrUplinkPowerControlTestCase::MoveUe,
670 this,
671 10,
672 -21,
673 -11);
674 Simulator::Schedule(MilliSeconds(1800),
675 &NrUplinkPowerControlTestCase::MoveUe,
676 this,
677 100,
678 -4,
679 6);
680 Simulator::Schedule(MilliSeconds(2000),
681 &NrUplinkPowerControlTestCase::MoveUe,
682 this,
683 1000,
684 13,
685 23);
686 }
687 }
688
689 Simulator::Stop(simTime);
690 Simulator::Run();
691
692 Simulator::Destroy();
693}
ns3::CcBwpCreator
Manages the correct creation of operation bands, component carriers and bandwidth parts.
Definition cc-bwp-helper.h:172
ns3::CcBwpCreator::CreateOperationBandContiguousCc
OperationBandInfo CreateOperationBandContiguousCc(const SimpleOperationBandConf &conf)
Create an operation band with the CC specified.
Definition cc-bwp-helper.cc:196
ns3::CcBwpCreator::GetAllBwps
static BandwidthPartInfoPtrVector GetAllBwps(const std::vector< std::reference_wrapper< OperationBandInfo > > &operationBands)
Get all the BWP pointers from the specified vector of operation bands.
Definition cc-bwp-helper.cc:258
ns3::DirectPathBeamforming::GetTypeId
static TypeId GetTypeId()
Get the type id.
Definition ideal-beamforming-algorithm.cc:490
ns3::NrChannelHelper::INIT_PROPAGATION
@ INIT_PROPAGATION
Initialize the propagation loss model.
Definition nr-channel-helper.h:54
ns3::NrEpsBearer
This class contains the specification of EPS Bearers.
Definition nr-eps-bearer.h:78
ns3::NrEpsBearer::GBR_CONV_VIDEO
@ GBR_CONV_VIDEO
GBR Conversational Video (Live streaming)
Definition nr-eps-bearer.h:95
ns3::BandwidthPartInfoPtrVector
std::vector< std::reference_wrapper< BandwidthPartInfoPtr > > BandwidthPartInfoPtrVector
vector of unique_ptr of BandwidthPartInfo
Definition cc-bwp-helper.h:86
ns3::CcBwpCreator::SimpleOperationBandConf
Minimum configuration requirements for a OperationBand.
Definition cc-bwp-helper.h:187
ns3::NrEpcTft::PacketFilter::direction
Direction direction
Whether the filter needs to be applied to uplink / downlink only, or in both cases.
Definition nr-epc-tft.h:104
ns3::NrEpcTft::PacketFilter::remotePortEnd
uint16_t remotePortEnd
end of the port number range of the remote host
Definition nr-epc-tft.h:117
ns3::NrEpcTft::PacketFilter::localPortStart
uint16_t localPortStart
start of the port number range of the UE
Definition nr-epc-tft.h:118
ns3::NrEpcTft::PacketFilter::remotePortStart
uint16_t remotePortStart
start of the port number range of the remote host
Definition nr-epc-tft.h:116
ns3::NrEpcTft::PacketFilter::localPortEnd
uint16_t localPortEnd
end of the port number range of the UE
Definition nr-epc-tft.h:119
ns3::OperationBandInfo
Operation band information structure.
Definition cc-bwp-helper.h:128