A Discrete-Event Network Simulator
API
lte-fr-soft-algorithm.cc
Go to the documentation of this file.
1 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2014 Piotr Gawlowicz
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation;
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  * Author: Piotr Gawlowicz <gawlowicz.p@gmail.com>
19  *
20  */
21 
22 #include "lte-fr-soft-algorithm.h"
23 #include <ns3/log.h>
24 #include "ns3/boolean.h"
25 
26 namespace ns3 {
27 
28 NS_LOG_COMPONENT_DEFINE ("LteFrSoftAlgorithm");
29 
30 NS_OBJECT_ENSURE_REGISTERED (LteFrSoftAlgorithm);
31 
33 {
34  uint8_t cellId;
35  uint8_t dlBandwidth;
39  { 1, 15, 0, 4},
40  { 2, 15, 4, 4},
41  { 3, 15, 8, 6},
42  { 1, 25, 0, 8},
43  { 2, 25, 8, 8},
44  { 3, 25, 16, 9},
45  { 1, 50, 0, 16},
46  { 2, 50, 16, 16},
47  { 3, 50, 32, 18},
48  { 1, 75, 0, 24},
49  { 2, 75, 24, 24},
50  { 3, 75, 48, 27},
51  { 1, 100, 0, 32},
52  { 2, 100, 32, 32},
53  { 3, 100, 64, 36}
54 };
55 
57 {
58  uint8_t cellId;
59  uint8_t ulBandwidth;
63  { 1, 15, 0, 5},
64  { 2, 15, 5, 5},
65  { 3, 15, 10, 5},
66  { 1, 25, 0, 8},
67  { 2, 25, 8, 8},
68  { 3, 25, 16, 9},
69  { 1, 50, 0, 16},
70  { 2, 50, 16, 16},
71  { 3, 50, 32, 18},
72  { 1, 75, 0, 24},
73  { 2, 75, 24, 24},
74  { 3, 75, 48, 27},
75  { 1, 100, 0, 32},
76  { 2, 100, 32, 32},
77  { 3, 100, 64, 36}
78 };
79 
80 const uint16_t NUM_DOWNLINK_CONFS (sizeof (g_frSoftDownlinkDefaultConfiguration) / sizeof (FrSoftDownlinkDefaultConfiguration));
81 const uint16_t NUM_UPLINK_CONFS (sizeof (g_frSoftUplinkDefaultConfiguration) / sizeof (FrSoftUplinkDefaultConfiguration));
82 
83 
85  : m_ffrSapUser (0),
86  m_ffrRrcSapUser (0),
87  m_dlEgdeSubBandOffset (0),
88  m_dlEdgeSubBandwidth (0),
89  m_ulEgdeSubBandOffset (0),
90  m_ulEdgeSubBandwidth (0),
91  m_measId (0)
92 {
93  NS_LOG_FUNCTION (this);
96 }
97 
98 
100 {
101  NS_LOG_FUNCTION (this);
102 }
103 
104 
105 void
107 {
108  NS_LOG_FUNCTION (this);
109  delete m_ffrSapProvider;
110  delete m_ffrRrcSapProvider;
111 }
112 
113 
114 TypeId
116 {
117  static TypeId tid = TypeId ("ns3::LteFrSoftAlgorithm")
119  .AddConstructor<LteFrSoftAlgorithm> ()
120  .AddAttribute ("UlEdgeSubBandOffset",
121  "Uplink Edge SubBand Offset in number of Resource Block Groups",
122  UintegerValue (0),
124  MakeUintegerChecker<uint8_t> ())
125  .AddAttribute ("UlEdgeSubBandwidth",
126  "Uplink Edge SubBandwidth Configuration in number of Resource Block Groups",
127  UintegerValue (0),
129  MakeUintegerChecker<uint8_t> ())
130  .AddAttribute ("DlEdgeSubBandOffset",
131  "Downlink Edge SubBand Offset in number of Resource Block Groups",
132  UintegerValue (0),
134  MakeUintegerChecker<uint8_t> ())
135  .AddAttribute ("DlEdgeSubBandwidth",
136  "Downlink Edge SubBandwidth Configuration in number of Resource Block Groups",
137  UintegerValue (0),
139  MakeUintegerChecker<uint8_t> ())
140  .AddAttribute ("AllowCenterUeUseEdgeSubBand",
141  "If true center UEs can receive on Edge SubBand RBGs",
142  BooleanValue (true),
145  .AddAttribute ("RsrqThreshold",
146  "If the RSRQ of is worse than this threshold, UE should be served in Edge sub-band",
147  UintegerValue (20),
149  MakeUintegerChecker<uint8_t> ())
150  .AddAttribute ("CenterPowerOffset",
151  "PdschConfigDedicated::Pa value for Edge Sub-band, default value dB0",
152  UintegerValue (5),
154  MakeUintegerChecker<uint8_t> ())
155  .AddAttribute ("EdgePowerOffset",
156  "PdschConfigDedicated::Pa value for Edge Sub-band, default value dB0",
157  UintegerValue (5),
159  MakeUintegerChecker<uint8_t> ())
160  .AddAttribute ("CenterAreaTpc",
161  "TPC value which will be set in DL-DCI for UEs in center area"
162  "Absolute mode is used, default value 1 is mapped to -1 according to"
163  "TS36.213 Table 5.1.1.1-2",
164  UintegerValue (1),
166  MakeUintegerChecker<uint8_t> ())
167  .AddAttribute ("EdgeAreaTpc",
168  "TPC value which will be set in DL-DCI for UEs in edge area"
169  "Absolute mode is used, default value 1 is mapped to -1 according to"
170  "TS36.213 Table 5.1.1.1-2",
171  UintegerValue (1),
173  MakeUintegerChecker<uint8_t> ())
174  ;
175  return tid;
176 }
177 
178 
179 void
181 {
182  NS_LOG_FUNCTION (this << s);
183  m_ffrSapUser = s;
184 }
185 
186 
189 {
190  NS_LOG_FUNCTION (this);
191  return m_ffrSapProvider;
192 }
193 
194 void
196 {
197  NS_LOG_FUNCTION (this << s);
198  m_ffrRrcSapUser = s;
199 }
200 
201 
204 {
205  NS_LOG_FUNCTION (this);
206  return m_ffrRrcSapProvider;
207 }
208 
209 
210 void
212 {
213  NS_LOG_FUNCTION (this);
215 
216  NS_ASSERT_MSG (m_dlBandwidth > 14,"DlBandwidth must be at least 15 to use FFR algorithms");
217  NS_ASSERT_MSG (m_ulBandwidth > 14,"UlBandwidth must be at least 15 to use FFR algorithms");
218 
219  if (m_frCellTypeId != 0)
220  {
223  }
224 
225  NS_LOG_LOGIC (this << " requesting Event A1 measurements"
226  << " (threshold = 0" << ")");
227  LteRrcSap::ReportConfigEutra reportConfig;
230  reportConfig.threshold1.range = 0;
234 }
235 
236 void
238 {
239  NS_LOG_FUNCTION (this);
240  if (m_frCellTypeId != 0)
241  {
244  }
247  m_needReconfiguration = false;
248 }
249 
250 void
251 LteFrSoftAlgorithm::SetDownlinkConfiguration (uint16_t cellId, uint8_t bandwidth)
252 {
253  NS_LOG_FUNCTION (this);
254  for (uint16_t i = 0; i < NUM_DOWNLINK_CONFS; ++i)
255  {
256  if ((g_frSoftDownlinkDefaultConfiguration[i].cellId == cellId)
258  {
261  }
262  }
263 }
264 
265 void
266 LteFrSoftAlgorithm::SetUplinkConfiguration (uint16_t cellId, uint8_t bandwidth)
267 {
268  NS_LOG_FUNCTION (this);
269  for (uint16_t i = 0; i < NUM_UPLINK_CONFS; ++i)
270  {
271  if ((g_frSoftUplinkDefaultConfiguration[i].cellId == cellId)
273  {
276  }
277  }
278 }
279 
280 void
282 {
283  m_dlRbgMap.clear ();
284  m_dlEdgeRbgMap.clear ();
285 
286  int rbgSize = GetRbgSize (m_dlBandwidth);
287  m_dlRbgMap.resize (m_dlBandwidth / rbgSize, false);
288  m_dlEdgeRbgMap.resize (m_dlBandwidth / rbgSize, false);
289 
290  NS_ASSERT_MSG (m_dlEgdeSubBandOffset <= m_dlBandwidth,"DlEgdeSubBandOffset higher than DlBandwidth");
291  NS_ASSERT_MSG (m_dlEdgeSubBandwidth <= m_dlBandwidth,"DlEdgeSubBandwidth higher than DlBandwidth");
293  "(DlEgdeSubBandOffset+DlEdgeSubBandwidth) higher than DlBandwidth");
294 
295  for (uint8_t i = m_dlEgdeSubBandOffset / rbgSize;
296  i < (m_dlEgdeSubBandOffset + m_dlEdgeSubBandwidth) / rbgSize; i++)
297  {
298  m_dlEdgeRbgMap[i] = true;
299  }
300 }
301 
302 void
304 {
305  m_ulRbgMap.clear ();
306  m_ulEdgeRbgMap.clear ();
307 
308  m_ulRbgMap.resize (m_ulBandwidth, false);
309  m_ulEdgeRbgMap.resize (m_ulBandwidth, false);
310 
311  NS_ASSERT_MSG (m_ulEgdeSubBandOffset <= m_dlBandwidth,"UlEgdeSubBandOffset higher than DlBandwidth");
312  NS_ASSERT_MSG (m_ulEdgeSubBandwidth <= m_dlBandwidth,"UlEdgeSubBandwidth higher than DlBandwidth");
314  "(UlEgdeSubBandOffset+UlEdgeSubBandwidth) higher than DlBandwidth");
315 
317  {
318  m_ulEdgeRbgMap[i] = true;
319  }
320 }
321 
322 std::vector <bool>
324 {
325  NS_LOG_FUNCTION (this);
326 
328  {
329  Reconfigure ();
330  }
331 
332  if (m_dlRbgMap.empty ())
333  {
335  }
336 
337  return m_dlRbgMap;
338 }
339 
340 bool
342 {
343  NS_LOG_FUNCTION (this);
344 
345  bool edgeRbg = m_dlEdgeRbgMap[rbgId];
346 
347  std::map< uint16_t, uint8_t >::iterator it = m_ues.find (rnti);
348  if (it == m_ues.end ())
349  {
350  m_ues.insert (std::pair< uint16_t, uint8_t > (rnti, AreaUnset));
351  return !edgeRbg;
352  }
353 
354  bool edgeUe = false;
355  if (it->second == CellEdge )
356  {
357  edgeUe = true;
358  }
359 
360  if (!edgeUe && m_isEdgeSubBandForCenterUe)
361  {
362  return true;
363  }
364 
365  return (edgeRbg && edgeUe) || (!edgeRbg && !edgeUe);
366 }
367 
368 std::vector <bool>
370 {
371  NS_LOG_FUNCTION (this);
372 
373  if (m_ulRbgMap.empty ())
374  {
376  }
377 
378  return m_ulRbgMap;
379 }
380 
381 bool
383 {
384  NS_LOG_FUNCTION (this);
385 
386  if (!m_enabledInUplink)
387  {
388  return true;
389  }
390 
391  bool edgeRbg = m_ulEdgeRbgMap[rbgId];
392 
393  std::map< uint16_t, uint8_t >::iterator it = m_ues.find (rnti);
394  if (it == m_ues.end ())
395  {
396  m_ues.insert (std::pair< uint16_t, uint8_t > (rnti, AreaUnset));
397  return !edgeRbg;
398  }
399 
400  bool edgeUe = false;
401  if (it->second == CellEdge )
402  {
403  edgeUe = true;
404  }
405 
406  if (!edgeUe && m_isEdgeSubBandForCenterUe)
407  {
408  return true;
409  }
410 
411  return (edgeRbg && edgeUe) || (!edgeRbg && !edgeUe);
412 }
413 
414 void
416 {
417  NS_LOG_FUNCTION (this);
418  NS_LOG_WARN ("Method should not be called, because it is empty");
419 }
420 
421 void
423 {
424  NS_LOG_FUNCTION (this);
425  NS_LOG_WARN ("Method should not be called, because it is empty");
426 }
427 
428 void
429 LteFrSoftAlgorithm::DoReportUlCqiInfo (std::map <uint16_t, std::vector <double> > ulCqiMap)
430 {
431  NS_LOG_FUNCTION (this);
432  NS_LOG_WARN ("Method should not be called, because it is empty");
433 }
434 
435 uint8_t
437 {
438  NS_LOG_FUNCTION (this);
439 
440  if (!m_enabledInUplink)
441  {
442  return 1; // 1 is mapped to 0 for Accumulated mode, and to -1 in Absolute mode TS36.213 Table 5.1.1.1-2
443  }
444 
445  //TS36.213 Table 5.1.1.1-2
446  // TPC | Accumulated Mode | Absolute Mode
447  //------------------------------------------------
448  // 0 | -1 | -4
449  // 1 | 0 | -1
450  // 2 | 1 | 1
451  // 3 | 3 | 4
452  //------------------------------------------------
453  // here Absolute mode is used
454 
455  std::map< uint16_t, uint8_t >::iterator it = m_ues.find (rnti);
456  if (it == m_ues.end ())
457  {
458  return 1;
459  }
460 
461  if (it->second == CellEdge )
462  {
463  return m_edgeAreaTpc;
464  }
465  else if (it->second == CellCenter )
466  {
467  return m_centerAreaTpc;
468  }
469 
470  return 1;
471 }
472 
473 uint8_t
475 {
476  NS_LOG_FUNCTION (this);
477 
478  uint8_t minContinuousUlBandwidth = m_ulBandwidth;
479 
480  if (!m_enabledInUplink)
481  {
482  return minContinuousUlBandwidth;
483  }
484 
485  uint8_t leftBandwidth = m_ulEgdeSubBandOffset;
486  uint8_t centerBandwidth = m_ulEdgeSubBandwidth;
487  uint8_t rightBandwidth = m_ulBandwidth - m_ulEdgeSubBandwidth - m_ulEgdeSubBandOffset;
488 
489  minContinuousUlBandwidth =
490  ((leftBandwidth > 0 ) && (leftBandwidth < minContinuousUlBandwidth)) ? leftBandwidth : minContinuousUlBandwidth;
491 
492  minContinuousUlBandwidth =
493  ((centerBandwidth > 0 ) && (centerBandwidth < minContinuousUlBandwidth)) ? centerBandwidth : minContinuousUlBandwidth;
494 
495  minContinuousUlBandwidth =
496  ((rightBandwidth > 0 ) && (rightBandwidth < minContinuousUlBandwidth)) ? rightBandwidth : minContinuousUlBandwidth;
497 
498  NS_LOG_INFO ("minContinuousUlBandwidth: " << (int)minContinuousUlBandwidth);
499 
500  return minContinuousUlBandwidth;
501 }
502 
503 void
505  LteRrcSap::MeasResults measResults)
506 {
507  NS_LOG_FUNCTION (this << rnti << (uint16_t) measResults.measId);
508  NS_LOG_INFO ("RNTI :" << rnti << " MeasId: " << (uint16_t) measResults.measId
509  << " RSRP: " << (uint16_t)measResults.rsrpResult
510  << " RSRQ: " << (uint16_t)measResults.rsrqResult);
511 
512  if (measResults.measId != m_measId)
513  {
514  NS_LOG_WARN ("Ignoring measId " << (uint16_t) measResults.measId);
515  }
516  else
517  {
518  std::map< uint16_t, uint8_t >::iterator it = m_ues.find (rnti);
519  if (it == m_ues.end ())
520  {
521  m_ues.insert (std::pair< uint16_t, uint8_t > (rnti, AreaUnset));
522  }
523  it = m_ues.find (rnti);
524 
525  if (measResults.rsrqResult < m_egdeSubBandThreshold)
526  {
527  if (it->second != CellEdge)
528  {
529  NS_LOG_INFO ("UE RNTI: " << rnti << " will be served in Edge sub-band");
530  it->second = CellEdge;
531 
532  LteRrcSap::PdschConfigDedicated pdschConfigDedicated;
533  pdschConfigDedicated.pa = m_edgePowerOffset;
534  m_ffrRrcSapUser->SetPdschConfigDedicated (rnti, pdschConfigDedicated);
535  }
536  }
537  else
538  {
539  if (it->second != CellCenter)
540  {
541  NS_LOG_INFO ("UE RNTI: " << rnti << " will be served in Center sub-band");
542  it->second = CellCenter;
543 
544  LteRrcSap::PdschConfigDedicated pdschConfigDedicated;
545  pdschConfigDedicated.pa = m_centerPowerOffset;
546  m_ffrRrcSapUser->SetPdschConfigDedicated (rnti, pdschConfigDedicated);
547  }
548  }
549  }
550 }
551 
552 void
554 {
555  NS_LOG_FUNCTION (this);
556  NS_LOG_WARN ("Method should not be called, because it is empty");
557 }
558 
559 } // end of namespace ns3
virtual void SetLteFfrRrcSapUser(LteFfrRrcSapUser *s)
Set the "user" part of the LteFfrRrcSap interface that this frequency reuse algorithm instance will i...
Service Access Point (SAP) offered by the Frequency Reuse algorithm instance to the eNodeB RRC instan...
Template for the implementation of the LteFfrRrcSapProvider as a member of an owner class of type C t...
Service Access Point (SAP) offered by the eNodeB RRC instance to the Frequency Reuse algorithm instan...
Definition: lte-ffr-sap.h:132
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by "...
static const struct ns3::FrSoftUplinkDefaultConfiguration g_frSoftUplinkDefaultConfiguration[]
virtual void SetLteFfrSapUser(LteFfrSapUser *s)
Set the "user" part of the LteFfrSap interface that this frequency reuse algorithm instance will inte...
AttributeValue implementation for Boolean.
Definition: boolean.h:34
void SetUplinkConfiguration(uint16_t cellId, uint8_t bandwidth)
virtual void DoReportDlCqiInfo(const struct FfMacSchedSapProvider::SchedDlCqiInfoReqParameters &params)
DoReportDlCqiInfo.
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition: object-base.h:44
void SetDownlinkConfiguration(uint16_t cellId, uint8_t bandwidth)
Ptr< const AttributeAccessor > MakeBooleanAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method...
Definition: boolean.h:81
virtual LteFfrRrcSapProvider * GetLteFfrRrcSapProvider()
Export the "provider" part of the LteFfrRrcSap interface.
ThresholdEutra threshold1
Threshold for event A1, A2, A4, and A5.
Definition: lte-rrc-sap.h:339
Specifies criteria for triggering of an E-UTRA measurement reporting event.
Definition: lte-rrc-sap.h:321
LteFrSoftAlgorithm()
Creates a trivial ffr algorithm instance.
uint8_t m_ulBandwidth
uplink bandwidth in RBs
enum ns3::LteRrcSap::ReportConfigEutra::@72 eventId
Choice of E-UTRA event triggered reporting criteria.
virtual uint8_t DoGetTpc(uint16_t rnti)
DoGetTpc for UE.
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:201
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:244
enum ns3::LteRrcSap::ReportConfigEutra::@76 reportInterval
Indicates the interval between periodical reports.
RSRQ is used for the threshold.
Definition: lte-rrc-sap.h:315
LteFfrRrcSapProvider * m_ffrRrcSapProvider
virtual uint8_t AddUeMeasReportConfigForFfr(LteRrcSap::ReportConfigEutra reportConfig)=0
Request a certain reporting configuration to be fulfilled by the UEs attached to the eNodeB entity...
virtual void SetPdschConfigDedicated(uint16_t rnti, LteRrcSap::PdschConfigDedicated pdschConfigDedicated)=0
Instruct the eNodeB RRC entity to perform RrcConnectionReconfiguration to inform UE about new PdschCo...
std::vector< bool > m_dlRbgMap
virtual std::vector< bool > DoGetAvailableUlRbg()
Implementation of LteFfrSapProvider::GetAvailableUlRbg.
Template for the implementation of the LteFfrSapProvider as a member of an owner class of type C to w...
Definition: lte-ffr-sap.h:146
LteFfrSapProvider * m_ffrSapProvider
LteFfrRrcSapUser * m_ffrRrcSapUser
Reference Signal Received Quality.
Definition: lte-rrc-sap.h:363
Service Access Point (SAP) offered by the Frequency Reuse algorithm instance to the MAC Scheduler ins...
Definition: lte-ffr-sap.h:39
Hold an unsigned integer type.
Definition: uinteger.h:44
Ptr< SampleEmitter > s
bool m_enabledInUplink
If true FR algorithm will also work in Uplink.
bool m_needReconfiguration
If true FR algorithm will be reconfigured.
virtual void Reconfigure()
Automatic FR reconfiguration.
virtual LteFfrSapProvider * GetLteFfrSapProvider()
Export the "provider" part of the LteFfrSap interface.
uint8_t m_dlBandwidth
downlink bandwidth in RBs
std::vector< bool > m_dlEdgeRbgMap
#define NS_LOG_LOGIC(msg)
Use NS_LOG to output a message of level LOG_LOGIC.
Definition: log.h:252
Every class exported by the ns3 library is enclosed in the ns3 namespace.
The abstract base class of a Frequency Reuse algorithm.
Ptr< const AttributeChecker > MakeBooleanChecker(void)
Definition: boolean.cc:121
enum ns3::LteRrcSap::ThresholdEutra::@70 choice
static const struct ns3::FrSoftDownlinkDefaultConfiguration g_frSoftDownlinkDefaultConfiguration[]
std::map< uint16_t, uint8_t > m_ues
uint8_t range
Value range used in RSRP/RSRQ threshold.
Definition: lte-rrc-sap.h:317
virtual bool DoIsUlRbgAvailableForUe(int i, uint16_t rnti)
Implementation of LteFfrSapProvider::IsUlRbgAvailableForUe.
Service Access Point (SAP) offered by the eNodeB RRC instance to the Frequency Reuse algorithm instan...
virtual void DoReportUeMeas(uint16_t rnti, LteRrcSap::MeasResults measResults)
Implementation of LteFfrRrcSapProvider::ReportUeMeas.
#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:84
Parameters of the SCHED_DL_CQI_INFO_REQ primitive.
enum ns3::LteRrcSap::ReportConfigEutra::@74 triggerQuantity
The quantities used to evaluate the triggering condition for the event, see 3GPP TS 36...
uint8_t m_frCellTypeId
FFR cell type ID for automatic configuration.
Parameters of the SCHED_UL_CQI_INFO_REQ primitive.
#define NS_LOG_WARN(msg)
Use NS_LOG to output a message of level LOG_WARN.
Definition: log.h:228
std::vector< bool > m_ulEdgeRbgMap
virtual void DoInitialize()
Initialize() implementation.
int GetRbgSize(int dlbandwidth)
Get RBG size for DL Bandwidth according to table 7.1.6.1-1 of 36.213.
Parameters of the LOAD INFORMATION message.
Definition: epc-x2-sap.h:300
virtual std::vector< bool > DoGetAvailableDlRbg()
Implementation of LteFfrSapProvider::GetAvailableDlRbg.
virtual void DoDispose()
Destructor implementation.
const uint16_t NUM_DOWNLINK_CONFS(sizeof(g_ffrEnhancedDownlinkDefaultConfiguration)/sizeof(FfrEnhancedDownlinkDefaultConfiguration))
virtual uint8_t DoGetMinContinuousUlBandwidth()
DoGetMinContinuousUlBandwidth in number of RB.
Ptr< const AttributeAccessor > MakeUintegerAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method...
Definition: uinteger.h:45
Event A1: Serving becomes better than absolute threshold.
Definition: lte-rrc-sap.h:331
a unique identifier for an interface.
Definition: type-id.h:51
TypeId SetParent(TypeId tid)
Definition: type-id.cc:631
virtual void DoReportUlCqiInfo(const struct FfMacSchedSapProvider::SchedUlCqiInfoReqParameters &params)
DoReportUlCqiInfo.
const uint16_t NUM_UPLINK_CONFS(sizeof(g_ffrEnhancedUplinkDefaultConfiguration)/sizeof(FfrEnhancedUplinkDefaultConfiguration))
std::vector< bool > m_ulRbgMap
virtual void DoInitialize(void)
Initialize() implementation.
Definition: object.cc:345
virtual void DoRecvLoadInformation(EpcX2Sap::LoadInformationParams params)
DoRecvLoadInformation.
virtual bool DoIsDlRbgAvailableForUe(int i, uint16_t rnti)
Implementation of LteFfrSapProvider::IsDlRbgAvailableForUe.