A Discrete-Event Network Simulator
API
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;
42 {1, 15, 2, 0, 4},
43 {2, 15, 2, 4, 4},
44 {3, 15, 2, 8, 4},
45 {1, 25, 6, 0, 6},
46 {2, 25, 6, 6, 6},
47 {3, 25, 6, 12, 6},
48 {1, 50, 21, 0, 9},
49 {2, 50, 21, 9, 9},
50 {3, 50, 21, 18, 11},
51 {1, 75, 36, 0, 12},
52 {2, 75, 36, 12, 12},
53 {3, 75, 36, 24, 15},
54 {1, 100, 28, 0, 24},
55 {2, 100, 28, 24, 24},
56 {3, 100, 28, 48, 24}};
57
60{
61 uint8_t cellId;
62 uint8_t ulBandwidth;
67 {1, 15, 3, 0, 4},
68 {2, 15, 3, 4, 4},
69 {3, 15, 3, 8, 4},
70 {1, 25, 6, 0, 6},
71 {2, 25, 6, 6, 6},
72 {3, 25, 6, 12, 6},
73 {1, 50, 21, 0, 9},
74 {2, 50, 21, 9, 9},
75 {3, 50, 21, 18, 11},
76 {1, 75, 36, 0, 12},
77 {2, 75, 36, 12, 12},
78 {3, 75, 36, 24, 15},
79 {1, 100, 28, 0, 24},
80 {2, 100, 28, 24, 24},
81 {3, 100, 28, 48, 24}};
82
89
91 : m_ffrSapUser(nullptr),
92 m_ffrRrcSapUser(nullptr),
93 m_dlEdgeSubBandOffset(0),
94 m_dlEdgeSubBandwidth(0),
95 m_ulEdgeSubBandOffset(0),
96 m_ulEdgeSubBandwidth(0),
97 m_measId(0)
98{
99 NS_LOG_FUNCTION(this);
102}
103
105{
106 NS_LOG_FUNCTION(this);
107}
108
109void
111{
112 NS_LOG_FUNCTION(this);
113 delete m_ffrSapProvider;
114 delete m_ffrRrcSapProvider;
115}
116
117TypeId
119{
120 static TypeId tid =
121 TypeId("ns3::LteFrStrictAlgorithm")
123 .SetGroupName("Lte")
124 .AddConstructor<LteFrStrictAlgorithm>()
125 .AddAttribute(
126 "UlCommonSubBandwidth",
127 "Uplink Common SubBandwidth Configuration in number of Resource Block Groups",
128 UintegerValue(25),
130 MakeUintegerChecker<uint8_t>())
131 .AddAttribute("UlEdgeSubBandOffset",
132 "Uplink Edge SubBand Offset in number of Resource Block Groups",
133 UintegerValue(0),
135 MakeUintegerChecker<uint8_t>())
136 .AddAttribute(
137 "UlEdgeSubBandwidth",
138 "Uplink Edge SubBandwidth Configuration in number of Resource Block Groups",
139 UintegerValue(0),
141 MakeUintegerChecker<uint8_t>())
142 .AddAttribute(
143 "DlCommonSubBandwidth",
144 "Downlink Common SubBandwidth Configuration in number of Resource Block Groups",
145 UintegerValue(25),
147 MakeUintegerChecker<uint8_t>())
148 .AddAttribute("DlEdgeSubBandOffset",
149 "Downlink Edge SubBand Offset in number of Resource Block Groups",
150 UintegerValue(0),
152 MakeUintegerChecker<uint8_t>())
153 .AddAttribute(
154 "DlEdgeSubBandwidth",
155 "Downlink Edge SubBandwidth Configuration in number of Resource Block Groups",
156 UintegerValue(0),
158 MakeUintegerChecker<uint8_t>())
159 .AddAttribute(
160 "RsrqThreshold",
161 "If the RSRQ of is worse than this threshold, UE should be served in Edge sub-band",
162 UintegerValue(20),
164 MakeUintegerChecker<uint8_t>())
165 .AddAttribute("CenterPowerOffset",
166 "PdschConfigDedicated::Pa value for Center Sub-band, default value dB0",
169 MakeUintegerChecker<uint8_t>())
170 .AddAttribute("EdgePowerOffset",
171 "PdschConfigDedicated::Pa value for Edge Sub-band, default value dB0",
172 UintegerValue(5),
174 MakeUintegerChecker<uint8_t>())
175 .AddAttribute("CenterAreaTpc",
176 "TPC value which will be set in DL-DCI for UEs in center area"
177 "Absolute mode is used, default value 1 is mapped to -1 according to"
178 "TS36.213 Table 5.1.1.1-2",
179 UintegerValue(1),
181 MakeUintegerChecker<uint8_t>())
182 .AddAttribute("EdgeAreaTpc",
183 "TPC value which will be set in DL-DCI for UEs in edge area"
184 "Absolute mode is used, default value 1 is mapped to -1 according to"
185 "TS36.213 Table 5.1.1.1-2",
186 UintegerValue(1),
188 MakeUintegerChecker<uint8_t>());
189 return tid;
190}
191
192void
194{
195 NS_LOG_FUNCTION(this << s);
196 m_ffrSapUser = s;
197}
198
201{
202 NS_LOG_FUNCTION(this);
203 return m_ffrSapProvider;
204}
205
206void
208{
209 NS_LOG_FUNCTION(this << s);
210 m_ffrRrcSapUser = s;
211}
212
215{
216 NS_LOG_FUNCTION(this);
217 return m_ffrRrcSapProvider;
218}
219
220void
222{
223 NS_LOG_FUNCTION(this);
225
226 NS_ASSERT_MSG(m_dlBandwidth > 14, "DlBandwidth must be at least 15 to use FFR algorithms");
227 NS_ASSERT_MSG(m_ulBandwidth > 14, "UlBandwidth must be at least 15 to use FFR algorithms");
228
229 if (m_frCellTypeId != 0)
230 {
233 }
234
235 NS_LOG_LOGIC(this << " requesting Event A1 measurements"
236 << " (threshold = 0"
237 << ")");
238 LteRrcSap::ReportConfigEutra reportConfig;
241 reportConfig.threshold1.range = 0;
245}
246
247void
249{
250 NS_LOG_FUNCTION(this);
251 if (m_frCellTypeId != 0)
252 {
255 }
258 m_needReconfiguration = false;
259}
260
261void
262LteFrStrictAlgorithm::SetDownlinkConfiguration(uint16_t cellId, uint8_t bandwidth)
263{
264 NS_LOG_FUNCTION(this);
265 for (uint16_t i = 0; i < NUM_DOWNLINK_CONFS; ++i)
266 {
267 if ((g_frStrictDownlinkDefaultConfiguration[i].cellId == cellId) &&
269 {
273 }
274 }
275}
276
277void
278LteFrStrictAlgorithm::SetUplinkConfiguration(uint16_t cellId, uint8_t bandwidth)
279{
280 NS_LOG_FUNCTION(this);
281 for (uint16_t i = 0; i < NUM_UPLINK_CONFS; ++i)
282 {
283 if ((g_frStrictUplinkDefaultConfiguration[i].cellId == cellId) &&
285 {
289 }
290 }
291}
292
293void
295{
296 m_dlRbgMap.clear();
297 m_dlEdgeRbgMap.clear();
298
299 int rbgSize = GetRbgSize(m_dlBandwidth);
300 m_dlRbgMap.resize(m_dlBandwidth / rbgSize, true);
301 m_dlEdgeRbgMap.resize(m_dlBandwidth / rbgSize, false);
302
304 "DlCommonSubBandwidth higher than DlBandwidth");
306 "DlEdgeSubBandOffset higher than DlBandwidth");
308 "DlEdgeSubBandwidth higher than DlBandwidth");
311 "(DlCommonSubBandwidth+DlEdgeSubBandOffset+DlEdgeSubBandwidth) higher than DlBandwidth");
312
313 for (int i = 0; i < m_dlCommonSubBandwidth / rbgSize; i++)
314 {
315 m_dlRbgMap[i] = false;
316 }
317
318 for (int i = m_dlCommonSubBandwidth / rbgSize + m_dlEdgeSubBandOffset / rbgSize;
319 i < (m_dlCommonSubBandwidth / rbgSize + m_dlEdgeSubBandOffset / rbgSize +
320 m_dlEdgeSubBandwidth / rbgSize);
321 i++)
322 {
323 m_dlRbgMap[i] = false;
324 m_dlEdgeRbgMap[i] = true;
325 }
326}
327
328void
330{
331 m_ulRbgMap.clear();
332 m_ulEdgeRbgMap.clear();
333
335 {
336 m_ulRbgMap.resize(m_ulBandwidth, false);
337 return;
338 }
339
340 m_ulRbgMap.resize(m_ulBandwidth, true);
341 m_ulEdgeRbgMap.resize(m_ulBandwidth, false);
342
344 "UlCommonSubBandwidth higher than UlBandwidth");
346 "UlEdgeSubBandOffset higher than UlBandwidth");
348 "UlEdgeSubBandwidth higher than UlBandwidth");
351 "(UlCommonSubBandwidth+UlEdgeSubBandOffset+UlEdgeSubBandwidth) higher than UlBandwidth");
352
353 for (uint8_t i = 0; i < m_ulCommonSubBandwidth; i++)
354 {
355 m_ulRbgMap[i] = false;
356 }
357
360 i++)
361 {
362 m_ulRbgMap[i] = false;
363 m_ulEdgeRbgMap[i] = true;
364 }
365}
366
367std::vector<bool>
369{
370 NS_LOG_FUNCTION(this);
371
373 {
374 Reconfigure();
375 }
376
377 if (m_dlRbgMap.empty())
378 {
380 }
381
382 return m_dlRbgMap;
383}
384
385bool
387{
388 NS_LOG_FUNCTION(this);
389
390 bool edgeRbg = m_dlEdgeRbgMap[rbgId];
391
392 std::map<uint16_t, uint8_t>::iterator it = m_ues.find(rnti);
393 if (it == m_ues.end())
394 {
395 m_ues.insert(std::pair<uint16_t, uint8_t>(rnti, AreaUnset));
396 return !edgeRbg;
397 }
398
399 bool edgeUe = false;
400 if (it->second == CellEdge)
401 {
402 edgeUe = true;
403 }
404
405 return (edgeRbg && edgeUe) || (!edgeRbg && !edgeUe);
406}
407
408std::vector<bool>
410{
411 NS_LOG_FUNCTION(this);
412
413 if (m_ulRbgMap.empty())
414 {
416 }
417
418 return m_ulRbgMap;
419}
420
421bool
423{
424 NS_LOG_FUNCTION(this);
425
427 {
428 return true;
429 }
430
431 bool edgeRbg = m_ulEdgeRbgMap[rbgId];
432
433 std::map<uint16_t, uint8_t>::iterator it = m_ues.find(rnti);
434 if (it == m_ues.end())
435 {
436 m_ues.insert(std::pair<uint16_t, uint8_t>(rnti, AreaUnset));
437 return !edgeRbg;
438 }
439
440 bool edgeUe = false;
441 if (it->second == CellEdge)
442 {
443 edgeUe = true;
444 }
445
446 return (edgeRbg && edgeUe) || (!edgeRbg && !edgeUe);
447}
448
449void
452{
453 NS_LOG_FUNCTION(this);
454 NS_LOG_WARN("Method should not be called, because it is empty");
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
466LteFrStrictAlgorithm::DoReportUlCqiInfo(std::map<uint16_t, std::vector<double>> ulCqiMap)
467{
468 NS_LOG_FUNCTION(this);
469 NS_LOG_WARN("Method should not be called, because it is empty");
470}
471
472uint8_t
474{
475 NS_LOG_FUNCTION(this);
476
478 {
479 return 1; // 1 is mapped to 0 for Accumulated mode, and to -1 in Absolute mode TS36.213
480 // Table 5.1.1.1-2
481 }
482
483 // TS36.213 Table 5.1.1.1-2
484 // TPC | Accumulated Mode | Absolute Mode
485 //------------------------------------------------
486 // 0 | -1 | -4
487 // 1 | 0 | -1
488 // 2 | 1 | 1
489 // 3 | 3 | 4
490 //------------------------------------------------
491 // here Absolute mode is used
492
493 std::map<uint16_t, uint8_t>::iterator it = m_ues.find(rnti);
494 if (it == m_ues.end())
495 {
496 return 1;
497 }
498
499 if (it->second == CellEdge)
500 {
501 return m_edgeAreaTpc;
502 }
503 else if (it->second == CellCenter)
504 {
505 return m_centerAreaTpc;
506 }
507
508 return 1;
509}
510
511uint16_t
513{
514 NS_LOG_FUNCTION(this);
515
517 {
518 return m_ulBandwidth;
519 }
520
521 uint8_t minContinuousUlBandwidth = m_ulCommonSubBandwidth < m_ulEdgeSubBandwidth
524 NS_LOG_INFO("minContinuousUlBandwidth: " << (int)minContinuousUlBandwidth);
525
526 return minContinuousUlBandwidth;
527}
528
529void
531{
532 NS_LOG_FUNCTION(this << rnti << (uint16_t)measResults.measId);
533 NS_LOG_INFO("RNTI :" << rnti << " MeasId: " << (uint16_t)measResults.measId
534 << " RSRP: " << (uint16_t)measResults.measResultPCell.rsrpResult
535 << " RSRQ: " << (uint16_t)measResults.measResultPCell.rsrqResult);
536
537 if (measResults.measId != m_measId)
538 {
539 NS_LOG_WARN("Ignoring measId " << (uint16_t)measResults.measId);
540 }
541 else
542 {
543 std::map<uint16_t, uint8_t>::iterator it = m_ues.find(rnti);
544 if (it == m_ues.end())
545 {
546 m_ues.insert(std::pair<uint16_t, uint8_t>(rnti, AreaUnset));
547 }
548 it = m_ues.find(rnti);
549
551 {
552 if (it->second != CellEdge)
553 {
554 NS_LOG_INFO("UE RNTI: " << rnti << " will be served in Edge sub-band");
555 it->second = CellEdge;
556
557 LteRrcSap::PdschConfigDedicated pdschConfigDedicated;
558 pdschConfigDedicated.pa = m_edgeAreaPowerOffset;
559 m_ffrRrcSapUser->SetPdschConfigDedicated(rnti, pdschConfigDedicated);
560 }
561 }
562 else
563 {
564 if (it->second != CellCenter)
565 {
566 NS_LOG_INFO("UE RNTI: " << rnti << " will be served in Center sub-band");
567 it->second = CellCenter;
568
569 LteRrcSap::PdschConfigDedicated pdschConfigDedicated;
570 pdschConfigDedicated.pa = m_centerAreaPowerOffset;
571 m_ffrRrcSapUser->SetPdschConfigDedicated(rnti, pdschConfigDedicated);
572 }
573 }
574 }
575}
576
577void
579{
580 NS_LOG_FUNCTION(this);
581 NS_LOG_WARN("Method should not be called, since it is empty");
582}
583
584} // 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:41
Service Access Point (SAP) offered by the eNodeB RRC instance to the Frequency Reuse algorithm instan...
Definition: lte-ffr-sap.h:141
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.
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
void DoReportUlCqiInfo(const struct FfMacSchedSapProvider::SchedUlCqiInfoReqParameters &params) override
DoReportUlCqiInfo.
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.
void DoReportDlCqiInfo(const struct FfMacSchedSapProvider::SchedDlCqiInfoReqParameters &params) override
DoReportDlCqiInfo.
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:360
a unique identifier for an interface.
Definition: type-id.h:60
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:935
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:45
Every class exported by the ns3 library is enclosed in the ns3 namespace.
static const struct ns3::FrStrictUplinkDefaultConfiguration g_frStrictUplinkDefaultConfiguration[]
the strict 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))
static const struct ns3::FrStrictDownlinkDefaultConfiguration g_frStrictDownlinkDefaultConfiguration[]
the strict downlink default configuration
Parameters of the LOAD INFORMATION message.
Definition: epc-x2-sap.h:305
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:661
uint8_t rsrpResult
the RSRP result
Definition: lte-rrc-sap.h:660
MeasResults structure.
Definition: lte-rrc-sap.h:703
uint8_t measId
measure ID
Definition: lte-rrc-sap.h:704
MeasResultPCell measResultPCell
measurement result primary cell
Definition: lte-rrc-sap.h:705
PdschConfigDedicated structure.
Definition: lte-rrc-sap.h:157
Specifies criteria for triggering of an E-UTRA measurement reporting event.
Definition: lte-rrc-sap.h:367
@ RSRQ
Reference Signal Received Quality.
Definition: lte-rrc-sap.h:418
enum ns3::LteRrcSap::ReportConfigEutra::@68 reportInterval
Report interval enumeration.
enum ns3::LteRrcSap::ReportConfigEutra::@65 eventId
Event enumeration.
enum ns3::LteRrcSap::ReportConfigEutra::@66 triggerQuantity
Trigger type enumeration.
ThresholdEutra threshold1
Threshold for event A1, A2, A4, and A5.
Definition: lte-rrc-sap.h:387
@ EVENT_A1
Event A1: Serving becomes better than absolute threshold.
Definition: lte-rrc-sap.h:378
@ THRESHOLD_RSRQ
RSRQ is used for the threshold.
Definition: lte-rrc-sap.h:359
uint8_t range
Value range used in RSRP/RSRQ threshold.
Definition: lte-rrc-sap.h:362
enum ns3::LteRrcSap::ThresholdEutra::@63 choice
Threshold enumeration.