A Discrete-Event Network Simulator
API
lte-helper.cc
Go to the documentation of this file.
1/* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
2/*
3 * Copyright (c) 2011 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
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: Nicola Baldo <nbaldo@cttc.es> (re-wrote from scratch this helper)
19 * Giuseppe Piro <g.piro@poliba.it> (parts of the PHY & channel creation & configuration copied from the GSoC 2011 code)
20 * Modified by: Danilo Abrignani <danilo.abrignani@unibo.it> (Carrier Aggregation - GSoC 2015)
21 * Biljana Bojovic <biljana.bojovic@cttc.es> (Carrier Aggregation)
22 */
23
24#include "lte-helper.h"
25#include <ns3/string.h>
26#include <ns3/log.h>
27#include <ns3/abort.h>
28#include <ns3/pointer.h>
29#include <ns3/lte-enb-rrc.h>
30#include <ns3/epc-ue-nas.h>
31#include <ns3/epc-enb-application.h>
32#include <ns3/lte-ue-rrc.h>
33#include <ns3/lte-ue-mac.h>
34#include <ns3/lte-enb-mac.h>
35#include <ns3/lte-enb-net-device.h>
36#include <ns3/lte-enb-phy.h>
37#include <ns3/lte-ue-phy.h>
38#include <ns3/lte-spectrum-phy.h>
39#include <ns3/lte-chunk-processor.h>
40#include <ns3/multi-model-spectrum-channel.h>
41#include <ns3/friis-spectrum-propagation-loss.h>
42#include <ns3/trace-fading-loss-model.h>
43#include <ns3/isotropic-antenna-model.h>
44#include <ns3/lte-ue-net-device.h>
45#include <ns3/ff-mac-scheduler.h>
46#include <ns3/lte-ffr-algorithm.h>
47#include <ns3/lte-handover-algorithm.h>
48#include <ns3/lte-enb-component-carrier-manager.h>
49#include <ns3/lte-ue-component-carrier-manager.h>
50#include <ns3/lte-anr.h>
51#include <ns3/lte-rlc.h>
52#include <ns3/lte-rlc-um.h>
53#include <ns3/lte-rlc-am.h>
54#include <ns3/epc-enb-s1-sap.h>
55#include <ns3/lte-rrc-protocol-ideal.h>
56#include <ns3/lte-rrc-protocol-real.h>
57#include <ns3/mac-stats-calculator.h>
58#include <ns3/phy-stats-calculator.h>
59#include <ns3/phy-tx-stats-calculator.h>
60#include <ns3/phy-rx-stats-calculator.h>
61#include <ns3/epc-helper.h>
62#include <iostream>
63#include <ns3/buildings-propagation-loss-model.h>
64#include <ns3/lte-spectrum-value-helper.h>
65#include <ns3/epc-x2.h>
66#include <ns3/object-map.h>
67#include <ns3/object-factory.h>
68
69namespace ns3 {
70
71NS_LOG_COMPONENT_DEFINE ("LteHelper");
72
74
76 : m_fadingStreamsAssigned (false),
77 m_imsiCounter (0),
78 m_cellIdCounter {1}
79{
80 NS_LOG_FUNCTION (this);
86}
87
88void
90{
91 NS_LOG_FUNCTION (this);
93 m_phyStats = CreateObject<PhyStatsCalculator> ();
94 m_phyTxStats = CreateObject<PhyTxStatsCalculator> ();
95 m_phyRxStats = CreateObject<PhyRxStatsCalculator> ();
96 m_macStats = CreateObject<MacStatsCalculator> ();
98
99}
100
102{
103 NS_LOG_FUNCTION (this);
104}
105
107{
108 static TypeId
109 tid =
110 TypeId ("ns3::LteHelper")
111 .SetParent<Object> ()
112 .AddConstructor<LteHelper> ()
113 .AddAttribute ("Scheduler",
114 "The type of scheduler to be used for eNBs. "
115 "The allowed values for this attributes are the type names "
116 "of any class inheriting from ns3::FfMacScheduler.",
117 StringValue ("ns3::PfFfMacScheduler"),
121 .AddAttribute ("FfrAlgorithm",
122 "The type of FFR algorithm to be used for eNBs. "
123 "The allowed values for this attributes are the type names "
124 "of any class inheriting from ns3::LteFfrAlgorithm.",
125 StringValue ("ns3::LteFrNoOpAlgorithm"),
129 .AddAttribute ("HandoverAlgorithm",
130 "The type of handover algorithm to be used for eNBs. "
131 "The allowed values for this attributes are the type names "
132 "of any class inheriting from ns3::LteHandoverAlgorithm.",
133 StringValue ("ns3::NoOpHandoverAlgorithm"),
137 .AddAttribute ("PathlossModel",
138 "The type of pathloss model to be used. "
139 "The allowed values for this attributes are the type names "
140 "of any class inheriting from ns3::PropagationLossModel.",
144 .AddAttribute ("FadingModel",
145 "The type of fading model to be used."
146 "The allowed values for this attributes are the type names "
147 "of any class inheriting from ns3::SpectrumPropagationLossModel."
148 "If the type is set to an empty string, no fading model is used.",
149 StringValue (""),
152 .AddAttribute ("UseIdealRrc",
153 "If true, LteRrcProtocolIdeal will be used for RRC signaling. "
154 "If false, LteRrcProtocolReal will be used.",
155 BooleanValue (true),
158 .AddAttribute ("AnrEnabled",
159 "Activate or deactivate Automatic Neighbour Relation function",
160 BooleanValue (true),
163 .AddAttribute ("UsePdschForCqiGeneration",
164 "If true, DL-CQI will be calculated from PDCCH as signal and PDSCH as interference "
165 "If false, DL-CQI will be calculated from PDCCH as signal and PDCCH as interference ",
166 BooleanValue (true),
169 .AddAttribute ("EnbComponentCarrierManager",
170 "The type of Component Carrier Manager to be used for eNBs. "
171 "The allowed values for this attributes are the type names "
172 "of any class inheriting ns3::LteEnbComponentCarrierManager.",
173 StringValue ("ns3::NoOpComponentCarrierManager"),
177 .AddAttribute ("UeComponentCarrierManager",
178 "The type of Component Carrier Manager to be used for UEs. "
179 "The allowed values for this attributes are the type names "
180 "of any class inheriting ns3::LteUeComponentCarrierManager.",
181 StringValue ("ns3::SimpleUeComponentCarrierManager"),
185 .AddAttribute ("UseCa",
186 "If true, Carrier Aggregation feature is enabled and a valid Component Carrier Map is expected."
187 "If false, single carrier simulation.",
188 BooleanValue (false),
191 .AddAttribute ("NumberOfComponentCarriers",
192 "Set the number of Component carrier to use "
193 "If it is more than one and m_useCa is false, it will raise an error ",
194 UintegerValue (1),
196 MakeUintegerChecker<uint16_t> (MIN_NO_CC, MAX_NO_CC))
197 ;
198 return tid;
199}
200
201void
203{
204 NS_LOG_FUNCTION (this);
206 m_uplinkChannel = 0;
209}
210
213{
214 return m_uplinkChannel;
215}
216
219{
220 return m_downlinkChannel;
221}
222
223void
225{
226 // Channel Object (i.e. Ptr<SpectrumChannel>) are within a vector
227 // PathLossModel Objects are vectors --> in InstallSingleEnb we will set the frequency
228 NS_LOG_FUNCTION (this << m_noOfCcs);
229
232
235 if (dlSplm != 0)
236 {
237 NS_LOG_LOGIC (this << " using a SpectrumPropagationLossModel in DL");
238 m_downlinkChannel->AddSpectrumPropagationLossModel (dlSplm);
239 }
240 else
241 {
242 NS_LOG_LOGIC (this << " using a PropagationLossModel in DL");
244 NS_ASSERT_MSG (dlPlm != 0, " " << m_downlinkPathlossModel << " is neither PropagationLossModel nor SpectrumPropagationLossModel");
245 m_downlinkChannel->AddPropagationLossModel (dlPlm);
246 }
247
250 if (ulSplm != 0)
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 != 0, " " << m_uplinkPathlossModel << " is neither PropagationLossModel nor SpectrumPropagationLossModel");
260 m_uplinkChannel->AddPropagationLossModel (ulPlm);
261 }
262 if (!m_fadingModelType.empty ())
263 {
265 m_fadingModel->Initialize ();
266 m_downlinkChannel->AddSpectrumPropagationLossModel (m_fadingModel);
267 m_uplinkChannel->AddSpectrumPropagationLossModel (m_fadingModel);
268 }
269}
270
271void
273{
274 NS_LOG_FUNCTION (this << h);
275 m_epcHelper = h;
276}
277
278void
280{
281 NS_LOG_FUNCTION (this << type);
284}
285
286std::string
288{
290}
291
292void
294{
295 NS_LOG_FUNCTION (this << n);
297}
298
299std::string
301{
303}
304
305void
307{
308 NS_LOG_FUNCTION (this << type);
311}
312
313void
315{
316 NS_LOG_FUNCTION (this << n);
318}
319
320std::string
322{
324}
325
326void
328{
329 NS_LOG_FUNCTION (this << type);
332}
333
334void
336{
337 NS_LOG_FUNCTION (this << n);
339}
340
341
342std::string
344{
346}
347
348void
350{
351 NS_LOG_FUNCTION (this << type);
354}
355
356void
358{
359 NS_LOG_FUNCTION (this << n);
361}
362
363std::string
365{
367}
368
369void
371{
372 NS_LOG_FUNCTION (this << type);
375}
376
377void
379{
380 NS_LOG_FUNCTION (this << n);
382}
383
384void
386{
387 NS_LOG_FUNCTION (this << type);
390}
391
392void
394{
395 NS_LOG_FUNCTION (this << n);
397}
398
399void
401{
402 NS_LOG_FUNCTION (this);
404}
405
406
407void
409{
410 NS_LOG_FUNCTION (this);
412}
413
414void
416{
417 NS_LOG_FUNCTION (this);
419}
420
421void
423{
424 NS_LOG_FUNCTION (this);
426}
427
428void
430{
431 NS_LOG_FUNCTION (this);
433}
434
435void
437{
438 NS_LOG_FUNCTION (this);
440}
441
442void
443LteHelper::SetFadingModel (std::string type)
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{
471}
472
475{
476 NS_LOG_FUNCTION (this);
477 Initialize (); // will run DoInitialize () if necessary
479 for (NodeContainer::Iterator 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);
493 for (NodeContainer::Iterator i = c.Begin (); i != c.End (); ++i)
494 {
495 Ptr<Node> node = *i;
497 devices.Add (device);
498 }
499 return devices;
500}
501
502
505{
506 NS_LOG_FUNCTION (this << n);
507 uint16_t cellId = m_cellIdCounter; // \todo Remove, eNB has no cell ID
508
511
512 NS_ABORT_MSG_IF (m_componentCarrierPhyParams.size() != 0, "CC map is not clean");
514 dev->GetUlBandwidth (), dev->GetDlBandwidth ());
516 "CC map size (" << m_componentCarrierPhyParams.size () <<
517 ") must be equal to number of carriers (" <<
518 m_noOfCcs << ")");
519
520 // create component carrier map for this eNb device
521 std::map<uint8_t,Ptr<ComponentCarrierBaseStation> > ccMap;
522 for (std::map<uint8_t, ComponentCarrier >::iterator it = m_componentCarrierPhyParams.begin ();
523 it != m_componentCarrierPhyParams.end ();
524 ++it)
525 {
526 Ptr <ComponentCarrierEnb> cc = CreateObject<ComponentCarrierEnb> ();
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, "You have to either specify carriers or disable carrier aggregation");
540 NS_ASSERT (ccMap.size () == m_noOfCcs);
541
542 for (auto it = ccMap.begin (); it != ccMap.end (); ++it)
543 {
544 NS_LOG_DEBUG (this << "component carrier map size " << (uint16_t) ccMap.size ());
545 Ptr<LteSpectrumPhy> dlPhy = CreateObject<LteSpectrumPhy> ();
546 Ptr<LteSpectrumPhy> ulPhy = CreateObject<LteSpectrumPhy> ();
547 Ptr<LteEnbPhy> phy = CreateObject<LteEnbPhy> (dlPhy, ulPhy);
548
549 Ptr<LteHarqPhy> harq = Create<LteHarqPhy> ();
550 dlPhy->SetHarqPhyModule (harq);
551 ulPhy->SetHarqPhyModule (harq);
552 phy->SetHarqPhyModule (harq);
553
554 Ptr<LteChunkProcessor> pCtrl = Create<LteChunkProcessor> ();
555 pCtrl->AddCallback (MakeCallback (&LteEnbPhy::GenerateCtrlCqiReport, phy));
556 ulPhy->AddCtrlSinrChunkProcessor (pCtrl); // for evaluating SRS UL-CQI
557
558 Ptr<LteChunkProcessor> pData = Create<LteChunkProcessor> ();
559 pData->AddCallback (MakeCallback (&LteEnbPhy::GenerateDataCqiReport, phy));
560 pData->AddCallback (MakeCallback (&LteSpectrumPhy::UpdateSinrPerceived, ulPhy));
561 ulPhy->AddDataSinrChunkProcessor (pData); // for evaluating PUSCH UL-CQI
562
563 Ptr<LteChunkProcessor> pInterf = Create<LteChunkProcessor> ();
564 pInterf->AddCallback (MakeCallback (&LteEnbPhy::ReportInterference, phy));
565 ulPhy->AddInterferenceDataChunkProcessor (pInterf); // for interference power tracing
566
567 dlPhy->SetChannel (m_downlinkChannel);
568 ulPhy->SetChannel (m_uplinkChannel);
569
570 Ptr<MobilityModel> mm = n->GetObject<MobilityModel> ();
571 NS_ASSERT_MSG (mm, "MobilityModel needs to be set on node before calling LteHelper::InstallEnbDevice ()");
572 dlPhy->SetMobility (mm);
573 ulPhy->SetMobility (mm);
574
575 Ptr<AntennaModel> antenna = (m_enbAntennaModelFactory.Create ())->GetObject<AntennaModel> ();
576 NS_ASSERT_MSG (antenna, "error in creating the AntennaModel object");
577 dlPhy->SetAntenna (antenna);
578 ulPhy->SetAntenna (antenna);
579
580 Ptr<LteEnbMac> mac = CreateObject<LteEnbMac> ();
583 DynamicCast<ComponentCarrierEnb> (it->second)->SetMac (mac);
584 DynamicCast<ComponentCarrierEnb> (it->second)->SetFfMacScheduler (sched);
585 DynamicCast<ComponentCarrierEnb> (it->second)->SetFfrAlgorithm (ffrAlgorithm);
586 DynamicCast<ComponentCarrierEnb> (it->second)->SetPhy (phy);
587 }
588
589 Ptr<LteEnbRrc> rrc = CreateObject<LteEnbRrc> ();
591
592 //ComponentCarrierManager SAP
593 rrc->SetLteCcmRrcSapProvider (ccmEnbManager->GetLteCcmRrcSapProvider ());
594 ccmEnbManager->SetLteCcmRrcSapUser (rrc->GetLteCcmRrcSapUser ());
595 // Set number of component carriers. Note: eNB CCM would also set the
596 // number of component carriers in eNB RRC
597 ccmEnbManager->SetNumberOfComponentCarriers (m_noOfCcs);
598
599 rrc->ConfigureCarriers (ccMap);
600
601 if (m_useIdealRrc)
602 {
603 Ptr<LteEnbRrcProtocolIdeal> rrcProtocol = CreateObject<LteEnbRrcProtocolIdeal> ();
604 rrcProtocol->SetLteEnbRrcSapProvider (rrc->GetLteEnbRrcSapProvider ());
605 rrc->SetLteEnbRrcSapUser (rrcProtocol->GetLteEnbRrcSapUser ());
606 rrc->AggregateObject (rrcProtocol);
607 rrcProtocol->SetCellId (cellId);
608 }
609 else
610 {
611 Ptr<LteEnbRrcProtocolReal> rrcProtocol = CreateObject<LteEnbRrcProtocolReal> ();
612 rrcProtocol->SetLteEnbRrcSapProvider (rrc->GetLteEnbRrcSapProvider ());
613 rrc->SetLteEnbRrcSapUser (rrcProtocol->GetLteEnbRrcSapUser ());
614 rrc->AggregateObject (rrcProtocol);
615 rrcProtocol->SetCellId (cellId);
616 }
617
618 if (m_epcHelper != 0)
619 {
620 EnumValue epsBearerToRlcMapping;
621 rrc->GetAttribute ("EpsBearerToRlcMapping", epsBearerToRlcMapping);
622 // it does not make sense to use RLC/SM when also using the EPC
623 if (epsBearerToRlcMapping.Get () == LteEnbRrc::RLC_SM_ALWAYS)
624 {
625 rrc->SetAttribute ("EpsBearerToRlcMapping", EnumValue (LteEnbRrc::RLC_UM_ALWAYS));
626 }
627 }
628
629 rrc->SetLteHandoverManagementSapProvider (handoverAlgorithm->GetLteHandoverManagementSapProvider ());
630 handoverAlgorithm->SetLteHandoverManagementSapUser (rrc->GetLteHandoverManagementSapUser ());
631
632 // This RRC attribute is used to connect each new RLC instance with the MAC layer
633 // (for function such as TransmitPdu, ReportBufferStatusReport).
634 // Since in this new architecture, the component carrier manager acts a proxy, it
635 // will have its own LteMacSapProvider interface, RLC will see it as through original MAC
636 // interface LteMacSapProvider, but the function call will go now through LteEnbComponentCarrierManager
637 // instance that needs to implement functions of this interface, and its task will be to
638 // forward these calls to the specific MAC of some of the instances of component carriers. This
639 // decision will depend on the specific implementation of the component carrier manager.
640 rrc->SetLteMacSapProvider (ccmEnbManager->GetLteMacSapProvider ());
641
642 bool ccmTest;
643 for (auto it = ccMap.begin (); it != ccMap.end (); ++it)
644 {
645 DynamicCast<ComponentCarrierEnb> (it->second)->GetPhy ()->SetLteEnbCphySapUser (rrc->GetLteEnbCphySapUser (it->first));
646 rrc->SetLteEnbCphySapProvider (DynamicCast<ComponentCarrierEnb> (it->second)->GetPhy ()->GetLteEnbCphySapProvider (), it->first);
647
648 rrc->SetLteEnbCmacSapProvider (DynamicCast<ComponentCarrierEnb> (it->second)->GetMac ()->GetLteEnbCmacSapProvider (),it->first );
649 DynamicCast<ComponentCarrierEnb> (it->second)->GetMac ()->SetLteEnbCmacSapUser (rrc->GetLteEnbCmacSapUser (it->first));
650
651 DynamicCast<ComponentCarrierEnb> (it->second)->GetPhy ()->SetComponentCarrierId (it->first);
652 DynamicCast<ComponentCarrierEnb> (it->second)->GetMac ()->SetComponentCarrierId (it->first);
653 //FFR SAP
654 DynamicCast<ComponentCarrierEnb> (it->second)->GetFfMacScheduler ()->SetLteFfrSapProvider (DynamicCast<ComponentCarrierEnb> (it->second)->GetFfrAlgorithm ()->GetLteFfrSapProvider ());
655 DynamicCast<ComponentCarrierEnb> (it->second)->GetFfrAlgorithm ()->SetLteFfrSapUser (DynamicCast<ComponentCarrierEnb> (it->second)->GetFfMacScheduler ()->GetLteFfrSapUser ());
656 rrc->SetLteFfrRrcSapProvider (DynamicCast<ComponentCarrierEnb> (it->second)->GetFfrAlgorithm ()->GetLteFfrRrcSapProvider (), it->first);
657 DynamicCast<ComponentCarrierEnb> (it->second)->GetFfrAlgorithm ()->SetLteFfrRrcSapUser (rrc->GetLteFfrRrcSapUser (it->first));
658 //FFR SAP END
659
660 // PHY <--> MAC SAP
661 DynamicCast<ComponentCarrierEnb> (it->second)->GetPhy ()->SetLteEnbPhySapUser (DynamicCast<ComponentCarrierEnb> (it->second)->GetMac ()->GetLteEnbPhySapUser ());
662 DynamicCast<ComponentCarrierEnb> (it->second)->GetMac ()->SetLteEnbPhySapProvider (DynamicCast<ComponentCarrierEnb> (it->second)->GetPhy ()->GetLteEnbPhySapProvider ());
663 // PHY <--> MAC SAP END
664
665 //Scheduler SAP
666 DynamicCast<ComponentCarrierEnb> (it->second)->GetMac ()->SetFfMacSchedSapProvider (DynamicCast<ComponentCarrierEnb> (it->second)->GetFfMacScheduler ()->GetFfMacSchedSapProvider ());
667 DynamicCast<ComponentCarrierEnb> (it->second)->GetMac ()->SetFfMacCschedSapProvider (DynamicCast<ComponentCarrierEnb> (it->second)->GetFfMacScheduler ()->GetFfMacCschedSapProvider ());
668
669 DynamicCast<ComponentCarrierEnb> (it->second)->GetFfMacScheduler ()->SetFfMacSchedSapUser (DynamicCast<ComponentCarrierEnb> (it->second)->GetMac ()->GetFfMacSchedSapUser ());
670 DynamicCast<ComponentCarrierEnb> (it->second)->GetFfMacScheduler ()->SetFfMacCschedSapUser (DynamicCast<ComponentCarrierEnb> (it->second)->GetMac ()->GetFfMacCschedSapUser ());
671 // Scheduler SAP END
672
673 DynamicCast<ComponentCarrierEnb> (it->second)->GetMac ()->SetLteCcmMacSapUser (ccmEnbManager->GetLteCcmMacSapUser ());
674 ccmEnbManager->SetCcmMacSapProviders (it->first, DynamicCast<ComponentCarrierEnb> (it->second)->GetMac ()->GetLteCcmMacSapProvider ());
675
676 // insert the pointer to the LteMacSapProvider interface of the MAC layer of the specific component carrier
677 ccmTest = ccmEnbManager->SetMacSapProvider (it->first, DynamicCast<ComponentCarrierEnb> (it->second)->GetMac ()->GetLteMacSapProvider());
678
679 if (ccmTest == false)
680 {
681 NS_FATAL_ERROR ("Error in SetComponentCarrierMacSapProviders");
682 }
683 }
684
685
686
687 dev->SetNode (n);
688 dev->SetAttribute ("CellId", UintegerValue (cellId));
689 dev->SetAttribute ("LteEnbComponentCarrierManager", PointerValue (ccmEnbManager));
690 dev->SetCcMap (ccMap);
691 std::map<uint8_t,Ptr<ComponentCarrierBaseStation> >::iterator it = ccMap.begin ();
692 dev->SetAttribute ("LteEnbRrc", PointerValue (rrc));
693 dev->SetAttribute ("LteHandoverAlgorithm", PointerValue (handoverAlgorithm));
694 dev->SetAttribute ("LteFfrAlgorithm", PointerValue (DynamicCast<ComponentCarrierEnb> (it->second)->GetFfrAlgorithm ()));
695
696 if (m_isAnrEnabled)
697 {
698 Ptr<LteAnr> anr = CreateObject<LteAnr> (cellId);
699 rrc->SetLteAnrSapProvider (anr->GetLteAnrSapProvider ());
700 anr->SetLteAnrSapUser (rrc->GetLteAnrSapUser ());
701 dev->SetAttribute ("LteAnr", PointerValue (anr));
702 }
703
704 for (it = ccMap.begin (); it != ccMap.end (); ++it)
705 {
706 Ptr<LteEnbPhy> ccPhy = DynamicCast<ComponentCarrierEnb> (it->second)->GetPhy ();
707 ccPhy->SetDevice (dev);
708 ccPhy->GetUlSpectrumPhy ()->SetDevice (dev);
709 ccPhy->GetDlSpectrumPhy ()->SetDevice (dev);
710 ccPhy->GetUlSpectrumPhy ()->SetLtePhyRxDataEndOkCallback (MakeCallback (&LteEnbPhy::PhyPduReceived, ccPhy));
711 ccPhy->GetUlSpectrumPhy ()->SetLtePhyRxCtrlEndOkCallback (MakeCallback (&LteEnbPhy::ReceiveLteControlMessageList, ccPhy));
712 ccPhy->GetUlSpectrumPhy ()->SetLtePhyUlHarqFeedbackCallback (MakeCallback (&LteEnbPhy::ReportUlHarqFeedback, ccPhy));
713 NS_LOG_LOGIC ("set the propagation model frequencies");
714 double dlFreq = LteSpectrumValueHelper::GetCarrierFrequency (it->second->GetDlEarfcn ());
715 NS_LOG_LOGIC ("DL freq: " << dlFreq);
716 bool dlFreqOk = m_downlinkPathlossModel->SetAttributeFailSafe ("Frequency", DoubleValue (dlFreq));
717 if (!dlFreqOk)
718 {
719 NS_LOG_WARN ("DL propagation model does not have a Frequency attribute");
720 }
721
722 double ulFreq = LteSpectrumValueHelper::GetCarrierFrequency (it->second->GetUlEarfcn ());
723
724 NS_LOG_LOGIC ("UL freq: " << ulFreq);
725 bool ulFreqOk = m_uplinkPathlossModel->SetAttributeFailSafe ("Frequency", DoubleValue (ulFreq));
726 if (!ulFreqOk)
727 {
728 NS_LOG_WARN ("UL propagation model does not have a Frequency attribute");
729 }
730 } //end for
731 rrc->SetForwardUpCallback (MakeCallback (&LteEnbNetDevice::Receive, dev));
732 dev->Initialize ();
733 n->AddDevice (dev);
734
735 for (it = ccMap.begin (); it != ccMap.end (); ++it)
736 {
737 m_uplinkChannel->AddRx (DynamicCast<ComponentCarrierEnb>(it->second)->GetPhy ()->GetUlSpectrumPhy ());
738 }
739
740 if (m_epcHelper != 0)
741 {
742 NS_LOG_INFO ("adding this eNB to the EPC");
743 m_epcHelper->AddEnb (n, dev, dev->GetCellId ());
744 Ptr<EpcEnbApplication> enbApp = n->GetApplication (0)->GetObject<EpcEnbApplication> ();
745 NS_ASSERT_MSG (enbApp != 0, "cannot retrieve EpcEnbApplication");
746
747 // S1 SAPs
748 rrc->SetS1SapProvider (enbApp->GetS1SapProvider ());
749 enbApp->SetS1SapUser (rrc->GetS1SapUser ());
750
751 // X2 SAPs
752 Ptr<EpcX2> x2 = n->GetObject<EpcX2> ();
753 x2->SetEpcX2SapUser (rrc->GetEpcX2SapUser ());
754 rrc->SetEpcX2SapProvider (x2->GetEpcX2SapProvider ());
755 }
756
757 return dev;
758}
759
762{
763 NS_LOG_FUNCTION (this);
764
766
767 // Initialize the component carriers with default values in order to initialize MACs and PHYs
768 // of each component carrier. These values must be updated once the UE is attached to the
769 // eNB and receives RRC Connection Reconfiguration message. In case of primary carrier or
770 // a single carrier, these values will be updated once the UE will receive SIB2 and MIB.
771 NS_ABORT_MSG_IF (m_componentCarrierPhyParams.size() != 0, "CC map is not clean");
772 DoComponentCarrierConfigure (dev->GetDlEarfcn () + 18000, dev->GetDlEarfcn (), 25, 25);
774 "CC map size (" << m_componentCarrierPhyParams.size () <<
775 ") must be equal to number of carriers (" <<
776 m_noOfCcs << ")");
777
778 std::map<uint8_t, Ptr<ComponentCarrierUe> > ueCcMap;
779
780 for (std::map< uint8_t, ComponentCarrier >::iterator it = m_componentCarrierPhyParams.begin();
781 it != m_componentCarrierPhyParams.end();
782 ++it)
783 {
784 Ptr <ComponentCarrierUe> cc = CreateObject<ComponentCarrierUe> ();
785 cc->SetUlBandwidth (it->second.GetUlBandwidth ());
786 cc->SetDlBandwidth (it->second.GetDlBandwidth ());
787 cc->SetDlEarfcn (it->second.GetDlEarfcn ());
788 cc->SetUlEarfcn (it->second.GetUlEarfcn ());
789 cc->SetAsPrimary (it->second.IsPrimary ());
790 Ptr<LteUeMac> mac = CreateObject<LteUeMac> ();
791 cc->SetMac (mac);
792 // cc->GetPhy ()->Initialize (); // it is initialized within the LteUeNetDevice::DoInitialize ()
793 ueCcMap.insert (std::pair<uint8_t, Ptr<ComponentCarrierUe> > (it->first, cc));
794 }
795 // CC map is not needed anymore
797
798 for (std::map<uint8_t, Ptr<ComponentCarrierUe> >::iterator it = ueCcMap.begin (); it != ueCcMap.end (); ++it)
799 {
800 Ptr<LteSpectrumPhy> dlPhy = CreateObject<LteSpectrumPhy> ();
801 Ptr<LteSpectrumPhy> ulPhy = CreateObject<LteSpectrumPhy> ();
802
803 Ptr<LteUePhy> phy = CreateObject<LteUePhy> (dlPhy, ulPhy);
804
805 Ptr<LteHarqPhy> harq = Create<LteHarqPhy> ();
806 dlPhy->SetHarqPhyModule (harq);
807 ulPhy->SetHarqPhyModule (harq);
808 phy->SetHarqPhyModule (harq);
809
810 Ptr<LteChunkProcessor> pRs = Create<LteChunkProcessor> ();
811 pRs->AddCallback (MakeCallback (&LteUePhy::ReportRsReceivedPower, phy));
812 dlPhy->AddRsPowerChunkProcessor (pRs);
813
814 Ptr<LteChunkProcessor> pInterf = Create<LteChunkProcessor> ();
815 pInterf->AddCallback (MakeCallback (&LteUePhy::ReportInterference, phy));
816 dlPhy->AddInterferenceCtrlChunkProcessor (pInterf); // for RSRQ evaluation of UE Measurements
817
818 Ptr<LteChunkProcessor> pCtrl = Create<LteChunkProcessor> ();
819 pCtrl->AddCallback (MakeCallback (&LteSpectrumPhy::UpdateSinrPerceived, dlPhy));
820 dlPhy->AddCtrlSinrChunkProcessor (pCtrl);
821
822 Ptr<LteChunkProcessor> pData = Create<LteChunkProcessor> ();
823 pData->AddCallback (MakeCallback (&LteSpectrumPhy::UpdateSinrPerceived, dlPhy));
824 dlPhy->AddDataSinrChunkProcessor (pData);
825
827 {
828 // CQI calculation based on PDCCH for signal and PDSCH for interference
829 //NOTE: Change in pCtrl chunk processor could impact the RLF detection
830 //since it is based on CTRL SINR.
831 pCtrl->AddCallback (MakeCallback (&LteUePhy::GenerateMixedCqiReport, phy));
832 Ptr<LteChunkProcessor> pDataInterf = Create<LteChunkProcessor> ();
833 pDataInterf->AddCallback (MakeCallback (&LteUePhy::ReportDataInterference, phy));
834 dlPhy->AddInterferenceDataChunkProcessor (pDataInterf);
835 }
836 else
837 {
838 // CQI calculation based on PDCCH for both signal and interference
839 pCtrl->AddCallback (MakeCallback (&LteUePhy::GenerateCtrlCqiReport, phy));
840 }
841
842 dlPhy->SetChannel (m_downlinkChannel);
843 ulPhy->SetChannel (m_uplinkChannel);
844
845 Ptr<MobilityModel> mm = n->GetObject<MobilityModel> ();
846 NS_ASSERT_MSG (mm, "MobilityModel needs to be set on node before calling LteHelper::InstallUeDevice ()");
847 dlPhy->SetMobility (mm);
848 ulPhy->SetMobility (mm);
849
850 Ptr<AntennaModel> antenna = (m_ueAntennaModelFactory.Create ())->GetObject<AntennaModel> ();
851 NS_ASSERT_MSG (antenna, "error in creating the AntennaModel object");
852 dlPhy->SetAntenna (antenna);
853 ulPhy->SetAntenna (antenna);
854
855 it->second->SetPhy(phy);
856 }
858
859 Ptr<LteUeRrc> rrc = CreateObject<LteUeRrc> ();
860 rrc->SetLteMacSapProvider (ccmUe->GetLteMacSapProvider ());
861 // setting ComponentCarrierManager SAP
862 rrc->SetLteCcmRrcSapProvider (ccmUe->GetLteCcmRrcSapProvider ());
863 ccmUe->SetLteCcmRrcSapUser (rrc->GetLteCcmRrcSapUser ());
864 // Set number of component carriers. Note: UE CCM would also set the
865 // number of component carriers in UE RRC
866 ccmUe->SetNumberOfComponentCarriers (m_noOfCcs);
867
868 // run intializeSap to create the proper number of MAC and PHY control sap provider/users
869 rrc->InitializeSap();
870
871 if (m_useIdealRrc)
872 {
873 Ptr<LteUeRrcProtocolIdeal> rrcProtocol = CreateObject<LteUeRrcProtocolIdeal> ();
874 rrcProtocol->SetUeRrc (rrc);
875 rrc->AggregateObject (rrcProtocol);
876 rrcProtocol->SetLteUeRrcSapProvider (rrc->GetLteUeRrcSapProvider ());
877 rrc->SetLteUeRrcSapUser (rrcProtocol->GetLteUeRrcSapUser ());
878 }
879 else
880 {
881 Ptr<LteUeRrcProtocolReal> rrcProtocol = CreateObject<LteUeRrcProtocolReal> ();
882 rrcProtocol->SetUeRrc (rrc);
883 rrc->AggregateObject (rrcProtocol);
884 rrcProtocol->SetLteUeRrcSapProvider (rrc->GetLteUeRrcSapProvider ());
885 rrc->SetLteUeRrcSapUser (rrcProtocol->GetLteUeRrcSapUser ());
886 }
887
888 if (m_epcHelper != 0)
889 {
890 rrc->SetUseRlcSm (false);
891 }
892 Ptr<EpcUeNas> nas = CreateObject<EpcUeNas> ();
893
894 nas->SetAsSapProvider (rrc->GetAsSapProvider ());
895 rrc->SetAsSapUser (nas->GetAsSapUser ());
896
897 for (std::map<uint8_t, Ptr<ComponentCarrierUe> >::iterator it = ueCcMap.begin (); it != ueCcMap.end (); ++it)
898 {
899 rrc->SetLteUeCmacSapProvider (it->second->GetMac ()->GetLteUeCmacSapProvider (), it->first);
900 it->second->GetMac ()->SetLteUeCmacSapUser (rrc->GetLteUeCmacSapUser (it->first));
901 it->second->GetMac ()->SetComponentCarrierId (it->first);
902
903 it->second->GetPhy ()->SetLteUeCphySapUser (rrc->GetLteUeCphySapUser (it->first));
904 rrc->SetLteUeCphySapProvider (it->second->GetPhy ()->GetLteUeCphySapProvider (), it->first);
905 it->second->GetPhy ()->SetComponentCarrierId (it->first);
906 it->second->GetPhy ()->SetLteUePhySapUser (it->second->GetMac ()->GetLteUePhySapUser ());
907 it->second->GetMac ()->SetLteUePhySapProvider (it->second->GetPhy ()->GetLteUePhySapProvider ());
908
909 bool ccmTest = ccmUe->SetComponentCarrierMacSapProviders (it->first, it->second->GetMac ()->GetLteMacSapProvider());
910
911 if (ccmTest == false)
912 {
913 NS_FATAL_ERROR ("Error in SetComponentCarrierMacSapProviders");
914 }
915 }
916
917 NS_ABORT_MSG_IF (m_imsiCounter >= 0xFFFFFFFF, "max num UEs exceeded");
918 uint64_t imsi = ++m_imsiCounter;
919
920
921 dev->SetNode (n);
922 dev->SetAttribute ("Imsi", UintegerValue (imsi));
923 dev->SetCcMap (ueCcMap);
924 dev->SetAttribute ("LteUeRrc", PointerValue (rrc));
925 dev->SetAttribute ("EpcUeNas", PointerValue (nas));
926 dev->SetAttribute ("LteUeComponentCarrierManager", PointerValue (ccmUe));
927 // \todo The UE identifier should be dynamically set by the EPC
928 // when the default PDP context is created. This is a simplification.
929 dev->SetAddress (Mac64Address::Allocate ());
930
931 for (std::map<uint8_t, Ptr<ComponentCarrierUe> >::iterator it = ueCcMap.begin (); it != ueCcMap.end (); ++it)
932 {
933 Ptr<LteUePhy> ccPhy = it->second->GetPhy ();
934 ccPhy->SetDevice (dev);
935 ccPhy->GetUlSpectrumPhy ()->SetDevice (dev);
936 ccPhy->GetDlSpectrumPhy ()->SetDevice (dev);
937 ccPhy->GetDlSpectrumPhy ()->SetLtePhyRxDataEndOkCallback (MakeCallback (&LteUePhy::PhyPduReceived, ccPhy));
938 ccPhy->GetDlSpectrumPhy ()->SetLtePhyRxCtrlEndOkCallback (MakeCallback (&LteUePhy::ReceiveLteControlMessageList, ccPhy));
939 ccPhy->GetDlSpectrumPhy ()->SetLtePhyRxPssCallback (MakeCallback (&LteUePhy::ReceivePss, ccPhy));
940 ccPhy->GetDlSpectrumPhy ()->SetLtePhyDlHarqFeedbackCallback (MakeCallback (&LteUePhy::EnqueueDlHarqFeedback, ccPhy));
941 }
942
943 nas->SetDevice (dev);
944
945 n->AddDevice (dev);
946
947 nas->SetForwardUpCallback (MakeCallback (&LteUeNetDevice::Receive, dev));
948
949 if (m_epcHelper != 0)
950 {
951 m_epcHelper->AddUe (dev, dev->GetImsi ());
952 }
953
954 dev->Initialize ();
955
956 return dev;
957}
958
959
960void
962{
963 NS_LOG_FUNCTION (this);
964 for (NetDeviceContainer::Iterator i = ueDevices.Begin (); i != ueDevices.End (); ++i)
965 {
966 Attach (*i);
967 }
968}
969
970void
972{
973 NS_LOG_FUNCTION (this);
974
975 if (m_epcHelper == 0)
976 {
977 NS_FATAL_ERROR ("This function is not valid without properly configured EPC");
978 }
979
980 Ptr<LteUeNetDevice> ueLteDevice = ueDevice->GetObject<LteUeNetDevice> ();
981 if (ueLteDevice == 0)
982 {
983 NS_FATAL_ERROR ("The passed NetDevice must be an LteUeNetDevice");
984 }
985
986 // initiate cell selection
987 Ptr<EpcUeNas> ueNas = ueLteDevice->GetNas ();
988 NS_ASSERT (ueNas != 0);
989 uint32_t dlEarfcn = ueLteDevice->GetDlEarfcn ();
990 ueNas->StartCellSelection (dlEarfcn);
991
992 // instruct UE to immediately enter CONNECTED mode after camping
993 ueNas->Connect ();
994
995 // activate default EPS bearer
996 m_epcHelper->ActivateEpsBearer (ueDevice, ueLteDevice->GetImsi (),
999}
1000
1001void
1003{
1004 NS_LOG_FUNCTION (this);
1005 for (NetDeviceContainer::Iterator i = ueDevices.Begin (); i != ueDevices.End (); ++i)
1006 {
1007 Attach (*i, enbDevice);
1008 }
1009}
1010
1011void
1013{
1014 NS_LOG_FUNCTION (this);
1015 //enbRrc->SetCellId (enbDevice->GetObject<LteEnbNetDevice> ()->GetCellId ());
1016
1017 Ptr<LteUeNetDevice> ueLteDevice = ueDevice->GetObject<LteUeNetDevice> ();
1018 Ptr<LteEnbNetDevice> enbLteDevice = enbDevice->GetObject<LteEnbNetDevice> ();
1019
1020 Ptr<EpcUeNas> ueNas = ueLteDevice->GetNas ();
1021 ueNas->Connect (enbLteDevice->GetCellId (), enbLteDevice->GetDlEarfcn ());
1022
1023 if (m_epcHelper != 0)
1024 {
1025 // activate default EPS bearer
1026 m_epcHelper->ActivateEpsBearer (ueDevice, ueLteDevice->GetImsi (), EpcTft::Default (), EpsBearer (EpsBearer::NGBR_VIDEO_TCP_DEFAULT));
1027 }
1028
1029 // tricks needed for the simplified LTE-only simulations
1030 if (m_epcHelper == 0)
1031 {
1032 ueDevice->GetObject<LteUeNetDevice> ()->SetTargetEnb (enbDevice->GetObject<LteEnbNetDevice> ());
1033 }
1034}
1035
1036void
1038{
1039 NS_LOG_FUNCTION (this);
1040 for (NetDeviceContainer::Iterator i = ueDevices.Begin (); i != ueDevices.End (); ++i)
1041 {
1042 AttachToClosestEnb (*i, enbDevices);
1043 }
1044}
1045
1046void
1048{
1049 NS_LOG_FUNCTION (this);
1050 NS_ASSERT_MSG (enbDevices.GetN () > 0, "empty enb device container");
1051 Vector uepos = ueDevice->GetNode ()->GetObject<MobilityModel> ()->GetPosition ();
1052 double minDistance = std::numeric_limits<double>::infinity ();
1053 Ptr<NetDevice> closestEnbDevice;
1054 for (NetDeviceContainer::Iterator i = enbDevices.Begin (); i != enbDevices.End (); ++i)
1055 {
1056 Vector enbpos = (*i)->GetNode ()->GetObject<MobilityModel> ()->GetPosition ();
1057 double distance = CalculateDistance (uepos, enbpos);
1058 if (distance < minDistance)
1059 {
1060 minDistance = distance;
1061 closestEnbDevice = *i;
1062 }
1063 }
1064 NS_ASSERT (closestEnbDevice != 0);
1065 Attach (ueDevice, closestEnbDevice);
1066}
1067
1068uint8_t
1070{
1071 NS_LOG_FUNCTION (this);
1072 for (NetDeviceContainer::Iterator i = ueDevices.Begin (); i != ueDevices.End (); ++i)
1073 {
1074 uint8_t bearerId = ActivateDedicatedEpsBearer (*i, bearer, tft);
1075 return bearerId;
1076 }
1077 return 0;
1078}
1079
1080
1081uint8_t
1083{
1084 NS_LOG_FUNCTION (this);
1085
1086 NS_ASSERT_MSG (m_epcHelper != 0, "dedicated EPS bearers cannot be set up when the EPC is not used");
1087
1088 uint64_t imsi = ueDevice->GetObject<LteUeNetDevice> ()->GetImsi ();
1089 uint8_t bearerId = m_epcHelper->ActivateEpsBearer (ueDevice, imsi, tft, bearer);
1090 return bearerId;
1091}
1092
1102class DrbActivator : public SimpleRefCount<DrbActivator>
1103{
1104public:
1111 DrbActivator (Ptr<NetDevice> ueDevice, EpsBearer bearer);
1112
1123 static void ActivateCallback (Ptr<DrbActivator> a, std::string context, uint64_t imsi, uint16_t cellId, uint16_t rnti);
1124
1135 void ActivateDrb (uint64_t imsi, uint16_t cellId, uint16_t rnti);
1136private:
1154 uint64_t m_imsi;
1155};
1156
1158 : m_active (false),
1159 m_ueDevice (ueDevice),
1160 m_bearer (bearer),
1161 m_imsi (m_ueDevice->GetObject<LteUeNetDevice> ()->GetImsi ())
1162{
1163}
1164
1165void
1166DrbActivator::ActivateCallback (Ptr<DrbActivator> a, std::string context, uint64_t imsi, uint16_t cellId, uint16_t rnti)
1167{
1168 NS_LOG_FUNCTION (a << context << imsi << cellId << rnti);
1169 a->ActivateDrb (imsi, cellId, rnti);
1170}
1171
1172void
1173DrbActivator::ActivateDrb (uint64_t imsi, uint16_t cellId, uint16_t rnti)
1174{
1175 NS_LOG_FUNCTION (this << imsi << cellId << rnti << m_active);
1176 if ((!m_active) && (imsi == m_imsi))
1177 {
1178 Ptr<LteUeRrc> ueRrc = m_ueDevice->GetObject<LteUeNetDevice> ()->GetRrc ();
1179 NS_ASSERT (ueRrc->GetState () == LteUeRrc::CONNECTED_NORMALLY);
1180 uint16_t rnti = ueRrc->GetRnti ();
1181 Ptr<LteEnbNetDevice> enbLteDevice = m_ueDevice->GetObject<LteUeNetDevice> ()->GetTargetEnb ();
1182 Ptr<LteEnbRrc> enbRrc = enbLteDevice->GetObject<LteEnbNetDevice> ()->GetRrc ();
1183 NS_ASSERT (ueRrc->GetCellId () == enbLteDevice->GetCellId ());
1184 Ptr<UeManager> ueManager = enbRrc->GetUeManager (rnti);
1185 NS_ASSERT (ueManager->GetState () == UeManager::CONNECTED_NORMALLY
1186 || ueManager->GetState () == UeManager::CONNECTION_RECONFIGURATION);
1188 params.rnti = rnti;
1189 params.bearer = m_bearer;
1190 params.bearerId = 0;
1191 params.gtpTeid = 0; // don't care
1192 enbRrc->GetS1SapUser ()->DataRadioBearerSetupRequest (params);
1193 m_active = true;
1194 }
1195}
1196
1197
1198void
1200{
1201 NS_LOG_FUNCTION (this << ueDevice);
1202 NS_ASSERT_MSG (m_epcHelper == 0, "this method must not be used when the EPC is being used");
1203
1204 // Normally it is the EPC that takes care of activating DRBs
1205 // when the UE gets connected. When the EPC is not used, we achieve
1206 // the same behavior by hooking a dedicated DRB activation function
1207 // to the Enb RRC Connection Established trace source
1208
1209
1210 Ptr<LteEnbNetDevice> enbLteDevice = ueDevice->GetObject<LteUeNetDevice> ()->GetTargetEnb ();
1211
1212 std::ostringstream path;
1213 path << "/NodeList/" << enbLteDevice->GetNode ()->GetId ()
1214 << "/DeviceList/" << enbLteDevice->GetIfIndex ()
1215 << "/LteEnbRrc/ConnectionEstablished";
1216 Ptr<DrbActivator> arg = Create<DrbActivator> (ueDevice, bearer);
1218}
1219
1220void
1222{
1223 NS_LOG_FUNCTION (this);
1224
1225 NS_ASSERT_MSG (m_epcHelper != 0, "X2 interfaces cannot be set up when the EPC is not used");
1226
1227 for (NodeContainer::Iterator i = enbNodes.Begin (); i != enbNodes.End (); ++i)
1228 {
1229 for (NodeContainer::Iterator j = i + 1; j != enbNodes.End (); ++j)
1230 {
1231 AddX2Interface (*i, *j);
1232 }
1233 }
1234}
1235
1236void
1238{
1239 NS_LOG_FUNCTION (this);
1240 NS_LOG_INFO ("setting up the X2 interface");
1241
1242 m_epcHelper->AddX2Interface (enbNode1, enbNode2);
1243}
1244
1245void
1247{
1248 NS_LOG_FUNCTION (this << ueDev << sourceEnbDev << targetEnbDev);
1249 NS_ASSERT_MSG (m_epcHelper, "Handover requires the use of the EPC - did you forget to call LteHelper::SetEpcHelper () ?");
1250 uint16_t targetCellId = targetEnbDev->GetObject<LteEnbNetDevice> ()->GetCellId ();
1251 Simulator::Schedule (hoTime, &LteHelper::DoHandoverRequest, this, ueDev, sourceEnbDev, targetCellId);
1252}
1253
1254void
1255LteHelper::HandoverRequest (Time hoTime, Ptr<NetDevice> ueDev, Ptr<NetDevice> sourceEnbDev, uint16_t targetCellId)
1256{
1257 NS_LOG_FUNCTION (this << ueDev << sourceEnbDev << targetCellId);
1258 NS_ASSERT_MSG (m_epcHelper, "Handover requires the use of the EPC - did you forget to call LteHelper::SetEpcHelper () ?");
1259 Simulator::Schedule (hoTime, &LteHelper::DoHandoverRequest, this, ueDev, sourceEnbDev, targetCellId);
1260}
1261
1262void
1263LteHelper::DoHandoverRequest (Ptr<NetDevice> ueDev, Ptr<NetDevice> sourceEnbDev, uint16_t targetCellId)
1264{
1265 NS_LOG_FUNCTION (this << ueDev << sourceEnbDev << targetCellId);
1266
1267 Ptr<LteEnbRrc> sourceRrc = sourceEnbDev->GetObject<LteEnbNetDevice> ()->GetRrc ();
1268 uint16_t rnti = ueDev->GetObject<LteUeNetDevice> ()->GetRrc ()->GetRnti ();
1269 sourceRrc->SendHandoverRequest (rnti, targetCellId);
1270}
1271
1272void
1274{
1275 NS_LOG_FUNCTION (this << ueDevice << bearerId);
1276 NS_ASSERT_MSG (m_epcHelper != 0, "Dedicated EPS bearers cannot be de-activated when the EPC is not used");
1277 NS_ASSERT_MSG (bearerId != 1, "Default bearer cannot be de-activated until and unless and UE is released");
1278
1279 DoDeActivateDedicatedEpsBearer (ueDevice, enbDevice, bearerId);
1280}
1281
1282void
1284{
1285 NS_LOG_FUNCTION (this << ueDevice << bearerId);
1286
1287 //Extract IMSI and rnti
1288 uint64_t imsi = ueDevice->GetObject<LteUeNetDevice> ()->GetImsi ();
1289 uint16_t rnti = ueDevice->GetObject<LteUeNetDevice> ()->GetRrc ()->GetRnti ();
1290
1291
1292 Ptr<LteEnbRrc> enbRrc = enbDevice->GetObject<LteEnbNetDevice> ()->GetRrc ();
1293
1294 enbRrc->DoSendReleaseDataRadioBearer (imsi,rnti,bearerId);
1295}
1296
1297void
1298LteHelper::DoComponentCarrierConfigure (uint32_t ulEarfcn, uint32_t dlEarfcn, uint16_t ulbw, uint16_t dlbw)
1299{
1300 NS_LOG_FUNCTION (this << ulEarfcn << dlEarfcn << ulbw << dlbw);
1301
1302 NS_ABORT_MSG_IF (m_componentCarrierPhyParams.size() != 0, "CC map is not clean");
1303 Ptr<CcHelper> ccHelper = CreateObject<CcHelper> ();
1304 ccHelper->SetNumberOfComponentCarriers (m_noOfCcs);
1305 ccHelper->SetUlEarfcn (ulEarfcn);
1306 ccHelper->SetDlEarfcn (dlEarfcn);
1307 ccHelper->SetDlBandwidth (dlbw);
1308 ccHelper->SetUlBandwidth (ulbw);
1309 m_componentCarrierPhyParams = ccHelper->EquallySpacedCcs ();
1310 m_componentCarrierPhyParams.at (0).SetAsPrimary (true);
1311}
1312
1313void
1315{
1316 NS_LOG_FUNCTION (this);
1317 for (NetDeviceContainer::Iterator i = ueDevices.Begin (); i != ueDevices.End (); ++i)
1318 {
1319 ActivateDataRadioBearer (*i, bearer);
1320 }
1321}
1322
1323void
1325{
1329 // Model directory
1330 LogComponentEnable ("A2A4RsrqHandoverAlgorithm", LOG_LEVEL_ALL);
1331 LogComponentEnable ("A3RsrpHandoverAlgorithm", LOG_LEVEL_ALL);
1332 LogComponentEnable ("Asn1Header", LOG_LEVEL_ALL);
1333 LogComponentEnable ("ComponentCarrier", LOG_LEVEL_ALL);
1334 LogComponentEnable ("ComponentCarrierEnb", LOG_LEVEL_ALL);
1335 LogComponentEnable ("ComponentCarrierUe", LOG_LEVEL_ALL);
1336 LogComponentEnable ("CqaFfMacScheduler", LOG_LEVEL_ALL);
1337 LogComponentEnable ("EpcEnbApplication", LOG_LEVEL_ALL);
1338 LogComponentEnable ("EpcMmeApplication", LOG_LEVEL_ALL);
1339 LogComponentEnable ("EpcPgwApplication", LOG_LEVEL_ALL);
1340 LogComponentEnable ("EpcSgwApplication", LOG_LEVEL_ALL);
1342 LogComponentEnable ("EpcTftClassifier", LOG_LEVEL_ALL);
1343 LogComponentEnable ("EpcUeNas", LOG_LEVEL_ALL);
1345 LogComponentEnable ("EpcX2Header", LOG_LEVEL_ALL);
1346 LogComponentEnable ("FdBetFfMacScheduler", LOG_LEVEL_ALL);
1347 LogComponentEnable ("FdMtFfMacScheduler", LOG_LEVEL_ALL);
1348 LogComponentEnable ("FdTbfqFfMacScheduler", LOG_LEVEL_ALL);
1349 LogComponentEnable ("FfMacScheduler", LOG_LEVEL_ALL);
1350 LogComponentEnable ("GtpuHeader", LOG_LEVEL_ALL);
1353 LogComponentEnable ("LteChunkProcessor", LOG_LEVEL_ALL);
1354 LogComponentEnable ("LteCommon", LOG_LEVEL_ALL);
1355 LogComponentEnable ("LteControlMessage", LOG_LEVEL_ALL);
1356 LogComponentEnable ("LteEnbComponentCarrierManager", LOG_LEVEL_ALL);
1357 LogComponentEnable ("LteEnbMac", LOG_LEVEL_ALL);
1358 LogComponentEnable ("LteEnbNetDevice", LOG_LEVEL_ALL);
1359 LogComponentEnable ("LteEnbPhy", LOG_LEVEL_ALL);
1360 LogComponentEnable ("LteEnbRrc", LOG_LEVEL_ALL);
1361 LogComponentEnable ("LteFfrAlgorithm", LOG_LEVEL_ALL);
1362 LogComponentEnable ("LteFfrDistributedAlgorithm", LOG_LEVEL_ALL);
1363 LogComponentEnable ("LteFfrEnhancedAlgorithm", LOG_LEVEL_ALL);
1364 LogComponentEnable ("LteFfrSoftAlgorithm", LOG_LEVEL_ALL);
1365 LogComponentEnable ("LteFrHardAlgorithm", LOG_LEVEL_ALL);
1366 LogComponentEnable ("LteFrNoOpAlgorithm", LOG_LEVEL_ALL);
1367 LogComponentEnable ("LteFrSoftAlgorithm", LOG_LEVEL_ALL);
1368 LogComponentEnable ("LteFrStrictAlgorithm", LOG_LEVEL_ALL);
1369 LogComponentEnable ("LteHandoverAlgorithm", LOG_LEVEL_ALL);
1370 LogComponentEnable ("LteHarqPhy", LOG_LEVEL_ALL);
1371 LogComponentEnable ("LteInterference", LOG_LEVEL_ALL);
1372 LogComponentEnable ("LteMiErrorModel", LOG_LEVEL_ALL);
1373 LogComponentEnable ("LteNetDevice", LOG_LEVEL_ALL);
1374 LogComponentEnable ("LtePdcp", LOG_LEVEL_ALL);
1375 LogComponentEnable ("LtePdcpHeader", LOG_LEVEL_ALL);
1378 LogComponentEnable ("LteRlcAm", LOG_LEVEL_ALL);
1379 LogComponentEnable ("LteRlcAmHeader", LOG_LEVEL_ALL);
1380 LogComponentEnable ("LteRlcHeader", LOG_LEVEL_ALL);
1381 LogComponentEnable ("LteRlcTm", LOG_LEVEL_ALL);
1382 LogComponentEnable ("LteRlcUm", LOG_LEVEL_ALL);
1383 LogComponentEnable ("LteRrcProtocolIdeal", LOG_LEVEL_ALL);
1384 LogComponentEnable ("LteRrcProtocolReal", LOG_LEVEL_ALL);
1385 LogComponentEnable ("LteSpectrumPhy", LOG_LEVEL_ALL);
1386 LogComponentEnable ("LteSpectrumSignalParameters", LOG_LEVEL_ALL);
1387 LogComponentEnable ("LteSpectrumValueHelper", LOG_LEVEL_ALL);
1388 LogComponentEnable ("LteUeComponentCarrierManager", LOG_LEVEL_ALL);
1389 LogComponentEnable ("LteUeMac", LOG_LEVEL_ALL);
1390 LogComponentEnable ("LteUeNetDevice", LOG_LEVEL_ALL);
1391 LogComponentEnable ("LteUePhy", LOG_LEVEL_ALL);
1392 LogComponentEnable ("LteUePowerControl", LOG_LEVEL_ALL);
1393 LogComponentEnable ("LteUeRrc", LOG_LEVEL_ALL);
1394 LogComponentEnable ("LteVendorSpecificParameters", LOG_LEVEL_ALL);
1395 LogComponentEnable ("NoOpComponentCarrierManager", LOG_LEVEL_ALL);
1396 LogComponentEnable ("NoOpHandoverAlgorithm", LOG_LEVEL_ALL);
1397 LogComponentEnable ("PfFfMacScheduler", LOG_LEVEL_ALL);
1398 LogComponentEnable ("PssFfMacScheduler", LOG_LEVEL_ALL);
1399 LogComponentEnable ("RemSpectrumPhy", LOG_LEVEL_ALL);
1400 LogComponentEnable ("RrcHeader", LOG_LEVEL_ALL);
1401 LogComponentEnable ("RrFfMacScheduler", LOG_LEVEL_ALL);
1402 LogComponentEnable ("SimpleUeComponentCarrierManager", LOG_LEVEL_ALL);
1403 LogComponentEnable ("TdBetFfMacScheduler", LOG_LEVEL_ALL);
1404 LogComponentEnable ("TdMtFfMacScheduler", LOG_LEVEL_ALL);
1405 LogComponentEnable ("TdTbfqFfMacScheduler", LOG_LEVEL_ALL);
1406 LogComponentEnable ("TraceFadingLossModel", LOG_LEVEL_ALL);
1407 LogComponentEnable ("TtaFfMacScheduler", LOG_LEVEL_ALL);
1408 // Helper directory
1409 LogComponentEnable ("CcHelper", LOG_LEVEL_ALL);
1410 LogComponentEnable ("EmuEpcHelper", LOG_LEVEL_ALL);
1411 LogComponentEnable ("EpcHelper", LOG_LEVEL_ALL);
1412 LogComponentEnable ("LteGlobalPathlossDatabase", LOG_LEVEL_ALL);
1413 LogComponentEnable ("LteHelper", LOG_LEVEL_ALL);
1414 LogComponentEnable ("LteHexGridEnbTopologyHelper", LOG_LEVEL_ALL);
1415 LogComponentEnable ("LteStatsCalculator", LOG_LEVEL_ALL);
1416 LogComponentEnable ("MacStatsCalculator", LOG_LEVEL_ALL);
1417 LogComponentEnable ("PhyRxStatsCalculator", LOG_LEVEL_ALL);
1418 LogComponentEnable ("PhyStatsCalculator", LOG_LEVEL_ALL);
1419 LogComponentEnable ("PhyTxStatsCalculator", LOG_LEVEL_ALL);
1420 LogComponentEnable ("PointToPointEpcHelper", LOG_LEVEL_ALL);
1421 LogComponentEnable ("RadioBearerStatsCalculator", LOG_LEVEL_ALL);
1422 LogComponentEnable ("RadioBearerStatsConnector", LOG_LEVEL_ALL);
1423 LogComponentEnable ("RadioEnvironmentMapHelper", LOG_LEVEL_ALL);
1424}
1425
1426void
1428{
1429 EnablePhyTraces ();
1430 EnableMacTraces ();
1431 EnableRlcTraces ();
1433}
1434
1435void
1437{
1438 NS_ASSERT_MSG (m_rlcStats == 0, "please make sure that LteHelper::EnableRlcTraces is called at most once");
1439 m_rlcStats = CreateObject<RadioBearerStatsCalculator> ("RLC");
1441}
1442
1443int64_t
1445{
1446 int64_t currentStream = stream;
1447 if ((m_fadingModel != 0) && (m_fadingStreamsAssigned == false))
1448 {
1450 if (tflm != 0)
1451 {
1452 currentStream += tflm->AssignStreams (currentStream);
1454 }
1455 }
1456 Ptr<NetDevice> netDevice;
1457 for (NetDeviceContainer::Iterator i = c.Begin (); i != c.End (); ++i)
1458 {
1459 netDevice = (*i);
1460 Ptr<LteEnbNetDevice> lteEnb = DynamicCast<LteEnbNetDevice> (netDevice);
1461 if (lteEnb)
1462 {
1463 std::map< uint8_t, Ptr <ComponentCarrierBaseStation> > tmpMap = lteEnb->GetCcMap ();
1464 std::map< uint8_t, Ptr <ComponentCarrierBaseStation> >::iterator it;
1465 it = tmpMap.begin ();
1466 Ptr<LteSpectrumPhy> dlPhy = DynamicCast<ComponentCarrierEnb> (it->second)->GetPhy ()->GetDownlinkSpectrumPhy ();
1467 Ptr<LteSpectrumPhy> ulPhy = DynamicCast<ComponentCarrierEnb> (it->second)->GetPhy ()->GetUplinkSpectrumPhy ();
1468 currentStream += dlPhy->AssignStreams (currentStream);
1469 currentStream += ulPhy->AssignStreams (currentStream);
1470 }
1471 Ptr<LteUeNetDevice> lteUe = DynamicCast<LteUeNetDevice> (netDevice);
1472 if (lteUe)
1473 {
1474 std::map< uint8_t, Ptr <ComponentCarrierUe> > tmpMap = lteUe->GetCcMap ();
1475 std::map< uint8_t, Ptr <ComponentCarrierUe> >::iterator it;
1476 it = tmpMap.begin ();
1477 Ptr<LteSpectrumPhy> dlPhy = it->second->GetPhy ()->GetDownlinkSpectrumPhy ();
1478 Ptr<LteSpectrumPhy> ulPhy = it->second->GetPhy ()->GetUplinkSpectrumPhy ();
1479 Ptr<LteUeMac> ueMac = lteUe->GetMac ();
1480 currentStream += dlPhy->AssignStreams (currentStream);
1481 currentStream += ulPhy->AssignStreams (currentStream);
1482 currentStream += ueMac->AssignStreams (currentStream);
1483 }
1484 }
1485 return (currentStream - stream);
1486}
1487
1488
1489void
1491{
1498}
1499
1500void
1502{
1503 Config::Connect ("/NodeList/*/DeviceList/*/ComponentCarrierMap/*/LteEnbPhy/DlPhyTransmission",
1505}
1506
1507void
1509{
1510 Config::Connect ("/NodeList/*/DeviceList/*/ComponentCarrierMapUe/*/LteUePhy/UlPhyTransmission",
1512}
1513
1514void
1516{
1517 Config::Connect ("/NodeList/*/DeviceList/*/ComponentCarrierMapUe/*/LteUePhy/DlSpectrumPhy/DlPhyReception",
1519}
1520
1521void
1523{
1524 Config::Connect ("/NodeList/*/DeviceList/*/ComponentCarrierMap/*/LteEnbPhy/UlSpectrumPhy/UlPhyReception",
1526}
1527
1528
1529void
1531{
1534}
1535
1536
1537void
1539{
1541 Config::Connect ("/NodeList/*/DeviceList/*/ComponentCarrierMap/*/LteEnbMac/DlScheduling",
1543}
1544
1545void
1547{
1549 Config::Connect ("/NodeList/*/DeviceList/*/ComponentCarrierMap/*/LteEnbMac/UlScheduling",
1551}
1552
1553void
1555{
1557 Config::Connect ("/NodeList/*/DeviceList/*/ComponentCarrierMapUe/*/LteUePhy/ReportCurrentCellRsrpSinr",
1559}
1560
1561void
1563{
1565 Config::Connect ("/NodeList/*/DeviceList/*/ComponentCarrierMap/*/LteEnbPhy/ReportUeSinr",
1567 Config::Connect ("/NodeList/*/DeviceList/*/ComponentCarrierMap/*/LteEnbPhy/ReportInterference",
1569
1570}
1571
1574{
1575 return m_rlcStats;
1576}
1577
1578void
1580{
1581 NS_ASSERT_MSG (m_pdcpStats == 0, "please make sure that LteHelper::EnablePdcpTraces is called at most once");
1582 m_pdcpStats = CreateObject<RadioBearerStatsCalculator> ("PDCP");
1584}
1585
1588{
1589 return m_pdcpStats;
1590}
1591
1592} // namespace ns3
Hold a value for an Attribute.
Definition: attribute.h:69
AttributeValue implementation for Boolean.
Definition: boolean.h:37
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition: double.h:41
DrbActivatior allows user to activate bearers for UEs when EPC is not used.
Definition: lte-helper.cc:1103
EpsBearer m_bearer
Configuration of bearer which will be activated.
Definition: lte-helper.cc:1150
uint64_t m_imsi
imsi the unique UE identifier
Definition: lte-helper.cc:1154
DrbActivator(Ptr< NetDevice > ueDevice, EpsBearer bearer)
DrbActivator Constructor.
Definition: lte-helper.cc:1157
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...
Definition: lte-helper.cc:1166
Ptr< NetDevice > m_ueDevice
UeNetDevice for which bearer will be activated.
Definition: lte-helper.cc:1146
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...
Definition: lte-helper.cc:1173
bool m_active
Bearer can be activated only once.
Definition: lte-helper.cc:1142
Hold variables of type enum.
Definition: enum.h:55
int Get(void) const
Definition: enum.cc:54
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:224
This entity is installed inside an eNB and provides the functionality for the X2 interface.
Definition: epc-x2.h:100
This class contains the specification of EPS Bearers.
Definition: eps-bearer.h:92
@ NGBR_VIDEO_TCP_DEFAULT
Non-GBR TCP-based Video (Buffered Streaming, e.g., www, e-mail...)
Definition: eps-bearer.h:120
This abstract base class identifies the interface by means of which the helper object can plug on the...
static TypeId GetTypeId(void)
Get the type ID.
The class implements Component Carrier Manager (CCM) that operates using the Component Carrier Manage...
The eNodeB device implementation.
void SetCcMap(std::map< uint8_t, Ptr< ComponentCarrierBaseStation > > ccm)
Set the ComponentCarrier Map of the Enb.
static TypeId GetTypeId(void)
Get the type ID.
uint16_t GetDlBandwidth() const
uint32_t GetUlEarfcn() const
uint32_t GetDlEarfcn() const
uint16_t GetUlBandwidth() const
uint16_t GetCellId() const
std::map< uint8_t, Ptr< ComponentCarrierBaseStation > > GetCcMap(void) const
virtual void ReportUlHarqFeedback(UlInfoListElement_s mes)
Report the uplink HARQ feedback generated by LteSpectrumPhy to MAC.
virtual void ReportInterference(const SpectrumValue &interf)
generate a report based on the linear interference and noise power perceived during DATA frame NOTE: ...
Definition: lte-enb-phy.cc:850
virtual void GenerateDataCqiReport(const SpectrumValue &sinr)
generate a CQI report based on the given SINR of Data frame (used for PUSCH CQIs)
Definition: lte-enb-phy.cc:842
void PhyPduReceived(Ptr< Packet > p)
PhySpectrum received a new PHY-PDU.
Definition: lte-enb-phy.cc:434
virtual void ReceiveLteControlMessageList(std::list< Ptr< LteControlMessage > > msgList)
PhySpectrum received a new list of LteControlMessage.
Definition: lte-enb-phy.cc:527
virtual void GenerateCtrlCqiReport(const SpectrumValue &sinr)
generate a CQI report based on the given SINR of Ctrl frame
Definition: lte-enb-phy.cc:830
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...
Ptr< SpectrumChannel > GetDownlinkSpectrumChannel(void) const
Definition: lte-helper.cc:218
void SetFfrAlgorithmType(std::string type)
Set the type of FFR algorithm to be used by eNodeB devices.
Definition: lte-helper.cc:306
void EnableUlPhyTraces(void)
Enable trace sinks for UL PHY layer.
Definition: lte-helper.cc:1562
Ptr< SpectrumPropagationLossModel > m_fadingModel
The fading model used in both the downlink and uplink channels.
Definition: lte-helper.h:773
Ptr< Object > m_uplinkPathlossModel
The path loss model used in the uplink channel.
Definition: lte-helper.h:743
Ptr< RadioBearerStatsCalculator > GetPdcpStats(void)
Definition: lte-helper.cc:1587
void SetEnbComponentCarrierManagerType(std::string type)
Set the type of carrier component algorithm to be used by eNodeB devices.
Definition: lte-helper.cc:349
void EnableLogComponents(void)
Enables full-blown logging for major components of the LENA architecture.
Definition: lte-helper.cc:1324
ObjectFactory m_schedulerFactory
Factory of MAC scheduler object.
Definition: lte-helper.h:746
void SetUeAntennaModelType(std::string type)
Set the type of antenna model to be used by UE devices.
Definition: lte-helper.cc:429
ObjectFactory m_ffrAlgorithmFactory
Factory of FFR (frequency reuse) algorithm object.
Definition: lte-helper.h:748
void EnableUlTxPhyTraces(void)
Enable trace sinks for UL transmission PHY layer.
Definition: lte-helper.cc:1508
ObjectFactory m_channelFactory
Factory of both the downlink and uplink LTE channels.
Definition: lte-helper.h:766
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 ...
Definition: lte-helper.cc:272
ObjectFactory m_handoverAlgorithmFactory
Factory of handover algorithm object.
Definition: lte-helper.h:750
std::string m_fadingModelType
Name of fading model type, e.g., "ns3::TraceFadingLossModel".
Definition: lte-helper.h:769
ObjectFactory m_enbComponentCarrierManagerFactory
Factory of enb component carrier manager object.
Definition: lte-helper.h:752
void SetFadingModel(std::string type)
Set the type of fading model to be used in both DL and UL.
Definition: lte-helper.cc:443
void DoDeActivateDedicatedEpsBearer(Ptr< NetDevice > ueDevice, Ptr< NetDevice > enbDevice, uint8_t bearerId)
The actual function to trigger a manual bearer de-activation.
Definition: lte-helper.cc:1283
std::string GetEnbComponentCarrierManagerType() const
Definition: lte-helper.cc:343
void SetSchedulerAttribute(std::string n, const AttributeValue &v)
Set an attribute for the scheduler to be created.
Definition: lte-helper.cc:293
void ChannelModelInitialization(void)
Function that performs a channel model initialization of all component carriers.
Definition: lte-helper.cc:224
virtual void DoInitialize(void)
Initialize() implementation.
Definition: lte-helper.cc:89
Ptr< MacStatsCalculator > m_macStats
Container of MAC layer statistics.
Definition: lte-helper.h:787
void SetHandoverAlgorithmAttribute(std::string n, const AttributeValue &v)
Set an attribute for the handover algorithm to be created.
Definition: lte-helper.cc:335
void DeActivateDedicatedEpsBearer(Ptr< NetDevice > ueDevice, Ptr< NetDevice > enbDevice, uint8_t bearerId)
Manually trigger dedicated bearer de-activation at specific simulation time.
Definition: lte-helper.cc:1273
void HandoverRequest(Time hoTime, Ptr< NetDevice > ueDev, Ptr< NetDevice > sourceEnbDev, Ptr< NetDevice > targetEnbDev)
Manually trigger an X2-based handover.
Definition: lte-helper.cc:1246
Ptr< SpectrumChannel > m_downlinkChannel
This function create the component carrier based on provided configuration parameters.
Definition: lte-helper.h:737
NetDeviceContainer InstallEnbDevice(NodeContainer c)
Create a set of eNodeB devices.
Definition: lte-helper.cc:474
void SetUeComponentCarrierManagerAttribute(std::string n, const AttributeValue &v)
Set an attribute for the ue component carrier manager to be created.
Definition: lte-helper.cc:378
uint16_t m_cellIdCounter
Keep track of the number of cell ID allocated.
Definition: lte-helper.h:813
std::string GetFfrAlgorithmType() const
Definition: lte-helper.cc:300
void SetHandoverAlgorithmType(std::string type)
Set the type of handover algorithm to be used by eNodeB devices.
Definition: lte-helper.cc:327
void SetPathlossModelType(TypeId type)
Set the type of path loss model to be used for both DL and UL channels.
Definition: lte-helper.cc:385
Ptr< PhyTxStatsCalculator > m_phyTxStats
Container of PHY layer statistics related to transmission.
Definition: lte-helper.h:783
Ptr< RadioBearerStatsCalculator > GetRlcStats(void)
Definition: lte-helper.cc:1573
void SetEnbAntennaModelType(std::string type)
Set the type of antenna model to be used by eNodeB devices.
Definition: lte-helper.cc:408
void SetFfrAlgorithmAttribute(std::string n, const AttributeValue &v)
Set an attribute for the FFR algorithm to be created.
Definition: lte-helper.cc:314
void DoHandoverRequest(Ptr< NetDevice > ueDev, Ptr< NetDevice > sourceEnbDev, uint16_t targetCellId)
The actual function to trigger a manual handover.
Definition: lte-helper.cc:1263
bool m_isAnrEnabled
The AnrEnabled attribute.
Definition: lte-helper.h:824
void SetEnbComponentCarrierManagerAttribute(std::string n, const AttributeValue &v)
Set an attribute for the enb component carrier manager to be created.
Definition: lte-helper.cc:357
Ptr< PhyRxStatsCalculator > m_phyRxStats
Container of PHY layer statistics related to reception.
Definition: lte-helper.h:785
void SetSpectrumChannelType(std::string type)
Set the type of spectrum channel to be used in both DL and UL.
Definition: lte-helper.cc:461
ObjectFactory m_pathlossModelFactory
Factory of path loss model object.
Definition: lte-helper.h:764
bool m_fadingStreamsAssigned
True if a random variable stream number has been assigned for the fading model.
Definition: lte-helper.h:778
Ptr< SpectrumChannel > GetUplinkSpectrumChannel(void) const
Definition: lte-helper.cc:212
std::string GetUeComponentCarrierManagerType() const
Definition: lte-helper.cc:364
void SetSchedulerType(std::string type)
Set the type of scheduler to be used by eNodeB devices.
Definition: lte-helper.cc:279
RadioBearerStatsConnector m_radioBearerStatsConnector
Connects RLC and PDCP statistics containers to appropriate trace sources.
Definition: lte-helper.h:793
void EnableDlPhyTraces(void)
Enable trace sinks for DL PHY layer.
Definition: lte-helper.cc:1554
void Attach(NetDeviceContainer ueDevices)
Enables automatic attachment of a set of UE devices to a suitable cell using Idle mode initial cell s...
Definition: lte-helper.cc:961
ObjectFactory m_enbNetDeviceFactory
Factory of LteEnbNetDevice objects.
Definition: lte-helper.h:756
std::string GetHandoverAlgorithmType() const
Definition: lte-helper.cc:321
Ptr< PhyStatsCalculator > m_phyStats
Container of PHY layer statistics.
Definition: lte-helper.h:781
void SetPathlossModelAttribute(std::string n, const AttributeValue &v)
Set an attribute for the path loss models to be created.
Definition: lte-helper.cc:393
bool m_useIdealRrc
The UseIdealRrc attribute.
Definition: lte-helper.h:819
ObjectFactory m_ueComponentCarrierManagerFactory
Factory of ue component carrier manager object.
Definition: lte-helper.h:754
void DoComponentCarrierConfigure(uint32_t ulEarfcn, uint32_t dlEarfcn, uint16_t ulbw, uint16_t dlbw)
Configure the component carriers.
Definition: lte-helper.cc:1298
Ptr< Object > m_downlinkPathlossModel
The path loss model used in the downlink channel.
Definition: lte-helper.h:741
Ptr< RadioBearerStatsCalculator > m_pdcpStats
Container of PDCP layer statistics.
Definition: lte-helper.h:791
void EnableUlRxPhyTraces(void)
Enable trace sinks for UL reception PHY layer.
Definition: lte-helper.cc:1522
void EnableRlcTraces(void)
Enable trace sinks for RLC layer.
Definition: lte-helper.cc:1436
bool m_usePdschForCqiGeneration
The UsePdschForCqiGeneration attribute.
Definition: lte-helper.h:830
void SetUeAntennaModelAttribute(std::string n, const AttributeValue &v)
Set an attribute for the UE antenna model to be created.
Definition: lte-helper.cc:436
void SetEnbAntennaModelAttribute(std::string n, const AttributeValue &v)
Set an attribute for the eNodeB antenna model to be created.
Definition: lte-helper.cc:415
static TypeId GetTypeId(void)
Register this type.
Definition: lte-helper.cc:106
void SetEnbDeviceAttribute(std::string n, const AttributeValue &v)
Set an attribute for the eNodeB devices (LteEnbNetDevice) to be created.
Definition: lte-helper.cc:400
bool m_useCa
The UseCa attribute.
Definition: lte-helper.h:838
void ActivateDataRadioBearer(NetDeviceContainer ueDevices, EpsBearer bearer)
Activate a Data Radio Bearer on a given UE devices (for LTE-only simulation).
Definition: lte-helper.cc:1314
NetDeviceContainer InstallUeDevice(NodeContainer c)
Create a set of UE devices.
Definition: lte-helper.cc:489
void EnableDlMacTraces(void)
Enable trace sinks for DL MAC layer.
Definition: lte-helper.cc:1538
uint64_t m_imsiCounter
Keep track of the number of IMSI allocated.
Definition: lte-helper.h:807
ObjectFactory m_ueNetDeviceFactory
Factory for LteUeNetDevice objects.
Definition: lte-helper.h:760
virtual void DoDispose(void)
Destructor implementation.
Definition: lte-helper.cc:202
ObjectFactory m_ueAntennaModelFactory
Factory of antenna object for UE.
Definition: lte-helper.h:762
Ptr< SpectrumChannel > m_uplinkChannel
The uplink LTE channel used in the simulation.
Definition: lte-helper.h:739
void EnableUlMacTraces(void)
Enable trace sinks for UL MAC layer.
Definition: lte-helper.cc:1546
void EnablePhyTraces(void)
Enable trace sinks for PHY layer.
Definition: lte-helper.cc:1490
void SetSpectrumChannelAttribute(std::string n, const AttributeValue &v)
Set an attribute for the spectrum channel to be created (both DL and UL).
Definition: lte-helper.cc:468
void AddX2Interface(NodeContainer enbNodes)
Create an X2 interface between all the eNBs in a given set.
Definition: lte-helper.cc:1221
void EnablePdcpTraces(void)
Enable trace sinks for PDCP layer.
Definition: lte-helper.cc:1579
void EnableDlRxPhyTraces(void)
Enable trace sinks for DL reception PHY layer.
Definition: lte-helper.cc:1515
void SetUeDeviceAttribute(std::string n, const AttributeValue &v)
Set an attribute for the UE devices (LteUeNetDevice) to be created.
Definition: lte-helper.cc:422
uint16_t m_noOfCcs
Number of component carriers that will be installed by default at eNodeB and UE devices.
Definition: lte-helper.h:848
int64_t AssignStreams(NetDeviceContainer c, int64_t stream)
Assign a fixed random variable stream number to the random variables used.
Definition: lte-helper.cc:1444
virtual ~LteHelper(void)
Definition: lte-helper.cc:101
void EnableTraces(void)
Enables trace sinks for PHY, MAC, RLC and PDCP.
Definition: lte-helper.cc:1427
std::map< uint8_t, ComponentCarrier > m_componentCarrierPhyParams
This contains all the information about each component carrier.
Definition: lte-helper.h:843
void SetFadingModelAttribute(std::string n, const AttributeValue &v)
Set an attribute for the fading model to be created (both DL and UL).
Definition: lte-helper.cc:455
Ptr< EpcHelper > m_epcHelper
Helper which provides implementation of core network.
Definition: lte-helper.h:800
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...
Definition: lte-helper.cc:1037
uint8_t ActivateDedicatedEpsBearer(NetDeviceContainer ueDevices, EpsBearer bearer, Ptr< EpcTft > tft)
Activate a dedicated EPS bearer on a given set of UE devices.
Definition: lte-helper.cc:1069
ObjectFactory m_enbAntennaModelFactory
Factory of antenna object for eNodeB.
Definition: lte-helper.h:758
Ptr< RadioBearerStatsCalculator > m_rlcStats
Container of RLC layer statistics.
Definition: lte-helper.h:789
std::string GetSchedulerType() const
Definition: lte-helper.cc:287
void EnableDlTxPhyTraces(void)
Enable trace sinks for DL transmission PHY layer.
Definition: lte-helper.cc:1501
Ptr< NetDevice > InstallSingleUeDevice(Ptr< Node > n)
Create a UE device (LteUeNetDevice) on the given node.
Definition: lte-helper.cc:761
Ptr< NetDevice > InstallSingleEnbDevice(Ptr< Node > n)
Create an eNodeB device (LteEnbNetDevice) on the given node.
Definition: lte-helper.cc:504
void SetUeComponentCarrierManagerType(std::string type)
Set the type of Component Carrier Manager to be used by Ue devices.
Definition: lte-helper.cc:370
ObjectFactory m_fadingModelFactory
Factory of fading model object for both the downlink and uplink channels.
Definition: lte-helper.h:771
void EnableMacTraces(void)
Enable trace sinks for MAC layer.
Definition: lte-helper.cc:1530
virtual uint32_t GetIfIndex(void) const
void Receive(Ptr< Packet > p)
receive a packet from the lower layers in order to forward it to the upper layers
virtual Ptr< Node > GetNode(void) const
virtual void SetNode(Ptr< Node > node)
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(void)
Get the type ID.
virtual void ReportDataInterference(const SpectrumValue &interf)
Create the mixed CQI report.
Definition: lte-ue-phy.cc:806
virtual void ReceivePss(uint16_t cellId, Ptr< SpectrumValue > p)
Receive PSS function.
Definition: lte-ue-phy.cc:1185
virtual void ReceiveLteControlMessageList(std::list< Ptr< LteControlMessage > > msgList)
Receive LTE control message list function.
Definition: lte-ue-phy.cc:1030
virtual void GenerateCtrlCqiReport(const SpectrumValue &sinr)
generate a CQI report based on the given SINR of Ctrl frame
Definition: lte-ue-phy.cc:556
virtual void ReportInterference(const SpectrumValue &interf)
generate a report based on the linear interference and noise power perceived during DATA frame NOTE: ...
Definition: lte-ue-phy.cc:798
void PhyPduReceived(Ptr< Packet > p)
PhySpectrum received a new PHY-PDU.
Definition: lte-ue-phy.cc:503
virtual void ReportRsReceivedPower(const SpectrumValue &power)
generate a report based on the linear RS power perceived during CTRL frame NOTE: used only by UE for ...
Definition: lte-ue-phy.cc:815
virtual void EnqueueDlHarqFeedback(DlInfoListElement_s mes)
Enqueue the downlink HARQ feedback generated by LteSpectrumPhy.
Definition: lte-ue-phy.cc:1743
virtual void GenerateMixedCqiReport(const SpectrumValue &sinr)
Create the mixed CQI report.
Definition: lte-ue-phy.cc:732
static Mac64Address Allocate(void)
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(void)
Get the type ID.
holds a vector of ns3::NetDevice pointers
std::vector< Ptr< NetDevice > >::const_iterator Iterator
NetDevice container iterator.
Iterator End(void) const
Get an iterator which indicates past-the-last NetDevice in the container.
uint32_t GetN(void) const
Get the number of Ptr<NetDevice> stored in this container.
Iterator Begin(void) const
Get an iterator which refers to the first NetDevice in the container.
virtual Ptr< Node > GetNode(void) const =0
keep track of a set of node pointers.
std::vector< Ptr< Node > >::const_iterator Iterator
Node container iterator.
Iterator Begin(void) const
Get an iterator which refers to the first Node in the container.
Iterator End(void) const
Get an iterator which indicates past-the-last Node in the container.
uint32_t GetId(void) const
Definition: node.cc:109
bool SetAttributeFailSafe(std::string name, const AttributeValue &value)
Set a single attribute without raising errors.
Definition: object-base.cc:276
void SetAttribute(std::string name, const AttributeValue &value)
Set a single attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:256
void Set(const std::string &name, const AttributeValue &value, Args &&... args)
Set an attribute to be set during construction.
TypeId GetTypeId(void) const
Get the TypeId which will be created by this ObjectFactory.
Ptr< Object > Create(void) const
Create an Object instance of the configured TypeId.
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:88
friend class ObjectFactory
Friends.
Definition: object.h:328
virtual void DoDispose(void)
Destructor implementation.
Definition: object.cc:346
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:470
void Initialize(void)
Invoke DoInitialize on all Objects aggregated to this one.
Definition: object.cc:183
virtual void DoInitialize(void)
Initialize() implementation.
Definition: object.cc:353
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
Hold objects of type Ptr<T>.
Definition: pointer.h:37
Models the propagation loss through a transmission medium.
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:74
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(Time const &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
Definition: simulator.h:556
Defines the interface for spectrum-aware channel implementations.
spectrum-aware propagation loss model
Hold variables of type string.
Definition: string.h:41
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:103
fading loss model based on precalculated fading traces
a unique identifier for an interface.
Definition: type-id.h:59
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:922
std::string GetName(void) const
Get the name.
Definition: type-id.cc:976
AttributeValue implementation for TypeId.
Definition: type-id.h:595
@ CONNECTION_RECONFIGURATION
Definition: lte-enb-rrc.h:93
Hold an unsigned integer type.
Definition: uinteger.h:44
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition: assert.h:67
#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:88
Ptr< const AttributeChecker > MakeBooleanChecker(void)
Definition: boolean.cc:121
Ptr< const AttributeAccessor > MakeBooleanAccessor(T1 a1)
Definition: boolean.h:85
Ptr< const AttributeAccessor > MakeStringAccessor(T1 a1)
Definition: string.h:42
Ptr< const AttributeChecker > MakeStringChecker(void)
Definition: string.cc:30
Ptr< const AttributeAccessor > MakeTypeIdAccessor(T1 a1)
Definition: type-id.h:595
Ptr< const AttributeChecker > MakeTypeIdChecker(void)
Definition: type-id.cc:1226
Ptr< const AttributeAccessor > MakeUintegerAccessor(T1 a1)
Definition: uinteger.h:45
void Connect(std::string path, const CallbackBase &cb)
Definition: config.cc:920
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:165
#define NS_ABORT_MSG_IF(cond, msg)
Abnormal program termination if a condition is true, with a message.
Definition: abort.h:108
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:273
#define NS_LOG_LOGIC(msg)
Use NS_LOG to output a message of level LOG_LOGIC.
Definition: log.h:289
#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:265
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:281
Callback< R > MakeBoundCallback(R(*fnPtr)(TX), ARG a1)
Make Callbacks with one bound argument.
Definition: callback.h:1709
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition: object-base.h:45
#define MIN_NO_CC
Definition: lte-enb-rrc.h:56
#define MAX_NO_CC
Definition: lte-enb-rrc.h:57
devices
Definition: first.py:39
Every class exported by the ns3 library is enclosed in the ns3 namespace.
@ LOG_LEVEL_ALL
Print everything.
Definition: log.h:116
@ LOG_PREFIX_FUNC
Prefix all trace prints with function.
Definition: log.h:118
@ LOG_PREFIX_TIME
Prefix all trace prints with simulation time.
Definition: log.h:119
@ LOG_PREFIX_NODE
Prefix all trace prints with simulation node.
Definition: log.h:120
double CalculateDistance(const Vector3D &a, const Vector3D &b)
Definition: vector.cc:105
void LogComponentEnable(char const *name, enum LogLevel level)
Enable the logging output associated with that log component.
Definition: log.cc:361
void LogComponentEnableAll(enum LogLevel level)
Enable the logging output for all registered log components.
Definition: log.cc:385
Callback< R, Ts... > MakeCallback(R(T::*memPtr)(Ts...), OBJ objPtr)
Build Callbacks for class method members which take varying numbers of arguments and potentially retu...
Definition: callback.h:1648
mac
Definition: third.py:99
phy
Definition: third.py:93
Parameters passed to DataRadioBearerSetupRequest ()
EpsBearer bearer
the characteristics of the bearer to be setup
uint16_t rnti
the RNTI identifying the UE for which the DataRadioBearer is to be created
uint32_t gtpTeid
S1-bearer GTP tunnel endpoint identifier, see 36.423 9.2.1.
static Vector GetPosition(Ptr< Node > node)
Definition: wifi-ap.cc:96