A Discrete-Event Network Simulator
API
lte-helper.cc
Go to the documentation of this file.
1 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2011 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation;
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  * Author: Nicola Baldo <nbaldo@cttc.es> (re-wrote from scratch this helper)
19  * Giuseppe Piro <g.piro@poliba.it> (parts of the PHY & channel creation & configuration copied from the GSoC 2011 code)
20  * Modified by: Danilo Abrignani <danilo.abrignani@unibo.it> (Carrier Aggregation - GSoC 2015)
21  * Biljana Bojovic <biljana.bojovic@cttc.es> (Carrier Aggregation)
22  */
23 
24 #include "lte-helper.h"
25 #include <ns3/string.h>
26 #include <ns3/log.h>
27 #include <ns3/abort.h>
28 #include <ns3/pointer.h>
29 #include <ns3/lte-enb-rrc.h>
30 #include <ns3/epc-ue-nas.h>
31 #include <ns3/epc-enb-application.h>
32 #include <ns3/lte-ue-rrc.h>
33 #include <ns3/lte-ue-mac.h>
34 #include <ns3/lte-enb-mac.h>
35 #include <ns3/lte-enb-net-device.h>
36 #include <ns3/lte-enb-phy.h>
37 #include <ns3/lte-ue-phy.h>
38 #include <ns3/lte-spectrum-phy.h>
39 #include <ns3/lte-chunk-processor.h>
40 #include <ns3/multi-model-spectrum-channel.h>
41 #include <ns3/friis-spectrum-propagation-loss.h>
42 #include <ns3/trace-fading-loss-model.h>
43 #include <ns3/isotropic-antenna-model.h>
44 #include <ns3/lte-ue-net-device.h>
45 #include <ns3/ff-mac-scheduler.h>
46 #include <ns3/lte-ffr-algorithm.h>
47 #include <ns3/lte-handover-algorithm.h>
48 #include <ns3/lte-enb-component-carrier-manager.h>
49 #include <ns3/lte-ue-component-carrier-manager.h>
50 #include <ns3/lte-anr.h>
51 #include <ns3/lte-rlc.h>
52 #include <ns3/lte-rlc-um.h>
53 #include <ns3/lte-rlc-am.h>
54 #include <ns3/epc-enb-s1-sap.h>
55 #include <ns3/lte-rrc-protocol-ideal.h>
56 #include <ns3/lte-rrc-protocol-real.h>
57 #include <ns3/mac-stats-calculator.h>
58 #include <ns3/phy-stats-calculator.h>
59 #include <ns3/phy-tx-stats-calculator.h>
60 #include <ns3/phy-rx-stats-calculator.h>
61 #include <ns3/epc-helper.h>
62 #include <iostream>
63 #include <ns3/buildings-propagation-loss-model.h>
64 #include <ns3/lte-spectrum-value-helper.h>
65 #include <ns3/epc-x2.h>
66 #include <ns3/object-map.h>
67 #include <ns3/object-factory.h>
68 
69 namespace ns3 {
70 
71 NS_LOG_COMPONENT_DEFINE ("LteHelper");
72 
73 NS_OBJECT_ENSURE_REGISTERED (LteHelper);
74 
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
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 
101 LteHelper::~LteHelper (void)
102 {
103  NS_LOG_FUNCTION (this);
104 }
105 
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
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>
212 LteHelper::GetUplinkSpectrumChannel (void) const
213 {
214  return m_uplinkChannel;
215 }
216 
217 Ptr<SpectrumChannel>
218 LteHelper::GetDownlinkSpectrumChannel (void) const
219 {
220  return m_downlinkChannel;
221 }
222 
223 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
272 LteHelper::SetEpcHelper (Ptr<EpcHelper> h)
273 {
274  NS_LOG_FUNCTION (this << h);
275  m_epcHelper = h;
276 }
277 
278 void
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
287 LteHelper::GetSchedulerType () const
288 {
289  return m_schedulerFactory.GetTypeId ().GetName ();
290 }
291 
292 void
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
300 LteHelper::GetFfrAlgorithmType () const
301 {
302  return m_ffrAlgorithmFactory.GetTypeId ().GetName ();
303 }
304 
305 void
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
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
321 LteHelper::GetHandoverAlgorithmType () const
322 {
323  return m_handoverAlgorithmFactory.GetTypeId ().GetName ();
324 }
325 
326 void
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
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
343 LteHelper::GetEnbComponentCarrierManagerType () const
344 {
345  return m_enbComponentCarrierManagerFactory.GetTypeId ().GetName ();
346 }
347 
348 void
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
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
364 LteHelper::GetUeComponentCarrierManagerType () const
365 {
366  return m_ueComponentCarrierManagerFactory.GetTypeId ().GetName ();
367 }
368 
369 void
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
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
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
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
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
408 LteHelper::SetEnbAntennaModelType (std::string type)
409 {
410  NS_LOG_FUNCTION (this);
411  m_enbAntennaModelFactory.SetTypeId (type);
412 }
413 
414 void
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
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
429 LteHelper::SetUeAntennaModelType (std::string type)
430 {
431  NS_LOG_FUNCTION (this);
432  m_ueAntennaModelFactory.SetTypeId (type);
433 }
434 
435 void
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
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
455 LteHelper::SetFadingModelAttribute (std::string n, const AttributeValue &v)
456 {
457  m_fadingModelFactory.Set (n, v);
458 }
459 
460 void
461 LteHelper::SetSpectrumChannelType (std::string type)
462 {
463  NS_LOG_FUNCTION (this << type);
464  m_channelFactory.SetTypeId (type);
465 }
466 
467 void
468 LteHelper::SetSpectrumChannelAttribute (std::string n, const AttributeValue &v)
469 {
470  m_channelFactory.Set (n, v);
471 }
472 
473 NetDeviceContainer
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
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>
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>
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
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
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
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
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
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
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
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
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 
1102 class DrbActivator : public SimpleRefCount<DrbActivator>
1103 {
1104 public:
1111  DrbActivator (Ptr<NetDevice> ueDevice, EpsBearer bearer);
1112 
1123  static void ActivateCallback (Ptr<DrbActivator> a, std::string context, uint64_t imsi, uint16_t cellId, uint16_t rnti);
1124 
1135  void ActivateDrb (uint64_t imsi, uint16_t cellId, uint16_t rnti);
1136 private:
1142  bool m_active;
1146  Ptr<NetDevice> m_ueDevice;
1150  EpsBearer m_bearer;
1154  uint64_t m_imsi;
1155 };
1156 
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
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
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
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
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
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
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
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
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
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
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
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
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
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
1427 LteHelper::EnableTraces (void)
1428 {
1429  EnablePhyTraces ();
1430  EnableMacTraces ();
1431  EnableRlcTraces ();
1432  EnablePdcpTraces ();
1433 }
1434 
1435 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
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
1490 LteHelper::EnablePhyTraces (void)
1491 {
1492  EnableDlPhyTraces ();
1493  EnableUlPhyTraces ();
1494  EnableDlTxPhyTraces ();
1495  EnableUlTxPhyTraces ();
1496  EnableDlRxPhyTraces ();
1497  EnableUlRxPhyTraces ();
1498 }
1499 
1500 void
1501 LteHelper::EnableDlTxPhyTraces (void)
1502 {
1503  Config::Connect ("/NodeList/*/DeviceList/*/ComponentCarrierMap/*/LteEnbPhy/DlPhyTransmission",
1504  MakeBoundCallback (&PhyTxStatsCalculator::DlPhyTransmissionCallback, m_phyTxStats));
1505 }
1506 
1507 void
1508 LteHelper::EnableUlTxPhyTraces (void)
1509 {
1510  Config::Connect ("/NodeList/*/DeviceList/*/ComponentCarrierMapUe/*/LteUePhy/UlPhyTransmission",
1511  MakeBoundCallback (&PhyTxStatsCalculator::UlPhyTransmissionCallback, m_phyTxStats));
1512 }
1513 
1514 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
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
1530 LteHelper::EnableMacTraces (void)
1531 {
1532  EnableDlMacTraces ();
1533  EnableUlMacTraces ();
1534 }
1535 
1536 
1537 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
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
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
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>
1573 LteHelper::GetRlcStats (void)
1574 {
1575  return m_rlcStats;
1576 }
1577 
1578 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>
1587 LteHelper::GetPdcpStats (void)
1588 {
1589  return m_pdcpStats;
1590 }
1591 
1592 } // namespace ns3
ns3::NetDeviceContainer
holds a vector of ns3::NetDevice pointers
Definition: net-device-container.h:42
GetPosition
static Vector GetPosition(Ptr< Node > node)
Definition: wifi-ap.cc:96
ns3::LteEnbRrc::RLC_UM_ALWAYS
@ RLC_UM_ALWAYS
Definition: lte-enb-rrc.h:1041
ns3::TypeId
a unique identifier for an interface.
Definition: type-id.h:59
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
ns3::EpcEnbS1SapUser::DataRadioBearerSetupRequestParameters::bearer
EpsBearer bearer
the characteristics of the bearer to be setup
Definition: epc-enb-s1-sap.h:130
ns3::LteHelper::m_epcHelper
Ptr< EpcHelper > m_epcHelper
Helper which provides implementation of core network.
Definition: lte-helper.h:800
ns3::LteHelper::GetRlcStats
Ptr< RadioBearerStatsCalculator > GetRlcStats(void)
Definition: lte-helper.cc:1573
NS_OBJECT_ENSURE_REGISTERED
#define NS_OBJECT_ENSURE_REGISTERED(type)
Register an Object subclass with the TypeId system.
Definition: object-base.h:45
NS_ASSERT
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition: assert.h:67
ns3::BooleanValue
AttributeValue implementation for Boolean.
Definition: boolean.h:37
ns3::EpcEnbApplication
This application is installed inside eNBs and provides the bridge functionality for user data plane p...
Definition: epc-enb-application.h:50
ns3::PhyStatsCalculator::ReportInterference
void ReportInterference(uint16_t cellId, Ptr< SpectrumValue > interference)
Notifies the stats calculator that an interference report has occurred.
Definition: phy-stats-calculator.cc:190
ns3::LteHelper::SetFadingModelAttribute
void SetFadingModelAttribute(std::string n, const AttributeValue &v)
Set an attribute for the fading model to be created (both DL and UL).
Definition: lte-helper.cc:455
ns3::LteHelper::m_isAnrEnabled
bool m_isAnrEnabled
The AnrEnabled attribute.
Definition: lte-helper.h:824
ns3::LteHelper::m_phyStats
Ptr< PhyStatsCalculator > m_phyStats
Container of PHY layer statistics.
Definition: lte-helper.h:781
ns3::LteEnbNetDevice::GetCellId
uint16_t GetCellId() const
Definition: lte-enb-net-device.cc:224
ns3::SpectrumChannel
Defines the interface for spectrum-aware channel implementations.
Definition: spectrum-channel.h:49
ns3::Node::GetId
uint32_t GetId(void) const
Definition: node.cc:109
ns3::FfMacScheduler
This abstract base class identifies the interface by means of which the helper object can plug on the...
Definition: ff-mac-scheduler.h:54
ns3::LteHelper::LteHelper
LteHelper(void)
Definition: lte-helper.cc:75
ns3::RadioBearerStatsConnector::EnablePdcpStats
void EnablePdcpStats(Ptr< RadioBearerStatsCalculator > pdcpStats)
Enables trace sinks for PDCP layer.
Definition: radio-bearer-stats-connector.cc:133
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::LteHelper::EnableUlPhyTraces
void EnableUlPhyTraces(void)
Enable trace sinks for UL PHY layer.
Definition: lte-helper.cc:1562
ns3::ObjectBase::SetAttributeFailSafe
bool SetAttributeFailSafe(std::string name, const AttributeValue &value)
Set a single attribute without raising errors.
Definition: object-base.cc:205
ns3::EpcX2
This entity is installed inside an eNB and provides the functionality for the X2 interface.
Definition: epc-x2.h:100
ns3::LteHelper::DoComponentCarrierConfigure
void DoComponentCarrierConfigure(uint32_t ulEarfcn, uint32_t dlEarfcn, uint16_t ulbw, uint16_t dlbw)
Configure the component carriers.
Definition: lte-helper.cc:1298
ns3::LteHelper::SetEnbDeviceAttribute
void SetEnbDeviceAttribute(std::string n, const AttributeValue &v)
Set an attribute for the eNodeB devices (LteEnbNetDevice) to be created.
Definition: lte-helper.cc:400
ns3::LteHelper::m_rlcStats
Ptr< RadioBearerStatsCalculator > m_rlcStats
Container of RLC layer statistics.
Definition: lte-helper.h:789
ns3::LteHelper::ChannelModelInitialization
void ChannelModelInitialization(void)
Function that performs a channel model initialization of all component carriers.
Definition: lte-helper.cc:224
ns3::LteHelper::SetUeAntennaModelType
void SetUeAntennaModelType(std::string type)
Set the type of antenna model to be used by UE devices.
Definition: lte-helper.cc:429
ns3::LteHelper::m_schedulerFactory
ObjectFactory m_schedulerFactory
Factory of MAC scheduler object.
Definition: lte-helper.h:746
ns3::LteHelper::InstallEnbDevice
NetDeviceContainer InstallEnbDevice(NodeContainer c)
Create a set of eNodeB devices.
Definition: lte-helper.cc:474
ns3::EpcEnbS1SapUser::DataRadioBearerSetupRequestParameters
Parameters passed to DataRadioBearerSetupRequest ()
Definition: epc-enb-s1-sap.h:127
ns3::LOG_PREFIX_NODE
@ LOG_PREFIX_NODE
Prefix all trace prints with simulation node.
Definition: log.h:120
ns3::FriisPropagationLossModel::GetTypeId
static TypeId GetTypeId(void)
Get the type ID.
Definition: propagation-loss-model.cc:146
ns3::LteHelper::m_phyTxStats
Ptr< PhyTxStatsCalculator > m_phyTxStats
Container of PHY layer statistics related to transmission.
Definition: lte-helper.h:783
ns3::LteHelper::m_imsiCounter
uint64_t m_imsiCounter
Keep track of the number of IMSI allocated.
Definition: lte-helper.h:807
ns3::LteHelper::HandoverRequest
void HandoverRequest(Time hoTime, Ptr< NetDevice > ueDev, Ptr< NetDevice > sourceEnbDev, Ptr< NetDevice > targetEnbDev)
Manually trigger an X2-based handover.
Definition: lte-helper.cc:1246
ns3::PhyStatsCalculator::ReportCurrentCellRsrpSinrCallback
static void ReportCurrentCellRsrpSinrCallback(Ptr< PhyStatsCalculator > phyStats, std::string path, uint16_t cellId, uint16_t rnti, double rsrp, double sinr, uint8_t componentCarrierId)
trace sink
Definition: phy-stats-calculator.cc:226
ns3::LteEnbPhy::ReportInterference
virtual void ReportInterference(const SpectrumValue &interf)
generate a report based on the linear interference and noise power perceived during DATA frame NOTE: ...
Definition: lte-enb-phy.cc:850
ns3::Object::GetObject
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:470
ns3::LteHelper::InstallUeDevice
NetDeviceContainer InstallUeDevice(NodeContainer c)
Create a set of UE devices.
Definition: lte-helper.cc:489
ns3::LteUePhy::ReportDataInterference
virtual void ReportDataInterference(const SpectrumValue &interf)
Create the mixed CQI report.
Definition: lte-ue-phy.cc:806
ns3::LteEnbNetDevice::GetTypeId
static TypeId GetTypeId(void)
Get the type ID.
Definition: lte-enb-net-device.cc:59
ns3::LOG_LEVEL_ALL
@ LOG_LEVEL_ALL
Print everything.
Definition: log.h:116
ns3::AttributeValue
Hold a value for an Attribute.
Definition: attribute.h:69
ns3::PhyTxStatsCalculator::DlPhyTransmissionCallback
static void DlPhyTransmissionCallback(Ptr< PhyTxStatsCalculator > phyTxStats, std::string path, PhyTransmissionStatParameters params)
trace sink
Definition: phy-tx-stats-calculator.cc:180
ns3::LteUePhy::ReportInterference
virtual void ReportInterference(const SpectrumValue &interf)
generate a report based on the linear interference and noise power perceived during DATA frame NOTE: ...
Definition: lte-ue-phy.cc:798
NS_LOG_WARN
#define NS_LOG_WARN(msg)
Use NS_LOG to output a message of level LOG_WARN.
Definition: log.h:265
ns3::LteHelper::SetEnbAntennaModelAttribute
void SetEnbAntennaModelAttribute(std::string n, const AttributeValue &v)
Set an attribute for the eNodeB antenna model to be created.
Definition: lte-helper.cc:415
ns3::LteHelper::m_uplinkPathlossModel
Ptr< Object > m_uplinkPathlossModel
The path loss model used in the uplink channel.
Definition: lte-helper.h:743
ns3::LteHelper::AttachToClosestEnb
void AttachToClosestEnb(NetDeviceContainer ueDevices, NetDeviceContainer enbDevices)
Manual attachment of a set of UE devices to the network via the closest eNodeB (with respect to dista...
Definition: lte-helper.cc:1037
ns3::EnumValue::Get
int Get(void) const
Definition: enum.cc:54
ns3::PropagationLossModel
Models the propagation loss through a transmission medium.
Definition: propagation-loss-model.h:50
ns3::LogComponentEnable
void LogComponentEnable(char const *name, enum LogLevel level)
Enable the logging output associated with that log component.
Definition: log.cc:361
ns3::LteHelper::InstallSingleEnbDevice
Ptr< NetDevice > InstallSingleEnbDevice(Ptr< Node > n)
Create an eNodeB device (LteEnbNetDevice) on the given node.
Definition: lte-helper.cc:504
ns3::SimpleRefCount
A template-based reference counting class.
Definition: simple-ref-count.h:74
ns3::LogComponentEnableAll
void LogComponentEnableAll(enum LogLevel level)
Enable the logging output for all registered log components.
Definition: log.cc:385
ns3::LteHelper::~LteHelper
virtual ~LteHelper(void)
Definition: lte-helper.cc:101
ns3::LteHelper::m_pathlossModelFactory
ObjectFactory m_pathlossModelFactory
Factory of path loss model object.
Definition: lte-helper.h:764
ns3::LteHelper::EnableUlRxPhyTraces
void EnableUlRxPhyTraces(void)
Enable trace sinks for UL reception PHY layer.
Definition: lte-helper.cc:1522
ns3::LteHelper::GetDownlinkSpectrumChannel
Ptr< SpectrumChannel > GetDownlinkSpectrumChannel(void) const
Definition: lte-helper.cc:218
ns3::PointerValue
Hold objects of type Ptr<T>.
Definition: pointer.h:37
ns3::LteHelper::SetSpectrumChannelType
void SetSpectrumChannelType(std::string type)
Set the type of spectrum channel to be used in both DL and UL.
Definition: lte-helper.cc:461
ns3::ObjectBase::SetAttribute
void SetAttribute(std::string name, const AttributeValue &value)
Set a single attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:185
ns3::LteHelper::SetPathlossModelAttribute
void SetPathlossModelAttribute(std::string n, const AttributeValue &v)
Set an attribute for the path loss models to be created.
Definition: lte-helper.cc:393
ns3::SpectrumPropagationLossModel
spectrum-aware propagation loss model
Definition: spectrum-propagation-loss-model.h:45
ns3::LteHelper::m_noOfCcs
uint16_t m_noOfCcs
Number of component carriers that will be installed by default at eNodeB and UE devices.
Definition: lte-helper.h:848
ns3::LteHelper::m_fadingModelType
std::string m_fadingModelType
Name of fading model type, e.g., "ns3::TraceFadingLossModel".
Definition: lte-helper.h:769
third.mac
mac
Definition: third.py:99
ns3::LteEnbRrc::RLC_SM_ALWAYS
@ RLC_SM_ALWAYS
Definition: lte-enb-rrc.h:1040
ns3::RadioBearerStatsConnector::EnableRlcStats
void EnableRlcStats(Ptr< RadioBearerStatsCalculator > rlcStats)
Enables trace sinks for RLC layer.
Definition: radio-bearer-stats-connector.cc:126
ns3::LteEnbNetDevice::GetCcMap
std::map< uint8_t, Ptr< ComponentCarrierBaseStation > > GetCcMap(void) const
Definition: lte-enb-net-device.cc:351
ns3::Simulator::Schedule
static EventId Schedule(Time const &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
Definition: simulator.h:557
ns3::MakeBooleanAccessor
Ptr< const AttributeAccessor > MakeBooleanAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method.
Definition: boolean.h:85
ns3::EpcEnbS1SapUser::DataRadioBearerSetupRequestParameters::gtpTeid
uint32_t gtpTeid
S1-bearer GTP tunnel endpoint identifier, see 36.423 9.2.1.
Definition: epc-enb-s1-sap.h:132
first.devices
devices
Definition: first.py:39
ns3::TypeId::SetParent
TypeId SetParent(TypeId tid)
Set the parent TypeId.
Definition: type-id.cc:923
ns3::LteHelper::GetEnbComponentCarrierManagerType
std::string GetEnbComponentCarrierManagerType() const
Definition: lte-helper.cc:343
ns3::DoubleValue
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition: double.h:41
ns3::LteHelper::EnableDlTxPhyTraces
void EnableDlTxPhyTraces(void)
Enable trace sinks for DL transmission PHY layer.
Definition: lte-helper.cc:1501
ns3::EnumValue
Hold variables of type enum.
Definition: enum.h:55
ns3::LteHelper::m_enbAntennaModelFactory
ObjectFactory m_enbAntennaModelFactory
Factory of antenna object for eNodeB.
Definition: lte-helper.h:758
ns3::LteHelper::GetFfrAlgorithmType
std::string GetFfrAlgorithmType() const
Definition: lte-helper.cc:300
lte-helper.h
ns3::DrbActivator::ActivateCallback
static void ActivateCallback(Ptr< DrbActivator > a, std::string context, uint64_t imsi, uint16_t cellId, uint16_t rnti)
Function hooked to the Enb RRC Connection Established trace source Fired upon successful RRC connecti...
Definition: lte-helper.cc:1166
ns3::LteHelper::SetSpectrumChannelAttribute
void SetSpectrumChannelAttribute(std::string n, const AttributeValue &v)
Set an attribute for the spectrum channel to be created (both DL and UL).
Definition: lte-helper.cc:468
ns3::LteUePhy::GenerateCtrlCqiReport
virtual void GenerateCtrlCqiReport(const SpectrumValue &sinr)
generate a CQI report based on the given SINR of Ctrl frame
Definition: lte-ue-phy.cc:556
ns3::LteHelper::m_macStats
Ptr< MacStatsCalculator > m_macStats
Container of MAC layer statistics.
Definition: lte-helper.h:787
ns3::LteHelper::AddX2Interface
void AddX2Interface(NodeContainer enbNodes)
Create an X2 interface between all the eNBs in a given set.
Definition: lte-helper.cc:1221
ns3::EpcTft::Default
static Ptr< EpcTft > Default()
creates a TFT matching any traffic
Definition: epc-tft.cc:224
ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:74
ns3::LteHelper::GetUplinkSpectrumChannel
Ptr< SpectrumChannel > GetUplinkSpectrumChannel(void) const
Definition: lte-helper.cc:212
NS_FATAL_ERROR
#define NS_FATAL_ERROR(msg)
Report a fatal error with a message and terminate.
Definition: fatal-error.h:165
ns3::MacStatsCalculator::UlSchedulingCallback
static void UlSchedulingCallback(Ptr< MacStatsCalculator > macStats, std::string path, uint32_t frameNo, uint32_t subframeNo, uint16_t rnti, uint8_t mcs, uint16_t size, uint8_t componentCarrierId)
Trace sink for the ns3::LteEnbMac::UlScheduling trace source.
Definition: mac-stats-calculator.cc:210
ns3::LteNetDevice::GetIfIndex
virtual uint32_t GetIfIndex(void) const
Definition: lte-net-device.cc:176
ns3::LteEnbNetDevice::GetUlEarfcn
uint32_t GetUlEarfcn() const
Definition: lte-enb-net-device.cc:310
ns3::NetDeviceContainer::Begin
Iterator Begin(void) const
Get an iterator which refers to the first NetDevice in the container.
Definition: net-device-container.cc:46
ns3::TypeIdValue
AttributeValue implementation for TypeId.
Definition: type-id.h:595
ns3::LteHelper::m_fadingModelFactory
ObjectFactory m_fadingModelFactory
Factory of fading model object for both the downlink and uplink channels.
Definition: lte-helper.h:771
ns3::LteUePhy::EnqueueDlHarqFeedback
virtual void EnqueueDlHarqFeedback(DlInfoListElement_s mes)
Enqueue the downlink HARQ feedback generated by LteSpectrumPhy.
Definition: lte-ue-phy.cc:1743
ns3::ObjectFactory::GetTypeId
TypeId GetTypeId(void) const
Get the TypeId which will be created by this ObjectFactory.
Definition: object-factory.cc:91
ns3::LteHelper::GetSchedulerType
std::string GetSchedulerType() const
Definition: lte-helper.cc:287
ns3::LteHelper::SetPathlossModelType
void SetPathlossModelType(TypeId type)
Set the type of path loss model to be used for both DL and UL channels.
Definition: lte-helper.cc:385
ns3::LteHelper::GetPdcpStats
Ptr< RadioBearerStatsCalculator > GetPdcpStats(void)
Definition: lte-helper.cc:1587
ns3::LteHelper::m_fadingStreamsAssigned
bool m_fadingStreamsAssigned
True if a random variable stream number has been assigned for the fading model.
Definition: lte-helper.h:778
ns3::LteHelper::SetEnbAntennaModelType
void SetEnbAntennaModelType(std::string type)
Set the type of antenna model to be used by eNodeB devices.
Definition: lte-helper.cc:408
ns3::Object
A base class which provides memory management and object aggregation.
Definition: object.h:88
ns3::NodeContainer::Begin
Iterator Begin(void) const
Get an iterator which refers to the first Node in the container.
Definition: node-container.cc:77
ns3::LteHelper::m_enbComponentCarrierManagerFactory
ObjectFactory m_enbComponentCarrierManagerFactory
Factory of enb component carrier manager object.
Definition: lte-helper.h:752
ns3::LteUePhy::ReceivePss
virtual void ReceivePss(uint16_t cellId, Ptr< SpectrumValue > p)
Receive PSS function.
Definition: lte-ue-phy.cc:1185
ns3::LteHelper::DoDeActivateDedicatedEpsBearer
void DoDeActivateDedicatedEpsBearer(Ptr< NetDevice > ueDevice, Ptr< NetDevice > enbDevice, uint8_t bearerId)
The actual function to trigger a manual bearer de-activation.
Definition: lte-helper.cc:1283
ns3::LteHelper::m_ffrAlgorithmFactory
ObjectFactory m_ffrAlgorithmFactory
Factory of FFR (frequency reuse) algorithm object.
Definition: lte-helper.h:748
ns3::LteHelper::SetEpcHelper
void SetEpcHelper(Ptr< EpcHelper > h)
Set the EpcHelper to be used to setup the EPC network in conjunction with the setup of the LTE radio ...
Definition: lte-helper.cc:272
NS_LOG_INFO
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:281
ns3::LteHelper::m_cellIdCounter
uint16_t m_cellIdCounter
Keep track of the number of cell ID allocated.
Definition: lte-helper.h:813
ns3::NetDevice::GetNode
virtual Ptr< Node > GetNode(void) const =0
ns3::LteHelper::SetFadingModel
void SetFadingModel(std::string type)
Set the type of fading model to be used in both DL and UL.
Definition: lte-helper.cc:443
ns3::LteHelper::m_useCa
bool m_useCa
The UseCa attribute.
Definition: lte-helper.h:838
ns3::MultiModelSpectrumChannel::GetTypeId
static TypeId GetTypeId(void)
Get the type ID.
Definition: multi-model-spectrum-channel.cc:97
ns3::LteUeNetDevice
The LteUeNetDevice class implements the UE net device.
Definition: lte-ue-net-device.h:57
ns3::LteHelper::m_ueAntennaModelFactory
ObjectFactory m_ueAntennaModelFactory
Factory of antenna object for UE.
Definition: lte-helper.h:762
ns3::LteHelper::m_radioBearerStatsConnector
RadioBearerStatsConnector m_radioBearerStatsConnector
Connects RLC and PDCP statistics containers to appropriate trace sources.
Definition: lte-helper.h:793
ns3::LteUeComponentCarrierManager
The abstract base class of a Component Carrier Manager* for UE that operates using the component carr...
Definition: lte-ue-component-carrier-manager.h:51
ns3::UeManager::CONNECTED_NORMALLY
@ CONNECTED_NORMALLY
Definition: lte-enb-rrc.h:92
ns3::LteHelper::m_handoverAlgorithmFactory
ObjectFactory m_handoverAlgorithmFactory
Factory of handover algorithm object.
Definition: lte-helper.h:750
ns3::LteHelper::EnableDlPhyTraces
void EnableDlPhyTraces(void)
Enable trace sinks for DL PHY layer.
Definition: lte-helper.cc:1554
ns3::PhyRxStatsCalculator::DlPhyReceptionCallback
static void DlPhyReceptionCallback(Ptr< PhyRxStatsCalculator > phyRxStats, std::string path, PhyReceptionStatParameters params)
trace sink
Definition: phy-rx-stats-calculator.cc:180
ns3::MakeBooleanChecker
Ptr< const AttributeChecker > MakeBooleanChecker(void)
Definition: boolean.cc:121
ns3::LteHelper::SetEnbComponentCarrierManagerType
void SetEnbComponentCarrierManagerType(std::string type)
Set the type of carrier component algorithm to be used by eNodeB devices.
Definition: lte-helper.cc:349
ns3::LteUePhy::GenerateMixedCqiReport
virtual void GenerateMixedCqiReport(const SpectrumValue &sinr)
Create the mixed CQI report.
Definition: lte-ue-phy.cc:732
ns3::LteHelper::DeActivateDedicatedEpsBearer
void DeActivateDedicatedEpsBearer(Ptr< NetDevice > ueDevice, Ptr< NetDevice > enbDevice, uint8_t bearerId)
Manually trigger dedicated bearer de-activation at specific simulation time.
Definition: lte-helper.cc:1273
ns3::LteHelper::SetHandoverAlgorithmAttribute
void SetHandoverAlgorithmAttribute(std::string n, const AttributeValue &v)
Set an attribute for the handover algorithm to be created.
Definition: lte-helper.cc:335
ns3::LteHelper::m_pdcpStats
Ptr< RadioBearerStatsCalculator > m_pdcpStats
Container of PDCP layer statistics.
Definition: lte-helper.h:791
ns3::CalculateDistance
double CalculateDistance(const Vector3D &a, const Vector3D &b)
Definition: vector.cc:105
ns3::LteHelper::EnableMacTraces
void EnableMacTraces(void)
Enable trace sinks for MAC layer.
Definition: lte-helper.cc:1530
ns3::Time
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:104
ns3::PhyRxStatsCalculator::UlPhyReceptionCallback
static void UlPhyReceptionCallback(Ptr< PhyRxStatsCalculator > phyRxStats, std::string path, PhyReceptionStatParameters params)
trace sink
Definition: phy-rx-stats-calculator.cc:203
NS_ABORT_MSG_IF
#define NS_ABORT_MSG_IF(cond, msg)
Abnormal program termination if a condition is true, with a message.
Definition: abort.h:108
ns3::LteHelper::SetFfrAlgorithmAttribute
void SetFfrAlgorithmAttribute(std::string n, const AttributeValue &v)
Set an attribute for the FFR algorithm to be created.
Definition: lte-helper.cc:314
ns3::LteUePhy::ReceiveLteControlMessageList
virtual void ReceiveLteControlMessageList(std::list< Ptr< LteControlMessage > > msgList)
Receive LTE control message list function.
Definition: lte-ue-phy.cc:1030
ns3::LteNetDevice::SetNode
virtual void SetNode(Ptr< Node > node)
Definition: lte-net-device.cc:112
ns3::LteSpectrumPhy::UpdateSinrPerceived
void UpdateSinrPerceived(const SpectrumValue &sinr)
Definition: lte-spectrum-phy.cc:925
ns3::LteHelper::EnableLogComponents
void EnableLogComponents(void)
Enables full-blown logging for major components of the LENA architecture.
Definition: lte-helper.cc:1324
ns3::LteEnbNetDevice::GetDlEarfcn
uint32_t GetDlEarfcn() const
Definition: lte-enb-net-device.cc:297
NS_ASSERT_MSG
#define NS_ASSERT_MSG(condition, message)
At runtime, in debugging builds, if this condition is not true, the program prints the message to out...
Definition: assert.h:88
ns3::LteHelper::ActivateDedicatedEpsBearer
uint8_t ActivateDedicatedEpsBearer(NetDeviceContainer ueDevices, EpsBearer bearer, Ptr< EpcTft > tft)
Activate a dedicated EPS bearer on a given set of UE devices.
Definition: lte-helper.cc:1069
ns3::NetDeviceContainer::End
Iterator End(void) const
Get an iterator which indicates past-the-last NetDevice in the container.
Definition: net-device-container.cc:51
ns3::LteHelper::EnableTraces
void EnableTraces(void)
Enables trace sinks for PHY, MAC, RLC and PDCP.
Definition: lte-helper.cc:1427
ns3::Object::DoInitialize
virtual void DoInitialize(void)
Initialize() implementation.
Definition: object.cc:353
ns3::Object::ObjectFactory
friend class ObjectFactory
Friends.
Definition: object.h:328
ns3::LteHelper::EnableUlTxPhyTraces
void EnableUlTxPhyTraces(void)
Enable trace sinks for UL transmission PHY layer.
Definition: lte-helper.cc:1508
ns3::LteHelper::EnableRlcTraces
void EnableRlcTraces(void)
Enable trace sinks for RLC layer.
Definition: lte-helper.cc:1436
ns3::EpcEnbS1SapUser::DataRadioBearerSetupRequestParameters::rnti
uint16_t rnti
the RNTI identifying the UE for which the DataRadioBearer is to be created
Definition: epc-enb-s1-sap.h:128
ns3::TraceFadingLossModel
fading loss model based on precalculated fading traces
Definition: trace-fading-loss-model.h:45
ns3::DrbActivator::DrbActivator
DrbActivator(Ptr< NetDevice > ueDevice, EpsBearer bearer)
DrbActivator Constructor.
Definition: lte-helper.cc:1157
ns3::DrbActivator::m_ueDevice
Ptr< NetDevice > m_ueDevice
UeNetDevice for which bearer will be activated.
Definition: lte-helper.cc:1146
ns3::LteHelper::EnableDlMacTraces
void EnableDlMacTraces(void)
Enable trace sinks for DL MAC layer.
Definition: lte-helper.cc:1538
ns3::LteEnbPhy::PhyPduReceived
void PhyPduReceived(Ptr< Packet > p)
PhySpectrum received a new PHY-PDU.
Definition: lte-enb-phy.cc:434
ns3::LteHelper::AssignStreams
int64_t AssignStreams(NetDeviceContainer c, int64_t stream)
Assign a fixed random variable stream number to the random variables used.
Definition: lte-helper.cc:1444
ns3::PhyStatsCalculator::ReportUeSinr
void ReportUeSinr(uint16_t cellId, uint64_t imsi, uint16_t rnti, double sinrLinear, uint8_t componentCarrierId)
Notifies the stats calculator that an UE SINR report has occurred.
Definition: phy-stats-calculator.cc:152
ns3::MakeCallback
Callback< R, Ts... > MakeCallback(R(T::*memPtr)(Ts...), OBJ objPtr)
Build Callbacks for class method members which take varying numbers of arguments and potentially retu...
Definition: callback.h:1642
NS_LOG_LOGIC
#define NS_LOG_LOGIC(msg)
Use NS_LOG to output a message of level LOG_LOGIC.
Definition: log.h:289
ns3::LteHelper::GetTypeId
static TypeId GetTypeId(void)
Register this type.
Definition: lte-helper.cc:106
ns3::StringValue
Hold variables of type string.
Definition: string.h:41
ns3::LteHelper::m_downlinkChannel
Ptr< SpectrumChannel > m_downlinkChannel
This function create the component carrier based on provided configuration parameters.
Definition: lte-helper.h:737
ns3::LteHelper::SetUeAntennaModelAttribute
void SetUeAntennaModelAttribute(std::string n, const AttributeValue &v)
Set an attribute for the UE antenna model to be created.
Definition: lte-helper.cc:436
ns3::DrbActivator
DrbActivatior allows user to activate bearers for UEs when EPC is not used.
Definition: lte-helper.cc:1103
ns3::DrbActivator::m_bearer
EpsBearer m_bearer
Configuration of bearer which will be activated.
Definition: lte-helper.cc:1150
ns3::NetDeviceContainer::Iterator
std::vector< Ptr< NetDevice > >::const_iterator Iterator
NetDevice container iterator.
Definition: net-device-container.h:45
NS_LOG_FUNCTION_NOARGS
#define NS_LOG_FUNCTION_NOARGS()
Output the name of the function.
Definition: log-macros-enabled.h:209
ns3::LteEnbPhy::GenerateCtrlCqiReport
virtual void GenerateCtrlCqiReport(const SpectrumValue &sinr)
generate a CQI report based on the given SINR of Ctrl frame
Definition: lte-enb-phy.cc:830
ns3::LteHelper::m_downlinkPathlossModel
Ptr< Object > m_downlinkPathlossModel
The path loss model used in the downlink channel.
Definition: lte-helper.h:741
ns3::NodeContainer::Iterator
std::vector< Ptr< Node > >::const_iterator Iterator
Node container iterator.
Definition: node-container.h:42
ns3::LteEnbComponentCarrierManager
The class implements Component Carrier Manager (CCM) that operates using the Component Carrier Manage...
Definition: lte-enb-component-carrier-manager.h:79
ns3::LOG_PREFIX_TIME
@ LOG_PREFIX_TIME
Prefix all trace prints with simulation time.
Definition: log.h:119
ns3::TypeId::GetName
std::string GetName(void) const
Get the name.
Definition: type-id.cc:977
ns3::Config::Connect
void Connect(std::string path, const CallbackBase &cb)
Definition: config.cc:920
ns3::Mac64Address::Allocate
static Mac64Address Allocate(void)
Allocate a new Mac64Address.
Definition: mac64-address.cc:137
ns3::LteHelper::GetUeComponentCarrierManagerType
std::string GetUeComponentCarrierManagerType() const
Definition: lte-helper.cc:364
ns3::UeManager::CONNECTION_RECONFIGURATION
@ CONNECTION_RECONFIGURATION
Definition: lte-enb-rrc.h:93
ns3::EpsBearer
This class contains the specification of EPS Bearers.
Definition: eps-bearer.h:92
ns3::MacStatsCalculator::DlSchedulingCallback
static void DlSchedulingCallback(Ptr< MacStatsCalculator > macStats, std::string path, DlSchedulingCallbackInfo dlSchedulingCallbackInfo)
Trace sink for the ns3::LteEnbMac::DlScheduling trace source.
Definition: mac-stats-calculator.cc:179
ns3::LteHelper::m_phyRxStats
Ptr< PhyRxStatsCalculator > m_phyRxStats
Container of PHY layer statistics related to reception.
Definition: lte-helper.h:785
ns3::LteHelper::m_useIdealRrc
bool m_useIdealRrc
The UseIdealRrc attribute.
Definition: lte-helper.h:819
NS_LOG_DEBUG
#define NS_LOG_DEBUG(msg)
Use NS_LOG to output a message of level LOG_DEBUG.
Definition: log.h:273
ns3::LteHelper::EnableDlRxPhyTraces
void EnableDlRxPhyTraces(void)
Enable trace sinks for DL reception PHY layer.
Definition: lte-helper.cc:1515
ns3::LteHelper::m_enbNetDeviceFactory
ObjectFactory m_enbNetDeviceFactory
Factory of LteEnbNetDevice objects.
Definition: lte-helper.h:756
ns3::LteHelper::m_usePdschForCqiGeneration
bool m_usePdschForCqiGeneration
The UsePdschForCqiGeneration attribute.
Definition: lte-helper.h:830
ns3::LteHelper::SetHandoverAlgorithmType
void SetHandoverAlgorithmType(std::string type)
Set the type of handover algorithm to be used by eNodeB devices.
Definition: lte-helper.cc:327
ns3::PhyTxStatsCalculator::UlPhyTransmissionCallback
static void UlPhyTransmissionCallback(Ptr< PhyTxStatsCalculator > phyTxStats, std::string path, PhyTransmissionStatParameters params)
trace sink
Definition: phy-tx-stats-calculator.cc:203
ns3::LteHelper::SetSchedulerAttribute
void SetSchedulerAttribute(std::string n, const AttributeValue &v)
Set an attribute for the scheduler to be created.
Definition: lte-helper.cc:293
ns3::LteEnbPhy::ReceiveLteControlMessageList
virtual void ReceiveLteControlMessageList(std::list< Ptr< LteControlMessage > >)
PhySpectrum received a new list of LteControlMessage.
Definition: lte-enb-phy.cc:527
ns3::LteNetDevice::Receive
void Receive(Ptr< Packet > p)
receive a packet from the lower layers in order to forward it to the upper layers
Definition: lte-net-device.cc:278
ns3::MakeBoundCallback
Callback< R > MakeBoundCallback(R(*fnPtr)(TX), ARG a1)
Make Callbacks with one bound argument.
Definition: callback.h:1703
ns3::LOG_PREFIX_FUNC
@ LOG_PREFIX_FUNC
Prefix all trace prints with function.
Definition: log.h:118
ns3::LteHelper::EnablePdcpTraces
void EnablePdcpTraces(void)
Enable trace sinks for PDCP layer.
Definition: lte-helper.cc:1579
ns3::LteHelper::SetFfrAlgorithmType
void SetFfrAlgorithmType(std::string type)
Set the type of FFR algorithm to be used by eNodeB devices.
Definition: lte-helper.cc:306
ns3::ObjectFactory::Set
void Set(const std::string &name, const AttributeValue &value, Args &&... args)
Set an attribute to be set during construction.
Definition: object-factory.h:223
ns3::LteNetDevice::GetNode
virtual Ptr< Node > GetNode(void) const
Definition: lte-net-device.cc:120
ns3::DrbActivator::m_active
bool m_active
Bearer can be activated only once.
Definition: lte-helper.cc:1142
ns3::LteEnbPhy::GenerateDataCqiReport
virtual void GenerateDataCqiReport(const SpectrumValue &sinr)
generate a CQI report based on the given SINR of Data frame (used for PUSCH CQIs)
Definition: lte-enb-phy.cc:842
ns3::LteFfrAlgorithm
The abstract base class of a Frequency Reuse algorithm.
Definition: lte-ffr-algorithm.h:58
NS_LOG_FUNCTION
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by ",...
Definition: log-macros-enabled.h:244
ns3::MobilityModel
Keep track of the current position and velocity of an object.
Definition: mobility-model.h:40
ns3::NodeContainer
keep track of a set of node pointers.
Definition: node-container.h:39
ns3::LteHelper::m_componentCarrierPhyParams
std::map< uint8_t, ComponentCarrier > m_componentCarrierPhyParams
This contains all the information about each component carrier.
Definition: lte-helper.h:843
ns3::LteHelper::Attach
void Attach(NetDeviceContainer ueDevices)
Enables automatic attachment of a set of UE devices to a suitable cell using Idle mode initial cell s...
Definition: lte-helper.cc:961
ns3::LteHelper::DoHandoverRequest
void DoHandoverRequest(Ptr< NetDevice > ueDev, Ptr< NetDevice > sourceEnbDev, uint16_t targetCellId)
The actual function to trigger a manual handover.
Definition: lte-helper.cc:1263
ns3::IsotropicAntennaModel::GetTypeId
static TypeId GetTypeId()
Definition: isotropic-antenna-model.cc:38
ns3::LteHelper::SetUeComponentCarrierManagerAttribute
void SetUeComponentCarrierManagerAttribute(std::string n, const AttributeValue &v)
Set an attribute for the ue component carrier manager to be created.
Definition: lte-helper.cc:378
ns3::NodeContainer::End
Iterator End(void) const
Get an iterator which indicates past-the-last Node in the container.
Definition: node-container.cc:82
ns3::MakeStringChecker
Ptr< const AttributeChecker > MakeStringChecker(void)
Definition: string.cc:30
ns3::LteHelper::GetHandoverAlgorithmType
std::string GetHandoverAlgorithmType() const
Definition: lte-helper.cc:321
ns3::LteUePhy::ReportRsReceivedPower
virtual void ReportRsReceivedPower(const SpectrumValue &power)
generate a report based on the linear RS power perceived during CTRL frame NOTE: used only by UE for ...
Definition: lte-ue-phy.cc:815
ns3::LteHelper::m_ueNetDeviceFactory
ObjectFactory m_ueNetDeviceFactory
Factory for LteUeNetDevice objects.
Definition: lte-helper.h:760
ns3::ObjectFactory::SetTypeId
void SetTypeId(TypeId tid)
Set the TypeId of the Objects to be created by this factory.
Definition: object-factory.cc:40
ns3::UintegerValue
Hold an unsigned integer type.
Definition: uinteger.h:44
ns3::LteUeNetDevice::GetTypeId
static TypeId GetTypeId(void)
Get the type ID.
Definition: lte-ue-net-device.cc:63
ns3::ObjectFactory::Create
Ptr< Object > Create(void) const
Create an Object instance of the configured TypeId.
Definition: object-factory.cc:98
ns3::EpsBearer::NGBR_VIDEO_TCP_DEFAULT
@ NGBR_VIDEO_TCP_DEFAULT
Non-GBR TCP-based Video (Buffered Streaming, e.g., www, e-mail...)
Definition: eps-bearer.h:120
ns3::LteUePhy::PhyPduReceived
void PhyPduReceived(Ptr< Packet > p)
PhySpectrum received a new PHY-PDU.
Definition: lte-ue-phy.cc:503
ns3::LteEnbPhy::ReportUlHarqFeedback
virtual void ReportUlHarqFeedback(UlInfoListElement_s mes)
Report the uplink HARQ feedback generated by LteSpectrumPhy to MAC.
Definition: lte-enb-phy.cc:1170
ns3::NetDeviceContainer::GetN
uint32_t GetN(void) const
Get the number of Ptr<NetDevice> stored in this container.
Definition: net-device-container.cc:57
ns3::LteHelper::SetSchedulerType
void SetSchedulerType(std::string type)
Set the type of scheduler to be used by eNodeB devices.
Definition: lte-helper.cc:279
ns3::LteHelper::m_fadingModel
Ptr< SpectrumPropagationLossModel > m_fadingModel
The fading model used in both the downlink and uplink channels.
Definition: lte-helper.h:773
ns3::MakeUintegerAccessor
Ptr< const AttributeAccessor > MakeUintegerAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method.
Definition: uinteger.h:45
ns3::EpcEnbS1SapUser::DataRadioBearerSetupRequestParameters::bearerId
uint8_t bearerId
the EPS Bearer Identifier
Definition: epc-enb-s1-sap.h:131
ns3::LteHelper::SetUeComponentCarrierManagerType
void SetUeComponentCarrierManagerType(std::string type)
Set the type of Component Carrier Manager to be used by Ue devices.
Definition: lte-helper.cc:370
ns3::LteHelper::InstallSingleUeDevice
Ptr< NetDevice > InstallSingleUeDevice(Ptr< Node > n)
Create a UE device (LteUeNetDevice) on the given node.
Definition: lte-helper.cc:761
ns3::LteSpectrumValueHelper::GetCarrierFrequency
static double GetCarrierFrequency(uint32_t earfcn)
Calculates the carrier frequency from the E-UTRA Absolute Radio Frequency Channel Number (EARFCN) acc...
Definition: lte-spectrum-value-helper.cc:102
ns3::Object::Initialize
void Initialize(void)
Invoke DoInitialize on all Objects aggregated to this one.
Definition: object.cc:183
ns3::LteUeRrc::CONNECTED_NORMALLY
@ CONNECTED_NORMALLY
Definition: lte-ue-rrc.h:116
MAX_NO_CC
#define MAX_NO_CC
Definition: lte-enb-rrc.h:57
ns3::LteHelper::SetEnbComponentCarrierManagerAttribute
void SetEnbComponentCarrierManagerAttribute(std::string n, const AttributeValue &v)
Set an attribute for the enb component carrier manager to be created.
Definition: lte-helper.cc:357
ns3::DrbActivator::m_imsi
uint64_t m_imsi
imsi the unique UE identifier
Definition: lte-helper.cc:1154
ns3::LteHelper::EnablePhyTraces
void EnablePhyTraces(void)
Enable trace sinks for PHY layer.
Definition: lte-helper.cc:1490
ns3::LteHelper::m_ueComponentCarrierManagerFactory
ObjectFactory m_ueComponentCarrierManagerFactory
Factory of ue component carrier manager object.
Definition: lte-helper.h:754
ns3::LteHandoverAlgorithm
The abstract base class of a handover algorithm that operates using the Handover Management SAP inter...
Definition: lte-handover-algorithm.h:67
ns3::LteHelper::DoInitialize
virtual void DoInitialize(void)
Initialize() implementation.
Definition: lte-helper.cc:89
ns3::Object::DoDispose
virtual void DoDispose(void)
Destructor implementation.
Definition: object.cc:346
ns3::LteEnbNetDevice::GetUlBandwidth
uint16_t GetUlBandwidth() const
Definition: lte-enb-net-device.cc:243
ns3::DrbActivator::ActivateDrb
void ActivateDrb(uint64_t imsi, uint16_t cellId, uint16_t rnti)
Procedure firstly checks if bearer was not activated, if IMSI from trace source equals configured one...
Definition: lte-helper.cc:1173
ns3::LteHelper::m_uplinkChannel
Ptr< SpectrumChannel > m_uplinkChannel
The uplink LTE channel used in the simulation.
Definition: lte-helper.h:739
ns3::LteEnbNetDevice
The eNodeB device implementation.
Definition: lte-enb-net-device.h:57
ns3::MakeStringAccessor
Ptr< const AttributeAccessor > MakeStringAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method.
Definition: string.h:42
sample-rng-plot.n
n
Definition: sample-rng-plot.py:37
ns3::LteHelper::m_channelFactory
ObjectFactory m_channelFactory
Factory of both the downlink and uplink LTE channels.
Definition: lte-helper.h:766
ns3::MakeTypeIdChecker
Ptr< const AttributeChecker > MakeTypeIdChecker(void)
Definition: type-id.cc:1227
ns3::MakeTypeIdAccessor
Ptr< const AttributeAccessor > MakeTypeIdAccessor(T1 a1)
Create an AttributeAccessor for a class data member, or a lone class get functor or set method.
Definition: type-id.h:595
third.phy
phy
Definition: third.py:93
ns3::LteEnbNetDevice::GetDlBandwidth
uint16_t GetDlBandwidth() const
Definition: lte-enb-net-device.cc:270
ns3::LteHelper::SetUeDeviceAttribute
void SetUeDeviceAttribute(std::string n, const AttributeValue &v)
Set an attribute for the UE devices (LteUeNetDevice) to be created.
Definition: lte-helper.cc:422
ns3::LteHelper::ActivateDataRadioBearer
void ActivateDataRadioBearer(NetDeviceContainer ueDevices, EpsBearer bearer)
Activate a Data Radio Bearer on a given UE devices (for LTE-only simulation).
Definition: lte-helper.cc:1314
ns3::LteEnbNetDevice::SetCcMap
void SetCcMap(std::map< uint8_t, Ptr< ComponentCarrierBaseStation > > ccm)
Set the ComponentCarrier Map of the Enb.
Definition: lte-enb-net-device.cc:357
ns3::LteHelper::EnableUlMacTraces
void EnableUlMacTraces(void)
Enable trace sinks for UL MAC layer.
Definition: lte-helper.cc:1546
ns3::LteHelper::DoDispose
virtual void DoDispose(void)
Destructor implementation.
Definition: lte-helper.cc:202
MIN_NO_CC
#define MIN_NO_CC
Definition: lte-enb-rrc.h:56