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 * 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 "ns3/boolean.h"
24#include <ns3/log.h>
25
26namespace ns3
27{
28
29NS_LOG_COMPONENT_DEFINE("LteFfrSoftAlgorithm");
30
31NS_OBJECT_ENSURE_REGISTERED(LteFfrSoftAlgorithm);
32
35{
36 uint8_t cellId;
37 uint8_t dlBandwidth;
41};
42
45 {1, 15, 2, 0, 4},
46 {2, 15, 2, 4, 4},
47 {3, 15, 2, 8, 4},
48 {1, 25, 6, 0, 6},
49 {2, 25, 6, 6, 6},
50 {3, 25, 6, 12, 6},
51 {1, 50, 21, 0, 9},
52 {2, 50, 21, 9, 9},
53 {3, 50, 21, 18, 11},
54 {1, 75, 36, 0, 12},
55 {2, 75, 36, 12, 12},
56 {3, 75, 36, 24, 15},
57 {1, 100, 28, 0, 24},
58 {2, 100, 28, 24, 24},
59 {3, 100, 28, 48, 24},
60};
61
64{
65 uint8_t cellId;
66 uint8_t ulBandwidth;
70};
71
74 {1, 15, 3, 0, 4},
75 {2, 15, 3, 4, 4},
76 {3, 15, 3, 8, 4},
77 {1, 25, 6, 0, 6},
78 {2, 25, 6, 6, 6},
79 {3, 25, 6, 12, 6},
80 {1, 50, 21, 0, 9},
81 {2, 50, 21, 9, 9},
82 {3, 50, 21, 18, 11},
83 {1, 75, 36, 0, 12},
84 {2, 75, 36, 12, 12},
85 {3, 75, 36, 24, 15},
86 {1, 100, 28, 0, 24},
87 {2, 100, 28, 24, 24},
88 {3, 100, 28, 48, 24},
89};
90
97
99 : m_ffrSapUser(nullptr),
100 m_ffrRrcSapUser(nullptr),
101 m_dlEdgeSubBandOffset(0),
102 m_dlEdgeSubBandwidth(0),
103 m_ulEdgeSubBandOffset(0),
104 m_ulEdgeSubBandwidth(0),
105 m_measId(0)
106{
107 NS_LOG_FUNCTION(this);
110}
111
113{
114 NS_LOG_FUNCTION(this);
115}
116
117void
119{
120 NS_LOG_FUNCTION(this);
121 delete m_ffrSapProvider;
122 delete m_ffrRrcSapProvider;
123}
124
125TypeId
127{
128 static TypeId tid =
129 TypeId("ns3::LteFfrSoftAlgorithm")
131 .SetGroupName("Lte")
132 .AddConstructor<LteFfrSoftAlgorithm>()
133 .AddAttribute("UlCommonSubBandwidth",
134 "Uplink Medium (Common) SubBandwidth Configuration in number of Resource "
135 "Block Groups",
136 UintegerValue(6),
138 MakeUintegerChecker<uint8_t>())
139 .AddAttribute("UlEdgeSubBandOffset",
140 "Uplink Edge SubBand Offset in number of Resource Block Groups",
141 UintegerValue(0),
143 MakeUintegerChecker<uint8_t>())
144 .AddAttribute(
145 "UlEdgeSubBandwidth",
146 "Uplink Edge SubBandwidth Configuration in number of Resource Block Groups",
147 UintegerValue(6),
149 MakeUintegerChecker<uint8_t>())
150 .AddAttribute("DlCommonSubBandwidth",
151 "Downlink Medium (Common) SubBandwidth Configuration in number of "
152 "Resource Block Groups",
153 UintegerValue(6),
155 MakeUintegerChecker<uint8_t>())
156 .AddAttribute("DlEdgeSubBandOffset",
157 "Downlink Edge SubBand Offset in number of Resource Block Groups",
158 UintegerValue(0),
160 MakeUintegerChecker<uint8_t>())
161 .AddAttribute(
162 "DlEdgeSubBandwidth",
163 "Downlink Edge SubBandwidth Configuration in number of Resource Block Groups",
164 UintegerValue(0),
166 MakeUintegerChecker<uint8_t>())
167 .AddAttribute("CenterRsrqThreshold",
168 "If the RSRQ of is worse than this threshold, UE should be served in "
169 "Medium sub-band",
170 UintegerValue(30),
172 MakeUintegerChecker<uint8_t>())
173 .AddAttribute(
174 "EdgeRsrqThreshold",
175 "If the RSRQ of is worse than this threshold, UE should be served in Edge sub-band",
176 UintegerValue(20),
178 MakeUintegerChecker<uint8_t>())
179 .AddAttribute("CenterAreaPowerOffset",
180 "PdschConfigDedicated::Pa value for Center Sub-band, default value dB0",
181 UintegerValue(5),
183 MakeUintegerChecker<uint8_t>())
184 .AddAttribute("MediumAreaPowerOffset",
185 "PdschConfigDedicated::Pa value for Medium Sub-band, default value dB0",
186 UintegerValue(5),
188 MakeUintegerChecker<uint8_t>())
189 .AddAttribute("EdgeAreaPowerOffset",
190 "PdschConfigDedicated::Pa value for Edge Sub-band, default value dB0",
191 UintegerValue(5),
193 MakeUintegerChecker<uint8_t>())
194 .AddAttribute("CenterAreaTpc",
195 "TPC value which will be set in DL-DCI for UEs in center area"
196 "Absolute mode is used, default value 1 is mapped to -1 according to"
197 "TS36.213 Table 5.1.1.1-2",
198 UintegerValue(1),
200 MakeUintegerChecker<uint8_t>())
201 .AddAttribute("MediumAreaTpc",
202 "TPC value which will be set in DL-DCI for UEs in medium area"
203 "Absolute mode is used, default value 1 is mapped to -1 according to"
204 "TS36.213 Table 5.1.1.1-2",
205 UintegerValue(1),
207 MakeUintegerChecker<uint8_t>())
208 .AddAttribute("EdgeAreaTpc",
209 "TPC value which will be set in DL-DCI for UEs in edge area"
210 "Absolute mode is used, default value 1 is mapped to -1 according to"
211 "TS36.213 Table 5.1.1.1-2",
212 UintegerValue(1),
214 MakeUintegerChecker<uint8_t>());
215 return tid;
216}
217
218void
220{
221 NS_LOG_FUNCTION(this << s);
222 m_ffrSapUser = s;
223}
224
227{
228 NS_LOG_FUNCTION(this);
229 return m_ffrSapProvider;
230}
231
232void
234{
235 NS_LOG_FUNCTION(this << s);
236 m_ffrRrcSapUser = s;
237}
238
241{
242 NS_LOG_FUNCTION(this);
243 return m_ffrRrcSapProvider;
244}
245
246void
248{
249 NS_LOG_FUNCTION(this);
251
252 NS_ASSERT_MSG(m_dlBandwidth > 14, "DlBandwidth must be at least 15 to use FFR algorithms");
253 NS_ASSERT_MSG(m_ulBandwidth > 14, "UlBandwidth must be at least 15 to use FFR algorithms");
254
255 if (m_frCellTypeId != 0)
256 {
259 }
260
261 NS_LOG_LOGIC(this << " requesting Event A1 measurements"
262 << " (threshold = 0"
263 << ")");
264 LteRrcSap::ReportConfigEutra reportConfig;
267 reportConfig.threshold1.range = 0;
271}
272
273void
275{
276 NS_LOG_FUNCTION(this);
277 if (m_frCellTypeId != 0)
278 {
281 }
284 m_needReconfiguration = false;
285}
286
287void
288LteFfrSoftAlgorithm::SetDownlinkConfiguration(uint16_t cellId, uint8_t bandwidth)
289{
290 NS_LOG_FUNCTION(this);
291 for (uint16_t i = 0; i < NUM_DOWNLINK_CONFS; ++i)
292 {
293 if ((g_ffrSoftDownlinkDefaultConfiguration[i].cellId == cellId) &&
295 {
299 }
300 }
301}
302
303void
304LteFfrSoftAlgorithm::SetUplinkConfiguration(uint16_t cellId, uint8_t bandwidth)
305{
306 NS_LOG_FUNCTION(this);
307 for (uint16_t i = 0; i < NUM_UPLINK_CONFS; ++i)
308 {
309 if ((g_ffrSoftUplinkDefaultConfiguration[i].cellId == cellId) &&
311 {
315 }
316 }
317}
318
319void
321{
322 m_dlRbgMap.clear();
323 m_dlCenterRbgMap.clear();
324 m_dlMediumRbgMap.clear();
325 m_dlEdgeRbgMap.clear();
326
327 int rbgSize = GetRbgSize(m_dlBandwidth);
328 m_dlRbgMap.resize(m_dlBandwidth / rbgSize, false);
329 m_dlCenterRbgMap.resize(m_dlBandwidth / rbgSize, true);
330 m_dlMediumRbgMap.resize(m_dlBandwidth / rbgSize, false);
331 m_dlEdgeRbgMap.resize(m_dlBandwidth / rbgSize, false);
332
334 "DlCommonSubBandwidth higher than DlBandwidth");
336 "DlCommonSubBandwidth + DlEdgeSubBandOffset higher than DlBandwidth");
338 "DlEdgeSubBandOffset higher than DlBandwidth");
340 "DlEdgeSubBandwidth higher than DlBandwidth");
343 "(DlCommonSubBandwidth + DlEdgeSubBandOffset+DlEdgeSubBandwidth) higher than DlBandwidth");
344
345 for (int i = 0; i < m_dlCommonSubBandwidth / rbgSize; i++)
346 {
347 m_dlMediumRbgMap[i] = true;
348 m_dlCenterRbgMap[i] = false;
349 }
350
351 for (int i = (m_dlCommonSubBandwidth + m_dlEdgeSubBandOffset) / rbgSize;
353 i++)
354 {
355 m_dlEdgeRbgMap[i] = true;
356 m_dlCenterRbgMap[i] = false;
357 }
358}
359
360void
362{
363 m_ulRbgMap.clear();
364 m_ulCenterRbgMap.clear();
365 m_ulMediumRbgMap.clear();
366 m_ulEdgeRbgMap.clear();
367
368 m_ulRbgMap.resize(m_ulBandwidth, false);
369 m_ulCenterRbgMap.resize(m_ulBandwidth, true);
370 m_ulMediumRbgMap.resize(m_ulBandwidth, false);
371 m_ulEdgeRbgMap.resize(m_ulBandwidth, false);
372
374 "UlCommonSubBandwidth higher than UlBandwidth");
376 "UlCommonSubBandwidth + UlEdgeSubBandOffset higher than UlBandwidth");
378 "UlEdgeSubBandOffset higher than UlBandwidth");
380 "UlEdgeSubBandwidth higher than UlBandwidth");
383 "(UlCommonSubBandwidth + UlEdgeSubBandOffset+UlEdgeSubBandwidth) higher than UlBandwidth");
384
385 for (uint8_t i = 0; i < m_ulCommonSubBandwidth; i++)
386 {
387 m_ulMediumRbgMap[i] = true;
388 m_ulCenterRbgMap[i] = false;
389 }
390
393 i++)
394 {
395 m_ulEdgeRbgMap[i] = true;
396 m_ulCenterRbgMap[i] = false;
397 }
398}
399
400std::vector<bool>
402{
403 NS_LOG_FUNCTION(this);
404
406 {
407 Reconfigure();
408 }
409
410 if (m_dlRbgMap.empty())
411 {
413 }
414
415 return m_dlRbgMap;
416}
417
418bool
420{
421 NS_LOG_FUNCTION(this);
422
423 bool isCenterRbg = m_dlCenterRbgMap[rbgId];
424 bool isMediumRbg = m_dlMediumRbgMap[rbgId];
425 bool isEdgeRbg = m_dlEdgeRbgMap[rbgId];
426
427 auto it = m_ues.find(rnti);
428 if (it == m_ues.end())
429 {
430 m_ues.insert(std::pair<uint16_t, uint8_t>(rnti, AreaUnset));
431 }
432
433 it = m_ues.find(rnti);
434
435 // if UE area is unknown, serve UE in medium (common) RBGs
436 if (it->second == AreaUnset)
437 {
438 return isMediumRbg;
439 }
440
441 bool isCenterUe = false;
442 bool isMediumUe = false;
443 bool isEdgeUe = false;
444
445 if (it->second == CenterArea)
446 {
447 isCenterUe = true;
448 }
449 else if (it->second == MediumArea)
450 {
451 isMediumUe = true;
452 }
453 else if (it->second == EdgeArea)
454 {
455 isEdgeUe = true;
456 }
457
458 return (isCenterRbg && isCenterUe) || (isMediumRbg && isMediumUe) || (isEdgeRbg && isEdgeUe);
459}
460
461std::vector<bool>
463{
464 NS_LOG_FUNCTION(this);
465
466 if (m_ulRbgMap.empty())
467 {
469 }
470
471 return m_ulRbgMap;
472}
473
474bool
476{
477 NS_LOG_FUNCTION(this);
478
480 {
481 return true;
482 }
483
484 bool isCenterRbg = m_ulCenterRbgMap[rbgId];
485 bool isMediumRbg = m_ulMediumRbgMap[rbgId];
486 bool isEdgeRbg = m_ulEdgeRbgMap[rbgId];
487
488 auto it = m_ues.find(rnti);
489 if (it == m_ues.end())
490 {
491 m_ues.insert(std::pair<uint16_t, uint8_t>(rnti, AreaUnset));
492 }
493
494 it = m_ues.find(rnti);
495
496 // if UE area is unknown, serve UE in medium (common) RBGs
497 if (it->second == AreaUnset)
498 {
499 return isMediumRbg;
500 }
501
502 bool isCenterUe = false;
503 bool isMediumUe = false;
504 bool isEdgeUe = false;
505
506 if (it->second == CenterArea)
507 {
508 isCenterUe = true;
509 }
510 else if (it->second == MediumArea)
511 {
512 isMediumUe = true;
513 }
514 else if (it->second == EdgeArea)
515 {
516 isEdgeUe = true;
517 }
518
519 return (isCenterRbg && isCenterUe) || (isMediumRbg && isMediumUe) || (isEdgeRbg && isEdgeUe);
520}
521
522void
525{
526 NS_LOG_FUNCTION(this);
527 NS_LOG_WARN("Method should not be called, because it is empty");
528}
529
530void
533{
534 NS_LOG_FUNCTION(this);
535 NS_LOG_WARN("Method should not be called, because it is empty");
536}
537
538void
539LteFfrSoftAlgorithm::DoReportUlCqiInfo(std::map<uint16_t, std::vector<double>> ulCqiMap)
540{
541 NS_LOG_FUNCTION(this);
542 NS_LOG_WARN("Method should not be called, because it is empty");
543}
544
545uint8_t
547{
548 NS_LOG_FUNCTION(this);
549
551 {
552 return 1; // 1 is mapped to 0 for Accumulated mode, and to -1 in Absolute mode TS36.213
553 // Table 5.1.1.1-2
554 }
555
556 // TS36.213 Table 5.1.1.1-2
557 // TPC | Accumulated Mode | Absolute Mode
558 //------------------------------------------------
559 // 0 | -1 | -4
560 // 1 | 0 | -1
561 // 2 | 1 | 1
562 // 3 | 3 | 4
563 //------------------------------------------------
564 // here Absolute mode is used
565
566 auto it = m_ues.find(rnti);
567 if (it == m_ues.end())
568 {
569 return 1;
570 }
571
572 if (it->second == CenterArea)
573 {
574 return m_centerAreaTpc;
575 }
576 else if (it->second == MediumArea)
577 {
578 return m_mediumAreaTpc;
579 }
580 else if (it->second == EdgeArea)
581 {
582 return m_edgeAreaTpc;
583 }
584
585 return 1;
586}
587
588uint16_t
590{
591 NS_LOG_FUNCTION(this);
592
594 {
595 return m_ulBandwidth;
596 }
597
598 uint8_t centerSubBandwidth = 0;
599 uint8_t mediumSubBandwidth = 0;
600 uint8_t edgeSubBandwidth = 0;
601
602 for (std::size_t i = 0; i < m_ulCenterRbgMap.size(); i++)
603 {
604 if (m_ulCenterRbgMap[i])
605 {
606 centerSubBandwidth++;
607 }
608 }
609
610 for (std::size_t i = 0; i < m_ulMediumRbgMap.size(); i++)
611 {
612 if (m_ulMediumRbgMap[i])
613 {
614 mediumSubBandwidth++;
615 }
616 }
617
618 for (std::size_t i = 0; i < m_ulEdgeRbgMap.size(); i++)
619 {
620 if (m_ulEdgeRbgMap[i])
621 {
622 edgeSubBandwidth++;
623 }
624 }
625
626 uint8_t minContinuousUlBandwidth = m_ulBandwidth;
627
628 minContinuousUlBandwidth =
629 ((centerSubBandwidth > 0) && (centerSubBandwidth < minContinuousUlBandwidth))
630 ? centerSubBandwidth
631 : minContinuousUlBandwidth;
632
633 minContinuousUlBandwidth =
634 ((mediumSubBandwidth > 0) && (mediumSubBandwidth < minContinuousUlBandwidth))
635 ? mediumSubBandwidth
636 : minContinuousUlBandwidth;
637
638 minContinuousUlBandwidth =
639 ((edgeSubBandwidth > 0) && (edgeSubBandwidth < minContinuousUlBandwidth))
640 ? edgeSubBandwidth
641 : minContinuousUlBandwidth;
642
643 NS_LOG_INFO("minContinuousUlBandwidth: " << (int)minContinuousUlBandwidth);
644
645 return minContinuousUlBandwidth;
646}
647
648void
650{
651 NS_LOG_FUNCTION(this << rnti << (uint16_t)measResults.measId);
652 NS_LOG_INFO("RNTI :" << rnti << " MeasId: " << (uint16_t)measResults.measId
653 << " RSRP: " << (uint16_t)measResults.measResultPCell.rsrpResult
654 << " RSRQ: " << (uint16_t)measResults.measResultPCell.rsrqResult);
655
657 "CenterSubBandThreshold must be higher than EdgeSubBandThreshold");
658
659 if (measResults.measId != m_measId)
660 {
661 NS_LOG_WARN("Ignoring measId " << (uint16_t)measResults.measId);
662 }
663 else
664 {
665 auto it = m_ues.find(rnti);
666 if (it == m_ues.end())
667 {
668 m_ues.insert(std::pair<uint16_t, uint8_t>(rnti, AreaUnset));
669 }
670
671 it = m_ues.find(rnti);
673 {
674 if (it->second != CenterArea)
675 {
676 NS_LOG_INFO("UE RNTI: " << rnti << " will be served in Center sub-band");
677 it->second = CenterArea;
678
679 LteRrcSap::PdschConfigDedicated pdschConfigDedicated;
680 pdschConfigDedicated.pa = m_centerAreaPowerOffset;
681 m_ffrRrcSapUser->SetPdschConfigDedicated(rnti, pdschConfigDedicated);
682 }
683 }
685 {
686 if (it->second != EdgeArea)
687 {
688 NS_LOG_INFO("UE RNTI: " << rnti << " will be served in Edge sub-band");
689 it->second = EdgeArea;
690
691 LteRrcSap::PdschConfigDedicated pdschConfigDedicated;
692 pdschConfigDedicated.pa = m_edgeAreaPowerOffset;
693 m_ffrRrcSapUser->SetPdschConfigDedicated(rnti, pdschConfigDedicated);
694 }
695 }
696 else
697 {
698 if (it->second != MediumArea)
699 {
700 NS_LOG_INFO("UE RNTI: " << rnti << " will be served in Medium sub-band");
701 it->second = MediumArea;
702
703 LteRrcSap::PdschConfigDedicated pdschConfigDedicated;
704 pdschConfigDedicated.pa = m_mediumAreaPowerOffset;
705 m_ffrRrcSapUser->SetPdschConfigDedicated(rnti, pdschConfigDedicated);
706 }
707 }
708 }
709}
710
711void
713{
714 NS_LOG_FUNCTION(this);
715 NS_LOG_WARN("Method should not be called, because it is empty");
716}
717
718} // 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:40
Service Access Point (SAP) offered by the eNodeB RRC instance to the Frequency Reuse algorithm instan...
Definition: lte-ffr-sap.h:140
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:451
a unique identifier for an interface.
Definition: type-id.h:59
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:932
Hold an unsigned integer type.
Definition: uinteger.h:45
#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:86
Ptr< const AttributeAccessor > MakeUintegerAccessor(T1 a1)
Definition: uinteger.h:46
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
#define NS_LOG_LOGIC(msg)
Use NS_LOG to output a message of level LOG_LOGIC.
Definition: log.h:282
#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:261
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:275
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition: object-base.h:46
Every class exported by the ns3 library is enclosed in the ns3 namespace.
static const FfrSoftDownlinkDefaultConfiguration g_ffrSoftDownlinkDefaultConfiguration[]
The soft downlink default configuration.
static const FfrSoftUplinkDefaultConfiguration g_ffrSoftUplinkDefaultConfiguration[]
The soft uplink default configuration.
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:306
Parameters of the SCHED_DL_CQI_INFO_REQ primitive.
Parameters of the SCHED_UL_CQI_INFO_REQ primitive.
uint8_t rsrqResult
the RSRQ result
Definition: lte-rrc-sap.h:675
uint8_t rsrpResult
the RSRP result
Definition: lte-rrc-sap.h:674
MeasResults structure.
Definition: lte-rrc-sap.h:717
uint8_t measId
measure ID
Definition: lte-rrc-sap.h:718
MeasResultPCell measResultPCell
measurement result primary cell
Definition: lte-rrc-sap.h:719
PdschConfigDedicated structure.
Definition: lte-rrc-sap.h:163
Specifies criteria for triggering of an E-UTRA measurement reporting event.
Definition: lte-rrc-sap.h:373
enum ns3::LteRrcSap::ReportConfigEutra::@62 eventId
Event enumeration.
@ RSRQ
Reference Signal Received Quality.
Definition: lte-rrc-sap.h:426
@ EVENT_A1
Event A1: Serving becomes better than absolute threshold.
Definition: lte-rrc-sap.h:384
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.
Definition: lte-rrc-sap.h:393
@ THRESHOLD_RSRQ
RSRQ is used for the threshold.
Definition: lte-rrc-sap.h:365
enum ns3::LteRrcSap::ThresholdEutra::@60 choice
Threshold enumeration.
uint8_t range
Value range used in RSRP/RSRQ threshold.
Definition: lte-rrc-sap.h:368