A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
lte-ffr-soft-algorithm.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2014 Piotr Gawlowicz
3 *
4 * SPDX-License-Identifier: GPL-2.0-only
5 *
6 * Author: Piotr Gawlowicz <gawlowicz.p@gmail.com>
7 *
8 */
9
11
12#include "ns3/boolean.h"
13#include <ns3/log.h>
14
15namespace ns3
16{
17
18NS_LOG_COMPONENT_DEFINE("LteFfrSoftAlgorithm");
19
20NS_OBJECT_ENSURE_REGISTERED(LteFfrSoftAlgorithm);
21
22/// FfrSoftDownlinkDefaultConfiguration structure
24{
25 uint8_t cellId; ///< cell ID
26 uint8_t dlBandwidth; ///< DL bandwidth
27 uint8_t dlCommonSubBandwidth; ///< DL common subbandwidth
28 uint8_t dlEdgeSubBandOffset; ///< DL edge subband offset
29 uint8_t dlEdgeSubBandwidth; ///< DL edge subbandwidth
30};
31
32/// The soft downlink default configuration
34 {1, 15, 2, 0, 4},
35 {2, 15, 2, 4, 4},
36 {3, 15, 2, 8, 4},
37 {1, 25, 6, 0, 6},
38 {2, 25, 6, 6, 6},
39 {3, 25, 6, 12, 6},
40 {1, 50, 21, 0, 9},
41 {2, 50, 21, 9, 9},
42 {3, 50, 21, 18, 11},
43 {1, 75, 36, 0, 12},
44 {2, 75, 36, 12, 12},
45 {3, 75, 36, 24, 15},
46 {1, 100, 28, 0, 24},
47 {2, 100, 28, 24, 24},
48 {3, 100, 28, 48, 24},
49};
50
51/// FfrSoftUplinkDefaultConfiguration structure
53{
54 uint8_t cellId; ///< cell ID
55 uint8_t ulBandwidth; ///< UL bandwidth
56 uint8_t ulCommonSubBandwidth; ///< UL common subbandwidth
57 uint8_t ulEdgeSubBandOffset; ///< UL edge subband offset
58 uint8_t ulEdgeSubBandwidth; ///< edge subbandwidth
59};
60
61/// The soft uplink default configuration
63 {1, 15, 3, 0, 4},
64 {2, 15, 3, 4, 4},
65 {3, 15, 3, 8, 4},
66 {1, 25, 6, 0, 6},
67 {2, 25, 6, 6, 6},
68 {3, 25, 6, 12, 6},
69 {1, 50, 21, 0, 9},
70 {2, 50, 21, 9, 9},
71 {3, 50, 21, 18, 11},
72 {1, 75, 36, 0, 12},
73 {2, 75, 36, 12, 12},
74 {3, 75, 36, 24, 15},
75 {1, 100, 28, 0, 24},
76 {2, 100, 28, 24, 24},
77 {3, 100, 28, 48, 24},
78};
79
80/** \returns number of downlink configurations */
83/** \returns number of uplink configurations */
86
88 : m_ffrSapUser(nullptr),
89 m_ffrRrcSapUser(nullptr),
90 m_dlEdgeSubBandOffset(0),
91 m_dlEdgeSubBandwidth(0),
92 m_ulEdgeSubBandOffset(0),
93 m_ulEdgeSubBandwidth(0),
94 m_measId(0)
95{
96 NS_LOG_FUNCTION(this);
99}
100
105
106void
113
114TypeId
116{
117 static TypeId tid =
118 TypeId("ns3::LteFfrSoftAlgorithm")
120 .SetGroupName("Lte")
121 .AddConstructor<LteFfrSoftAlgorithm>()
122 .AddAttribute("UlCommonSubBandwidth",
123 "Uplink Medium (Common) SubBandwidth Configuration in number of Resource "
124 "Block Groups",
125 UintegerValue(6),
128 .AddAttribute("UlEdgeSubBandOffset",
129 "Uplink Edge SubBand Offset in number of Resource Block Groups",
130 UintegerValue(0),
133 .AddAttribute(
134 "UlEdgeSubBandwidth",
135 "Uplink Edge SubBandwidth Configuration in number of Resource Block Groups",
136 UintegerValue(6),
139 .AddAttribute("DlCommonSubBandwidth",
140 "Downlink Medium (Common) SubBandwidth Configuration in number of "
141 "Resource Block Groups",
142 UintegerValue(6),
145 .AddAttribute("DlEdgeSubBandOffset",
146 "Downlink Edge SubBand Offset in number of Resource Block Groups",
147 UintegerValue(0),
150 .AddAttribute(
151 "DlEdgeSubBandwidth",
152 "Downlink Edge SubBandwidth Configuration in number of Resource Block Groups",
153 UintegerValue(0),
156 .AddAttribute("CenterRsrqThreshold",
157 "If the RSRQ of is worse than this threshold, UE should be served in "
158 "Medium sub-band",
159 UintegerValue(30),
162 .AddAttribute(
163 "EdgeRsrqThreshold",
164 "If the RSRQ of is worse than this threshold, UE should be served in Edge sub-band",
165 UintegerValue(20),
168 .AddAttribute("CenterAreaPowerOffset",
169 "PdschConfigDedicated::Pa value for Center Sub-band, default value dB0",
170 UintegerValue(5),
173 .AddAttribute("MediumAreaPowerOffset",
174 "PdschConfigDedicated::Pa value for Medium Sub-band, default value dB0",
175 UintegerValue(5),
178 .AddAttribute("EdgeAreaPowerOffset",
179 "PdschConfigDedicated::Pa value for Edge Sub-band, default value dB0",
180 UintegerValue(5),
183 .AddAttribute("CenterAreaTpc",
184 "TPC value which will be set in DL-DCI for UEs in center area"
185 "Absolute mode is used, default value 1 is mapped to -1 according to"
186 "TS36.213 Table 5.1.1.1-2",
187 UintegerValue(1),
190 .AddAttribute("MediumAreaTpc",
191 "TPC value which will be set in DL-DCI for UEs in medium area"
192 "Absolute mode is used, default value 1 is mapped to -1 according to"
193 "TS36.213 Table 5.1.1.1-2",
194 UintegerValue(1),
197 .AddAttribute("EdgeAreaTpc",
198 "TPC value which will be set in DL-DCI for UEs in edge area"
199 "Absolute mode is used, default value 1 is mapped to -1 according to"
200 "TS36.213 Table 5.1.1.1-2",
201 UintegerValue(1),
204 return tid;
205}
206
207void
213
220
221void
227
234
235void
237{
238 NS_LOG_FUNCTION(this);
240
241 NS_ASSERT_MSG(m_dlBandwidth > 14, "DlBandwidth must be at least 15 to use FFR algorithms");
242 NS_ASSERT_MSG(m_ulBandwidth > 14, "UlBandwidth must be at least 15 to use FFR algorithms");
243
244 if (m_frCellTypeId != 0)
245 {
248 }
249
250 NS_LOG_LOGIC(this << " requesting Event A1 measurements"
251 << " (threshold = 0"
252 << ")");
253 LteRrcSap::ReportConfigEutra reportConfig;
256 reportConfig.threshold1.range = 0;
260}
261
262void
275
276void
291
292void
307
308void
310{
311 m_dlRbgMap.clear();
312 m_dlCenterRbgMap.clear();
313 m_dlMediumRbgMap.clear();
314 m_dlEdgeRbgMap.clear();
315
316 int rbgSize = GetRbgSize(m_dlBandwidth);
317 m_dlRbgMap.resize(m_dlBandwidth / rbgSize, false);
318 m_dlCenterRbgMap.resize(m_dlBandwidth / rbgSize, true);
319 m_dlMediumRbgMap.resize(m_dlBandwidth / rbgSize, false);
320 m_dlEdgeRbgMap.resize(m_dlBandwidth / rbgSize, false);
321
323 "DlCommonSubBandwidth higher than DlBandwidth");
325 "DlCommonSubBandwidth + DlEdgeSubBandOffset higher than DlBandwidth");
327 "DlEdgeSubBandOffset higher than DlBandwidth");
329 "DlEdgeSubBandwidth higher than DlBandwidth");
332 "(DlCommonSubBandwidth + DlEdgeSubBandOffset+DlEdgeSubBandwidth) higher than DlBandwidth");
333
334 for (int i = 0; i < m_dlCommonSubBandwidth / rbgSize; i++)
335 {
336 m_dlMediumRbgMap[i] = true;
337 m_dlCenterRbgMap[i] = false;
338 }
339
340 for (int i = (m_dlCommonSubBandwidth + m_dlEdgeSubBandOffset) / rbgSize;
342 i++)
343 {
344 m_dlEdgeRbgMap[i] = true;
345 m_dlCenterRbgMap[i] = false;
346 }
347}
348
349void
351{
352 m_ulRbgMap.clear();
353 m_ulCenterRbgMap.clear();
354 m_ulMediumRbgMap.clear();
355 m_ulEdgeRbgMap.clear();
356
357 m_ulRbgMap.resize(m_ulBandwidth, false);
358 m_ulCenterRbgMap.resize(m_ulBandwidth, true);
359 m_ulMediumRbgMap.resize(m_ulBandwidth, false);
360 m_ulEdgeRbgMap.resize(m_ulBandwidth, false);
361
363 "UlCommonSubBandwidth higher than UlBandwidth");
365 "UlCommonSubBandwidth + UlEdgeSubBandOffset higher than UlBandwidth");
367 "UlEdgeSubBandOffset higher than UlBandwidth");
369 "UlEdgeSubBandwidth higher than UlBandwidth");
372 "(UlCommonSubBandwidth + UlEdgeSubBandOffset+UlEdgeSubBandwidth) higher than UlBandwidth");
373
374 for (uint8_t i = 0; i < m_ulCommonSubBandwidth; i++)
375 {
376 m_ulMediumRbgMap[i] = true;
377 m_ulCenterRbgMap[i] = false;
378 }
379
382 i++)
383 {
384 m_ulEdgeRbgMap[i] = true;
385 m_ulCenterRbgMap[i] = false;
386 }
387}
388
389std::vector<bool>
391{
392 NS_LOG_FUNCTION(this);
393
395 {
396 Reconfigure();
397 }
398
399 if (m_dlRbgMap.empty())
400 {
402 }
403
404 return m_dlRbgMap;
405}
406
407bool
409{
410 NS_LOG_FUNCTION(this);
411
412 bool isCenterRbg = m_dlCenterRbgMap[rbgId];
413 bool isMediumRbg = m_dlMediumRbgMap[rbgId];
414 bool isEdgeRbg = m_dlEdgeRbgMap[rbgId];
415
416 auto it = m_ues.find(rnti);
417 if (it == m_ues.end())
418 {
419 m_ues.insert(std::pair<uint16_t, uint8_t>(rnti, AreaUnset));
420 }
421
422 it = m_ues.find(rnti);
423
424 // if UE area is unknown, serve UE in medium (common) RBGs
425 if (it->second == AreaUnset)
426 {
427 return isMediumRbg;
428 }
429
430 bool isCenterUe = false;
431 bool isMediumUe = false;
432 bool isEdgeUe = false;
433
434 if (it->second == CenterArea)
435 {
436 isCenterUe = true;
437 }
438 else if (it->second == MediumArea)
439 {
440 isMediumUe = true;
441 }
442 else if (it->second == EdgeArea)
443 {
444 isEdgeUe = true;
445 }
446
447 return (isCenterRbg && isCenterUe) || (isMediumRbg && isMediumUe) || (isEdgeRbg && isEdgeUe);
448}
449
450std::vector<bool>
452{
453 NS_LOG_FUNCTION(this);
454
455 if (m_ulRbgMap.empty())
456 {
458 }
459
460 return m_ulRbgMap;
461}
462
463bool
465{
466 NS_LOG_FUNCTION(this);
467
469 {
470 return true;
471 }
472
473 bool isCenterRbg = m_ulCenterRbgMap[rbgId];
474 bool isMediumRbg = m_ulMediumRbgMap[rbgId];
475 bool isEdgeRbg = m_ulEdgeRbgMap[rbgId];
476
477 auto it = m_ues.find(rnti);
478 if (it == m_ues.end())
479 {
480 m_ues.insert(std::pair<uint16_t, uint8_t>(rnti, AreaUnset));
481 }
482
483 it = m_ues.find(rnti);
484
485 // if UE area is unknown, serve UE in medium (common) RBGs
486 if (it->second == AreaUnset)
487 {
488 return isMediumRbg;
489 }
490
491 bool isCenterUe = false;
492 bool isMediumUe = false;
493 bool isEdgeUe = false;
494
495 if (it->second == CenterArea)
496 {
497 isCenterUe = true;
498 }
499 else if (it->second == MediumArea)
500 {
501 isMediumUe = true;
502 }
503 else if (it->second == EdgeArea)
504 {
505 isEdgeUe = true;
506 }
507
508 return (isCenterRbg && isCenterUe) || (isMediumRbg && isMediumUe) || (isEdgeRbg && isEdgeUe);
509}
510
511void
514{
515 NS_LOG_FUNCTION(this);
516 NS_LOG_WARN("Method should not be called, because it is empty");
517}
518
519void
522{
523 NS_LOG_FUNCTION(this);
524 NS_LOG_WARN("Method should not be called, because it is empty");
525}
526
527void
528LteFfrSoftAlgorithm::DoReportUlCqiInfo(std::map<uint16_t, std::vector<double>> ulCqiMap)
529{
530 NS_LOG_FUNCTION(this);
531 NS_LOG_WARN("Method should not be called, because it is empty");
532}
533
534uint8_t
536{
537 NS_LOG_FUNCTION(this);
538
540 {
541 return 1; // 1 is mapped to 0 for Accumulated mode, and to -1 in Absolute mode TS36.213
542 // Table 5.1.1.1-2
543 }
544
545 // TS36.213 Table 5.1.1.1-2
546 // TPC | Accumulated Mode | Absolute Mode
547 //------------------------------------------------
548 // 0 | -1 | -4
549 // 1 | 0 | -1
550 // 2 | 1 | 1
551 // 3 | 3 | 4
552 //------------------------------------------------
553 // here Absolute mode is used
554
555 auto it = m_ues.find(rnti);
556 if (it == m_ues.end())
557 {
558 return 1;
559 }
560
561 if (it->second == CenterArea)
562 {
563 return m_centerAreaTpc;
564 }
565 else if (it->second == MediumArea)
566 {
567 return m_mediumAreaTpc;
568 }
569 else if (it->second == EdgeArea)
570 {
571 return m_edgeAreaTpc;
572 }
573
574 return 1;
575}
576
577uint16_t
579{
580 NS_LOG_FUNCTION(this);
581
583 {
584 return m_ulBandwidth;
585 }
586
587 uint8_t centerSubBandwidth = 0;
588 uint8_t mediumSubBandwidth = 0;
589 uint8_t edgeSubBandwidth = 0;
590
591 for (std::size_t i = 0; i < m_ulCenterRbgMap.size(); i++)
592 {
593 if (m_ulCenterRbgMap[i])
594 {
595 centerSubBandwidth++;
596 }
597 }
598
599 for (std::size_t i = 0; i < m_ulMediumRbgMap.size(); i++)
600 {
601 if (m_ulMediumRbgMap[i])
602 {
603 mediumSubBandwidth++;
604 }
605 }
606
607 for (std::size_t i = 0; i < m_ulEdgeRbgMap.size(); i++)
608 {
609 if (m_ulEdgeRbgMap[i])
610 {
611 edgeSubBandwidth++;
612 }
613 }
614
615 uint8_t minContinuousUlBandwidth = m_ulBandwidth;
616
617 minContinuousUlBandwidth =
618 ((centerSubBandwidth > 0) && (centerSubBandwidth < minContinuousUlBandwidth))
619 ? centerSubBandwidth
620 : minContinuousUlBandwidth;
621
622 minContinuousUlBandwidth =
623 ((mediumSubBandwidth > 0) && (mediumSubBandwidth < minContinuousUlBandwidth))
624 ? mediumSubBandwidth
625 : minContinuousUlBandwidth;
626
627 minContinuousUlBandwidth =
628 ((edgeSubBandwidth > 0) && (edgeSubBandwidth < minContinuousUlBandwidth))
629 ? edgeSubBandwidth
630 : minContinuousUlBandwidth;
631
632 NS_LOG_INFO("minContinuousUlBandwidth: " << (int)minContinuousUlBandwidth);
633
634 return minContinuousUlBandwidth;
635}
636
637void
639{
640 NS_LOG_FUNCTION(this << rnti << (uint16_t)measResults.measId);
641 NS_LOG_INFO("RNTI :" << rnti << " MeasId: " << (uint16_t)measResults.measId
642 << " RSRP: " << (uint16_t)measResults.measResultPCell.rsrpResult
643 << " RSRQ: " << (uint16_t)measResults.measResultPCell.rsrqResult);
644
646 "CenterSubBandThreshold must be higher than EdgeSubBandThreshold");
647
648 if (measResults.measId != m_measId)
649 {
650 NS_LOG_WARN("Ignoring measId " << (uint16_t)measResults.measId);
651 }
652 else
653 {
654 auto it = m_ues.find(rnti);
655 if (it == m_ues.end())
656 {
657 m_ues.insert(std::pair<uint16_t, uint8_t>(rnti, AreaUnset));
658 }
659
660 it = m_ues.find(rnti);
662 {
663 if (it->second != CenterArea)
664 {
665 NS_LOG_INFO("UE RNTI: " << rnti << " will be served in Center sub-band");
666 it->second = CenterArea;
667
668 LteRrcSap::PdschConfigDedicated pdschConfigDedicated;
669 pdschConfigDedicated.pa = m_centerAreaPowerOffset;
670 m_ffrRrcSapUser->SetPdschConfigDedicated(rnti, pdschConfigDedicated);
671 }
672 }
674 {
675 if (it->second != EdgeArea)
676 {
677 NS_LOG_INFO("UE RNTI: " << rnti << " will be served in Edge sub-band");
678 it->second = EdgeArea;
679
680 LteRrcSap::PdschConfigDedicated pdschConfigDedicated;
681 pdschConfigDedicated.pa = m_edgeAreaPowerOffset;
682 m_ffrRrcSapUser->SetPdschConfigDedicated(rnti, pdschConfigDedicated);
683 }
684 }
685 else
686 {
687 if (it->second != MediumArea)
688 {
689 NS_LOG_INFO("UE RNTI: " << rnti << " will be served in Medium sub-band");
690 it->second = MediumArea;
691
692 LteRrcSap::PdschConfigDedicated pdschConfigDedicated;
693 pdschConfigDedicated.pa = m_mediumAreaPowerOffset;
694 m_ffrRrcSapUser->SetPdschConfigDedicated(rnti, pdschConfigDedicated);
695 }
696 }
697 }
698}
699
700void
702{
703 NS_LOG_FUNCTION(this);
704 NS_LOG_WARN("Method should not be called, because it is empty");
705}
706
707} // end of namespace ns3
The abstract base class of a Frequency Reuse algorithm.
bool m_needReconfiguration
If true FR algorithm will be reconfigured.
uint8_t m_frCellTypeId
FFR cell type ID for automatic configuration.
int GetRbgSize(int dlbandwidth)
Get RBG size for DL Bandwidth according to table 7.1.6.1-1 of 36.213.
bool m_enabledInUplink
If true FR algorithm will also work in Uplink.
uint8_t m_dlBandwidth
downlink bandwidth in RBs
uint8_t m_ulBandwidth
uplink bandwidth in RBs
Service Access Point (SAP) offered by the Frequency Reuse algorithm instance to the eNodeB RRC instan...
Service Access Point (SAP) offered by the eNodeB RRC instance to the Frequency Reuse algorithm instan...
virtual void SetPdschConfigDedicated(uint16_t rnti, LteRrcSap::PdschConfigDedicated pdschConfigDedicated)=0
Instruct the eNodeB RRC entity to perform RrcConnectionReconfiguration to inform UE about new PdschCo...
virtual uint8_t AddUeMeasReportConfigForFfr(LteRrcSap::ReportConfigEutra reportConfig)=0
Request a certain reporting configuration to be fulfilled by the UEs attached to the eNodeB entity.
Service Access Point (SAP) offered by the Frequency Reuse algorithm instance to the MAC Scheduler ins...
Definition lte-ffr-sap.h:29
Service Access Point (SAP) offered by the eNodeB RRC instance to the Frequency Reuse algorithm instan...
Soft Fractional Frequency Reuse algorithm implementation.
void SetUplinkConfiguration(uint16_t cellId, uint8_t bandwidth)
Set uplink configuration function.
std::vector< bool > m_dlRbgMap
DL RBG Map.
LteFfrSoftAlgorithm()
Creates a trivial ffr algorithm instance.
void DoReportUlCqiInfo(const FfMacSchedSapProvider::SchedUlCqiInfoReqParameters &params) override
DoReportUlCqiInfo.
void DoInitialize() override
Initialize() implementation.
LteFfrRrcSapProvider * GetLteFfrRrcSapProvider() override
Export the "provider" part of the LteFfrRrcSap interface.
uint8_t m_dlEdgeSubBandOffset
DL edge subband offset.
LteFfrSapProvider * m_ffrSapProvider
FFR SAP provider.
friend class MemberLteFfrRrcSapProvider< LteFfrSoftAlgorithm >
let the forwarder class access the protected and private members
std::vector< bool > m_ulMediumRbgMap
UL medium RBG map.
uint8_t m_ulEdgeSubBandwidth
UL edge subbandwidth.
LteFfrSapProvider * GetLteFfrSapProvider() override
Export the "provider" part of the LteFfrSap interface.
uint8_t m_centerAreaTpc
center area tpc
std::vector< bool > m_ulRbgMap
UL RBG map.
void DoDispose() override
Destructor implementation.
std::vector< bool > m_dlMediumRbgMap
DL medium RBG map.
void SetLteFfrSapUser(LteFfrSapUser *s) override
Set the "user" part of the LteFfrSap interface that this frequency reuse algorithm instance will inte...
std::vector< bool > DoGetAvailableDlRbg() override
Implementation of LteFfrSapProvider::GetAvailableDlRbg.
std::vector< bool > m_dlEdgeRbgMap
DL edge RBG map.
bool DoIsUlRbgAvailableForUe(int i, uint16_t rnti) override
Implementation of LteFfrSapProvider::IsUlRbgAvailableForUe.
uint8_t m_mediumAreaPowerOffset
medium area power offset
void SetLteFfrRrcSapUser(LteFfrRrcSapUser *s) override
Set the "user" part of the LteFfrRrcSap interface that this frequency reuse algorithm instance will i...
void DoReportDlCqiInfo(const FfMacSchedSapProvider::SchedDlCqiInfoReqParameters &params) override
DoReportDlCqiInfo.
uint8_t m_edgeAreaPowerOffset
edge area power offset
std::vector< bool > m_dlCenterRbgMap
DL center RBG map.
uint8_t m_mediumAreaTpc
medium area tpc
void InitializeUplinkRbgMaps()
Initialize uplink RBG maps function.
uint8_t m_ulEdgeSubBandOffset
UL edge subband offset.
uint8_t m_dlEdgeSubBandwidth
DL edge subbandwidth.
uint8_t m_edgeSubBandThreshold
edge subband threshold
LteFfrSapUser * m_ffrSapUser
FFR SAP user.
std::vector< bool > m_ulCenterRbgMap
UL center RBG map.
void SetDownlinkConfiguration(uint16_t cellId, uint8_t bandwidth)
Set downlink configuration function.
std::vector< bool > m_ulEdgeRbgMap
UL edge RBG map.
uint8_t m_ulCommonSubBandwidth
UL common subbandwidth.
void Reconfigure() override
Automatic FR reconfiguration.
uint16_t DoGetMinContinuousUlBandwidth() override
DoGetMinContinuousUlBandwidth in number of RB.
uint8_t m_centerAreaPowerOffset
center area power offset
uint8_t m_centerSubBandThreshold
center subband threshold
uint8_t m_measId
The expected measurement identity.
std::vector< bool > DoGetAvailableUlRbg() override
Implementation of LteFfrSapProvider::GetAvailableUlRbg.
LteFfrRrcSapProvider * m_ffrRrcSapProvider
FFR RRC SAP provider.
LteFfrRrcSapUser * m_ffrRrcSapUser
FFR RRC SAP user.
bool DoIsDlRbgAvailableForUe(int i, uint16_t rnti) override
Implementation of LteFfrSapProvider::IsDlRbgAvailableForUe.
uint8_t m_dlCommonSubBandwidth
DL common subbandwidth.
void InitializeDownlinkRbgMaps()
Initialize downlink RBG maps function.
std::map< uint16_t, uint8_t > m_ues
UEs.
friend class MemberLteFfrSapProvider< LteFfrSoftAlgorithm >
let the forwarder class access the protected and private members
void DoRecvLoadInformation(EpcX2Sap::LoadInformationParams params) override
DoRecvLoadInformation.
uint8_t m_edgeAreaTpc
edge area tpc
uint8_t DoGetTpc(uint16_t rnti) override
DoGetTpc for UE.
void DoReportUeMeas(uint16_t rnti, LteRrcSap::MeasResults measResults) override
Implementation of LteFfrRrcSapProvider::ReportUeMeas.
static TypeId GetTypeId()
Get the type ID.
virtual void DoInitialize()
Initialize() implementation.
Definition object.cc:440
a unique identifier for an interface.
Definition type-id.h:48
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition type-id.cc:1001
Hold an unsigned integer type.
Definition uinteger.h:34
#define NS_ASSERT_MSG(condition, message)
At runtime, in debugging builds, if this condition is not true, the program prints the message to out...
Definition assert.h:75
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition log.h:191
#define NS_LOG_LOGIC(msg)
Use NS_LOG to output a message of level LOG_LOGIC.
Definition log.h:271
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
#define NS_LOG_WARN(msg)
Use NS_LOG to output a message of level LOG_WARN.
Definition log.h:250
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition log.h:264
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition object-base.h:35
Every class exported by the ns3 library is enclosed in the ns3 namespace.
static const FfrSoftDownlinkDefaultConfiguration g_ffrSoftDownlinkDefaultConfiguration[]
The soft downlink default configuration.
Ptr< const AttributeChecker > MakeUintegerChecker()
Definition uinteger.h:85
static const FfrSoftUplinkDefaultConfiguration g_ffrSoftUplinkDefaultConfiguration[]
The soft uplink default configuration.
Ptr< const AttributeAccessor > MakeUintegerAccessor(T1 a1)
Definition uinteger.h:35
const uint16_t NUM_DOWNLINK_CONFS(sizeof(g_ffrEnhancedDownlinkDefaultConfiguration)/sizeof(FfrEnhancedDownlinkDefaultConfiguration))
const uint16_t NUM_UPLINK_CONFS(sizeof(g_ffrEnhancedUplinkDefaultConfiguration)/sizeof(FfrEnhancedUplinkDefaultConfiguration))
Parameters of the LOAD INFORMATION message.
Definition epc-x2-sap.h:295
Parameters of the SCHED_DL_CQI_INFO_REQ primitive.
Parameters of the SCHED_UL_CQI_INFO_REQ primitive.
uint8_t rsrqResult
the RSRQ result
uint8_t rsrpResult
the RSRP result
MeasResults structure.
uint8_t measId
measure ID
MeasResultPCell measResultPCell
measurement result primary cell
PdschConfigDedicated structure.
Specifies criteria for triggering of an E-UTRA measurement reporting event.
enum ns3::LteRrcSap::ReportConfigEutra::@62 eventId
Event enumeration.
@ RSRQ
Reference Signal Received Quality.
@ EVENT_A1
Event A1: Serving becomes better than absolute threshold.
enum ns3::LteRrcSap::ReportConfigEutra::@65 reportInterval
Report interval enumeration.
enum ns3::LteRrcSap::ReportConfigEutra::@63 triggerQuantity
Trigger type enumeration.
ThresholdEutra threshold1
Threshold for event A1, A2, A4, and A5.
@ THRESHOLD_RSRQ
RSRQ is used for the threshold.
enum ns3::LteRrcSap::ThresholdEutra::@60 choice
Threshold enumeration.
uint8_t range
Value range used in RSRP/RSRQ threshold.