A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
lte-fr-strict-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("LteFrStrictAlgorithm");
30
31NS_OBJECT_ENSURE_REGISTERED(LteFrStrictAlgorithm);
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::LteFrStrictAlgorithm")
131 .SetGroupName("Lte")
132 .AddConstructor<LteFrStrictAlgorithm>()
133 .AddAttribute(
134 "UlCommonSubBandwidth",
135 "Uplink Common SubBandwidth Configuration in number of Resource Block Groups",
136 UintegerValue(25),
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(0),
149 MakeUintegerChecker<uint8_t>())
150 .AddAttribute(
151 "DlCommonSubBandwidth",
152 "Downlink Common SubBandwidth Configuration in number of Resource Block Groups",
153 UintegerValue(25),
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(
168 "RsrqThreshold",
169 "If the RSRQ of is worse than this threshold, UE should be served in Edge sub-band",
170 UintegerValue(20),
172 MakeUintegerChecker<uint8_t>())
173 .AddAttribute("CenterPowerOffset",
174 "PdschConfigDedicated::Pa value for Center Sub-band, default value dB0",
177 MakeUintegerChecker<uint8_t>())
178 .AddAttribute("EdgePowerOffset",
179 "PdschConfigDedicated::Pa value for Edge Sub-band, default value dB0",
180 UintegerValue(5),
182 MakeUintegerChecker<uint8_t>())
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),
189 MakeUintegerChecker<uint8_t>())
190 .AddAttribute("EdgeAreaTpc",
191 "TPC value which will be set in DL-DCI for UEs in edge 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),
196 MakeUintegerChecker<uint8_t>());
197 return tid;
198}
199
200void
202{
203 NS_LOG_FUNCTION(this << s);
204 m_ffrSapUser = s;
205}
206
209{
210 NS_LOG_FUNCTION(this);
211 return m_ffrSapProvider;
212}
213
214void
216{
217 NS_LOG_FUNCTION(this << s);
218 m_ffrRrcSapUser = s;
219}
220
223{
224 NS_LOG_FUNCTION(this);
225 return m_ffrRrcSapProvider;
226}
227
228void
230{
231 NS_LOG_FUNCTION(this);
233
234 NS_ASSERT_MSG(m_dlBandwidth > 14, "DlBandwidth must be at least 15 to use FFR algorithms");
235 NS_ASSERT_MSG(m_ulBandwidth > 14, "UlBandwidth must be at least 15 to use FFR algorithms");
236
237 if (m_frCellTypeId != 0)
238 {
241 }
242
243 NS_LOG_LOGIC(this << " requesting Event A1 measurements"
244 << " (threshold = 0"
245 << ")");
246 LteRrcSap::ReportConfigEutra reportConfig;
249 reportConfig.threshold1.range = 0;
253}
254
255void
257{
258 NS_LOG_FUNCTION(this);
259 if (m_frCellTypeId != 0)
260 {
263 }
266 m_needReconfiguration = false;
267}
268
269void
270LteFrStrictAlgorithm::SetDownlinkConfiguration(uint16_t cellId, uint8_t bandwidth)
271{
272 NS_LOG_FUNCTION(this);
273 for (uint16_t i = 0; i < NUM_DOWNLINK_CONFS; ++i)
274 {
275 if ((g_frStrictDownlinkDefaultConfiguration[i].cellId == cellId) &&
277 {
281 }
282 }
283}
284
285void
286LteFrStrictAlgorithm::SetUplinkConfiguration(uint16_t cellId, uint8_t bandwidth)
287{
288 NS_LOG_FUNCTION(this);
289 for (uint16_t i = 0; i < NUM_UPLINK_CONFS; ++i)
290 {
291 if ((g_frStrictUplinkDefaultConfiguration[i].cellId == cellId) &&
293 {
297 }
298 }
299}
300
301void
303{
304 m_dlRbgMap.clear();
305 m_dlEdgeRbgMap.clear();
306
307 int rbgSize = GetRbgSize(m_dlBandwidth);
308 m_dlRbgMap.resize(m_dlBandwidth / rbgSize, true);
309 m_dlEdgeRbgMap.resize(m_dlBandwidth / rbgSize, false);
310
312 "DlCommonSubBandwidth higher than DlBandwidth");
314 "DlEdgeSubBandOffset higher than DlBandwidth");
316 "DlEdgeSubBandwidth higher than DlBandwidth");
319 "(DlCommonSubBandwidth+DlEdgeSubBandOffset+DlEdgeSubBandwidth) higher than DlBandwidth");
320
321 for (int i = 0; i < m_dlCommonSubBandwidth / rbgSize; i++)
322 {
323 m_dlRbgMap[i] = false;
324 }
325
326 for (int i = m_dlCommonSubBandwidth / rbgSize + m_dlEdgeSubBandOffset / rbgSize;
327 i < (m_dlCommonSubBandwidth / rbgSize + m_dlEdgeSubBandOffset / rbgSize +
328 m_dlEdgeSubBandwidth / rbgSize);
329 i++)
330 {
331 m_dlRbgMap[i] = false;
332 m_dlEdgeRbgMap[i] = true;
333 }
334}
335
336void
338{
339 m_ulRbgMap.clear();
340 m_ulEdgeRbgMap.clear();
341
343 {
344 m_ulRbgMap.resize(m_ulBandwidth, false);
345 return;
346 }
347
348 m_ulRbgMap.resize(m_ulBandwidth, true);
349 m_ulEdgeRbgMap.resize(m_ulBandwidth, false);
350
352 "UlCommonSubBandwidth higher than UlBandwidth");
354 "UlEdgeSubBandOffset higher than UlBandwidth");
356 "UlEdgeSubBandwidth higher than UlBandwidth");
359 "(UlCommonSubBandwidth+UlEdgeSubBandOffset+UlEdgeSubBandwidth) higher than UlBandwidth");
360
361 for (uint8_t i = 0; i < m_ulCommonSubBandwidth; i++)
362 {
363 m_ulRbgMap[i] = false;
364 }
365
368 i++)
369 {
370 m_ulRbgMap[i] = false;
371 m_ulEdgeRbgMap[i] = true;
372 }
373}
374
375std::vector<bool>
377{
378 NS_LOG_FUNCTION(this);
379
381 {
382 Reconfigure();
383 }
384
385 if (m_dlRbgMap.empty())
386 {
388 }
389
390 return m_dlRbgMap;
391}
392
393bool
395{
396 NS_LOG_FUNCTION(this);
397
398 bool edgeRbg = m_dlEdgeRbgMap[rbgId];
399
400 auto it = m_ues.find(rnti);
401 if (it == m_ues.end())
402 {
403 m_ues.insert(std::pair<uint16_t, uint8_t>(rnti, AreaUnset));
404 return !edgeRbg;
405 }
406
407 bool edgeUe = false;
408 if (it->second == CellEdge)
409 {
410 edgeUe = true;
411 }
412
413 return (edgeRbg && edgeUe) || (!edgeRbg && !edgeUe);
414}
415
416std::vector<bool>
418{
419 NS_LOG_FUNCTION(this);
420
421 if (m_ulRbgMap.empty())
422 {
424 }
425
426 return m_ulRbgMap;
427}
428
429bool
431{
432 NS_LOG_FUNCTION(this);
433
435 {
436 return true;
437 }
438
439 bool edgeRbg = m_ulEdgeRbgMap[rbgId];
440
441 auto it = m_ues.find(rnti);
442 if (it == m_ues.end())
443 {
444 m_ues.insert(std::pair<uint16_t, uint8_t>(rnti, AreaUnset));
445 return !edgeRbg;
446 }
447
448 bool edgeUe = false;
449 if (it->second == CellEdge)
450 {
451 edgeUe = true;
452 }
453
454 return (edgeRbg && edgeUe) || (!edgeRbg && !edgeUe);
455}
456
457void
460{
461 NS_LOG_FUNCTION(this);
462 NS_LOG_WARN("Method should not be called, because it is empty");
463}
464
465void
468{
469 NS_LOG_FUNCTION(this);
470 NS_LOG_WARN("Method should not be called, because it is empty");
471}
472
473void
474LteFrStrictAlgorithm::DoReportUlCqiInfo(std::map<uint16_t, std::vector<double>> ulCqiMap)
475{
476 NS_LOG_FUNCTION(this);
477 NS_LOG_WARN("Method should not be called, because it is empty");
478}
479
480uint8_t
482{
483 NS_LOG_FUNCTION(this);
484
486 {
487 return 1; // 1 is mapped to 0 for Accumulated mode, and to -1 in Absolute mode TS36.213
488 // Table 5.1.1.1-2
489 }
490
491 // TS36.213 Table 5.1.1.1-2
492 // TPC | Accumulated Mode | Absolute Mode
493 //------------------------------------------------
494 // 0 | -1 | -4
495 // 1 | 0 | -1
496 // 2 | 1 | 1
497 // 3 | 3 | 4
498 //------------------------------------------------
499 // here Absolute mode is used
500
501 auto it = m_ues.find(rnti);
502 if (it == m_ues.end())
503 {
504 return 1;
505 }
506
507 if (it->second == CellEdge)
508 {
509 return m_edgeAreaTpc;
510 }
511 else if (it->second == CellCenter)
512 {
513 return m_centerAreaTpc;
514 }
515
516 return 1;
517}
518
519uint16_t
521{
522 NS_LOG_FUNCTION(this);
523
525 {
526 return m_ulBandwidth;
527 }
528
529 uint8_t minContinuousUlBandwidth = m_ulCommonSubBandwidth < m_ulEdgeSubBandwidth
532 NS_LOG_INFO("minContinuousUlBandwidth: " << (int)minContinuousUlBandwidth);
533
534 return minContinuousUlBandwidth;
535}
536
537void
539{
540 NS_LOG_FUNCTION(this << rnti << (uint16_t)measResults.measId);
541 NS_LOG_INFO("RNTI :" << rnti << " MeasId: " << (uint16_t)measResults.measId
542 << " RSRP: " << (uint16_t)measResults.measResultPCell.rsrpResult
543 << " RSRQ: " << (uint16_t)measResults.measResultPCell.rsrqResult);
544
545 if (measResults.measId != m_measId)
546 {
547 NS_LOG_WARN("Ignoring measId " << (uint16_t)measResults.measId);
548 }
549 else
550 {
551 auto it = m_ues.find(rnti);
552 if (it == m_ues.end())
553 {
554 m_ues.insert(std::pair<uint16_t, uint8_t>(rnti, AreaUnset));
555 }
556 it = m_ues.find(rnti);
557
559 {
560 if (it->second != CellEdge)
561 {
562 NS_LOG_INFO("UE RNTI: " << rnti << " will be served in Edge sub-band");
563 it->second = CellEdge;
564
565 LteRrcSap::PdschConfigDedicated pdschConfigDedicated;
566 pdschConfigDedicated.pa = m_edgeAreaPowerOffset;
567 m_ffrRrcSapUser->SetPdschConfigDedicated(rnti, pdschConfigDedicated);
568 }
569 }
570 else
571 {
572 if (it->second != CellCenter)
573 {
574 NS_LOG_INFO("UE RNTI: " << rnti << " will be served in Center sub-band");
575 it->second = CellCenter;
576
577 LteRrcSap::PdschConfigDedicated pdschConfigDedicated;
578 pdschConfigDedicated.pa = m_centerAreaPowerOffset;
579 m_ffrRrcSapUser->SetPdschConfigDedicated(rnti, pdschConfigDedicated);
580 }
581 }
582 }
583}
584
585void
587{
588 NS_LOG_FUNCTION(this);
589 NS_LOG_WARN("Method should not be called, since it is empty");
590}
591
592} // 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
Strict Frequency Reuse algorithm implementation.
LteFfrSapProvider * GetLteFfrSapProvider() override
Export the "provider" part of the LteFfrSap interface.
uint8_t m_centerAreaPowerOffset
center area power offset
std::vector< bool > m_ulRbgMap
UL RBG map.
uint8_t m_ulCommonSubBandwidth
UL common subbandwidth.
void DoInitialize() override
Initialize() implementation.
uint16_t DoGetMinContinuousUlBandwidth() override
DoGetMinContinuousUlBandwidth in number of RB.
void DoRecvLoadInformation(EpcX2Sap::LoadInformationParams params) override
DoRecvLoadInformation.
void DoReportDlCqiInfo(const FfMacSchedSapProvider::SchedDlCqiInfoReqParameters &params) override
DoReportDlCqiInfo.
void DoReportUlCqiInfo(const FfMacSchedSapProvider::SchedUlCqiInfoReqParameters &params) override
DoReportUlCqiInfo.
uint8_t m_dlCommonSubBandwidth
DL common subbandwidth.
LteFfrRrcSapProvider * m_ffrRrcSapProvider
FFR RRC SAP provider.
LteFfrSapUser * m_ffrSapUser
FFR SAP user.
uint8_t m_ulEdgeSubBandwidth
UL edge subbandwidth.
uint8_t m_dlEdgeSubBandOffset
DL edge subband offset.
void InitializeUplinkRbgMaps()
Initialize uplink RBG maps.
void DoDispose() override
Destructor implementation.
friend class MemberLteFfrSapProvider< LteFrStrictAlgorithm >
let the forwarder class access the protected and private members
uint8_t m_dlEdgeSubBandwidth
DL edge subbandwidth.
uint8_t m_edgeAreaTpc
edge area tpc
uint8_t m_edgeAreaPowerOffset
edge area power offset
std::vector< bool > DoGetAvailableUlRbg() override
Implementation of LteFfrSapProvider::GetAvailableUlRbg.
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.
static TypeId GetTypeId()
Get the type ID.
bool DoIsUlRbgAvailableForUe(int i, uint16_t rnti) override
Implementation of LteFfrSapProvider::IsUlRbgAvailableForUe.
void SetUplinkConfiguration(uint16_t cellId, uint8_t bandwidth)
Set uplink configuration.
void Reconfigure() override
Automatic FR reconfiguration.
bool DoIsDlRbgAvailableForUe(int i, uint16_t rnti) override
Implementation of LteFfrSapProvider::IsDlRbgAvailableForUe.
LteFfrRrcSapProvider * GetLteFfrRrcSapProvider() override
Export the "provider" part of the LteFfrRrcSap interface.
LteFfrRrcSapUser * m_ffrRrcSapUser
FFR RRC SAP user.
uint8_t m_centerAreaTpc
center area tpc
uint8_t m_measId
The expected measurement identity.
std::vector< bool > m_dlEdgeRbgMap
DL edge RBG map.
void DoReportUeMeas(uint16_t rnti, LteRrcSap::MeasResults measResults) override
Implementation of LteFfrRrcSapProvider::ReportUeMeas.
void SetDownlinkConfiguration(uint16_t cellId, uint8_t bandwidth)
Set downlink configuration.
friend class MemberLteFfrRrcSapProvider< LteFrStrictAlgorithm >
let the forwarder class access the protected and private members
LteFrStrictAlgorithm()
Creates a trivial ffr algorithm instance.
uint8_t m_ulEdgeSubBandOffset
UL edge subband offset.
uint8_t DoGetTpc(uint16_t rnti) override
DoGetTpc for UE.
uint8_t m_edgeSubBandThreshold
Edge subband threshold.
std::vector< bool > m_ulEdgeRbgMap
UL edge RBG map.
std::vector< bool > m_dlRbgMap
DL RBG map.
void InitializeDownlinkRbgMaps()
Initialize downlink RBG maps.
LteFfrSapProvider * m_ffrSapProvider
FFR SAP provider.
void SetLteFfrRrcSapUser(LteFfrRrcSapUser *s) override
Set the "user" part of the LteFfrRrcSap interface that this frequency reuse algorithm instance will i...
std::map< uint16_t, uint8_t > m_ues
UEs.
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.
const uint16_t NUM_DOWNLINK_CONFS(sizeof(g_ffrEnhancedDownlinkDefaultConfiguration)/sizeof(FfrEnhancedDownlinkDefaultConfiguration))
static const FrStrictUplinkDefaultConfiguration g_frStrictUplinkDefaultConfiguration[]
The strict uplink default configuration.
const uint16_t NUM_UPLINK_CONFS(sizeof(g_ffrEnhancedUplinkDefaultConfiguration)/sizeof(FfrEnhancedUplinkDefaultConfiguration))
static const FrStrictDownlinkDefaultConfiguration g_frStrictDownlinkDefaultConfiguration[]
The strict downlink default configuration.
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