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