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 
69 namespace ns3 {
70 
71 NS_LOG_COMPONENT_DEFINE ("LteHelper");
72 
73 NS_OBJECT_ENSURE_REGISTERED (LteHelper);
74 
LteHelper(void)75 LteHelper::LteHelper (void)
76   : m_fadingStreamsAssigned (false),
77     m_imsiCounter (0),
78     m_cellIdCounter {1}
79 {
80   NS_LOG_FUNCTION (this);
81   m_enbNetDeviceFactory.SetTypeId (LteEnbNetDevice::GetTypeId ());
82   m_enbAntennaModelFactory.SetTypeId (IsotropicAntennaModel::GetTypeId ());
83   m_ueNetDeviceFactory.SetTypeId (LteUeNetDevice::GetTypeId ());
84   m_ueAntennaModelFactory.SetTypeId (IsotropicAntennaModel::GetTypeId ());
85   m_channelFactory.SetTypeId (MultiModelSpectrumChannel::GetTypeId ());
86 }
87 
88 void
DoInitialize(void)89 LteHelper::DoInitialize (void)
90 {
91   NS_LOG_FUNCTION (this);
92   ChannelModelInitialization ();
93   m_phyStats = CreateObject<PhyStatsCalculator> ();
94   m_phyTxStats = CreateObject<PhyTxStatsCalculator> ();
95   m_phyRxStats = CreateObject<PhyRxStatsCalculator> ();
96   m_macStats = CreateObject<MacStatsCalculator> ();
97   Object::DoInitialize ();
98 
99 }
100 
~LteHelper(void)101 LteHelper::~LteHelper (void)
102 {
103   NS_LOG_FUNCTION (this);
104 }
105 
GetTypeId(void)106 TypeId LteHelper::GetTypeId (void)
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"),
118                    MakeStringAccessor (&LteHelper::SetSchedulerType,
119                                        &LteHelper::GetSchedulerType),
120                    MakeStringChecker ())
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"),
126                    MakeStringAccessor (&LteHelper::SetFfrAlgorithmType,
127                                        &LteHelper::GetFfrAlgorithmType),
128                    MakeStringChecker ())
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"),
134                    MakeStringAccessor (&LteHelper::SetHandoverAlgorithmType,
135                                        &LteHelper::GetHandoverAlgorithmType),
136                    MakeStringChecker ())
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.",
141                    TypeIdValue (FriisPropagationLossModel::GetTypeId ()),
142                    MakeTypeIdAccessor (&LteHelper::SetPathlossModelType),
143                    MakeTypeIdChecker ())
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 (""),
150                    MakeStringAccessor (&LteHelper::SetFadingModel),
151                    MakeStringChecker ())
152     .AddAttribute ("UseIdealRrc",
153                    "If true, LteRrcProtocolIdeal will be used for RRC signaling. "
154                    "If false, LteRrcProtocolReal will be used.",
155                    BooleanValue (true),
156                    MakeBooleanAccessor (&LteHelper::m_useIdealRrc),
157                    MakeBooleanChecker ())
158     .AddAttribute ("AnrEnabled",
159                    "Activate or deactivate Automatic Neighbour Relation function",
160                    BooleanValue (true),
161                    MakeBooleanAccessor (&LteHelper::m_isAnrEnabled),
162                    MakeBooleanChecker ())
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),
167                    MakeBooleanAccessor (&LteHelper::m_usePdschForCqiGeneration),
168                    MakeBooleanChecker ())
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"),
174                    MakeStringAccessor (&LteHelper::SetEnbComponentCarrierManagerType,
175                                        &LteHelper::GetEnbComponentCarrierManagerType),
176                    MakeStringChecker ())
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"),
182                    MakeStringAccessor (&LteHelper::SetUeComponentCarrierManagerType,
183                                        &LteHelper::GetUeComponentCarrierManagerType),
184                    MakeStringChecker ())
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),
189                    MakeBooleanAccessor (&LteHelper::m_useCa),
190                    MakeBooleanChecker ())
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),
195                    MakeUintegerAccessor (&LteHelper::m_noOfCcs),
196                    MakeUintegerChecker<uint16_t> (MIN_NO_CC, MAX_NO_CC))
197   ;
198   return tid;
199 }
200 
201 void
DoDispose()202 LteHelper::DoDispose ()
203 {
204   NS_LOG_FUNCTION (this);
205   m_downlinkChannel = 0;
206   m_uplinkChannel = 0;
207   m_componentCarrierPhyParams.clear();
208   Object::DoDispose ();
209 }
210 
211 Ptr<SpectrumChannel>
GetUplinkSpectrumChannel(void) const212 LteHelper::GetUplinkSpectrumChannel (void) const
213 {
214   return m_uplinkChannel;
215 }
216 
217 Ptr<SpectrumChannel>
GetDownlinkSpectrumChannel(void) const218 LteHelper::GetDownlinkSpectrumChannel (void) const
219 {
220   return m_downlinkChannel;
221 }
222 
223 void
ChannelModelInitialization(void)224 LteHelper::ChannelModelInitialization (void)
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 
230   m_downlinkChannel = m_channelFactory.Create<SpectrumChannel> ();
231   m_uplinkChannel = m_channelFactory.Create<SpectrumChannel> ();
232 
233   m_downlinkPathlossModel = m_pathlossModelFactory.Create ();
234   Ptr<SpectrumPropagationLossModel> dlSplm = m_downlinkPathlossModel->GetObject<SpectrumPropagationLossModel> ();
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");
243       Ptr<PropagationLossModel> dlPlm = m_downlinkPathlossModel->GetObject<PropagationLossModel> ();
244       NS_ASSERT_MSG (dlPlm != 0, " " << m_downlinkPathlossModel << " is neither PropagationLossModel nor SpectrumPropagationLossModel");
245       m_downlinkChannel->AddPropagationLossModel (dlPlm);
246     }
247 
248   m_uplinkPathlossModel = m_pathlossModelFactory.Create ();
249   Ptr<SpectrumPropagationLossModel> ulSplm = m_uplinkPathlossModel->GetObject<SpectrumPropagationLossModel> ();
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");
258       Ptr<PropagationLossModel> ulPlm = m_uplinkPathlossModel->GetObject<PropagationLossModel> ();
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     {
264       m_fadingModel = m_fadingModelFactory.Create<SpectrumPropagationLossModel> ();
265       m_fadingModel->Initialize ();
266       m_downlinkChannel->AddSpectrumPropagationLossModel (m_fadingModel);
267       m_uplinkChannel->AddSpectrumPropagationLossModel (m_fadingModel);
268     }
269 }
270 
271 void
SetEpcHelper(Ptr<EpcHelper> h)272 LteHelper::SetEpcHelper (Ptr<EpcHelper> h)
273 {
274   NS_LOG_FUNCTION (this << h);
275   m_epcHelper = h;
276 }
277 
278 void
SetSchedulerType(std::string type)279 LteHelper::SetSchedulerType (std::string type)
280 {
281   NS_LOG_FUNCTION (this << type);
282   m_schedulerFactory = ObjectFactory ();
283   m_schedulerFactory.SetTypeId (type);
284 }
285 
286 std::string
GetSchedulerType() const287 LteHelper::GetSchedulerType () const
288 {
289   return m_schedulerFactory.GetTypeId ().GetName ();
290 }
291 
292 void
SetSchedulerAttribute(std::string n,const AttributeValue & v)293 LteHelper::SetSchedulerAttribute (std::string n, const AttributeValue &v)
294 {
295   NS_LOG_FUNCTION (this << n);
296   m_schedulerFactory.Set (n, v);
297 }
298 
299 std::string
GetFfrAlgorithmType() const300 LteHelper::GetFfrAlgorithmType () const
301 {
302   return m_ffrAlgorithmFactory.GetTypeId ().GetName ();
303 }
304 
305 void
SetFfrAlgorithmType(std::string type)306 LteHelper::SetFfrAlgorithmType (std::string type)
307 {
308   NS_LOG_FUNCTION (this << type);
309   m_ffrAlgorithmFactory = ObjectFactory ();
310   m_ffrAlgorithmFactory.SetTypeId (type);
311 }
312 
313 void
SetFfrAlgorithmAttribute(std::string n,const AttributeValue & v)314 LteHelper::SetFfrAlgorithmAttribute (std::string n, const AttributeValue &v)
315 {
316   NS_LOG_FUNCTION (this << n);
317   m_ffrAlgorithmFactory.Set (n, v);
318 }
319 
320 std::string
GetHandoverAlgorithmType() const321 LteHelper::GetHandoverAlgorithmType () const
322 {
323   return m_handoverAlgorithmFactory.GetTypeId ().GetName ();
324 }
325 
326 void
SetHandoverAlgorithmType(std::string type)327 LteHelper::SetHandoverAlgorithmType (std::string type)
328 {
329   NS_LOG_FUNCTION (this << type);
330   m_handoverAlgorithmFactory = ObjectFactory ();
331   m_handoverAlgorithmFactory.SetTypeId (type);
332 }
333 
334 void
SetHandoverAlgorithmAttribute(std::string n,const AttributeValue & v)335 LteHelper::SetHandoverAlgorithmAttribute (std::string n, const AttributeValue &v)
336 {
337   NS_LOG_FUNCTION (this << n);
338   m_handoverAlgorithmFactory.Set (n, v);
339 }
340 
341 
342 std::string
GetEnbComponentCarrierManagerType() const343 LteHelper::GetEnbComponentCarrierManagerType () const
344 {
345   return m_enbComponentCarrierManagerFactory.GetTypeId ().GetName ();
346 }
347 
348 void
SetEnbComponentCarrierManagerType(std::string type)349 LteHelper::SetEnbComponentCarrierManagerType (std::string type)
350 {
351   NS_LOG_FUNCTION (this << type);
352   m_enbComponentCarrierManagerFactory = ObjectFactory ();
353   m_enbComponentCarrierManagerFactory.SetTypeId (type);
354 }
355 
356 void
SetEnbComponentCarrierManagerAttribute(std::string n,const AttributeValue & v)357 LteHelper::SetEnbComponentCarrierManagerAttribute (std::string n, const AttributeValue &v)
358 {
359   NS_LOG_FUNCTION (this << n);
360   m_enbComponentCarrierManagerFactory.Set (n, v);
361 }
362 
363 std::string
GetUeComponentCarrierManagerType() const364 LteHelper::GetUeComponentCarrierManagerType () const
365 {
366   return m_ueComponentCarrierManagerFactory.GetTypeId ().GetName ();
367 }
368 
369 void
SetUeComponentCarrierManagerType(std::string type)370 LteHelper::SetUeComponentCarrierManagerType (std::string type)
371 {
372   NS_LOG_FUNCTION (this << type);
373   m_ueComponentCarrierManagerFactory = ObjectFactory ();
374   m_ueComponentCarrierManagerFactory.SetTypeId (type);
375 }
376 
377 void
SetUeComponentCarrierManagerAttribute(std::string n,const AttributeValue & v)378 LteHelper::SetUeComponentCarrierManagerAttribute (std::string n, const AttributeValue &v)
379 {
380   NS_LOG_FUNCTION (this << n);
381   m_ueComponentCarrierManagerFactory.Set (n, v);
382 }
383 
384 void
SetPathlossModelType(TypeId type)385 LteHelper::SetPathlossModelType (TypeId type)
386 {
387   NS_LOG_FUNCTION (this << type);
388   m_pathlossModelFactory = ObjectFactory ();
389   m_pathlossModelFactory.SetTypeId (type);
390 }
391 
392 void
SetPathlossModelAttribute(std::string n,const AttributeValue & v)393 LteHelper::SetPathlossModelAttribute (std::string n, const AttributeValue &v)
394 {
395   NS_LOG_FUNCTION (this << n);
396   m_pathlossModelFactory.Set (n, v);
397 }
398 
399 void
SetEnbDeviceAttribute(std::string n,const AttributeValue & v)400 LteHelper::SetEnbDeviceAttribute (std::string n, const AttributeValue &v)
401 {
402   NS_LOG_FUNCTION (this);
403   m_enbNetDeviceFactory.Set (n, v);
404 }
405 
406 
407 void
SetEnbAntennaModelType(std::string type)408 LteHelper::SetEnbAntennaModelType (std::string type)
409 {
410   NS_LOG_FUNCTION (this);
411   m_enbAntennaModelFactory.SetTypeId (type);
412 }
413 
414 void
SetEnbAntennaModelAttribute(std::string n,const AttributeValue & v)415 LteHelper::SetEnbAntennaModelAttribute (std::string n, const AttributeValue &v)
416 {
417   NS_LOG_FUNCTION (this);
418   m_enbAntennaModelFactory.Set (n, v);
419 }
420 
421 void
SetUeDeviceAttribute(std::string n,const AttributeValue & v)422 LteHelper::SetUeDeviceAttribute (std::string n, const AttributeValue &v)
423 {
424   NS_LOG_FUNCTION (this);
425   m_ueNetDeviceFactory.Set (n, v);
426 }
427 
428 void
SetUeAntennaModelType(std::string type)429 LteHelper::SetUeAntennaModelType (std::string type)
430 {
431   NS_LOG_FUNCTION (this);
432   m_ueAntennaModelFactory.SetTypeId (type);
433 }
434 
435 void
SetUeAntennaModelAttribute(std::string n,const AttributeValue & v)436 LteHelper::SetUeAntennaModelAttribute (std::string n, const AttributeValue &v)
437 {
438   NS_LOG_FUNCTION (this);
439   m_ueAntennaModelFactory.Set (n, v);
440 }
441 
442 void
SetFadingModel(std::string type)443 LteHelper::SetFadingModel (std::string type)
444 {
445   NS_LOG_FUNCTION (this << type);
446   m_fadingModelType = type;
447   if (!type.empty ())
448     {
449       m_fadingModelFactory = ObjectFactory ();
450       m_fadingModelFactory.SetTypeId (type);
451     }
452 }
453 
454 void
SetFadingModelAttribute(std::string n,const AttributeValue & v)455 LteHelper::SetFadingModelAttribute (std::string n, const AttributeValue &v)
456 {
457   m_fadingModelFactory.Set (n, v);
458 }
459 
460 void
SetSpectrumChannelType(std::string type)461 LteHelper::SetSpectrumChannelType (std::string type)
462 {
463   NS_LOG_FUNCTION (this << type);
464   m_channelFactory.SetTypeId (type);
465 }
466 
467 void
SetSpectrumChannelAttribute(std::string n,const AttributeValue & v)468 LteHelper::SetSpectrumChannelAttribute (std::string n, const AttributeValue &v)
469 {
470   m_channelFactory.Set (n, v);
471 }
472 
473 NetDeviceContainer
InstallEnbDevice(NodeContainer c)474 LteHelper::InstallEnbDevice (NodeContainer c)
475 {
476   NS_LOG_FUNCTION (this);
477   Initialize ();  // will run DoInitialize () if necessary
478   NetDeviceContainer devices;
479   for (NodeContainer::Iterator i = c.Begin (); i != c.End (); ++i)
480     {
481       Ptr<Node> node = *i;
482       Ptr<NetDevice> device = InstallSingleEnbDevice (node);
483       devices.Add (device);
484     }
485   return devices;
486 }
487 
488 NetDeviceContainer
InstallUeDevice(NodeContainer c)489 LteHelper::InstallUeDevice (NodeContainer c)
490 {
491   NS_LOG_FUNCTION (this);
492   NetDeviceContainer devices;
493   for (NodeContainer::Iterator i = c.Begin (); i != c.End (); ++i)
494     {
495       Ptr<Node> node = *i;
496       Ptr<NetDevice> device = InstallSingleUeDevice (node);
497       devices.Add (device);
498     }
499   return devices;
500 }
501 
502 
503 Ptr<NetDevice>
InstallSingleEnbDevice(Ptr<Node> n)504 LteHelper::InstallSingleEnbDevice (Ptr<Node> n)
505 {
506   NS_LOG_FUNCTION (this << n);
507   uint16_t cellId = m_cellIdCounter; // \todo Remove, eNB has no cell ID
508 
509   Ptr<LteEnbNetDevice> dev = m_enbNetDeviceFactory.Create<LteEnbNetDevice> ();
510   Ptr<LteHandoverAlgorithm> handoverAlgorithm = m_handoverAlgorithmFactory.Create<LteHandoverAlgorithm> ();
511 
512   NS_ABORT_MSG_IF (m_componentCarrierPhyParams.size() != 0, "CC map is not clean");
513   DoComponentCarrierConfigure (dev->GetUlEarfcn (), dev->GetDlEarfcn (),
514                                dev->GetUlBandwidth (), dev->GetDlBandwidth ());
515   NS_ABORT_MSG_IF (m_componentCarrierPhyParams.size() != m_noOfCcs,
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
537   m_componentCarrierPhyParams.clear ();
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> ();
581       Ptr<FfMacScheduler> sched = m_schedulerFactory.Create<FfMacScheduler> ();
582       Ptr<LteFfrAlgorithm> ffrAlgorithm = m_ffrAlgorithmFactory.Create<LteFfrAlgorithm> ();
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> ();
590   Ptr<LteEnbComponentCarrierManager> ccmEnbManager = m_enbComponentCarrierManagerFactory.Create<LteEnbComponentCarrierManager> ();
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 
760 Ptr<NetDevice>
InstallSingleUeDevice(Ptr<Node> n)761 LteHelper::InstallSingleUeDevice (Ptr<Node> n)
762 {
763   NS_LOG_FUNCTION (this);
764 
765   Ptr<LteUeNetDevice> dev = m_ueNetDeviceFactory.Create<LteUeNetDevice> ();
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);
773   NS_ABORT_MSG_IF (m_componentCarrierPhyParams.size() != m_noOfCcs,
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
796   m_componentCarrierPhyParams.clear ();
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 
826       if (m_usePdschForCqiGeneration)
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     }
857   Ptr<LteUeComponentCarrierManager> ccmUe = m_ueComponentCarrierManagerFactory.Create<LteUeComponentCarrierManager> ();
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 
960 void
Attach(NetDeviceContainer ueDevices)961 LteHelper::Attach (NetDeviceContainer ueDevices)
962 {
963   NS_LOG_FUNCTION (this);
964   for (NetDeviceContainer::Iterator i = ueDevices.Begin (); i != ueDevices.End (); ++i)
965     {
966       Attach (*i);
967     }
968 }
969 
970 void
Attach(Ptr<NetDevice> ueDevice)971 LteHelper::Attach (Ptr<NetDevice> ueDevice)
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 (),
997                                   EpcTft::Default (),
998                                   EpsBearer (EpsBearer::NGBR_VIDEO_TCP_DEFAULT));
999 }
1000 
1001 void
Attach(NetDeviceContainer ueDevices,Ptr<NetDevice> enbDevice)1002 LteHelper::Attach (NetDeviceContainer ueDevices, Ptr<NetDevice> enbDevice)
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 
1011 void
Attach(Ptr<NetDevice> ueDevice,Ptr<NetDevice> enbDevice)1012 LteHelper::Attach (Ptr<NetDevice> ueDevice, Ptr<NetDevice> enbDevice)
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 
1036 void
AttachToClosestEnb(NetDeviceContainer ueDevices,NetDeviceContainer enbDevices)1037 LteHelper::AttachToClosestEnb (NetDeviceContainer ueDevices, NetDeviceContainer enbDevices)
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 
1046 void
AttachToClosestEnb(Ptr<NetDevice> ueDevice,NetDeviceContainer enbDevices)1047 LteHelper::AttachToClosestEnb (Ptr<NetDevice> ueDevice, NetDeviceContainer enbDevices)
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 
1068 uint8_t
ActivateDedicatedEpsBearer(NetDeviceContainer ueDevices,EpsBearer bearer,Ptr<EpcTft> tft)1069 LteHelper::ActivateDedicatedEpsBearer (NetDeviceContainer ueDevices, EpsBearer bearer, Ptr<EpcTft> tft)
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 
1081 uint8_t
ActivateDedicatedEpsBearer(Ptr<NetDevice> ueDevice,EpsBearer bearer,Ptr<EpcTft> tft)1082 LteHelper::ActivateDedicatedEpsBearer (Ptr<NetDevice> ueDevice, EpsBearer bearer, Ptr<EpcTft> tft)
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 
1093 /**
1094  * \ingroup lte
1095  *
1096  * DrbActivatior allows user to activate bearers for UEs
1097  * when EPC is not used. Activation function is hooked to
1098  * the Enb RRC Connection Established trace source. When
1099  * UE change its RRC state to CONNECTED_NORMALLY, activation
1100  * function is called and bearer is activated.
1101 */
1102 class DrbActivator : public SimpleRefCount<DrbActivator>
1103 {
1104 public:
1105   /**
1106   * DrbActivator Constructor
1107   *
1108   * \param ueDevice the UeNetDevice for which bearer will be activated
1109   * \param bearer the bearer configuration
1110   */
1111   DrbActivator (Ptr<NetDevice> ueDevice, EpsBearer bearer);
1112 
1113   /**
1114    * Function hooked to the Enb RRC Connection Established trace source
1115    * Fired upon successful RRC connection establishment.
1116    *
1117    * \param a DrbActivator object
1118    * \param context
1119    * \param imsi
1120    * \param cellId
1121    * \param rnti
1122    */
1123   static void ActivateCallback (Ptr<DrbActivator> a, std::string context, uint64_t imsi, uint16_t cellId, uint16_t rnti);
1124 
1125   /**
1126    * Procedure firstly checks if bearer was not activated, if IMSI
1127    * from trace source equals configured one and if UE is really
1128    * in RRC connected state. If all requirements are met, it performs
1129    * bearer activation.
1130    *
1131    * \param imsi
1132    * \param cellId
1133    * \param rnti
1134    */
1135   void ActivateDrb (uint64_t imsi, uint16_t cellId, uint16_t rnti);
1136 private:
1137   /**
1138    * Bearer can be activated only once. This value stores state of
1139    * bearer. Initially is set to false and changed to true during
1140    * bearer activation.
1141    */
1142   bool m_active;
1143   /**
1144    * UeNetDevice for which bearer will be activated
1145    */
1146   Ptr<NetDevice> m_ueDevice;
1147   /**
1148    * Configuration of bearer which will be activated
1149    */
1150   EpsBearer m_bearer;
1151   /**
1152    * imsi the unique UE identifier
1153    */
1154   uint64_t m_imsi;
1155 };
1156 
DrbActivator(Ptr<NetDevice> ueDevice,EpsBearer bearer)1157 DrbActivator::DrbActivator (Ptr<NetDevice> ueDevice, EpsBearer bearer)
1158   : m_active (false),
1159     m_ueDevice (ueDevice),
1160     m_bearer (bearer),
1161     m_imsi (m_ueDevice->GetObject<LteUeNetDevice> ()->GetImsi ())
1162 {
1163 }
1164 
1165 void
ActivateCallback(Ptr<DrbActivator> a,std::string context,uint64_t imsi,uint16_t cellId,uint16_t rnti)1166 DrbActivator::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 
1172 void
ActivateDrb(uint64_t imsi,uint16_t cellId,uint16_t rnti)1173 DrbActivator::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);
1187       EpcEnbS1SapUser::DataRadioBearerSetupRequestParameters params;
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 
1198 void
ActivateDataRadioBearer(Ptr<NetDevice> ueDevice,EpsBearer bearer)1199 LteHelper::ActivateDataRadioBearer (Ptr<NetDevice> ueDevice, EpsBearer bearer)
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);
1217   Config::Connect (path.str (), MakeBoundCallback (&DrbActivator::ActivateCallback, arg));
1218 }
1219 
1220 void
AddX2Interface(NodeContainer enbNodes)1221 LteHelper::AddX2Interface (NodeContainer enbNodes)
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 
1236 void
AddX2Interface(Ptr<Node> enbNode1,Ptr<Node> enbNode2)1237 LteHelper::AddX2Interface (Ptr<Node> enbNode1, Ptr<Node> enbNode2)
1238 {
1239   NS_LOG_FUNCTION (this);
1240   NS_LOG_INFO ("setting up the X2 interface");
1241 
1242   m_epcHelper->AddX2Interface (enbNode1, enbNode2);
1243 }
1244 
1245 void
HandoverRequest(Time hoTime,Ptr<NetDevice> ueDev,Ptr<NetDevice> sourceEnbDev,Ptr<NetDevice> targetEnbDev)1246 LteHelper::HandoverRequest (Time hoTime, Ptr<NetDevice> ueDev, Ptr<NetDevice> sourceEnbDev, Ptr<NetDevice> targetEnbDev)
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 
1254 void
HandoverRequest(Time hoTime,Ptr<NetDevice> ueDev,Ptr<NetDevice> sourceEnbDev,uint16_t targetCellId)1255 LteHelper::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 
1262 void
DoHandoverRequest(Ptr<NetDevice> ueDev,Ptr<NetDevice> sourceEnbDev,uint16_t targetCellId)1263 LteHelper::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 
1272 void
DeActivateDedicatedEpsBearer(Ptr<NetDevice> ueDevice,Ptr<NetDevice> enbDevice,uint8_t bearerId)1273 LteHelper::DeActivateDedicatedEpsBearer (Ptr<NetDevice> ueDevice,Ptr<NetDevice> enbDevice, uint8_t bearerId)
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 
1282 void
DoDeActivateDedicatedEpsBearer(Ptr<NetDevice> ueDevice,Ptr<NetDevice> enbDevice,uint8_t bearerId)1283 LteHelper::DoDeActivateDedicatedEpsBearer (Ptr<NetDevice> ueDevice, Ptr<NetDevice> enbDevice, uint8_t bearerId)
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 
1297 void
DoComponentCarrierConfigure(uint32_t ulEarfcn,uint32_t dlEarfcn,uint16_t ulbw,uint16_t dlbw)1298 LteHelper::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 
1313 void
ActivateDataRadioBearer(NetDeviceContainer ueDevices,EpsBearer bearer)1314 LteHelper::ActivateDataRadioBearer (NetDeviceContainer ueDevices, EpsBearer bearer)
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 
1323 void
EnableLogComponents(void)1324 LteHelper::EnableLogComponents (void)
1325 {
1326   LogComponentEnableAll (LOG_PREFIX_TIME);
1327   LogComponentEnableAll (LOG_PREFIX_FUNC);
1328   LogComponentEnableAll (LOG_PREFIX_NODE);
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);
1341   LogComponentEnable ("EpcTft", LOG_LEVEL_ALL);
1342   LogComponentEnable ("EpcTftClassifier", LOG_LEVEL_ALL);
1343   LogComponentEnable ("EpcUeNas", LOG_LEVEL_ALL);
1344   LogComponentEnable ("EpcX2", 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);
1351   LogComponentEnable ("LteAmc", LOG_LEVEL_ALL);
1352   LogComponentEnable ("LteAnr", 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);
1376   LogComponentEnable ("LtePhy", LOG_LEVEL_ALL);
1377   LogComponentEnable ("LteRlc", 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 
1426 void
EnableTraces(void)1427 LteHelper::EnableTraces (void)
1428 {
1429   EnablePhyTraces ();
1430   EnableMacTraces ();
1431   EnableRlcTraces ();
1432   EnablePdcpTraces ();
1433 }
1434 
1435 void
EnableRlcTraces(void)1436 LteHelper::EnableRlcTraces (void)
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");
1440   m_radioBearerStatsConnector.EnableRlcStats (m_rlcStats);
1441 }
1442 
1443 int64_t
AssignStreams(NetDeviceContainer c,int64_t stream)1444 LteHelper::AssignStreams (NetDeviceContainer c, int64_t stream)
1445 {
1446   int64_t currentStream = stream;
1447   if ((m_fadingModel != 0) && (m_fadingStreamsAssigned == false))
1448     {
1449       Ptr<TraceFadingLossModel> tflm = m_fadingModel->GetObject<TraceFadingLossModel> ();
1450       if (tflm != 0)
1451         {
1452           currentStream += tflm->AssignStreams (currentStream);
1453           m_fadingStreamsAssigned = true;
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 
1489 void
EnablePhyTraces(void)1490 LteHelper::EnablePhyTraces (void)
1491 {
1492   EnableDlPhyTraces ();
1493   EnableUlPhyTraces ();
1494   EnableDlTxPhyTraces ();
1495   EnableUlTxPhyTraces ();
1496   EnableDlRxPhyTraces ();
1497   EnableUlRxPhyTraces ();
1498 }
1499 
1500 void
EnableDlTxPhyTraces(void)1501 LteHelper::EnableDlTxPhyTraces (void)
1502 {
1503   Config::Connect ("/NodeList/*/DeviceList/*/ComponentCarrierMap/*/LteEnbPhy/DlPhyTransmission",
1504                    MakeBoundCallback (&PhyTxStatsCalculator::DlPhyTransmissionCallback, m_phyTxStats));
1505 }
1506 
1507 void
EnableUlTxPhyTraces(void)1508 LteHelper::EnableUlTxPhyTraces (void)
1509 {
1510   Config::Connect ("/NodeList/*/DeviceList/*/ComponentCarrierMapUe/*/LteUePhy/UlPhyTransmission",
1511                    MakeBoundCallback (&PhyTxStatsCalculator::UlPhyTransmissionCallback, m_phyTxStats));
1512 }
1513 
1514 void
EnableDlRxPhyTraces(void)1515 LteHelper::EnableDlRxPhyTraces (void)
1516 {
1517   Config::Connect ("/NodeList/*/DeviceList/*/ComponentCarrierMapUe/*/LteUePhy/DlSpectrumPhy/DlPhyReception",
1518                    MakeBoundCallback (&PhyRxStatsCalculator::DlPhyReceptionCallback, m_phyRxStats));
1519 }
1520 
1521 void
EnableUlRxPhyTraces(void)1522 LteHelper::EnableUlRxPhyTraces (void)
1523 {
1524   Config::Connect ("/NodeList/*/DeviceList/*/ComponentCarrierMap/*/LteEnbPhy/UlSpectrumPhy/UlPhyReception",
1525                    MakeBoundCallback (&PhyRxStatsCalculator::UlPhyReceptionCallback, m_phyRxStats));
1526 }
1527 
1528 
1529 void
EnableMacTraces(void)1530 LteHelper::EnableMacTraces (void)
1531 {
1532   EnableDlMacTraces ();
1533   EnableUlMacTraces ();
1534 }
1535 
1536 
1537 void
EnableDlMacTraces(void)1538 LteHelper::EnableDlMacTraces (void)
1539 {
1540   NS_LOG_FUNCTION_NOARGS ();
1541   Config::Connect ("/NodeList/*/DeviceList/*/ComponentCarrierMap/*/LteEnbMac/DlScheduling",
1542                    MakeBoundCallback (&MacStatsCalculator::DlSchedulingCallback, m_macStats));
1543 }
1544 
1545 void
EnableUlMacTraces(void)1546 LteHelper::EnableUlMacTraces (void)
1547 {
1548   NS_LOG_FUNCTION_NOARGS ();
1549   Config::Connect ("/NodeList/*/DeviceList/*/ComponentCarrierMap/*/LteEnbMac/UlScheduling",
1550                    MakeBoundCallback (&MacStatsCalculator::UlSchedulingCallback, m_macStats));
1551 }
1552 
1553 void
EnableDlPhyTraces(void)1554 LteHelper::EnableDlPhyTraces (void)
1555 {
1556   NS_LOG_FUNCTION_NOARGS ();
1557   Config::Connect ("/NodeList/*/DeviceList/*/ComponentCarrierMapUe/*/LteUePhy/ReportCurrentCellRsrpSinr",
1558                    MakeBoundCallback (&PhyStatsCalculator::ReportCurrentCellRsrpSinrCallback, m_phyStats));
1559 }
1560 
1561 void
EnableUlPhyTraces(void)1562 LteHelper::EnableUlPhyTraces (void)
1563 {
1564   NS_LOG_FUNCTION_NOARGS ();
1565   Config::Connect ("/NodeList/*/DeviceList/*/ComponentCarrierMap/*/LteEnbPhy/ReportUeSinr",
1566                    MakeBoundCallback (&PhyStatsCalculator::ReportUeSinr, m_phyStats));
1567   Config::Connect ("/NodeList/*/DeviceList/*/ComponentCarrierMap/*/LteEnbPhy/ReportInterference",
1568                    MakeBoundCallback (&PhyStatsCalculator::ReportInterference, m_phyStats));
1569 
1570 }
1571 
1572 Ptr<RadioBearerStatsCalculator>
GetRlcStats(void)1573 LteHelper::GetRlcStats (void)
1574 {
1575   return m_rlcStats;
1576 }
1577 
1578 void
EnablePdcpTraces(void)1579 LteHelper::EnablePdcpTraces (void)
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");
1583   m_radioBearerStatsConnector.EnablePdcpStats (m_pdcpStats);
1584 }
1585 
1586 Ptr<RadioBearerStatsCalculator>
GetPdcpStats(void)1587 LteHelper::GetPdcpStats (void)
1588 {
1589   return m_pdcpStats;
1590 }
1591 
1592 } // namespace ns3
1593