A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
lte-ffr-distributed-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/log.h>
13
14namespace ns3
15{
16
17NS_LOG_COMPONENT_DEFINE("LteFfrDistributedAlgorithm");
18
19NS_OBJECT_ENSURE_REGISTERED(LteFfrDistributedAlgorithm);
20
29
34
35void
42
45{
46 static TypeId tid =
47 TypeId("ns3::LteFfrDistributedAlgorithm")
49 .SetGroupName("Lte")
50 .AddConstructor<LteFfrDistributedAlgorithm>()
51 .AddAttribute(
52 "CalculationInterval",
53 "Time interval between calculation of Edge sub-band, Default value 1 second",
57 .AddAttribute(
58 "RsrqThreshold",
59 "If the RSRQ of is worse than this threshold, UE should be served in Edge sub-band",
60 UintegerValue(20),
63 .AddAttribute(
64 "RsrpDifferenceThreshold",
65 "If the difference between the power of the signal received by UE from "
66 "the serving cell and the power of the signal received from the adjacent cell is "
67 "less "
68 "than a RsrpDifferenceThreshold value, the cell weight is incremented",
69 UintegerValue(20),
72 .AddAttribute("CenterPowerOffset",
73 "PdschConfigDedicated::Pa value for Center Sub-band, default value dB0",
77 .AddAttribute("EdgePowerOffset",
78 "PdschConfigDedicated::Pa value for Edge Sub-band, default value dB0",
82 .AddAttribute("EdgeRbNum",
83 "Number of RB that can be used in edge Sub-band",
87 .AddAttribute("CenterAreaTpc",
88 "TPC value which will be set in DL-DCI for UEs in center area"
89 "Absolute mode is used, default value 1 is mapped to -1 according to"
90 "TS36.213 Table 5.1.1.1-2",
94 .AddAttribute("EdgeAreaTpc",
95 "TPC value which will be set in DL-DCI for UEs in edge area"
96 "Absolute mode is used, default value 1 is mapped to -1 according to"
97 "TS36.213 Table 5.1.1.1-2",
101
102 ;
103 return tid;
104}
105
106void
112
119
120void
126
133
134void
136{
137 NS_LOG_FUNCTION(this);
139
140 if (m_frCellTypeId != 0)
141 {
144 }
145
146 NS_LOG_LOGIC(this << " requesting Event A1 and A4 measurements"
147 << " (threshold = 0"
148 << ")");
149 LteRrcSap::ReportConfigEutra reportConfig;
152 reportConfig.threshold1.range = 0;
156
157 LteRrcSap::ReportConfigEutra reportConfigA4;
160 reportConfigA4.threshold1.range = 0; // intentionally very low threshold
164
165 int rbgSize = GetRbgSize(m_dlBandwidth);
166 m_dlEdgeRbgMap.resize(m_dlBandwidth / rbgSize, false);
167 m_ulEdgeRbgMap.resize(m_ulBandwidth, false);
169}
170
171void
184
185void
187{
188 NS_LOG_FUNCTION(this);
189}
190
191void
192LteFfrDistributedAlgorithm::SetUplinkConfiguration(uint16_t cellId, uint8_t bandwidth)
193{
194 NS_LOG_FUNCTION(this);
195}
196
197void
199{
200 NS_LOG_FUNCTION(this);
201 m_dlRbgMap.clear();
202 int rbgSize = GetRbgSize(m_dlBandwidth);
203 m_dlRbgMap.resize(m_dlBandwidth / rbgSize, false);
204}
205
206void
213
214std::vector<bool>
216{
217 NS_LOG_FUNCTION(this);
218
220 {
221 Reconfigure();
222 }
223
224 if (m_dlRbgMap.empty())
225 {
227 }
228
229 return m_dlRbgMap;
230}
231
232bool
234{
235 NS_LOG_FUNCTION(this);
236
237 bool edgeRbg = m_dlEdgeRbgMap[rbgId];
238
239 auto it = m_ues.find(rnti);
240 if (it == m_ues.end())
241 {
242 m_ues.insert(std::pair<uint16_t, uint8_t>(rnti, AreaUnset));
243 return !edgeRbg;
244 }
245
246 bool edgeUe = false;
247 if (it->second == EdgeArea)
248 {
249 edgeUe = true;
250 }
251
252 return (edgeRbg && edgeUe) || (!edgeRbg && !edgeUe);
253}
254
255std::vector<bool>
257{
258 NS_LOG_FUNCTION(this);
259
260 if (m_ulRbgMap.empty())
261 {
263 }
264
265 return m_ulRbgMap;
266}
267
268bool
270{
271 NS_LOG_FUNCTION(this);
272
274 {
275 return true;
276 }
277
278 bool edgeRbg = m_ulEdgeRbgMap[rbId];
279
280 auto it = m_ues.find(rnti);
281 if (it == m_ues.end())
282 {
283 m_ues.insert(std::pair<uint16_t, uint8_t>(rnti, AreaUnset));
284 return !edgeRbg;
285 }
286
287 bool edgeUe = false;
288 if (it->second == EdgeArea)
289 {
290 edgeUe = true;
291 }
292
293 return (edgeRbg && edgeUe) || (!edgeRbg && !edgeUe);
294}
295
296void
299{
300 NS_LOG_FUNCTION(this);
301 NS_LOG_WARN("Method should not be called, because it is empty");
302}
303
304void
307{
308 NS_LOG_FUNCTION(this);
309 NS_LOG_WARN("Method should not be called, because it is empty");
310}
311
312void
313LteFfrDistributedAlgorithm::DoReportUlCqiInfo(std::map<uint16_t, std::vector<double>> ulCqiMap)
314{
315 NS_LOG_FUNCTION(this);
316 NS_LOG_WARN("Method should not be called, because it is empty");
317}
318
319uint8_t
321{
322 NS_LOG_FUNCTION(this);
323
325 {
326 return 1; // 1 is mapped to 0 for Accumulated mode, and to -1 in Absolute mode TS36.213
327 // Table 5.1.1.1-2
328 }
329
330 // TS36.213 Table 5.1.1.1-2
331 // TPC | Accumulated Mode | Absolute Mode
332 //------------------------------------------------
333 // 0 | -1 | -4
334 // 1 | 0 | -1
335 // 2 | 1 | 1
336 // 3 | 3 | 4
337 //------------------------------------------------
338 // here Absolute mode is used
339
340 auto it = m_ues.find(rnti);
341 if (it == m_ues.end())
342 {
343 return 1;
344 }
345
346 if (it->second == EdgeArea)
347 {
348 return m_edgeAreaTpc;
349 }
350 else
351 {
352 return m_centerAreaTpc;
353 }
354
355 return 1;
356}
357
358uint16_t
360{
361 NS_LOG_FUNCTION(this);
362
363 uint8_t minContinuousUlBandwidth = m_ulBandwidth;
364
366 {
367 return minContinuousUlBandwidth;
368 }
369
370 minContinuousUlBandwidth = ((m_edgeRbNum > 0) && (m_edgeRbNum < minContinuousUlBandwidth))
372 : minContinuousUlBandwidth;
373
374 return minContinuousUlBandwidth;
375}
376
377void
379{
380 NS_LOG_FUNCTION(this << rnti << (uint16_t)measResults.measId);
381 NS_LOG_INFO("CellId: " << m_cellId << " RNTI :" << rnti
382 << " MeasId: " << (uint16_t)measResults.measId
383 << " RSRP: " << (uint16_t)measResults.measResultPCell.rsrpResult
384 << " RSRQ: " << (uint16_t)measResults.measResultPCell.rsrqResult);
385
386 if (measResults.measId == m_rsrqMeasId)
387 {
388 // check if it is center or edge UE
389 auto it = m_ues.find(rnti);
390 if (it == m_ues.end())
391 {
392 m_ues.insert(std::pair<uint16_t, uint8_t>(rnti, AreaUnset));
393 }
394
395 it = m_ues.find(rnti);
397 {
398 if (it->second != CenterArea)
399 {
400 NS_LOG_INFO("UE RNTI: " << rnti << " will be served in Center sub-band");
401 it->second = CenterArea;
402
403 LteRrcSap::PdschConfigDedicated pdschConfigDedicated;
404 pdschConfigDedicated.pa = m_centerPowerOffset;
405 m_ffrRrcSapUser->SetPdschConfigDedicated(rnti, pdschConfigDedicated);
406 }
407 }
408 else
409 {
410 if (it->second != EdgeArea)
411 {
412 NS_LOG_INFO("UE RNTI: " << rnti << " will be served in Edge sub-band");
413 it->second = EdgeArea;
414
415 LteRrcSap::PdschConfigDedicated pdschConfigDedicated;
416 pdschConfigDedicated.pa = m_edgePowerOffset;
417 m_ffrRrcSapUser->SetPdschConfigDedicated(rnti, pdschConfigDedicated);
418 }
419 }
420 }
421 else if (measResults.measId == m_rsrpMeasId)
422 {
423 auto it = m_ues.find(rnti);
424 if (it == m_ues.end())
425 {
426 m_ues.insert(std::pair<uint16_t, uint8_t>(rnti, AreaUnset));
427 }
428
430 m_cellId,
431 measResults.measResultPCell.rsrpResult,
432 measResults.measResultPCell.rsrqResult);
433
434 if (measResults.haveMeasResultNeighCells && !measResults.measResultListEutra.empty())
435 {
436 for (auto it = measResults.measResultListEutra.begin();
437 it != measResults.measResultListEutra.end();
438 ++it)
439 {
440 NS_ASSERT_MSG(it->haveRsrpResult == true,
441 "RSRP measurement is missing from cellId " << it->physCellId);
442 NS_ASSERT_MSG(it->haveRsrqResult == true,
443 "RSRQ measurement is missing from cellId " << it->physCellId);
444 UpdateNeighbourMeasurements(rnti, it->physCellId, it->rsrpResult, it->rsrqResult);
445
446 bool found = false;
447 for (auto ncIt = m_neighborCell.begin(); ncIt != m_neighborCell.end(); ncIt++)
448 {
449 if ((*ncIt) == it->physCellId)
450 {
451 found = true;
452 }
453 }
454 if (!found)
455 {
456 m_neighborCell.push_back(it->physCellId);
457 }
458 }
459 }
460 else
461 {
463 this << " Event A4 received without measurement results from neighbouring cells");
464 }
465 }
466 else
467 {
468 NS_LOG_WARN("Ignoring measId " << (uint16_t)measResults.measId);
469 }
470}
471
472void
474{
475 NS_LOG_FUNCTION(this);
478
479 int rbgSize = GetRbgSize(m_dlBandwidth);
480 uint16_t rbgNum = m_dlBandwidth / rbgSize;
481
482 m_cellWeightMap.clear();
483 m_dlEdgeRbgMap.clear();
484 m_dlEdgeRbgMap.resize(m_dlBandwidth / rbgSize, false);
485 m_ulEdgeRbgMap.clear();
486 m_ulEdgeRbgMap.resize(m_ulBandwidth, false);
487
488 Ptr<UeMeasure> servingCellMeasures;
489 Ptr<UeMeasure> neighbourCellMeasures;
490
491 uint32_t edgeUeNum = 0;
492 for (auto areaIt = m_ues.begin(); areaIt != m_ues.end(); areaIt++)
493 {
494 if (areaIt->second == EdgeArea)
495 {
496 edgeUeNum++;
497 }
498 }
499
500 if (edgeUeNum != 0)
501 {
502 for (auto it1 = m_ueMeasures.begin(); it1 != m_ueMeasures.end(); it1++)
503 {
504 auto areaIt = m_ues.find(it1->first);
505 if (areaIt->second != EdgeArea)
506 {
507 continue;
508 }
509
510 servingCellMeasures = nullptr;
511 neighbourCellMeasures = nullptr;
512
513 auto it2 = it1->second.find(m_cellId);
514 if (it2 != it1->second.end())
515 {
516 servingCellMeasures = it2->second;
517 }
518 else
519 {
520 continue;
521 }
522
523 for (it2 = it1->second.begin(); it2 != it1->second.end(); it2++)
524 {
525 if (it2->first != m_cellId)
526 {
527 neighbourCellMeasures = it2->second;
528 }
529 else
530 {
531 continue;
532 }
533
534 if (servingCellMeasures && neighbourCellMeasures)
535 {
536 int16_t rsrpDifference =
537 servingCellMeasures->m_rsrp - neighbourCellMeasures->m_rsrp;
538 NS_LOG_INFO("CellId: " << m_cellId << " UE RNTI: " << it1->first
539 << " NeighborCellId: " << neighbourCellMeasures->m_cellId
540 << " RSRP Serving: " << (int)servingCellMeasures->m_rsrp
541 << " RSRP Neighbor: "
542 << (int)neighbourCellMeasures->m_rsrp
543 << " RSRP Difference: " << (int)rsrpDifference);
544
545 if (rsrpDifference < m_rsrpDifferenceThreshold)
546 {
547 m_cellWeightMap[neighbourCellMeasures->m_cellId]++;
548 }
549 }
550 }
551 }
552
553 std::map<uint16_t, uint64_t> metricA;
554 for (uint16_t i = 0; i < rbgNum; i++)
555 {
556 metricA[i] = 0;
557 }
558
559 for (auto cellIt = m_cellWeightMap.begin(); cellIt != m_cellWeightMap.end(); cellIt++)
560 {
561 NS_LOG_INFO("CellId: " << m_cellId << " NeighborCellId: " << cellIt->first
562 << " Weight: " << cellIt->second);
563
564 auto rntpIt = m_rntp.find(cellIt->first);
565 if (rntpIt == m_rntp.end())
566 {
567 continue;
568 }
569
570 for (uint16_t i = 0; i < rbgNum; i++)
571 {
572 if (rntpIt->second[i])
573 {
574 metricA[i] += cellIt->second;
575 }
576 }
577 }
578
579 std::vector<uint16_t> sortedRbgByMetric;
580 std::multimap<uint64_t, uint16_t> sortedMetricA;
581 for (auto it = metricA.begin(); it != metricA.end(); ++it)
582 {
583 sortedMetricA.insert(std::pair<uint64_t, uint16_t>(it->second, it->first));
584 }
585
586 for (auto it = sortedMetricA.begin(); it != sortedMetricA.end(); ++it)
587 {
588 sortedRbgByMetric.push_back(it->second);
589 }
590
591 for (int i = 0; i < m_edgeRbNum / rbgSize; i++)
592 {
593 m_dlEdgeRbgMap[sortedRbgByMetric[i]] = true;
594 }
595
596 for (int i = 0; i < m_edgeRbNum / rbgSize; i++)
597 {
598 uint32_t rbgIndex = sortedRbgByMetric[i];
599 for (int k = 0; k < rbgSize; k++)
600 {
601 uint32_t rbIndex = rbgSize * rbgIndex + k;
602 m_ulEdgeRbgMap[rbIndex] = true;
603 }
604 }
605 }
606
607 for (auto ncIt = m_neighborCell.begin(); ncIt != m_neighborCell.end(); ncIt++)
608 {
609 SendLoadInformation(*ncIt);
610 }
611}
612
613void
615{
616 NS_LOG_FUNCTION(this);
617
618 NS_LOG_INFO("SendLoadInformation to CellId : " << targetCellId);
619
620 std::vector<EpcX2Sap::UlInterferenceOverloadIndicationItem>
621 m_currentUlInterferenceOverloadIndicationList;
622 std::vector<EpcX2Sap::UlHighInterferenceInformationItem>
623 m_currentUlHighInterferenceInformationList;
624 EpcX2Sap::RelativeNarrowbandTxBand m_currentRelativeNarrowbandTxBand;
625
626 m_currentRelativeNarrowbandTxBand.rntpPerPrbList = m_dlEdgeRbgMap;
627
630 cii.ulInterferenceOverloadIndicationList = m_currentUlInterferenceOverloadIndicationList;
631 cii.ulHighInterferenceInformationList = m_currentUlHighInterferenceInformationList;
632 cii.relativeNarrowbandTxBand = m_currentRelativeNarrowbandTxBand;
633
635 params.targetCellId = targetCellId;
636 params.cellInformationList.push_back(cii);
637
639}
640
641void
643{
644 NS_LOG_FUNCTION(this);
645 NS_LOG_INFO("CellId: " << m_cellId << " Recv X2 message: LOAD INFORMATION from CellId:"
646 << params.cellInformationList[0].sourceCellId);
647
648 if (params.cellInformationList[0].sourceCellId > m_cellId)
649 {
650 return;
651 }
652
653 uint16_t neighborCellId = params.cellInformationList[0].sourceCellId;
654 auto it = m_rntp.find(neighborCellId);
655 if (it != m_rntp.end())
656 {
657 it->second = params.cellInformationList[0].relativeNarrowbandTxBand.rntpPerPrbList;
658 }
659 else
660 {
661 m_rntp.insert(std::pair<uint16_t, std::vector<bool>>(
662 neighborCellId,
663 params.cellInformationList[0].relativeNarrowbandTxBand.rntpPerPrbList));
664 }
665}
666
667void
669 uint16_t cellId,
670 uint8_t rsrp,
671 uint8_t rsrq)
672{
673 NS_LOG_FUNCTION(this << rnti << cellId << (uint16_t)rsrq);
674
675 auto it1 = m_ueMeasures.find(rnti);
676
677 if (it1 == m_ueMeasures.end())
678 {
679 // insert a new UE entry
681 auto ret = m_ueMeasures.insert(std::pair<uint16_t, MeasurementRow_t>(rnti, row));
682 NS_ASSERT(ret.second);
683 it1 = ret.first;
684 }
685
686 NS_ASSERT(it1 != m_ueMeasures.end());
687 auto it2 = it1->second.find(cellId);
688
689 if (it2 != it1->second.end())
690 {
691 it2->second->m_cellId = cellId;
692 it2->second->m_rsrp = rsrp;
693 it2->second->m_rsrq = rsrq;
694 }
695 else
696 {
697 // insert a new cell entry
698 Ptr<UeMeasure> cellMeasures = Create<UeMeasure>();
699 cellMeasures->m_cellId = cellId;
700 cellMeasures->m_rsrp = rsrp;
701 cellMeasures->m_rsrq = rsrq;
702 it1->second[cellId] = cellMeasures;
703 }
704
705} // end of UpdateNeighbourMeasurements
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
Distributed Fractional Frequency Reuse algorithm implementation.
std::map< uint16_t, Ptr< UeMeasure > > MeasurementRow_t
Cell Id is used as the key for the following map.
void DoReportUeMeas(uint16_t rnti, LteRrcSap::MeasResults measResults) override
Implementation of LteFfrRrcSapProvider::ReportUeMeas.
uint8_t DoGetTpc(uint16_t rnti) override
DoGetTpc for UE.
LteFfrSapProvider * m_ffrSapProvider
FFR SAP Provider.
LteFfrRrcSapProvider * m_ffrRrcSapProvider
FFR RRC SAP Provider.
std::map< uint16_t, uint8_t > m_ues
UEs map.
void UpdateNeighbourMeasurements(uint16_t rnti, uint16_t cellId, uint8_t rsrp, uint8_t rsrq)
Initialize up link RBG maps function.
uint8_t m_rsrpDifferenceThreshold
RSRP difference threshold.
void DoDispose() override
Destructor implementation.
LteFfrRrcSapUser * m_ffrRrcSapUser
FFR RRC SAP User.
std::map< uint16_t, uint32_t > m_cellWeightMap
cell weight map
friend class MemberLteFfrSapProvider< LteFfrDistributedAlgorithm >
let the forwarder class access the protected and private members
bool DoIsDlRbgAvailableForUe(int i, uint16_t rnti) override
Implementation of LteFfrSapProvider::IsDlRbgAvailableForUe.
void SetUplinkConfiguration(uint16_t cellId, uint8_t bandwidth)
Set up link configuration function.
void DoInitialize() override
Initialize() implementation.
void DoReportDlCqiInfo(const FfMacSchedSapProvider::SchedDlCqiInfoReqParameters &params) override
DoReportDlCqiInfo.
uint16_t DoGetMinContinuousUlBandwidth() override
DoGetMinContinuousUlBandwidth in number of RB.
void SetLteFfrSapUser(LteFfrSapUser *s) override
Set the "user" part of the LteFfrSap interface that this frequency reuse algorithm instance will inte...
void DoRecvLoadInformation(EpcX2Sap::LoadInformationParams params) override
DoRecvLoadInformation.
MeasurementTable_t m_ueMeasures
UE measures.
std::vector< bool > DoGetAvailableDlRbg() override
Implementation of LteFfrSapProvider::GetAvailableDlRbg.
std::map< uint16_t, std::vector< bool > > m_rntp
RNTP.
void SetDownlinkConfiguration(uint16_t cellId, uint8_t bandwidth)
Set down link configuration function.
std::vector< uint16_t > m_neighborCell
neighbor cell
friend class MemberLteFfrRrcSapProvider< LteFfrDistributedAlgorithm >
let the forwarder class access the protected and private members
std::vector< bool > m_ulRbgMap
UL RBG map.
std::vector< bool > m_ulEdgeRbgMap
UL edge RBG map.
uint8_t m_edgeSubBandRsrqThreshold
edge sub band RSRQ threshold
std::vector< bool > DoGetAvailableUlRbg() override
Implementation of LteFfrSapProvider::GetAvailableUlRbg.
bool DoIsUlRbgAvailableForUe(int i, uint16_t rnti) override
Implementation of LteFfrSapProvider::IsUlRbgAvailableForUe.
static TypeId GetTypeId()
Get the type ID.
LteFfrSapProvider * GetLteFfrSapProvider() override
Export the "provider" part of the LteFfrSap interface.
LteFfrRrcSapProvider * GetLteFfrRrcSapProvider() override
Export the "provider" part of the LteFfrRrcSap interface.
std::vector< bool > m_dlRbgMap
DL RBG map.
void SetLteFfrRrcSapUser(LteFfrRrcSapUser *s) override
Set the "user" part of the LteFfrRrcSap interface that this frequency reuse algorithm instance will i...
void Reconfigure() override
Automatic FR reconfiguration.
void InitializeUplinkRbgMaps()
Initialize up link RBG maps function.
std::vector< bool > m_dlEdgeRbgMap
DL edge RBG map.
void DoReportUlCqiInfo(const FfMacSchedSapProvider::SchedUlCqiInfoReqParameters &params) override
DoReportUlCqiInfo.
void SendLoadInformation(uint16_t targetCellId)
Send load information function.
void InitializeDownlinkRbgMaps()
Initialize down link RBG maps function.
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.
virtual void SendLoadInformation(EpcX2Sap::LoadInformationParams params)=0
SendLoadInformation.
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...
virtual void DoInitialize()
Initialize() implementation.
Definition object.cc:440
Smart pointer class similar to boost::intrusive_ptr.
static EventId Schedule(const Time &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
Definition simulator.h:560
static EventId ScheduleNow(FUNC f, Ts &&... args)
Schedule an event to expire Now.
Definition simulator.h:594
AttributeValue implementation for Time.
Definition nstime.h:1395
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(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition assert.h:55
#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
Ptr< const AttributeAccessor > MakeTimeAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method.
Definition nstime.h:1396
Ptr< const AttributeChecker > MakeTimeChecker()
Helper to make an unbounded Time checker.
Definition nstime.h:1416
Ptr< const AttributeChecker > MakeUintegerChecker()
Definition uinteger.h:85
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:35
#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
Ptr< T > Create(Ts &&... args)
Create class instances by constructors with varying numbers of arguments and return them by Ptr.
Definition ptr.h:436
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition nstime.h:1308
Every class exported by the ns3 library is enclosed in the ns3 namespace.
Cell Information Item as it is used in the LOAD INFORMATION message.
Definition epc-x2-sap.h:147
uint16_t sourceCellId
source cell ID
Definition epc-x2-sap.h:148
std::vector< UlHighInterferenceInformationItem > ulHighInterferenceInformationList
UL high interference information list.
Definition epc-x2-sap.h:152
RelativeNarrowbandTxBand relativeNarrowbandTxBand
relative narrow transmit band
Definition epc-x2-sap.h:153
std::vector< UlInterferenceOverloadIndicationItem > ulInterferenceOverloadIndicationList
UL interference overload indication list.
Definition epc-x2-sap.h:150
Parameters of the LOAD INFORMATION message.
Definition epc-x2-sap.h:295
Relative Narrowband Tx Power (RNTP) as it is used in the LOAD INFORMATION message.
Definition epc-x2-sap.h:133
std::vector< bool > rntpPerPrbList
RNTP per prb list.
Definition epc-x2-sap.h:134
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
bool haveMeasResultNeighCells
have measure result neighbor cells
std::list< MeasResultEutra > measResultListEutra
measure result list eutra
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.
@ RSRP
Reference Signal Received Power.
@ RSRQ
Reference Signal Received Quality.
@ EVENT_A4
Event A4: Neighbour becomes better than absolute threshold.
@ 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_RSRP
RSRP is used for the threshold.
@ 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.