A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
lte-helper.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2011 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
3 *
4 * SPDX-License-Identifier: GPL-2.0-only
5 *
6 * Author: Nicola Baldo <nbaldo@cttc.es> (re-wrote from scratch this helper)
7 * Giuseppe Piro <g.piro@poliba.it> (parts of the PHY & channel creation & configuration
8 * copied from the GSoC 2011 code) Modified by: Danilo Abrignani <danilo.abrignani@unibo.it>
9 * (Carrier Aggregation - GSoC 2015) Biljana Bojovic <biljana.bojovic@cttc.es> (Carrier Aggregation)
10 */
11
12#include "lte-helper.h"
13
14#include "cc-helper.h"
15#include "epc-helper.h"
20
21#include <ns3/abort.h>
22#include <ns3/buildings-propagation-loss-model.h>
23#include <ns3/epc-enb-application.h>
24#include <ns3/epc-enb-s1-sap.h>
25#include <ns3/epc-ue-nas.h>
26#include <ns3/epc-x2.h>
27#include <ns3/ff-mac-scheduler.h>
28#include <ns3/friis-spectrum-propagation-loss.h>
29#include <ns3/isotropic-antenna-model.h>
30#include <ns3/log.h>
31#include <ns3/lte-anr.h>
32#include <ns3/lte-chunk-processor.h>
33#include <ns3/lte-common.h>
34#include <ns3/lte-enb-component-carrier-manager.h>
35#include <ns3/lte-enb-mac.h>
36#include <ns3/lte-enb-net-device.h>
37#include <ns3/lte-enb-phy.h>
38#include <ns3/lte-enb-rrc.h>
39#include <ns3/lte-ffr-algorithm.h>
40#include <ns3/lte-handover-algorithm.h>
41#include <ns3/lte-rlc-am.h>
42#include <ns3/lte-rlc-um.h>
43#include <ns3/lte-rlc.h>
44#include <ns3/lte-rrc-protocol-ideal.h>
45#include <ns3/lte-rrc-protocol-real.h>
46#include <ns3/lte-spectrum-phy.h>
47#include <ns3/lte-spectrum-value-helper.h>
48#include <ns3/lte-ue-component-carrier-manager.h>
49#include <ns3/lte-ue-mac.h>
50#include <ns3/lte-ue-net-device.h>
51#include <ns3/lte-ue-phy.h>
52#include <ns3/lte-ue-rrc.h>
53#include <ns3/multi-model-spectrum-channel.h>
54#include <ns3/object-factory.h>
55#include <ns3/object-map.h>
56#include <ns3/pointer.h>
57#include <ns3/string.h>
58#include <ns3/trace-fading-loss-model.h>
59
60#include <iostream>
61
62namespace ns3
63{
64
65NS_LOG_COMPONENT_DEFINE("LteHelper");
66
68
81
82void
93
98
101{
102 static TypeId tid =
103 TypeId("ns3::LteHelper")
104 .SetParent<Object>()
105 .AddConstructor<LteHelper>()
106 .AddAttribute(
107 "Scheduler",
108 "The type of scheduler to be used for eNBs. "
109 "The allowed values for this attributes are the type names "
110 "of any class inheriting from ns3::FfMacScheduler.",
111 StringValue("ns3::PfFfMacScheduler"),
114 .AddAttribute("FfrAlgorithm",
115 "The type of FFR algorithm to be used for eNBs. "
116 "The allowed values for this attributes are the type names "
117 "of any class inheriting from ns3::LteFfrAlgorithm.",
118 StringValue("ns3::LteFrNoOpAlgorithm"),
122 .AddAttribute("HandoverAlgorithm",
123 "The type of handover algorithm to be used for eNBs. "
124 "The allowed values for this attributes are the type names "
125 "of any class inheriting from ns3::LteHandoverAlgorithm.",
126 StringValue("ns3::NoOpHandoverAlgorithm"),
130 .AddAttribute("PathlossModel",
131 "The type of pathloss model to be used. "
132 "The allowed values for this attributes are the type names "
133 "of any class inheriting from ns3::PropagationLossModel.",
137 .AddAttribute("FadingModel",
138 "The type of fading model to be used."
139 "The allowed values for this attributes are the type names "
140 "of any class inheriting from ns3::SpectrumPropagationLossModel."
141 "If the type is set to an empty string, no fading model is used.",
142 StringValue(""),
145 .AddAttribute("UseIdealRrc",
146 "If true, LteRrcProtocolIdeal will be used for RRC signaling. "
147 "If false, LteRrcProtocolReal will be used.",
148 BooleanValue(true),
151 .AddAttribute("AnrEnabled",
152 "Activate or deactivate Automatic Neighbour Relation function",
153 BooleanValue(true),
156 .AddAttribute("UsePdschForCqiGeneration",
157 "If true, DL-CQI will be calculated from PDCCH as signal and PDSCH as "
158 "interference. "
159 "If false, DL-CQI will be calculated from PDCCH as signal and PDCCH as "
160 "interference.",
161 BooleanValue(true),
164 .AddAttribute("EnbComponentCarrierManager",
165 "The type of Component Carrier Manager to be used for eNBs. "
166 "The allowed values for this attributes are the type names "
167 "of any class inheriting ns3::LteEnbComponentCarrierManager.",
168 StringValue("ns3::NoOpComponentCarrierManager"),
172 .AddAttribute("UeComponentCarrierManager",
173 "The type of Component Carrier Manager to be used for UEs. "
174 "The allowed values for this attributes are the type names "
175 "of any class inheriting ns3::LteUeComponentCarrierManager.",
176 StringValue("ns3::SimpleUeComponentCarrierManager"),
180 .AddAttribute("UseCa",
181 "If true, Carrier Aggregation feature is enabled and a valid Component "
182 "Carrier Map is expected. "
183 "If false, single carrier simulation.",
184 BooleanValue(false),
187 .AddAttribute("NumberOfComponentCarriers",
188 "Set the number of Component carrier to use. "
189 "If it is more than one and m_useCa is false, it will raise an error.",
190 UintegerValue(1),
193 return tid;
194}
195
196void
198{
199 NS_LOG_FUNCTION(this);
200 m_downlinkChannel = nullptr;
201 m_uplinkChannel = nullptr;
204}
205
211
217
218void
220{
221 // Channel Object (i.e. Ptr<SpectrumChannel>) are within a vector
222 // PathLossModel Objects are vectors --> in InstallSingleEnb we will set the frequency
223 NS_LOG_FUNCTION(this << m_noOfCcs);
224
227
231 if (dlSplm)
232 {
233 NS_LOG_LOGIC(this << " using a SpectrumPropagationLossModel in DL");
234 m_downlinkChannel->AddSpectrumPropagationLossModel(dlSplm);
235 }
236 else
237 {
238 NS_LOG_LOGIC(this << " using a PropagationLossModel in DL");
241 NS_ASSERT_MSG(dlPlm,
243 << " is neither PropagationLossModel nor SpectrumPropagationLossModel");
244 m_downlinkChannel->AddPropagationLossModel(dlPlm);
245 }
246
250 if (ulSplm)
251 {
252 NS_LOG_LOGIC(this << " using a SpectrumPropagationLossModel in UL");
253 m_uplinkChannel->AddSpectrumPropagationLossModel(ulSplm);
254 }
255 else
256 {
257 NS_LOG_LOGIC(this << " using a PropagationLossModel in UL");
259 NS_ASSERT_MSG(ulPlm,
261 << " is neither PropagationLossModel nor SpectrumPropagationLossModel");
262 m_uplinkChannel->AddPropagationLossModel(ulPlm);
263 }
264 if (!m_fadingModelType.empty())
265 {
268 m_downlinkChannel->AddSpectrumPropagationLossModel(m_fadingModel);
269 m_uplinkChannel->AddSpectrumPropagationLossModel(m_fadingModel);
270 }
271}
272
273void
279
280void
282{
283 NS_LOG_FUNCTION(this << type);
286}
287
288std::string
293
294void
296{
297 NS_LOG_FUNCTION(this << n);
299}
300
301std::string
306
307void
314
315void
317{
318 NS_LOG_FUNCTION(this << n);
320}
321
322std::string
327
328void
335
336void
342
343std::string
348
349void
356
357void
363
364std::string
369
370void
377
378void
384
385void
392
393void
395{
396 NS_LOG_FUNCTION(this << n);
398}
399
400void
402{
403 NS_LOG_FUNCTION(this);
405}
406
407void
413
414void
420
421void
423{
424 NS_LOG_FUNCTION(this);
426}
427
428void
434
435void
441
442void
444{
445 NS_LOG_FUNCTION(this << type);
446 m_fadingModelType = type;
447 if (!type.empty())
448 {
451 }
452}
453
454void
456{
458}
459
460void
462{
463 NS_LOG_FUNCTION(this << type);
465}
466
467void
469{
470 m_channelFactory.Set(n, v);
471}
472
475{
476 NS_LOG_FUNCTION(this);
477 Initialize(); // will run DoInitialize () if necessary
478 NetDeviceContainer devices;
479 for (auto i = c.Begin(); i != c.End(); ++i)
480 {
481 Ptr<Node> node = *i;
483 devices.Add(device);
484 }
485 return devices;
486}
487
490{
491 NS_LOG_FUNCTION(this);
492 NetDeviceContainer devices;
493 for (auto i = c.Begin(); i != c.End(); ++i)
494 {
495 Ptr<Node> node = *i;
497 devices.Add(device);
498 }
499 return devices;
500}
501
504{
505 NS_LOG_FUNCTION(this << n);
506 uint16_t cellId = m_cellIdCounter; // \todo Remove, eNB has no cell ID
507
509 Ptr<LteHandoverAlgorithm> handoverAlgorithm =
511
512 NS_ABORT_MSG_IF(!m_componentCarrierPhyParams.empty(), "CC map is not clean");
513 DoComponentCarrierConfigure(dev->GetUlEarfcn(),
514 dev->GetDlEarfcn(),
515 dev->GetUlBandwidth(),
516 dev->GetDlBandwidth());
518 "CC map size (" << m_componentCarrierPhyParams.size()
519 << ") must be equal to number of carriers (" << m_noOfCcs
520 << ")");
521 // create component carrier map for this eNb device
522 std::map<uint8_t, Ptr<ComponentCarrierBaseStation>> ccMap;
523 for (auto it = m_componentCarrierPhyParams.begin(); it != m_componentCarrierPhyParams.end();
524 ++it)
525 {
527 cc->SetUlBandwidth(it->second.GetUlBandwidth());
528 cc->SetDlBandwidth(it->second.GetDlBandwidth());
529 cc->SetDlEarfcn(it->second.GetDlEarfcn());
530 cc->SetUlEarfcn(it->second.GetUlEarfcn());
531 cc->SetAsPrimary(it->second.IsPrimary());
532 NS_ABORT_MSG_IF(m_cellIdCounter == 65535, "max num cells exceeded");
533 cc->SetCellId(m_cellIdCounter++);
534 ccMap[it->first] = cc;
535 }
536 // CC map is not needed anymore
538
539 NS_ABORT_MSG_IF(m_useCa && ccMap.size() < 2,
540 "You have to either specify carriers or disable carrier aggregation");
541 NS_ASSERT(ccMap.size() == m_noOfCcs);
542
543 for (auto it = ccMap.begin(); it != ccMap.end(); ++it)
544 {
545 NS_LOG_DEBUG(this << "component carrier map size " << (uint16_t)ccMap.size());
548 Ptr<LteEnbPhy> phy = CreateObject<LteEnbPhy>(dlPhy, ulPhy);
549
551 dlPhy->SetHarqPhyModule(harq);
552 ulPhy->SetHarqPhyModule(harq);
553 phy->SetHarqPhyModule(harq);
554
556 pCtrl->AddCallback(MakeCallback(&LteEnbPhy::GenerateCtrlCqiReport, phy));
557 ulPhy->AddCtrlSinrChunkProcessor(pCtrl); // for evaluating SRS UL-CQI
558
560 pData->AddCallback(MakeCallback(&LteEnbPhy::GenerateDataCqiReport, phy));
561 pData->AddCallback(MakeCallback(&LteSpectrumPhy::UpdateSinrPerceived, ulPhy));
562 ulPhy->AddDataSinrChunkProcessor(pData); // for evaluating PUSCH UL-CQI
563
565 pInterf->AddCallback(MakeCallback(&LteEnbPhy::ReportInterference, phy));
566 ulPhy->AddInterferenceDataChunkProcessor(pInterf); // for interference power tracing
567
568 dlPhy->SetChannel(m_downlinkChannel);
569 ulPhy->SetChannel(m_uplinkChannel);
570
571 Ptr<MobilityModel> mm = n->GetObject<MobilityModel>();
573 mm,
574 "MobilityModel needs to be set on node before calling LteHelper::InstallEnbDevice ()");
575 dlPhy->SetMobility(mm);
576 ulPhy->SetMobility(mm);
577
579 NS_ASSERT_MSG(antenna, "error in creating the AntennaModel object");
580 dlPhy->SetAntenna(antenna);
581 ulPhy->SetAntenna(antenna);
582
586 DynamicCast<ComponentCarrierEnb>(it->second)->SetMac(mac);
587 DynamicCast<ComponentCarrierEnb>(it->second)->SetFfMacScheduler(sched);
588 DynamicCast<ComponentCarrierEnb>(it->second)->SetFfrAlgorithm(ffrAlgorithm);
589 DynamicCast<ComponentCarrierEnb>(it->second)->SetPhy(phy);
590 }
591
595
596 // ComponentCarrierManager SAP
597 rrc->SetLteCcmRrcSapProvider(ccmEnbManager->GetLteCcmRrcSapProvider());
598 ccmEnbManager->SetLteCcmRrcSapUser(rrc->GetLteCcmRrcSapUser());
599 // Set number of component carriers. Note: eNB CCM would also set the
600 // number of component carriers in eNB RRC
601 ccmEnbManager->SetNumberOfComponentCarriers(m_noOfCcs);
602
603 rrc->ConfigureCarriers(ccMap);
604
605 if (m_useIdealRrc)
606 {
608 rrcProtocol->SetLteEnbRrcSapProvider(rrc->GetLteEnbRrcSapProvider());
609 rrc->SetLteEnbRrcSapUser(rrcProtocol->GetLteEnbRrcSapUser());
610 rrc->AggregateObject(rrcProtocol);
611 rrcProtocol->SetCellId(cellId);
612 }
613 else
614 {
616 rrcProtocol->SetLteEnbRrcSapProvider(rrc->GetLteEnbRrcSapProvider());
617 rrc->SetLteEnbRrcSapUser(rrcProtocol->GetLteEnbRrcSapUser());
618 rrc->AggregateObject(rrcProtocol);
619 rrcProtocol->SetCellId(cellId);
620 }
621
622 if (m_epcHelper)
623 {
625 rrc->GetAttribute("EpsBearerToRlcMapping", epsBearerToRlcMapping);
626 // it does not make sense to use RLC/SM when also using the EPC
627 if (epsBearerToRlcMapping.Get() == LteEnbRrc::RLC_SM_ALWAYS)
628 {
629 rrc->SetAttribute("EpsBearerToRlcMapping", EnumValue(LteEnbRrc::RLC_UM_ALWAYS));
630 }
631 }
632
633 rrc->SetLteHandoverManagementSapProvider(
634 handoverAlgorithm->GetLteHandoverManagementSapProvider());
635 handoverAlgorithm->SetLteHandoverManagementSapUser(rrc->GetLteHandoverManagementSapUser());
636
637 // This RRC attribute is used to connect each new RLC instance with the MAC layer
638 // (for function such as TransmitPdu, ReportBufferStatusReport).
639 // Since in this new architecture, the component carrier manager acts a proxy, it
640 // will have its own LteMacSapProvider interface, RLC will see it as through original MAC
641 // interface LteMacSapProvider, but the function call will go now through
642 // LteEnbComponentCarrierManager instance that needs to implement functions of this interface,
643 // and its task will be to forward these calls to the specific MAC of some of the instances of
644 // component carriers. This decision will depend on the specific implementation of the component
645 // carrier manager.
646 rrc->SetLteMacSapProvider(ccmEnbManager->GetLteMacSapProvider());
647
648 bool ccmTest;
649 for (auto it = ccMap.begin(); it != ccMap.end(); ++it)
650 {
652 ->GetPhy()
653 ->SetLteEnbCphySapUser(rrc->GetLteEnbCphySapUser(it->first));
654 rrc->SetLteEnbCphySapProvider(
655 DynamicCast<ComponentCarrierEnb>(it->second)->GetPhy()->GetLteEnbCphySapProvider(),
656 it->first);
657
658 rrc->SetLteEnbCmacSapProvider(
659 DynamicCast<ComponentCarrierEnb>(it->second)->GetMac()->GetLteEnbCmacSapProvider(),
660 it->first);
662 ->GetMac()
663 ->SetLteEnbCmacSapUser(rrc->GetLteEnbCmacSapUser(it->first));
664
665 DynamicCast<ComponentCarrierEnb>(it->second)->GetPhy()->SetComponentCarrierId(it->first);
666 DynamicCast<ComponentCarrierEnb>(it->second)->GetMac()->SetComponentCarrierId(it->first);
667 // FFR SAP
669 ->GetFfMacScheduler()
670 ->SetLteFfrSapProvider(DynamicCast<ComponentCarrierEnb>(it->second)
671 ->GetFfrAlgorithm()
672 ->GetLteFfrSapProvider());
674 ->GetFfrAlgorithm()
675 ->SetLteFfrSapUser(DynamicCast<ComponentCarrierEnb>(it->second)
676 ->GetFfMacScheduler()
677 ->GetLteFfrSapUser());
678 rrc->SetLteFfrRrcSapProvider(DynamicCast<ComponentCarrierEnb>(it->second)
679 ->GetFfrAlgorithm()
680 ->GetLteFfrRrcSapProvider(),
681 it->first);
683 ->GetFfrAlgorithm()
684 ->SetLteFfrRrcSapUser(rrc->GetLteFfrRrcSapUser(it->first));
685 // FFR SAP END
686
687 // PHY <--> MAC SAP
689 ->GetPhy()
690 ->SetLteEnbPhySapUser(
691 DynamicCast<ComponentCarrierEnb>(it->second)->GetMac()->GetLteEnbPhySapUser());
693 ->GetMac()
694 ->SetLteEnbPhySapProvider(
695 DynamicCast<ComponentCarrierEnb>(it->second)->GetPhy()->GetLteEnbPhySapProvider());
696 // PHY <--> MAC SAP END
697
698 // Scheduler SAP
700 ->GetMac()
701 ->SetFfMacSchedSapProvider(DynamicCast<ComponentCarrierEnb>(it->second)
702 ->GetFfMacScheduler()
703 ->GetFfMacSchedSapProvider());
705 ->GetMac()
706 ->SetFfMacCschedSapProvider(DynamicCast<ComponentCarrierEnb>(it->second)
707 ->GetFfMacScheduler()
708 ->GetFfMacCschedSapProvider());
709
711 ->GetFfMacScheduler()
712 ->SetFfMacSchedSapUser(
713 DynamicCast<ComponentCarrierEnb>(it->second)->GetMac()->GetFfMacSchedSapUser());
715 ->GetFfMacScheduler()
716 ->SetFfMacCschedSapUser(
717 DynamicCast<ComponentCarrierEnb>(it->second)->GetMac()->GetFfMacCschedSapUser());
718 // Scheduler SAP END
719
721 ->GetMac()
722 ->SetLteCcmMacSapUser(ccmEnbManager->GetLteCcmMacSapUser());
723 ccmEnbManager->SetCcmMacSapProviders(
724 it->first,
725 DynamicCast<ComponentCarrierEnb>(it->second)->GetMac()->GetLteCcmMacSapProvider());
726
727 // insert the pointer to the LteMacSapProvider interface of the MAC layer of the specific
728 // component carrier
729 ccmTest = ccmEnbManager->SetMacSapProvider(
730 it->first,
731 DynamicCast<ComponentCarrierEnb>(it->second)->GetMac()->GetLteMacSapProvider());
732
733 if (!ccmTest)
734 {
735 NS_FATAL_ERROR("Error in SetComponentCarrierMacSapProviders");
736 }
737 }
738
739 dev->SetNode(n);
740 dev->SetAttribute("CellId", UintegerValue(cellId));
741 dev->SetAttribute("LteEnbComponentCarrierManager", PointerValue(ccmEnbManager));
742 dev->SetCcMap(ccMap);
743 auto it = ccMap.begin();
744 dev->SetAttribute("LteEnbRrc", PointerValue(rrc));
745 dev->SetAttribute("LteHandoverAlgorithm", PointerValue(handoverAlgorithm));
746 dev->SetAttribute(
747 "LteFfrAlgorithm",
748 PointerValue(DynamicCast<ComponentCarrierEnb>(it->second)->GetFfrAlgorithm()));
749
750 if (m_isAnrEnabled)
751 {
752 Ptr<LteAnr> anr = CreateObject<LteAnr>(cellId);
753 rrc->SetLteAnrSapProvider(anr->GetLteAnrSapProvider());
754 anr->SetLteAnrSapUser(rrc->GetLteAnrSapUser());
755 dev->SetAttribute("LteAnr", PointerValue(anr));
756 }
757
758 for (it = ccMap.begin(); it != ccMap.end(); ++it)
759 {
760 Ptr<LteEnbPhy> ccPhy = DynamicCast<ComponentCarrierEnb>(it->second)->GetPhy();
761 ccPhy->SetDevice(dev);
762 ccPhy->GetUlSpectrumPhy()->SetDevice(dev);
763 ccPhy->GetDlSpectrumPhy()->SetDevice(dev);
764 ccPhy->GetUlSpectrumPhy()->SetLtePhyRxDataEndOkCallback(
766 ccPhy->GetUlSpectrumPhy()->SetLtePhyRxCtrlEndOkCallback(
768 ccPhy->GetUlSpectrumPhy()->SetLtePhyUlHarqFeedbackCallback(
770 NS_LOG_LOGIC("set the propagation model frequencies");
771 double dlFreq = LteSpectrumValueHelper::GetCarrierFrequency(it->second->GetDlEarfcn());
772 NS_LOG_LOGIC("DL freq: " << dlFreq);
773 bool dlFreqOk =
775 if (!dlFreqOk)
776 {
777 NS_LOG_WARN("DL propagation model does not have a Frequency attribute");
778 }
779
780 double ulFreq = LteSpectrumValueHelper::GetCarrierFrequency(it->second->GetUlEarfcn());
781
782 NS_LOG_LOGIC("UL freq: " << ulFreq);
783 bool ulFreqOk =
785 if (!ulFreqOk)
786 {
787 NS_LOG_WARN("UL propagation model does not have a Frequency attribute");
788 }
789 } // end for
790 rrc->SetForwardUpCallback(MakeCallback(&LteEnbNetDevice::Receive, dev));
791 dev->Initialize();
792 n->AddDevice(dev);
793
794 for (it = ccMap.begin(); it != ccMap.end(); ++it)
795 {
796 m_uplinkChannel->AddRx(
797 DynamicCast<ComponentCarrierEnb>(it->second)->GetPhy()->GetUlSpectrumPhy());
798 }
799
800 if (m_epcHelper)
801 {
802 NS_LOG_INFO("adding this eNB to the EPC");
803 m_epcHelper->AddEnb(n, dev, dev->GetCellIds());
804 Ptr<EpcEnbApplication> enbApp = n->GetApplication(0)->GetObject<EpcEnbApplication>();
805 NS_ASSERT_MSG(enbApp, "cannot retrieve EpcEnbApplication");
806
807 // S1 SAPs
808 rrc->SetS1SapProvider(enbApp->GetS1SapProvider());
809 enbApp->SetS1SapUser(rrc->GetS1SapUser());
810
811 // X2 SAPs
812 Ptr<EpcX2> x2 = n->GetObject<EpcX2>();
813 x2->SetEpcX2SapUser(rrc->GetEpcX2SapUser());
814 rrc->SetEpcX2SapProvider(x2->GetEpcX2SapProvider());
815 }
816
817 return dev;
818}
819
822{
823 NS_LOG_FUNCTION(this);
824
826
827 // Initialize the component carriers with default values in order to initialize MACs and PHYs
828 // of each component carrier. These values must be updated once the UE is attached to the
829 // eNB and receives RRC Connection Reconfiguration message. In case of primary carrier or
830 // a single carrier, these values will be updated once the UE will receive SIB2 and MIB.
831 NS_ABORT_MSG_IF(!m_componentCarrierPhyParams.empty(), "CC map is not clean");
832 DoComponentCarrierConfigure(dev->GetDlEarfcn() + 18000, dev->GetDlEarfcn(), 25, 25);
834 "CC map size (" << m_componentCarrierPhyParams.size()
835 << ") must be equal to number of carriers (" << m_noOfCcs
836 << ")");
837 std::map<uint8_t, Ptr<ComponentCarrierUe>> ueCcMap;
838
839 for (auto it = m_componentCarrierPhyParams.begin(); it != m_componentCarrierPhyParams.end();
840 ++it)
841 {
843 cc->SetUlBandwidth(it->second.GetUlBandwidth());
844 cc->SetDlBandwidth(it->second.GetDlBandwidth());
845 cc->SetDlEarfcn(it->second.GetDlEarfcn());
846 cc->SetUlEarfcn(it->second.GetUlEarfcn());
847 cc->SetAsPrimary(it->second.IsPrimary());
849 cc->SetMac(mac);
850 // cc->GetPhy ()->Initialize (); // it is initialized within the
851 // LteUeNetDevice::DoInitialize ()
852 ueCcMap.insert(std::pair<uint8_t, Ptr<ComponentCarrierUe>>(it->first, cc));
853 }
854 // CC map is not needed anymore
856
857 for (auto it = ueCcMap.begin(); it != ueCcMap.end(); ++it)
858 {
861
862 Ptr<LteUePhy> phy = CreateObject<LteUePhy>(dlPhy, ulPhy);
863
865 dlPhy->SetHarqPhyModule(harq);
866 ulPhy->SetHarqPhyModule(harq);
867 phy->SetHarqPhyModule(harq);
868
870 pRs->AddCallback(MakeCallback(&LteUePhy::ReportRsReceivedPower, phy));
871 dlPhy->AddRsPowerChunkProcessor(pRs);
872
874 pInterf->AddCallback(MakeCallback(&LteUePhy::ReportInterference, phy));
875 dlPhy->AddInterferenceCtrlChunkProcessor(pInterf); // for RSRQ evaluation of UE Measurements
876
878 pCtrl->AddCallback(MakeCallback(&LteSpectrumPhy::UpdateSinrPerceived, dlPhy));
879 dlPhy->AddCtrlSinrChunkProcessor(pCtrl);
880
882 pData->AddCallback(MakeCallback(&LteSpectrumPhy::UpdateSinrPerceived, dlPhy));
883 dlPhy->AddDataSinrChunkProcessor(pData);
884
886 {
887 // CQI calculation based on PDCCH for signal and PDSCH for interference
888 // NOTE: Change in pCtrl chunk processor could impact the RLF detection
889 // since it is based on CTRL SINR.
890 pCtrl->AddCallback(MakeCallback(&LteUePhy::GenerateMixedCqiReport, phy));
892 pDataInterf->AddCallback(MakeCallback(&LteUePhy::ReportDataInterference, phy));
893 dlPhy->AddInterferenceDataChunkProcessor(pDataInterf);
894 }
895 else
896 {
897 // CQI calculation based on PDCCH for both signal and interference
898 pCtrl->AddCallback(MakeCallback(&LteUePhy::GenerateCtrlCqiReport, phy));
899 }
900
901 dlPhy->SetChannel(m_downlinkChannel);
902 ulPhy->SetChannel(m_uplinkChannel);
903
904 Ptr<MobilityModel> mm = n->GetObject<MobilityModel>();
906 mm,
907 "MobilityModel needs to be set on node before calling LteHelper::InstallUeDevice ()");
908 dlPhy->SetMobility(mm);
909 ulPhy->SetMobility(mm);
910
912 NS_ASSERT_MSG(antenna, "error in creating the AntennaModel object");
913 dlPhy->SetAntenna(antenna);
914 ulPhy->SetAntenna(antenna);
915
916 it->second->SetPhy(phy);
917 }
920
922 rrc->SetLteMacSapProvider(ccmUe->GetLteMacSapProvider());
923 // setting ComponentCarrierManager SAP
924 rrc->SetLteCcmRrcSapProvider(ccmUe->GetLteCcmRrcSapProvider());
925 ccmUe->SetLteCcmRrcSapUser(rrc->GetLteCcmRrcSapUser());
926 // Set number of component carriers. Note: UE CCM would also set the
927 // number of component carriers in UE RRC
928 ccmUe->SetNumberOfComponentCarriers(m_noOfCcs);
929
930 // run initializeSap to create the proper number of MAC and PHY control sap provider/users
931 rrc->InitializeSap();
932
933 if (m_useIdealRrc)
934 {
936 rrcProtocol->SetUeRrc(rrc);
937 rrc->AggregateObject(rrcProtocol);
938 rrcProtocol->SetLteUeRrcSapProvider(rrc->GetLteUeRrcSapProvider());
939 rrc->SetLteUeRrcSapUser(rrcProtocol->GetLteUeRrcSapUser());
940 }
941 else
942 {
944 rrcProtocol->SetUeRrc(rrc);
945 rrc->AggregateObject(rrcProtocol);
946 rrcProtocol->SetLteUeRrcSapProvider(rrc->GetLteUeRrcSapProvider());
947 rrc->SetLteUeRrcSapUser(rrcProtocol->GetLteUeRrcSapUser());
948 }
949
950 if (m_epcHelper)
951 {
952 rrc->SetUseRlcSm(false);
953 }
955
956 nas->SetAsSapProvider(rrc->GetAsSapProvider());
957 rrc->SetAsSapUser(nas->GetAsSapUser());
958
959 for (auto it = ueCcMap.begin(); it != ueCcMap.end(); ++it)
960 {
961 rrc->SetLteUeCmacSapProvider(it->second->GetMac()->GetLteUeCmacSapProvider(), it->first);
962 it->second->GetMac()->SetLteUeCmacSapUser(rrc->GetLteUeCmacSapUser(it->first));
963 it->second->GetMac()->SetComponentCarrierId(it->first);
964
965 it->second->GetPhy()->SetLteUeCphySapUser(rrc->GetLteUeCphySapUser(it->first));
966 rrc->SetLteUeCphySapProvider(it->second->GetPhy()->GetLteUeCphySapProvider(), it->first);
967 it->second->GetPhy()->SetComponentCarrierId(it->first);
968 it->second->GetPhy()->SetLteUePhySapUser(it->second->GetMac()->GetLteUePhySapUser());
969 it->second->GetMac()->SetLteUePhySapProvider(
970 it->second->GetPhy()->GetLteUePhySapProvider());
971
972 bool ccmTest =
973 ccmUe->SetComponentCarrierMacSapProviders(it->first,
974 it->second->GetMac()->GetLteMacSapProvider());
975
976 if (!ccmTest)
977 {
978 NS_FATAL_ERROR("Error in SetComponentCarrierMacSapProviders");
979 }
980 }
981
982 NS_ABORT_MSG_IF(m_imsiCounter >= 0xFFFFFFFF, "max num UEs exceeded");
983 uint64_t imsi = ++m_imsiCounter;
984
985 dev->SetNode(n);
986 dev->SetAttribute("Imsi", UintegerValue(imsi));
987 dev->SetCcMap(ueCcMap);
988 dev->SetAttribute("LteUeRrc", PointerValue(rrc));
989 dev->SetAttribute("EpcUeNas", PointerValue(nas));
990 dev->SetAttribute("LteUeComponentCarrierManager", PointerValue(ccmUe));
991 // \todo The UE identifier should be dynamically set by the EPC
992 // when the default PDP context is created. This is a simplification.
993 dev->SetAddress(Mac64Address::Allocate());
994
995 for (auto it = ueCcMap.begin(); it != ueCcMap.end(); ++it)
996 {
997 Ptr<LteUePhy> ccPhy = it->second->GetPhy();
998 ccPhy->SetDevice(dev);
999 ccPhy->GetUlSpectrumPhy()->SetDevice(dev);
1000 ccPhy->GetDlSpectrumPhy()->SetDevice(dev);
1001 ccPhy->GetDlSpectrumPhy()->SetLtePhyRxDataEndOkCallback(
1003 ccPhy->GetDlSpectrumPhy()->SetLtePhyRxCtrlEndOkCallback(
1005 ccPhy->GetDlSpectrumPhy()->SetLtePhyRxPssCallback(
1007 ccPhy->GetDlSpectrumPhy()->SetLtePhyDlHarqFeedbackCallback(
1009 }
1010
1011 nas->SetDevice(dev);
1012
1013 n->AddDevice(dev);
1014
1015 nas->SetForwardUpCallback(MakeCallback(&LteUeNetDevice::Receive, dev));
1016
1017 if (m_epcHelper)
1018 {
1019 m_epcHelper->AddUe(dev, dev->GetImsi());
1020 }
1021
1022 dev->Initialize();
1023
1024 return dev;
1025}
1026
1027void
1029{
1030 NS_LOG_FUNCTION(this);
1031 for (auto i = ueDevices.Begin(); i != ueDevices.End(); ++i)
1032 {
1033 Attach(*i);
1034 }
1035}
1036
1037void
1039{
1040 NS_LOG_FUNCTION(this);
1041
1042 if (!m_epcHelper)
1043 {
1044 NS_FATAL_ERROR("This function is not valid without properly configured EPC");
1045 }
1046
1047 Ptr<LteUeNetDevice> ueLteDevice = ueDevice->GetObject<LteUeNetDevice>();
1048 if (!ueLteDevice)
1049 {
1050 NS_FATAL_ERROR("The passed NetDevice must be an LteUeNetDevice");
1051 }
1052
1053 // initiate cell selection
1054 Ptr<EpcUeNas> ueNas = ueLteDevice->GetNas();
1055 NS_ASSERT(ueNas);
1056 uint32_t dlEarfcn = ueLteDevice->GetDlEarfcn();
1057 ueNas->StartCellSelection(dlEarfcn);
1058
1059 // instruct UE to immediately enter CONNECTED mode after camping
1060 ueNas->Connect();
1061
1062 // activate default EPS bearer
1063 m_epcHelper->ActivateEpsBearer(ueDevice,
1064 ueLteDevice->GetImsi(),
1067}
1068
1069void
1071{
1072 NS_LOG_FUNCTION(this);
1073 for (auto i = ueDevices.Begin(); i != ueDevices.End(); ++i)
1074 {
1075 Attach(*i, enbDevice);
1076 }
1077}
1078
1079void
1080LteHelper::Attach(Ptr<NetDevice> ueDevice, Ptr<NetDevice> enbDevice, uint8_t componentCarrierId)
1081{
1082 NS_LOG_FUNCTION(this);
1083 // enbRrc->SetCellId (enbDevice->GetObject<LteEnbNetDevice> ()->GetCellId ());
1084
1085 Ptr<LteUeNetDevice> ueLteDevice = ueDevice->GetObject<LteUeNetDevice>();
1086 Ptr<LteEnbNetDevice> enbLteDevice = enbDevice->GetObject<LteEnbNetDevice>();
1087
1088 Ptr<EpcUeNas> ueNas = ueLteDevice->GetNas();
1089 Ptr<ComponentCarrierEnb> componentCarrier =
1090 DynamicCast<ComponentCarrierEnb>(enbLteDevice->GetCcMap().at(componentCarrierId));
1091 ueNas->Connect(componentCarrier->GetCellId(), componentCarrier->GetDlEarfcn());
1092
1093 if (m_epcHelper)
1094 {
1095 // activate default EPS bearer
1096 m_epcHelper->ActivateEpsBearer(ueDevice,
1097 ueLteDevice->GetImsi(),
1100 }
1101
1102 // tricks needed for the simplified LTE-only simulations
1103 if (!m_epcHelper)
1104 {
1105 ueDevice->GetObject<LteUeNetDevice>()->SetTargetEnb(
1106 enbDevice->GetObject<LteEnbNetDevice>());
1107 }
1108}
1109
1110void
1112{
1113 NS_LOG_FUNCTION(this);
1114 for (auto i = ueDevices.Begin(); i != ueDevices.End(); ++i)
1115 {
1116 AttachToClosestEnb(*i, enbDevices);
1117 }
1118}
1119
1120void
1122{
1123 NS_LOG_FUNCTION(this);
1124 NS_ASSERT_MSG(enbDevices.GetN() > 0, "empty enb device container");
1125 Vector uepos = ueDevice->GetNode()->GetObject<MobilityModel>()->GetPosition();
1126 double minDistance = std::numeric_limits<double>::infinity();
1127 Ptr<NetDevice> closestEnbDevice;
1128 for (auto i = enbDevices.Begin(); i != enbDevices.End(); ++i)
1129 {
1130 Vector enbpos = (*i)->GetNode()->GetObject<MobilityModel>()->GetPosition();
1131 double distance = CalculateDistance(uepos, enbpos);
1132 if (distance < minDistance)
1133 {
1134 minDistance = distance;
1135 closestEnbDevice = *i;
1136 }
1137 }
1138 NS_ASSERT(closestEnbDevice);
1139 Attach(ueDevice, closestEnbDevice);
1140}
1141
1142uint8_t
1144 EpsBearer bearer,
1145 Ptr<EpcTft> tft)
1146{
1147 NS_LOG_FUNCTION(this);
1148 for (auto i = ueDevices.Begin(); i != ueDevices.End(); ++i)
1149 {
1150 uint8_t bearerId = ActivateDedicatedEpsBearer(*i, bearer, tft);
1151 return bearerId;
1152 }
1153 return 0;
1154}
1155
1156uint8_t
1158{
1159 NS_LOG_FUNCTION(this);
1160
1161 NS_ASSERT_MSG(m_epcHelper, "dedicated EPS bearers cannot be set up when the EPC is not used");
1162
1163 uint64_t imsi = ueDevice->GetObject<LteUeNetDevice>()->GetImsi();
1164 uint8_t bearerId = m_epcHelper->ActivateEpsBearer(ueDevice, imsi, tft, bearer);
1165 return bearerId;
1166}
1167
1168/**
1169 * \ingroup lte
1170 *
1171 * DrbActivatior allows user to activate bearers for UEs
1172 * when EPC is not used. Activation function is hooked to
1173 * the Enb RRC Connection Established trace source. When
1174 * UE change its RRC state to CONNECTED_NORMALLY, activation
1175 * function is called and bearer is activated.
1176 */
1177class DrbActivator : public SimpleRefCount<DrbActivator>
1178{
1179 public:
1180 /**
1181 * DrbActivator Constructor
1182 *
1183 * \param ueDevice the UeNetDevice for which bearer will be activated
1184 * \param bearer the bearer configuration
1185 */
1186 DrbActivator(Ptr<NetDevice> ueDevice, EpsBearer bearer);
1187
1188 /**
1189 * Function hooked to the Enb RRC Connection Established trace source
1190 * Fired upon successful RRC connection establishment.
1191 *
1192 * \param a DrbActivator object
1193 * \param context
1194 * \param imsi
1195 * \param cellId
1196 * \param rnti
1197 */
1198 static void ActivateCallback(Ptr<DrbActivator> a,
1199 std::string context,
1200 uint64_t imsi,
1201 uint16_t cellId,
1202 uint16_t rnti);
1203
1204 /**
1205 * Procedure firstly checks if bearer was not activated, if IMSI
1206 * from trace source equals configured one and if UE is really
1207 * in RRC connected state. If all requirements are met, it performs
1208 * bearer activation.
1209 *
1210 * \param imsi
1211 * \param cellId
1212 * \param rnti
1213 */
1214 void ActivateDrb(uint64_t imsi, uint16_t cellId, uint16_t rnti);
1215
1216 private:
1217 /**
1218 * Bearer can be activated only once. This value stores state of
1219 * bearer. Initially is set to false and changed to true during
1220 * bearer activation.
1221 */
1223 /**
1224 * UeNetDevice for which bearer will be activated
1225 */
1227 /**
1228 * Configuration of bearer which will be activated
1229 */
1231 /**
1232 * imsi the unique UE identifier
1233 */
1234 uint64_t m_imsi;
1235};
1236
1238 : m_active(false),
1239 m_ueDevice(ueDevice),
1240 m_bearer(bearer),
1241 m_imsi(m_ueDevice->GetObject<LteUeNetDevice>()->GetImsi())
1242{
1243}
1244
1245void
1247 std::string context,
1248 uint64_t imsi,
1249 uint16_t cellId,
1250 uint16_t rnti)
1251{
1252 NS_LOG_FUNCTION(a << context << imsi << cellId << rnti);
1253 a->ActivateDrb(imsi, cellId, rnti);
1254}
1255
1256void
1257DrbActivator::ActivateDrb(uint64_t imsi, uint16_t cellId, uint16_t rnti)
1258{
1259 NS_LOG_FUNCTION(this << imsi << cellId << rnti << m_active);
1260 if ((!m_active) && (imsi == m_imsi))
1261 {
1262 Ptr<LteUeRrc> ueRrc = m_ueDevice->GetObject<LteUeNetDevice>()->GetRrc();
1263 NS_ASSERT(ueRrc->GetState() == LteUeRrc::CONNECTED_NORMALLY);
1264 uint16_t rnti = ueRrc->GetRnti();
1265 Ptr<LteEnbNetDevice> enbLteDevice = m_ueDevice->GetObject<LteUeNetDevice>()->GetTargetEnb();
1266 Ptr<LteEnbRrc> enbRrc = enbLteDevice->GetObject<LteEnbNetDevice>()->GetRrc();
1267 NS_ASSERT(ueRrc->GetCellId() == enbLteDevice->GetCellId());
1268 Ptr<UeManager> ueManager = enbRrc->GetUeManager(rnti);
1269 NS_ASSERT(ueManager->GetState() == UeManager::CONNECTED_NORMALLY ||
1270 ueManager->GetState() == UeManager::CONNECTION_RECONFIGURATION);
1272 params.rnti = rnti;
1273 params.bearer = m_bearer;
1274 params.bearerId = 0;
1275 params.gtpTeid = 0; // don't care
1276 enbRrc->GetS1SapUser()->DataRadioBearerSetupRequest(params);
1277 m_active = true;
1278 }
1279}
1280
1281void
1283{
1284 NS_LOG_FUNCTION(this << ueDevice);
1285 NS_ASSERT_MSG(!m_epcHelper, "this method must not be used when the EPC is being used");
1286
1287 // Normally it is the EPC that takes care of activating DRBs
1288 // when the UE gets connected. When the EPC is not used, we achieve
1289 // the same behavior by hooking a dedicated DRB activation function
1290 // to the Enb RRC Connection Established trace source
1291
1292 Ptr<LteEnbNetDevice> enbLteDevice = ueDevice->GetObject<LteUeNetDevice>()->GetTargetEnb();
1293
1294 std::ostringstream path;
1295 path << "/NodeList/" << enbLteDevice->GetNode()->GetId() << "/DeviceList/"
1296 << enbLteDevice->GetIfIndex() << "/LteEnbRrc/ConnectionEstablished";
1297 Ptr<DrbActivator> arg = Create<DrbActivator>(ueDevice, bearer);
1299}
1300
1301void
1303{
1304 NS_LOG_FUNCTION(this);
1305
1306 NS_ASSERT_MSG(m_epcHelper, "X2 interfaces cannot be set up when the EPC is not used");
1307
1308 for (auto i = enbNodes.Begin(); i != enbNodes.End(); ++i)
1309 {
1310 for (auto j = i + 1; j != enbNodes.End(); ++j)
1311 {
1312 AddX2Interface(*i, *j);
1313 }
1314 }
1315}
1316
1317void
1319{
1320 NS_LOG_FUNCTION(this);
1321 NS_LOG_INFO("setting up the X2 interface");
1322
1323 m_epcHelper->AddX2Interface(enbNode1, enbNode2);
1324}
1325
1326void
1328 Ptr<NetDevice> ueDev,
1329 Ptr<NetDevice> sourceEnbDev,
1330 Ptr<NetDevice> targetEnbDev)
1331{
1332 NS_LOG_FUNCTION(this << ueDev << sourceEnbDev << targetEnbDev);
1334 "Handover requires the use of the EPC - did you forget to call "
1335 "LteHelper::SetEpcHelper () ?");
1336 uint16_t targetCellId = targetEnbDev->GetObject<LteEnbNetDevice>()->GetCellId();
1337 Simulator::Schedule(hoTime,
1339 this,
1340 ueDev,
1341 sourceEnbDev,
1342 targetCellId);
1343}
1344
1345void
1347 Ptr<NetDevice> ueDev,
1348 Ptr<NetDevice> sourceEnbDev,
1349 uint16_t targetCellId)
1350{
1351 NS_LOG_FUNCTION(this << ueDev << sourceEnbDev << targetCellId);
1353 "Handover requires the use of the EPC - did you forget to call "
1354 "LteHelper::SetEpcHelper () ?");
1355 Simulator::Schedule(hoTime,
1357 this,
1358 ueDev,
1359 sourceEnbDev,
1360 targetCellId);
1361}
1362
1363void
1365 Ptr<NetDevice> sourceEnbDev,
1366 uint16_t targetCellId)
1367{
1368 NS_LOG_FUNCTION(this << ueDev << sourceEnbDev << targetCellId);
1369
1370 Ptr<LteEnbRrc> sourceRrc = sourceEnbDev->GetObject<LteEnbNetDevice>()->GetRrc();
1371 uint16_t rnti = ueDev->GetObject<LteUeNetDevice>()->GetRrc()->GetRnti();
1372 sourceRrc->SendHandoverRequest(rnti, targetCellId);
1373}
1374
1375void
1377 Ptr<NetDevice> enbDevice,
1378 uint8_t bearerId)
1379{
1380 NS_LOG_FUNCTION(this << ueDevice << bearerId);
1382 "Dedicated EPS bearers cannot be de-activated when the EPC is not used");
1383 NS_ASSERT_MSG(bearerId != 1,
1384 "Default bearer cannot be de-activated until and unless and UE is released");
1385
1386 DoDeActivateDedicatedEpsBearer(ueDevice, enbDevice, bearerId);
1387}
1388
1389void
1391 Ptr<NetDevice> enbDevice,
1392 uint8_t bearerId)
1393{
1394 NS_LOG_FUNCTION(this << ueDevice << bearerId);
1395
1396 // Extract IMSI and rnti
1397 uint64_t imsi = ueDevice->GetObject<LteUeNetDevice>()->GetImsi();
1398 uint16_t rnti = ueDevice->GetObject<LteUeNetDevice>()->GetRrc()->GetRnti();
1399
1400 Ptr<LteEnbRrc> enbRrc = enbDevice->GetObject<LteEnbNetDevice>()->GetRrc();
1401
1402 enbRrc->DoSendReleaseDataRadioBearer(imsi, rnti, bearerId);
1403}
1404
1405void
1407 uint32_t dlEarfcn,
1408 uint16_t ulbw,
1409 uint16_t dlbw)
1410{
1411 NS_LOG_FUNCTION(this << ulEarfcn << dlEarfcn << ulbw << dlbw);
1412
1413 NS_ABORT_MSG_IF(!m_componentCarrierPhyParams.empty(), "CC map is not clean");
1415 ccHelper->SetNumberOfComponentCarriers(m_noOfCcs);
1416 ccHelper->SetUlEarfcn(ulEarfcn);
1417 ccHelper->SetDlEarfcn(dlEarfcn);
1418 ccHelper->SetDlBandwidth(dlbw);
1419 ccHelper->SetUlBandwidth(ulbw);
1420 m_componentCarrierPhyParams = ccHelper->EquallySpacedCcs();
1421 m_componentCarrierPhyParams.at(0).SetAsPrimary(true);
1422}
1423
1424void
1426{
1427 NS_LOG_FUNCTION(this);
1428 for (auto i = ueDevices.Begin(); i != ueDevices.End(); ++i)
1429 {
1430 ActivateDataRadioBearer(*i, bearer);
1431 }
1432}
1433
1434void
1436{
1440 // Model directory
1441 LogComponentEnable("A2A4RsrqHandoverAlgorithm", LOG_LEVEL_ALL);
1442 LogComponentEnable("A3RsrpHandoverAlgorithm", LOG_LEVEL_ALL);
1443 LogComponentEnable("Asn1Header", LOG_LEVEL_ALL);
1444 LogComponentEnable("ComponentCarrier", LOG_LEVEL_ALL);
1445 LogComponentEnable("ComponentCarrierEnb", LOG_LEVEL_ALL);
1446 LogComponentEnable("ComponentCarrierUe", LOG_LEVEL_ALL);
1447 LogComponentEnable("CqaFfMacScheduler", LOG_LEVEL_ALL);
1448 LogComponentEnable("EpcEnbApplication", LOG_LEVEL_ALL);
1449 LogComponentEnable("EpcMmeApplication", LOG_LEVEL_ALL);
1450 LogComponentEnable("EpcPgwApplication", LOG_LEVEL_ALL);
1451 LogComponentEnable("EpcSgwApplication", LOG_LEVEL_ALL);
1453 LogComponentEnable("EpcTftClassifier", LOG_LEVEL_ALL);
1454 LogComponentEnable("EpcUeNas", LOG_LEVEL_ALL);
1456 LogComponentEnable("EpcX2Header", LOG_LEVEL_ALL);
1457 LogComponentEnable("FdBetFfMacScheduler", LOG_LEVEL_ALL);
1458 LogComponentEnable("FdMtFfMacScheduler", LOG_LEVEL_ALL);
1459 LogComponentEnable("FdTbfqFfMacScheduler", LOG_LEVEL_ALL);
1460 LogComponentEnable("FfMacScheduler", LOG_LEVEL_ALL);
1461 LogComponentEnable("GtpuHeader", LOG_LEVEL_ALL);
1464 LogComponentEnable("LteChunkProcessor", LOG_LEVEL_ALL);
1465 LogComponentEnable("LteCommon", LOG_LEVEL_ALL);
1466 LogComponentEnable("LteControlMessage", LOG_LEVEL_ALL);
1467 LogComponentEnable("LteEnbComponentCarrierManager", LOG_LEVEL_ALL);
1468 LogComponentEnable("LteEnbMac", LOG_LEVEL_ALL);
1469 LogComponentEnable("LteEnbNetDevice", LOG_LEVEL_ALL);
1470 LogComponentEnable("LteEnbPhy", LOG_LEVEL_ALL);
1471 LogComponentEnable("LteEnbRrc", LOG_LEVEL_ALL);
1472 LogComponentEnable("LteFfrAlgorithm", LOG_LEVEL_ALL);
1473 LogComponentEnable("LteFfrDistributedAlgorithm", LOG_LEVEL_ALL);
1474 LogComponentEnable("LteFfrEnhancedAlgorithm", LOG_LEVEL_ALL);
1475 LogComponentEnable("LteFfrSoftAlgorithm", LOG_LEVEL_ALL);
1476 LogComponentEnable("LteFrHardAlgorithm", LOG_LEVEL_ALL);
1477 LogComponentEnable("LteFrNoOpAlgorithm", LOG_LEVEL_ALL);
1478 LogComponentEnable("LteFrSoftAlgorithm", LOG_LEVEL_ALL);
1479 LogComponentEnable("LteFrStrictAlgorithm", LOG_LEVEL_ALL);
1480 LogComponentEnable("LteHandoverAlgorithm", LOG_LEVEL_ALL);
1481 LogComponentEnable("LteHarqPhy", LOG_LEVEL_ALL);
1482 LogComponentEnable("LteInterference", LOG_LEVEL_ALL);
1483 LogComponentEnable("LteMiErrorModel", LOG_LEVEL_ALL);
1484 LogComponentEnable("LteNetDevice", LOG_LEVEL_ALL);
1486 LogComponentEnable("LtePdcpHeader", LOG_LEVEL_ALL);
1489 LogComponentEnable("LteRlcAm", LOG_LEVEL_ALL);
1490 LogComponentEnable("LteRlcAmHeader", LOG_LEVEL_ALL);
1491 LogComponentEnable("LteRlcHeader", LOG_LEVEL_ALL);
1492 LogComponentEnable("LteRlcTm", LOG_LEVEL_ALL);
1493 LogComponentEnable("LteRlcUm", LOG_LEVEL_ALL);
1494 LogComponentEnable("LteRrcProtocolIdeal", LOG_LEVEL_ALL);
1495 LogComponentEnable("LteRrcProtocolReal", LOG_LEVEL_ALL);
1496 LogComponentEnable("LteSpectrumPhy", LOG_LEVEL_ALL);
1497 LogComponentEnable("LteSpectrumSignalParameters", LOG_LEVEL_ALL);
1498 LogComponentEnable("LteSpectrumValueHelper", LOG_LEVEL_ALL);
1499 LogComponentEnable("LteUeComponentCarrierManager", LOG_LEVEL_ALL);
1500 LogComponentEnable("LteUeMac", LOG_LEVEL_ALL);
1501 LogComponentEnable("LteUeNetDevice", LOG_LEVEL_ALL);
1502 LogComponentEnable("LteUePhy", LOG_LEVEL_ALL);
1503 LogComponentEnable("LteUePowerControl", LOG_LEVEL_ALL);
1504 LogComponentEnable("LteUeRrc", LOG_LEVEL_ALL);
1505 LogComponentEnable("LteVendorSpecificParameters", LOG_LEVEL_ALL);
1506 LogComponentEnable("NoOpComponentCarrierManager", LOG_LEVEL_ALL);
1507 LogComponentEnable("NoOpHandoverAlgorithm", LOG_LEVEL_ALL);
1508 LogComponentEnable("PfFfMacScheduler", LOG_LEVEL_ALL);
1509 LogComponentEnable("PssFfMacScheduler", LOG_LEVEL_ALL);
1510 LogComponentEnable("RemSpectrumPhy", LOG_LEVEL_ALL);
1511 LogComponentEnable("RrcHeader", LOG_LEVEL_ALL);
1512 LogComponentEnable("RrFfMacScheduler", LOG_LEVEL_ALL);
1513 LogComponentEnable("SimpleUeComponentCarrierManager", LOG_LEVEL_ALL);
1514 LogComponentEnable("TdBetFfMacScheduler", LOG_LEVEL_ALL);
1515 LogComponentEnable("TdMtFfMacScheduler", LOG_LEVEL_ALL);
1516 LogComponentEnable("TdTbfqFfMacScheduler", LOG_LEVEL_ALL);
1517 LogComponentEnable("TraceFadingLossModel", LOG_LEVEL_ALL);
1518 LogComponentEnable("TtaFfMacScheduler", LOG_LEVEL_ALL);
1519 // Helper directory
1520 LogComponentEnable("CcHelper", LOG_LEVEL_ALL);
1521 LogComponentEnable("EmuEpcHelper", LOG_LEVEL_ALL);
1522 LogComponentEnable("EpcHelper", LOG_LEVEL_ALL);
1523 LogComponentEnable("LteGlobalPathlossDatabase", LOG_LEVEL_ALL);
1524 LogComponentEnable("LteHelper", LOG_LEVEL_ALL);
1525 LogComponentEnable("LteHexGridEnbTopologyHelper", LOG_LEVEL_ALL);
1526 LogComponentEnable("LteStatsCalculator", LOG_LEVEL_ALL);
1527 LogComponentEnable("MacStatsCalculator", LOG_LEVEL_ALL);
1528 LogComponentEnable("PhyRxStatsCalculator", LOG_LEVEL_ALL);
1529 LogComponentEnable("PhyStatsCalculator", LOG_LEVEL_ALL);
1530 LogComponentEnable("PhyTxStatsCalculator", LOG_LEVEL_ALL);
1531 LogComponentEnable("PointToPointEpcHelper", LOG_LEVEL_ALL);
1532 LogComponentEnable("RadioBearerStatsCalculator", LOG_LEVEL_ALL);
1533 LogComponentEnable("RadioBearerStatsConnector", LOG_LEVEL_ALL);
1534 LogComponentEnable("RadioEnvironmentMapHelper", LOG_LEVEL_ALL);
1535}
1536
1537void
1545
1546void
1548{
1550 "please make sure that LteHelper::EnableRlcTraces is called at most once");
1553}
1554
1555int64_t
1557{
1558 int64_t currentStream = stream;
1560 {
1562 if (tflm)
1563 {
1564 currentStream += tflm->AssignStreams(currentStream);
1566 }
1567 }
1568 Ptr<NetDevice> netDevice;
1569 for (auto i = c.Begin(); i != c.End(); ++i)
1570 {
1571 netDevice = (*i);
1573 if (lteEnb)
1574 {
1575 std::map<uint8_t, Ptr<ComponentCarrierBaseStation>> tmpMap = lteEnb->GetCcMap();
1576 auto it = tmpMap.begin();
1577 Ptr<LteSpectrumPhy> dlPhy =
1578 DynamicCast<ComponentCarrierEnb>(it->second)->GetPhy()->GetDownlinkSpectrumPhy();
1579 Ptr<LteSpectrumPhy> ulPhy =
1580 DynamicCast<ComponentCarrierEnb>(it->second)->GetPhy()->GetUplinkSpectrumPhy();
1581 currentStream += dlPhy->AssignStreams(currentStream);
1582 currentStream += ulPhy->AssignStreams(currentStream);
1583 }
1585 if (lteUe)
1586 {
1587 std::map<uint8_t, Ptr<ComponentCarrierUe>> tmpMap = lteUe->GetCcMap();
1588 auto it = tmpMap.begin();
1589 Ptr<LteSpectrumPhy> dlPhy = it->second->GetPhy()->GetDownlinkSpectrumPhy();
1590 Ptr<LteSpectrumPhy> ulPhy = it->second->GetPhy()->GetUplinkSpectrumPhy();
1591 Ptr<LteUeMac> ueMac = lteUe->GetMac();
1592 currentStream += dlPhy->AssignStreams(currentStream);
1593 currentStream += ulPhy->AssignStreams(currentStream);
1594 currentStream += ueMac->AssignStreams(currentStream);
1595 }
1596 }
1597 if (m_epcHelper)
1598 {
1599 currentStream += m_epcHelper->AssignStreams(currentStream);
1600 }
1601 return (currentStream - stream);
1602}
1603
1604void
1614
1615void
1617{
1619 "/NodeList/*/DeviceList/*/ComponentCarrierMap/*/LteEnbPhy/DlPhyTransmission",
1621}
1622
1623void
1625{
1627 "/NodeList/*/DeviceList/*/ComponentCarrierMapUe/*/LteUePhy/UlPhyTransmission",
1629}
1630
1631void
1633{
1635 "/NodeList/*/DeviceList/*/ComponentCarrierMapUe/*/LteUePhy/DlSpectrumPhy/DlPhyReception",
1637}
1638
1639void
1641{
1643 "/NodeList/*/DeviceList/*/ComponentCarrierMap/*/LteEnbPhy/UlSpectrumPhy/UlPhyReception",
1645}
1646
1647void
1653
1654void
1656{
1658 Config::Connect("/NodeList/*/DeviceList/*/ComponentCarrierMap/*/LteEnbMac/DlScheduling",
1660}
1661
1662void
1664{
1666 Config::Connect("/NodeList/*/DeviceList/*/ComponentCarrierMap/*/LteEnbMac/UlScheduling",
1668}
1669
1670void
1672{
1675 "/NodeList/*/DeviceList/*/ComponentCarrierMapUe/*/LteUePhy/ReportCurrentCellRsrpSinr",
1677}
1678
1679void
1681{
1683 Config::Connect("/NodeList/*/DeviceList/*/ComponentCarrierMap/*/LteEnbPhy/ReportUeSinr",
1685 Config::Connect("/NodeList/*/DeviceList/*/ComponentCarrierMap/*/LteEnbPhy/ReportInterference",
1687}
1688
1691{
1692 return m_rlcStats;
1693}
1694
1695void
1697{
1699 "please make sure that LteHelper::EnablePdcpTraces is called at most once");
1702}
1703
1706{
1707 return m_pdcpStats;
1708}
1709
1710} // namespace ns3
Hold a value for an Attribute.
Definition attribute.h:59
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition double.h:31
DrbActivatior allows user to activate bearers for UEs when EPC is not used.
EpsBearer m_bearer
Configuration of bearer which will be activated.
uint64_t m_imsi
imsi the unique UE identifier
DrbActivator(Ptr< NetDevice > ueDevice, EpsBearer bearer)
DrbActivator Constructor.
static void ActivateCallback(Ptr< DrbActivator > a, std::string context, uint64_t imsi, uint16_t cellId, uint16_t rnti)
Function hooked to the Enb RRC Connection Established trace source Fired upon successful RRC connecti...
Ptr< NetDevice > m_ueDevice
UeNetDevice for which bearer will be activated.
void ActivateDrb(uint64_t imsi, uint16_t cellId, uint16_t rnti)
Procedure firstly checks if bearer was not activated, if IMSI from trace source equals configured one...
bool m_active
Bearer can be activated only once.
Hold variables of type enum.
Definition enum.h:52
T Get() const
Definition enum.h:87
This application is installed inside eNBs and provides the bridge functionality for user data plane p...
static Ptr< EpcTft > Default()
creates a TFT matching any traffic
Definition epc-tft.cc:218
This entity is installed inside an eNB and provides the functionality for the X2 interface.
Definition epc-x2.h:88
This class contains the specification of EPS Bearers.
Definition eps-bearer.h:80
@ NGBR_VIDEO_TCP_DEFAULT
Non-GBR TCP-based Video (Buffered Streaming, e.g., www, e-mail...)
Definition eps-bearer.h:115
This abstract base class identifies the interface by means of which the helper object can plug on the...
static TypeId GetTypeId()
Get the type ID.
static TypeId GetTypeId()
Get the type ID.
The class implements Component Carrier Manager (CCM) that operates using the Component Carrier Manage...
The eNodeB device implementation.
static TypeId GetTypeId()
Get the type ID.
virtual void ReportUlHarqFeedback(UlInfoListElement_s mes)
Report the uplink HARQ feedback generated by LteSpectrumPhy to MAC.
void GenerateCtrlCqiReport(const SpectrumValue &sinr) override
generate a CQI report based on the given SINR of Ctrl frame
void GenerateDataCqiReport(const SpectrumValue &sinr) override
generate a CQI report based on the given SINR of Data frame (used for PUSCH CQIs)
void PhyPduReceived(Ptr< Packet > p)
PhySpectrum received a new PHY-PDU.
virtual void ReceiveLteControlMessageList(std::list< Ptr< LteControlMessage > > msgList)
PhySpectrum received a new list of LteControlMessage.
void ReportInterference(const SpectrumValue &interf) override
generate a report based on the linear interference and noise power perceived during DATA frame NOTE: ...
The abstract base class of a Frequency Reuse algorithm.
The abstract base class of a handover algorithm that operates using the Handover Management SAP inter...
void SetFfrAlgorithmType(std::string type)
Set the type of FFR algorithm to be used by eNodeB devices.
Ptr< SpectrumPropagationLossModel > m_fadingModel
The fading model used in both the downlink and uplink channels.
Definition lte-helper.h:774
Ptr< Object > m_uplinkPathlossModel
The path loss model used in the uplink channel.
Definition lte-helper.h:744
void EnableLogComponents()
Enables full-blown logging for major components of the LENA architecture.
Ptr< SpectrumChannel > GetUplinkSpectrumChannel() const
void SetEnbComponentCarrierManagerType(std::string type)
Set the type of carrier component algorithm to be used by eNodeB devices.
void EnableUlRxPhyTraces()
Enable trace sinks for UL reception PHY layer.
ObjectFactory m_schedulerFactory
Factory of MAC scheduler object.
Definition lte-helper.h:747
void SetUeAntennaModelType(std::string type)
Set the type of antenna model to be used by UE devices.
ObjectFactory m_ffrAlgorithmFactory
Factory of FFR (frequency reuse) algorithm object.
Definition lte-helper.h:749
ObjectFactory m_channelFactory
Factory of both the downlink and uplink LTE channels.
Definition lte-helper.h:767
void SetEpcHelper(Ptr< EpcHelper > h)
Set the EpcHelper to be used to setup the EPC network in conjunction with the setup of the LTE radio ...
Ptr< RadioBearerStatsCalculator > GetRlcStats()
ObjectFactory m_handoverAlgorithmFactory
Factory of handover algorithm object.
Definition lte-helper.h:751
std::string m_fadingModelType
Name of fading model type, e.g., "ns3::TraceFadingLossModel".
Definition lte-helper.h:770
Ptr< RadioBearerStatsCalculator > GetPdcpStats()
void EnableDlMacTraces()
Enable trace sinks for DL MAC layer.
ObjectFactory m_enbComponentCarrierManagerFactory
Factory of enb component carrier manager object.
Definition lte-helper.h:753
void SetFadingModel(std::string type)
Set the type of fading model to be used in both DL and UL.
void DoDeActivateDedicatedEpsBearer(Ptr< NetDevice > ueDevice, Ptr< NetDevice > enbDevice, uint8_t bearerId)
The actual function to trigger a manual bearer de-activation.
std::string GetEnbComponentCarrierManagerType() const
void SetSchedulerAttribute(std::string n, const AttributeValue &v)
Set an attribute for the scheduler to be created.
Ptr< SpectrumChannel > GetDownlinkSpectrumChannel() const
~LteHelper() override
Definition lte-helper.cc:94
std::map< uint8_t, ComponentCarrier > m_componentCarrierPhyParams
This contains all the information about each component carrier.
Definition lte-helper.h:844
Ptr< MacStatsCalculator > m_macStats
Container of MAC layer statistics.
Definition lte-helper.h:788
void SetHandoverAlgorithmAttribute(std::string n, const AttributeValue &v)
Set an attribute for the handover algorithm to be created.
void EnablePhyTraces()
Enable trace sinks for PHY layer.
void DeActivateDedicatedEpsBearer(Ptr< NetDevice > ueDevice, Ptr< NetDevice > enbDevice, uint8_t bearerId)
Manually trigger dedicated bearer de-activation at specific simulation time.
void HandoverRequest(Time hoTime, Ptr< NetDevice > ueDev, Ptr< NetDevice > sourceEnbDev, Ptr< NetDevice > targetEnbDev)
Manually trigger an X2-based handover.
Ptr< SpectrumChannel > m_downlinkChannel
This function create the component carrier based on provided configuration parameters.
Definition lte-helper.h:738
NetDeviceContainer InstallEnbDevice(NodeContainer c)
Create a set of eNodeB devices.
void SetUeComponentCarrierManagerAttribute(std::string n, const AttributeValue &v)
Set an attribute for the ue component carrier manager to be created.
uint16_t m_cellIdCounter
Keep track of the number of cell ID allocated.
Definition lte-helper.h:814
std::string GetFfrAlgorithmType() const
void SetHandoverAlgorithmType(std::string type)
Set the type of handover algorithm to be used by eNodeB devices.
void SetPathlossModelType(TypeId type)
Set the type of path loss model to be used for both DL and UL channels.
void EnablePdcpTraces()
Enable trace sinks for PDCP layer.
Ptr< PhyTxStatsCalculator > m_phyTxStats
Container of PHY layer statistics related to transmission.
Definition lte-helper.h:784
void SetEnbAntennaModelType(std::string type)
Set the type of antenna model to be used by eNodeB devices.
void EnableTraces()
Enables trace sinks for PHY, MAC, RLC and PDCP.
void SetFfrAlgorithmAttribute(std::string n, const AttributeValue &v)
Set an attribute for the FFR algorithm to be created.
void DoHandoverRequest(Ptr< NetDevice > ueDev, Ptr< NetDevice > sourceEnbDev, uint16_t targetCellId)
The actual function to trigger a manual handover.
bool m_isAnrEnabled
The AnrEnabled attribute.
Definition lte-helper.h:825
void SetEnbComponentCarrierManagerAttribute(std::string n, const AttributeValue &v)
Set an attribute for the enb component carrier manager to be created.
void DoInitialize() override
Initialize() implementation.
Definition lte-helper.cc:83
Ptr< PhyRxStatsCalculator > m_phyRxStats
Container of PHY layer statistics related to reception.
Definition lte-helper.h:786
void SetSpectrumChannelType(std::string type)
Set the type of spectrum channel to be used in both DL and UL.
void EnableDlRxPhyTraces()
Enable trace sinks for DL reception PHY layer.
ObjectFactory m_pathlossModelFactory
Factory of path loss model object.
Definition lte-helper.h:765
bool m_fadingStreamsAssigned
True if a random variable stream number has been assigned for the fading model.
Definition lte-helper.h:779
std::string GetUeComponentCarrierManagerType() const
void SetSchedulerType(std::string type)
Set the type of scheduler to be used by eNodeB devices.
RadioBearerStatsConnector m_radioBearerStatsConnector
Connects RLC and PDCP statistics containers to appropriate trace sources.
Definition lte-helper.h:794
void Attach(NetDeviceContainer ueDevices)
Enables automatic attachment of a set of UE devices to a suitable cell using Idle mode initial cell s...
void DoDispose() override
Destructor implementation.
ObjectFactory m_enbNetDeviceFactory
Factory of LteEnbNetDevice objects.
Definition lte-helper.h:757
void EnableUlMacTraces()
Enable trace sinks for UL MAC layer.
std::string GetHandoverAlgorithmType() const
Ptr< PhyStatsCalculator > m_phyStats
Container of PHY layer statistics.
Definition lte-helper.h:782
void EnableUlPhyTraces()
Enable trace sinks for UL PHY layer.
void EnableDlTxPhyTraces()
Enable trace sinks for DL transmission PHY layer.
void SetPathlossModelAttribute(std::string n, const AttributeValue &v)
Set an attribute for the path loss models to be created.
void EnableRlcTraces()
Enable trace sinks for RLC layer.
bool m_useIdealRrc
The UseIdealRrc attribute.
Definition lte-helper.h:820
ObjectFactory m_ueComponentCarrierManagerFactory
Factory of ue component carrier manager object.
Definition lte-helper.h:755
void DoComponentCarrierConfigure(uint32_t ulEarfcn, uint32_t dlEarfcn, uint16_t ulbw, uint16_t dlbw)
Configure the component carriers.
Ptr< Object > m_downlinkPathlossModel
The path loss model used in the downlink channel.
Definition lte-helper.h:742
Ptr< RadioBearerStatsCalculator > m_pdcpStats
Container of PDCP layer statistics.
Definition lte-helper.h:792
void ChannelModelInitialization()
Function that performs a channel model initialization of all component carriers.
void EnableUlTxPhyTraces()
Enable trace sinks for UL transmission PHY layer.
bool m_usePdschForCqiGeneration
The UsePdschForCqiGeneration attribute.
Definition lte-helper.h:831
void SetUeAntennaModelAttribute(std::string n, const AttributeValue &v)
Set an attribute for the UE antenna model to be created.
void SetEnbAntennaModelAttribute(std::string n, const AttributeValue &v)
Set an attribute for the eNodeB antenna model to be created.
static TypeId GetTypeId()
Register this type.
void SetEnbDeviceAttribute(std::string n, const AttributeValue &v)
Set an attribute for the eNodeB devices (LteEnbNetDevice) to be created.
bool m_useCa
The UseCa attribute.
Definition lte-helper.h:839
void ActivateDataRadioBearer(NetDeviceContainer ueDevices, EpsBearer bearer)
Activate a Data Radio Bearer on a given UE devices (for LTE-only simulation).
NetDeviceContainer InstallUeDevice(NodeContainer c)
Create a set of UE devices.
uint64_t m_imsiCounter
Keep track of the number of IMSI allocated.
Definition lte-helper.h:808
ObjectFactory m_ueNetDeviceFactory
Factory for LteUeNetDevice objects.
Definition lte-helper.h:761
ObjectFactory m_ueAntennaModelFactory
Factory of antenna object for UE.
Definition lte-helper.h:763
Ptr< SpectrumChannel > m_uplinkChannel
The uplink LTE channel used in the simulation.
Definition lte-helper.h:740
void EnableMacTraces()
Enable trace sinks for MAC layer.
void SetSpectrumChannelAttribute(std::string n, const AttributeValue &v)
Set an attribute for the spectrum channel to be created (both DL and UL).
void EnableDlPhyTraces()
Enable trace sinks for DL PHY layer.
void AddX2Interface(NodeContainer enbNodes)
Create an X2 interface between all the eNBs in a given set.
void SetUeDeviceAttribute(std::string n, const AttributeValue &v)
Set an attribute for the UE devices (LteUeNetDevice) to be created.
uint16_t m_noOfCcs
Number of component carriers that will be installed by default at eNodeB and UE devices.
Definition lte-helper.h:849
int64_t AssignStreams(NetDeviceContainer c, int64_t stream)
Assign a fixed random variable stream number to the random variables used.
void SetFadingModelAttribute(std::string n, const AttributeValue &v)
Set an attribute for the fading model to be created (both DL and UL).
Ptr< EpcHelper > m_epcHelper
Helper which provides implementation of core network.
Definition lte-helper.h:801
void AttachToClosestEnb(NetDeviceContainer ueDevices, NetDeviceContainer enbDevices)
Manual attachment of a set of UE devices to the network via the closest eNodeB (with respect to dista...
uint8_t ActivateDedicatedEpsBearer(NetDeviceContainer ueDevices, EpsBearer bearer, Ptr< EpcTft > tft)
Activate a dedicated EPS bearer on a given set of UE devices.
ObjectFactory m_enbAntennaModelFactory
Factory of antenna object for eNodeB.
Definition lte-helper.h:759
Ptr< RadioBearerStatsCalculator > m_rlcStats
Container of RLC layer statistics.
Definition lte-helper.h:790
std::string GetSchedulerType() const
Ptr< NetDevice > InstallSingleUeDevice(Ptr< Node > n)
Create a UE device (LteUeNetDevice) on the given node.
Ptr< NetDevice > InstallSingleEnbDevice(Ptr< Node > n)
Create an eNodeB device (LteEnbNetDevice) on the given node.
void SetUeComponentCarrierManagerType(std::string type)
Set the type of Component Carrier Manager to be used by Ue devices.
ObjectFactory m_fadingModelFactory
Factory of fading model object for both the downlink and uplink channels.
Definition lte-helper.h:772
void Receive(Ptr< Packet > p)
receive a packet from the lower layers in order to forward it to the upper layers
void UpdateSinrPerceived(const SpectrumValue &sinr)
static double GetCarrierFrequency(uint32_t earfcn)
Calculates the carrier frequency from the E-UTRA Absolute Radio Frequency Channel Number (EARFCN) acc...
The abstract base class of a Component Carrier Manager* for UE that operates using the component carr...
The LteUeNetDevice class implements the UE net device.
static TypeId GetTypeId()
Get the type ID.
virtual void ReportDataInterference(const SpectrumValue &interf)
Create the mixed CQI report.
virtual void ReceivePss(uint16_t cellId, Ptr< SpectrumValue > p)
Receive PSS function.
void ReportRsReceivedPower(const SpectrumValue &power) override
generate a report based on the linear RS power perceived during CTRL frame NOTE: used only by UE for ...
virtual void ReceiveLteControlMessageList(std::list< Ptr< LteControlMessage > > msgList)
Receive LTE control message list function.
void GenerateCtrlCqiReport(const SpectrumValue &sinr) override
generate a CQI report based on the given SINR of Ctrl frame
void PhyPduReceived(Ptr< Packet > p)
PhySpectrum received a new PHY-PDU.
virtual void EnqueueDlHarqFeedback(DlInfoListElement_s mes)
Enqueue the downlink HARQ feedback generated by LteSpectrumPhy.
void ReportInterference(const SpectrumValue &interf) override
generate a report based on the linear interference and noise power perceived during DATA frame NOTE: ...
virtual void GenerateMixedCqiReport(const SpectrumValue &sinr)
Create the mixed CQI report.
static Mac64Address Allocate()
Allocate a new Mac64Address.
static void DlSchedulingCallback(Ptr< MacStatsCalculator > macStats, std::string path, DlSchedulingCallbackInfo dlSchedulingCallbackInfo)
Trace sink for the ns3::LteEnbMac::DlScheduling trace source.
static void UlSchedulingCallback(Ptr< MacStatsCalculator > macStats, std::string path, uint32_t frameNo, uint32_t subframeNo, uint16_t rnti, uint8_t mcs, uint16_t size, uint8_t componentCarrierId)
Trace sink for the ns3::LteEnbMac::UlScheduling trace source.
Keep track of the current position and velocity of an object.
static TypeId GetTypeId()
Get the type ID.
holds a vector of ns3::NetDevice pointers
uint32_t GetN() const
Get the number of Ptr<NetDevice> stored in this container.
Iterator Begin() const
Get an iterator which refers to the first NetDevice in the container.
Iterator End() const
Get an iterator which indicates past-the-last NetDevice in the container.
keep track of a set of node pointers.
Iterator End() const
Get an iterator which indicates past-the-last Node in the container.
Iterator Begin() const
Get an iterator which refers to the first Node in the container.
bool SetAttributeFailSafe(std::string name, const AttributeValue &value)
Set a single attribute without raising errors.
Ptr< Object > Create() const
Create an Object instance of the configured TypeId.
void Set(const std::string &name, const AttributeValue &value, Args &&... args)
Set an attribute to be set during construction.
TypeId GetTypeId() const
Get the TypeId which will be created by this ObjectFactory.
void SetTypeId(TypeId tid)
Set the TypeId of the Objects to be created by this factory.
A base class which provides memory management and object aggregation.
Definition object.h:78
void Initialize()
Invoke DoInitialize on all Objects aggregated to this one.
Definition object.cc:203
friend class ObjectFactory
Friends.
Definition object.h:357
Ptr< T > GetObject() const
Get a pointer to the requested aggregated Object.
Definition object.h:511
virtual void DoInitialize()
Initialize() implementation.
Definition object.cc:440
virtual void DoDispose()
Destructor implementation.
Definition object.cc:433
static void UlPhyReceptionCallback(Ptr< PhyRxStatsCalculator > phyRxStats, std::string path, PhyReceptionStatParameters params)
trace sink
static void DlPhyReceptionCallback(Ptr< PhyRxStatsCalculator > phyRxStats, std::string path, PhyReceptionStatParameters params)
trace sink
void ReportUeSinr(uint16_t cellId, uint64_t imsi, uint16_t rnti, double sinrLinear, uint8_t componentCarrierId)
Notifies the stats calculator that an UE SINR report has occurred.
void ReportInterference(uint16_t cellId, Ptr< SpectrumValue > interference)
Notifies the stats calculator that an interference report has occurred.
static void ReportCurrentCellRsrpSinrCallback(Ptr< PhyStatsCalculator > phyStats, std::string path, uint16_t cellId, uint16_t rnti, double rsrp, double sinr, uint8_t componentCarrierId)
trace sink
static void DlPhyTransmissionCallback(Ptr< PhyTxStatsCalculator > phyTxStats, std::string path, PhyTransmissionStatParameters params)
trace sink
static void UlPhyTransmissionCallback(Ptr< PhyTxStatsCalculator > phyTxStats, std::string path, PhyTransmissionStatParameters params)
trace sink
AttributeValue implementation for Pointer.
Models the propagation loss through a transmission medium.
Smart pointer class similar to boost::intrusive_ptr.
void EnablePdcpStats(Ptr< RadioBearerStatsCalculator > pdcpStats)
Enables trace sinks for PDCP layer.
void EnableRlcStats(Ptr< RadioBearerStatsCalculator > rlcStats)
Enables trace sinks for RLC layer.
A template-based reference counting class.
static EventId Schedule(const Time &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
Definition simulator.h:560
Defines the interface for spectrum-aware channel implementations.
spectrum-aware propagation loss model
Hold variables of type string.
Definition string.h:45
Simulation virtual time values and global simulation resolution.
Definition nstime.h:94
fading loss model based on precalculated fading traces
a unique identifier for an interface.
Definition type-id.h:48
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition type-id.cc:1001
std::string GetName() const
Get the name.
Definition type-id.cc:1061
@ CONNECTION_RECONFIGURATION
Definition lte-enb-rrc.h:73
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
void Connect(std::string path, const CallbackBase &cb)
Definition config.cc:967
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
#define NS_ABORT_MSG_IF(cond, msg)
Abnormal program termination if a condition is true, with a message.
Definition abort.h:97
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition log.h:191
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition log.h:257
#define NS_LOG_LOGIC(msg)
Use NS_LOG to output a message of level LOG_LOGIC.
Definition log.h:271
#define NS_LOG_FUNCTION_NOARGS()
Output the name of the function.
#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
auto MakeBoundCallback(R(*fnPtr)(Args...), BArgs &&... bargs)
Make Callbacks with varying number of bound arguments.
Definition callback.h:745
Ptr< T > CreateObject(Args &&... args)
Create an object by type, with varying number of constructor parameters.
Definition object.h:619
#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
Every class exported by the ns3 library is enclosed in the ns3 namespace.
Ptr< const AttributeChecker > MakeBooleanChecker()
Definition boolean.cc:113
void LogComponentEnable(const std::string &name, LogLevel level)
Enable the logging output associated with that log component.
Definition log.cc:291
Ptr< const AttributeChecker > MakeUintegerChecker()
Definition uinteger.h:85
Callback< R, Args... > MakeCallback(R(T::*memPtr)(Args...), OBJ objPtr)
Build Callbacks for class method members which take varying numbers of arguments and potentially retu...
Definition callback.h:684
Ptr< const AttributeAccessor > MakeUintegerAccessor(T1 a1)
Definition uinteger.h:35
Ptr< T1 > DynamicCast(const Ptr< T2 > &p)
Cast a Ptr.
Definition ptr.h:580
Ptr< const AttributeChecker > MakeTypeIdChecker()
Definition type-id.cc:1320
constexpr uint32_t MIN_NO_CC
Minimum number of carrier components allowed by 3GPP up to R13.
Definition lte-common.h:25
constexpr uint32_t MAX_NO_CC
Maximum number of carrier components allowed by 3GPP up to R13.
Definition lte-common.h:28
@ LOG_LEVEL_ALL
Print everything.
Definition log.h:105
@ LOG_PREFIX_FUNC
Prefix all trace prints with function.
Definition log.h:107
@ LOG_PREFIX_TIME
Prefix all trace prints with simulation time.
Definition log.h:108
@ LOG_PREFIX_NODE
Prefix all trace prints with simulation node.
Definition log.h:109
double CalculateDistance(const Vector3D &a, const Vector3D &b)
Definition vector.cc:98
Ptr< const AttributeChecker > MakeStringChecker()
Definition string.cc:19
Ptr< const AttributeAccessor > MakeStringAccessor(T1 a1)
Definition string.h:46
Ptr< const AttributeAccessor > MakeBooleanAccessor(T1 a1)
Definition boolean.h:70
void LogComponentEnableAll(LogLevel level)
Enable the logging output for all registered log components.
Definition log.cc:309
Ptr< const AttributeAccessor > MakeTypeIdAccessor(T1 a1)
Definition type-id.h:617
Parameters passed to DataRadioBearerSetupRequest ()