A Discrete-Event Network Simulator
API
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
lte-ue-phy.cc
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2010 TELEMATICS LAB, DEE - Politecnico di Bari
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: Giuseppe Piro <g.piro@poliba.it>
19  * Marco Miozzo <marco.miozzo@cttc.es>
20  * Nicola Baldo <nbaldo@cttc.es>
21  */
22 
23 #include <ns3/object-factory.h>
24 #include <ns3/log.h>
25 #include <cfloat>
26 #include <cmath>
27 #include <ns3/simulator.h>
28 #include <ns3/double.h>
29 #include "lte-ue-phy.h"
30 #include "lte-enb-phy.h"
31 #include "lte-net-device.h"
32 #include "lte-ue-net-device.h"
33 #include "lte-enb-net-device.h"
34 #include "lte-spectrum-value-helper.h"
35 #include "lte-amc.h"
36 #include "lte-ue-mac.h"
37 #include "ff-mac-common.h"
38 #include "lte-sinr-chunk-processor.h"
39 #include <ns3/lte-common.h>
40 #include <ns3/pointer.h>
41 
42 NS_LOG_COMPONENT_DEFINE ("LteUePhy");
43 
44 namespace ns3 {
45 
46 
47 
48 
49 // duration of data portion of UL subframe
50 // = TTI - 1 symbol for SRS - 1ns as margin to avoid overlapping simulator events
51 // (symbol duration in nanoseconds = TTI / 14 (rounded))
52 // in other words, duration of data portion of UL subframe = TTI*(13/14) -1ns
53 static const Time UL_DATA_DURATION = NanoSeconds (1e6 - 71429 - 1);
54 
55 // delay from subframe start to transmission of SRS
56 // = TTI - 1 symbol for SRS
57 static const Time UL_SRS_DELAY_FROM_SUBFRAME_START = NanoSeconds (1e6 - 71429);
58 
59 
60 
61 
63 // member SAP forwarders
65 
66 
67 class UeMemberLteUePhySapProvider : public LteUePhySapProvider
68 {
69 public:
70  UeMemberLteUePhySapProvider (LteUePhy* phy);
71 
72  // inherited from LtePhySapProvider
73  virtual void SendMacPdu (Ptr<Packet> p);
74  virtual void SendLteControlMessage (Ptr<LteControlMessage> msg);
75  virtual void SendRachPreamble (uint32_t prachId, uint32_t raRnti);
76 
77 private:
78  LteUePhy* m_phy;
79 };
80 
81 UeMemberLteUePhySapProvider::UeMemberLteUePhySapProvider (LteUePhy* phy) : m_phy (phy)
82 {
83 
84 }
85 
86 void
87 UeMemberLteUePhySapProvider::SendMacPdu (Ptr<Packet> p)
88 {
89  m_phy->DoSendMacPdu (p);
90 }
91 
92 void
93 UeMemberLteUePhySapProvider::SendLteControlMessage (Ptr<LteControlMessage> msg)
94 {
95  m_phy->DoSendLteControlMessage (msg);
96 }
97 
98 void
99 UeMemberLteUePhySapProvider::SendRachPreamble (uint32_t prachId, uint32_t raRnti)
100 {
101  m_phy->DoSendRachPreamble (prachId, raRnti);
102 }
103 
104 
106 // LteUePhy methods
108 
109 
110 NS_OBJECT_ENSURE_REGISTERED (LteUePhy);
111 
112 
113 LteUePhy::LteUePhy ()
114 {
115  NS_LOG_FUNCTION (this);
116  NS_FATAL_ERROR ("This constructor should not be called");
117 }
118 
119 LteUePhy::LteUePhy (Ptr<LteSpectrumPhy> dlPhy, Ptr<LteSpectrumPhy> ulPhy)
120  : LtePhy (dlPhy, ulPhy),
121  m_p10CqiPeriocity (MilliSeconds (1)), // ideal behavior
122  m_a30CqiPeriocity (MilliSeconds (1)), // ideal behavior
123  m_uePhySapUser (0),
124  m_ueCphySapUser (0),
125  m_subframeNo (0),
126  m_rsReceivedPowerUpdated (false),
127  m_rsInterferencePowerUpdated (false),
128  m_pssReceived (false),
129  m_ueMeasurementsFilterPeriod (MilliSeconds (200)),
130  m_ueMeasurementsFilterLast (MilliSeconds (0)),
131  m_rsrpSinrSampleCounter (0)
132 {
133  m_amc = CreateObject <LteAmc> ();
134  m_uePhySapProvider = new UeMemberLteUePhySapProvider (this);
135  m_ueCphySapProvider = new MemberLteUeCphySapProvider<LteUePhy> (this);
136  m_macChTtiDelay = UL_PUSCH_TTIS_DELAY;
137 
138  NS_ASSERT_MSG (Simulator::Now ().GetNanoSeconds () == 0,
139  "Cannot create UE devices after simulation started");
140  Simulator::ScheduleNow (&LteUePhy::SubframeIndication, this, 1, 1);
141  Simulator::Schedule (m_ueMeasurementsFilterPeriod, &LteUePhy::ReportUeMeasurements, this);
142 
143  DoReset ();
144 }
145 
146 
147 LteUePhy::~LteUePhy ()
148 {
149  m_txModeGain.clear ();
150 }
151 
152 void
153 LteUePhy::DoDispose ()
154 {
155  NS_LOG_FUNCTION (this);
156  delete m_uePhySapProvider;
157  delete m_ueCphySapProvider;
158  LtePhy::DoDispose ();
159 }
160 
161 
162 
163 TypeId
164 LteUePhy::GetTypeId (void)
165 {
166  static TypeId tid = TypeId ("ns3::LteUePhy")
167  .SetParent<LtePhy> ()
168  .AddConstructor<LteUePhy> ()
169  .AddAttribute ("TxPower",
170  "Transmission power in dBm",
171  DoubleValue (10.0),
172  MakeDoubleAccessor (&LteUePhy::SetTxPower,
173  &LteUePhy::GetTxPower),
174  MakeDoubleChecker<double> ())
175  .AddAttribute ("NoiseFigure",
176  "Loss (dB) in the Signal-to-Noise-Ratio due to non-idealities in the receiver."
177  " According to Wikipedia (http://en.wikipedia.org/wiki/Noise_figure), this is "
178  "\"the difference in decibels (dB) between"
179  " the noise output of the actual receiver to the noise output of an "
180  " ideal receiver with the same overall gain and bandwidth when the receivers "
181  " are connected to sources at the standard noise temperature T0.\" "
182  "In this model, we consider T0 = 290K.",
183  DoubleValue (9.0),
184  MakeDoubleAccessor (&LteUePhy::SetNoiseFigure,
185  &LteUePhy::GetNoiseFigure),
186  MakeDoubleChecker<double> ())
187  .AddAttribute ("TxMode1Gain",
188  "Transmission mode 1 gain in dB",
189  DoubleValue (0.0),
190  MakeDoubleAccessor (&LteUePhy::SetTxMode1Gain ),
191  MakeDoubleChecker<double> ())
192  .AddAttribute ("TxMode2Gain",
193  "Transmission mode 2 gain in dB",
194  DoubleValue (4.2),
195  MakeDoubleAccessor (&LteUePhy::SetTxMode2Gain ),
196  MakeDoubleChecker<double> ())
197  .AddAttribute ("TxMode3Gain",
198  "Transmission mode 3 gain in dB",
199  DoubleValue (-2.8),
200  MakeDoubleAccessor (&LteUePhy::SetTxMode3Gain ),
201  MakeDoubleChecker<double> ())
202  .AddAttribute ("TxMode4Gain",
203  "Transmission mode 4 gain in dB",
204  DoubleValue (0.0),
205  MakeDoubleAccessor (&LteUePhy::SetTxMode4Gain ),
206  MakeDoubleChecker<double> ())
207  .AddAttribute ("TxMode5Gain",
208  "Transmission mode 5 gain in dB",
209  DoubleValue (0.0),
210  MakeDoubleAccessor (&LteUePhy::SetTxMode5Gain ),
211  MakeDoubleChecker<double> ())
212  .AddAttribute ("TxMode6Gain",
213  "Transmission mode 6 gain in dB",
214  DoubleValue (0.0),
215  MakeDoubleAccessor (&LteUePhy::SetTxMode6Gain ),
216  MakeDoubleChecker<double> ())
217  .AddAttribute ("TxMode7Gain",
218  "Transmission mode 7 gain in dB",
219  DoubleValue (0.0),
220  MakeDoubleAccessor (&LteUePhy::SetTxMode7Gain ),
221  MakeDoubleChecker<double> ())
222  .AddTraceSource ("ReportCurrentCellRsrpSinr",
223  "RSRP and SINR statistics.",
224  MakeTraceSourceAccessor (&LteUePhy::m_reportCurrentCellRsrpSinrTrace))
225  .AddAttribute ("RsrpSinrSamplePeriod",
226  "The sampling period for reporting RSRP-SINR stats (default value 1)",
227  UintegerValue (1),
228  MakeUintegerAccessor (&LteUePhy::m_rsrpSinrSamplePeriod),
229  MakeUintegerChecker<uint16_t> ())
230  .AddTraceSource ("UlPhyTransmission",
231  "DL transmission PHY layer statistics.",
232  MakeTraceSourceAccessor (&LteUePhy::m_ulPhyTransmission))
233  .AddAttribute ("DlSpectrumPhy",
234  "The downlink LteSpectrumPhy associated to this LtePhy",
235  TypeId::ATTR_GET,
236  PointerValue (),
237  MakePointerAccessor (&LteUePhy::GetDlSpectrumPhy),
238  MakePointerChecker <LteSpectrumPhy> ())
239  .AddAttribute ("UlSpectrumPhy",
240  "The uplink LteSpectrumPhy associated to this LtePhy",
241  TypeId::ATTR_GET,
242  PointerValue (),
243  MakePointerAccessor (&LteUePhy::GetUlSpectrumPhy),
244  MakePointerChecker <LteSpectrumPhy> ())
245  .AddAttribute ("RsrqUeMeasThreshold",
246  "Receive threshold for PSS on RSRQ [dB]",
247  DoubleValue (-1000.0),
248  MakeDoubleAccessor (&LteUePhy::m_pssReceptionThreshold ),
249  MakeDoubleChecker<double> ())
250  .AddAttribute ("UeMeasurementsFilterPeriod",
251  "Time period for reporting UE measurements (default 200 ms.) ",
252  TimeValue (MilliSeconds (200)),
253  MakeTimeAccessor (&LteUePhy::m_ueMeasurementsFilterPeriod),
254  MakeTimeChecker ())
255  .AddTraceSource ("ReportUeMeasurements",
256  "Report UE measurements RSRP (dBm) and RSRQ (dB).",
257  MakeTraceSourceAccessor (&LteUePhy::m_reportUeMeasurements))
258  ;
259  return tid;
260 }
261 
262 void
263 LteUePhy::DoInitialize ()
264 {
265  NS_LOG_FUNCTION (this);
266  LtePhy::DoInitialize ();
267 }
268 
269 void
270 LteUePhy::SetLteUePhySapUser (LteUePhySapUser* s)
271 {
272  NS_LOG_FUNCTION (this);
273  m_uePhySapUser = s;
274 }
275 
276 LteUePhySapProvider*
277 LteUePhy::GetLteUePhySapProvider ()
278 {
279  NS_LOG_FUNCTION (this);
280  return (m_uePhySapProvider);
281 }
282 
283 
284 void
285 LteUePhy::SetLteUeCphySapUser (LteUeCphySapUser* s)
286 {
287  NS_LOG_FUNCTION (this);
288  m_ueCphySapUser = s;
289 }
290 
291 LteUeCphySapProvider*
292 LteUePhy::GetLteUeCphySapProvider ()
293 {
294  NS_LOG_FUNCTION (this);
295  return (m_ueCphySapProvider);
296 }
297 
298 void
299 LteUePhy::SetNoiseFigure (double nf)
300 {
301  NS_LOG_FUNCTION (this << nf);
302  m_noiseFigure = nf;
303 }
304 
305 double
306 LteUePhy::GetNoiseFigure () const
307 {
308  NS_LOG_FUNCTION (this);
309  return m_noiseFigure;
310 }
311 
312 void
313 LteUePhy::SetTxPower (double pow)
314 {
315  NS_LOG_FUNCTION (this << pow);
316  m_txPower = pow;
317 }
318 
319 double
320 LteUePhy::GetTxPower () const
321 {
322  NS_LOG_FUNCTION (this);
323  return m_txPower;
324 }
325 
326 
327 uint8_t
328 LteUePhy::GetMacChDelay (void) const
329 {
330  return (m_macChTtiDelay);
331 }
332 
333 Ptr<LteSpectrumPhy>
334 LteUePhy::GetDlSpectrumPhy () const
335 {
336  return m_downlinkSpectrumPhy;
337 }
338 
339 Ptr<LteSpectrumPhy>
340 LteUePhy::GetUlSpectrumPhy () const
341 {
342  return m_uplinkSpectrumPhy;
343 }
344 
345 void
346 LteUePhy::DoSendMacPdu (Ptr<Packet> p)
347 {
348  NS_LOG_FUNCTION (this);
349 
350  SetMacPdu (p);
351 }
352 
353 
354 void
355 LteUePhy::PhyPduReceived (Ptr<Packet> p)
356 {
357  m_uePhySapUser->ReceivePhyPdu (p);
358 }
359 
360 void
361 LteUePhy::SetSubChannelsForTransmission (std::vector <int> mask)
362 {
363  NS_LOG_FUNCTION (this);
364 
365  m_subChannelsForTransmission = mask;
366 
367  Ptr<SpectrumValue> txPsd = CreateTxPowerSpectralDensity ();
368  m_uplinkSpectrumPhy->SetTxPowerSpectralDensity (txPsd);
369 }
370 
371 
372 void
373 LteUePhy::SetSubChannelsForReception (std::vector <int> mask)
374 {
375  NS_LOG_FUNCTION (this);
376  m_subChannelsForReception = mask;
377 }
378 
379 
380 std::vector <int>
381 LteUePhy::GetSubChannelsForTransmission ()
382 {
383  NS_LOG_FUNCTION (this);
384  return m_subChannelsForTransmission;
385 }
386 
387 
388 std::vector <int>
389 LteUePhy::GetSubChannelsForReception ()
390 {
391  NS_LOG_FUNCTION (this);
392  return m_subChannelsForReception;
393 }
394 
395 
396 Ptr<SpectrumValue>
397 LteUePhy::CreateTxPowerSpectralDensity ()
398 {
399  NS_LOG_FUNCTION (this);
400  LteSpectrumValueHelper psdHelper;
401  Ptr<SpectrumValue> psd = psdHelper.CreateTxPowerSpectralDensity (m_ulEarfcn, m_ulBandwidth, m_txPower, GetSubChannelsForTransmission ());
402 
403  return psd;
404 }
405 
406 void
407 LteUePhy::GenerateCtrlCqiReport (const SpectrumValue& sinr)
408 {
409  NS_LOG_FUNCTION (this);
410 
411  if ((!(m_dlConfigured && m_ulConfigured)) || (m_rnti == 0))
412  {
413  // abort method, the UE is still not registered
414  m_pssList.clear ();
415  return;
416  }
417 
418  // check periodic wideband CQI
419  if (Simulator::Now () > m_p10CqiLast + m_p10CqiPeriocity)
420  {
421  Ptr<LteUeNetDevice> thisDevice = GetDevice ()->GetObject<LteUeNetDevice> ();
422  Ptr<DlCqiLteControlMessage> msg = CreateDlCqiFeedbackMessage (sinr);
423  if (msg)
424  {
425  DoSendLteControlMessage (msg);
426  }
427  m_p10CqiLast = Simulator::Now ();
428  }
429  // check aperiodic high-layer configured subband CQI
430  if (Simulator::Now () > m_a30CqiLast + m_a30CqiPeriocity)
431  {
432  Ptr<LteUeNetDevice> thisDevice = GetDevice ()->GetObject<LteUeNetDevice> ();
433  Ptr<DlCqiLteControlMessage> msg = CreateDlCqiFeedbackMessage (sinr);
434  if (msg)
435  {
436  DoSendLteControlMessage (msg);
437  }
438  m_a30CqiLast = Simulator::Now ();
439  }
440 
441  // Generate PHY trace
442  m_rsrpSinrSampleCounter++;
443  if (m_rsrpSinrSampleCounter==m_rsrpSinrSamplePeriod)
444  {
445  NS_ASSERT_MSG (m_rsReceivedPowerUpdated, " RS received power info obsolete");
446  // RSRP evaluated as averaged received power among RBs
447  double sum = 0.0;
448  uint8_t rbNum = 0;
449  Values::const_iterator it;
450  for (it = m_rsReceivedPower.ConstValuesBegin (); it != m_rsReceivedPower.ConstValuesEnd (); it++)
451  {
452  // convert PSD [W/Hz] to linear power [W] for the single RE
453  // we consider only one RE for the RS since the channel is
454  // flat within the same RB
455  double powerTxW = ((*it) * 180000.0) / 12.0;
456  sum += powerTxW;
457  rbNum++;
458  }
459  double rsrp = (rbNum > 0) ? (sum / rbNum) : DBL_MAX;
460  // averaged SINR among RBs
461  sum = 0.0;
462  rbNum = 0;
463  for (it = sinr.ConstValuesBegin (); it != sinr.ConstValuesEnd (); it++)
464  {
465  sum += (*it);
466  rbNum++;
467  }
468  double avSinr = (rbNum > 0) ? (sum / rbNum) : DBL_MAX;
469  NS_LOG_INFO (this << " cellId " << m_cellId << " rnti " << m_rnti << " RSRP " << rsrp << " SINR " << avSinr);
470 
471  m_reportCurrentCellRsrpSinrTrace (m_cellId, m_rnti, rsrp, avSinr);
472  m_rsrpSinrSampleCounter = 0;
473  }
474 
475  // Generate UE Measurements for upper layers
476  if (m_pssReceived)
477  {
478  NS_ASSERT_MSG (m_rsInterferencePowerUpdated, " RS interference power info obsolete");
479  // PSSs received
480  NS_LOG_DEBUG (this << " Process PSS RNTI " << m_rnti << " cellId " << m_cellId << " PSS num " << m_pssList.size ());
481  std::list <PssElement>::iterator itPss = m_pssList.begin ();
482  while (itPss != m_pssList.end ())
483  {
484  uint8_t rbNum = 0;
485  double rsrqSum = 0.0;
486  Values::const_iterator itIntN = m_rsIntereferencePower.ConstValuesBegin ();
487  Values::const_iterator itPj = m_rsReceivedPower.ConstValuesBegin ();
488  for (itPj = m_rsReceivedPower.ConstValuesBegin (); itPj != m_rsReceivedPower.ConstValuesEnd (); itIntN++, itPj++)
489  {
490  rbNum++;
491  // convert PSD [W/Hz] to linear power [W] for the single RE
492  double noisePowerTxW = ((*itIntN) * 180000.0) / 12.0;
493  double intPowerTxW = ((*itPj) * 180000.0) / 12.0;
494  rsrqSum += (2 * (noisePowerTxW + intPowerTxW));
495  }
496  NS_ASSERT (rbNum == (*itPss).nRB);
497  double rsrp_dBm = 10 * log10 (1000 * ((*itPss).pssPsdSum / (double)rbNum));
498  double rsrq_dB = 10 * log10 ((*itPss).pssPsdSum / rsrqSum);
499 
500  if (rsrq_dB > m_pssReceptionThreshold)
501  {
502  // report UE Measurements to upper layers
503  NS_LOG_INFO (this << " PSS received from CellId " << (*itPss).cellId << " has RSRP " << rsrp_dBm << " and RSRQ " << rsrq_dB << " RBnum " << (uint16_t)rbNum);
504  // store measurements
505  std::map <uint16_t, UeMeasurementsElement>::iterator itMeasMap = m_UeMeasurementsMap.find ((*itPss).cellId);
506  if (itMeasMap == m_UeMeasurementsMap.end ())
507  {
508  // insert new entry
509  UeMeasurementsElement newEl;
510  newEl.rsrpSum = rsrp_dBm;
511  newEl.rsrpNum = 1;
512  newEl.rsrqSum = rsrq_dB;
513  newEl.rsrqNum = 1;
514  m_UeMeasurementsMap.insert (std::pair <uint16_t, UeMeasurementsElement> ((*itPss).cellId, newEl));
515  }
516  else
517  {
518  (*itMeasMap).second.rsrpSum += rsrp_dBm;
519  (*itMeasMap).second.rsrpNum++;
520  (*itMeasMap).second.rsrqSum += rsrq_dB;
521  (*itMeasMap).second.rsrqNum++;
522  }
523 
524  }
525  itPss++;
526  }
527  m_pssList.clear ();
528  }
529 
530 
531 
532 }
533 
534 void
535 LteUePhy::GenerateDataCqiReport (const SpectrumValue& sinr)
536 {
537  // Not used by UE, CQI are based only on RS
538 }
539 
540 void
541 LteUePhy::ReportInterference (const SpectrumValue& interf)
542 {
543  NS_LOG_FUNCTION (this << interf);
544  m_rsInterferencePowerUpdated = true;
545  m_rsIntereferencePower = interf;
546 }
547 
548 void
549 LteUePhy::ReportRsReceivedPower (const SpectrumValue& power)
550 {
551  NS_LOG_FUNCTION (this << power);
552  m_rsReceivedPowerUpdated = true;
553  m_rsReceivedPower = power;
554 }
555 
556 
557 
558 Ptr<DlCqiLteControlMessage>
559 LteUePhy::CreateDlCqiFeedbackMessage (const SpectrumValue& sinr)
560 {
561  NS_LOG_FUNCTION (this);
562 
563 
564  // apply transmission mode gain
565  NS_ASSERT (m_transmissionMode < m_txModeGain.size ());
566  SpectrumValue newSinr = sinr;
567  newSinr *= m_txModeGain.at (m_transmissionMode);
568 
569  // CREATE DlCqiLteControlMessage
570  Ptr<DlCqiLteControlMessage> msg = Create<DlCqiLteControlMessage> ();
571  CqiListElement_s dlcqi;
572  std::vector<int> cqi;
573  if (Simulator::Now () > m_p10CqiLast + m_p10CqiPeriocity)
574  {
575  cqi = m_amc->CreateCqiFeedbacks (newSinr, m_dlBandwidth);
576 
577  int nLayer = TransmissionModesLayers::TxMode2LayerNum (m_transmissionMode);
578  int nbSubChannels = cqi.size ();
579  double cqiSum = 0.0;
580  int activeSubChannels = 0;
581  // average the CQIs of the different RBs
582  for (int i = 0; i < nbSubChannels; i++)
583  {
584  if (cqi.at (i) != -1)
585  {
586  cqiSum += cqi.at (i);
587  activeSubChannels++;
588  }
589  NS_LOG_DEBUG (this << " subch " << i << " cqi " << cqi.at (i));
590  }
591  dlcqi.m_rnti = m_rnti;
592  dlcqi.m_ri = 1; // not yet used
593  dlcqi.m_cqiType = CqiListElement_s::P10; // Peridic CQI using PUCCH wideband
594  NS_ASSERT_MSG (nLayer > 0, " nLayer negative");
595  NS_ASSERT_MSG (nLayer < 3, " nLayer limit is 2s");
596  for (int i = 0; i < nLayer; i++)
597  {
598  if (activeSubChannels > 0)
599  {
600  dlcqi.m_wbCqi.push_back ((uint16_t) cqiSum / activeSubChannels);
601  }
602  else
603  {
604  // approximate with the worst case -> CQI = 1
605  dlcqi.m_wbCqi.push_back (1);
606  }
607  }
608  //NS_LOG_DEBUG (this << " Generate P10 CQI feedback " << (uint16_t) cqiSum / activeSubChannels);
609  dlcqi.m_wbPmi = 0; // not yet used
610  // dl.cqi.m_sbMeasResult others CQI report modes: not yet implemented
611  }
612  else if (Simulator::Now () > m_a30CqiLast + m_a30CqiPeriocity)
613  {
614  cqi = m_amc->CreateCqiFeedbacks (newSinr, GetRbgSize ());
615  int nLayer = TransmissionModesLayers::TxMode2LayerNum (m_transmissionMode);
616  int nbSubChannels = cqi.size ();
617  int rbgSize = GetRbgSize ();
618  double cqiSum = 0.0;
619  int cqiNum = 0;
620  SbMeasResult_s rbgMeas;
621  //NS_LOG_DEBUG (this << " Create A30 CQI feedback, RBG " << rbgSize << " cqiNum " << nbSubChannels << " band " << (uint16_t)m_dlBandwidth);
622  for (int i = 0; i < nbSubChannels; i++)
623  {
624  if (cqi.at (i) != -1)
625  {
626  cqiSum += cqi.at (i);
627  }
628  // else "nothing" no CQI is treated as CQI = 0 (worst case scenario)
629  cqiNum++;
630  if (cqiNum == rbgSize)
631  {
632  // average the CQIs of the different RBGs
633  //NS_LOG_DEBUG (this << " RBG CQI " << (uint16_t) cqiSum / rbgSize);
634  HigherLayerSelected_s hlCqi;
635  hlCqi.m_sbPmi = 0; // not yet used
636  for (int i = 0; i < nLayer; i++)
637  {
638  hlCqi.m_sbCqi.push_back ((uint16_t) cqiSum / rbgSize);
639  }
640  rbgMeas.m_higherLayerSelected.push_back (hlCqi);
641  cqiSum = 0.0;
642  cqiNum = 0;
643  }
644  }
645  dlcqi.m_rnti = m_rnti;
646  dlcqi.m_ri = 1; // not yet used
647  dlcqi.m_cqiType = CqiListElement_s::A30; // Aperidic CQI using PUSCH
648  //dlcqi.m_wbCqi.push_back ((uint16_t) cqiSum / nbSubChannels);
649  dlcqi.m_wbPmi = 0; // not yet used
650  dlcqi.m_sbMeasResult = rbgMeas;
651  }
652 
653  msg->SetDlCqi (dlcqi);
654  return msg;
655 }
656 
657 
658 void
659 LteUePhy::ReportUeMeasurements ()
660 {
661  NS_LOG_FUNCTION (this << Simulator::Now ());
662  NS_LOG_DEBUG (this << " Report UE Measurements ");
663  LteUeCphySapUser::UeMeasurementsParameters ret;
664  std::map <uint16_t, UeMeasurementsElement>::iterator it;
665  for (it = m_UeMeasurementsMap.begin (); it != m_UeMeasurementsMap.end (); it++)
666  {
667  double avg_rsrp = (*it).second.rsrpSum / (double)(*it).second.rsrpNum;
668  double avg_rsrq = (*it).second.rsrqSum / (double)(*it).second.rsrqNum;
669  NS_LOG_DEBUG (this << " CellId " << (*it).first << " RSRP " << avg_rsrp << " (nSamples " << (*it).second.rsrpNum << ") RSRQ " << avg_rsrq << " (nSamples " << (*it).second.rsrpNum << ")");
670  LteUeCphySapUser::UeMeasurementsElement newEl;
671  newEl.m_cellId = (*it).first;
672  newEl.m_rsrp = avg_rsrp;
673  newEl.m_rsrq = avg_rsrq;
674  ret.m_ueMeasurementsList.push_back (newEl);
675  // report to UE measurements trace
676  m_reportUeMeasurements (m_rnti, m_cellId, avg_rsrp, avg_rsrq, ((*it).first == m_cellId ? 1 : 0));
677  }
678  m_ueCphySapUser-> ReportUeMeasurements(ret);
679  m_UeMeasurementsMap.clear ();
680  Simulator::Schedule (m_ueMeasurementsFilterPeriod, &LteUePhy::ReportUeMeasurements, this);
681 }
682 
683 
684 
685 void
686 LteUePhy::DoSendLteControlMessage (Ptr<LteControlMessage> msg)
687 {
688  NS_LOG_FUNCTION (this << msg);
689 
690  SetControlMessages (msg);
691 }
692 
693 void
694 LteUePhy::DoSendRachPreamble (uint32_t raPreambleId, uint32_t raRnti)
695 {
696  NS_LOG_FUNCTION (this << raPreambleId);
697 
698  // unlike other control messages, RACH preamble is sent ASAP
699  Ptr<RachPreambleLteControlMessage> msg = Create<RachPreambleLteControlMessage> ();
700  msg->SetRapId (raPreambleId);
701  m_raPreambleId = raPreambleId;
702  m_raRnti = raRnti;
703  m_controlMessagesQueue.at (0).push_back (msg);
704 }
705 
706 
707 void
708 LteUePhy::ReceiveLteControlMessageList (std::list<Ptr<LteControlMessage> > msgList)
709 {
710  NS_LOG_FUNCTION (this);
711 
712  std::list<Ptr<LteControlMessage> >::iterator it;
713  for (it = msgList.begin (); it != msgList.end(); it++)
714  {
715  Ptr<LteControlMessage> msg = (*it);
716 
717  if (msg->GetMessageType () == LteControlMessage::DL_DCI)
718  {
719  Ptr<DlDciLteControlMessage> msg2 = DynamicCast<DlDciLteControlMessage> (msg);
720 
721  DlDciListElement_s dci = msg2->GetDci ();
722  if (dci.m_rnti != m_rnti)
723  {
724  // DCI not for me
725  continue;
726  }
727 
728  if (dci.m_resAlloc != 0)
729  {
730  NS_FATAL_ERROR ("Resource Allocation type not implemented");
731  }
732 
733  std::vector <int> dlRb;
734 
735  // translate the DCI to Spectrum framework
736  uint32_t mask = 0x1;
737  for (int i = 0; i < 32; i++)
738  {
739  if (((dci.m_rbBitmap & mask) >> i) == 1)
740  {
741  for (int k = 0; k < GetRbgSize (); k++)
742  {
743  dlRb.push_back ((i * GetRbgSize ()) + k);
744 // NS_LOG_DEBUG(this << " RNTI " << m_rnti << " RBG " << i << " DL-DCI allocated PRB " << (i*GetRbgSize()) + k);
745  }
746  }
747  mask = (mask << 1);
748  }
749 
750  // send TB info to LteSpectrumPhy
751  NS_LOG_DEBUG (this << " UE " << m_rnti << " DL-DCI " << dci.m_rnti << " bitmap " << dci.m_rbBitmap);
752  for (uint8_t i = 0; i < dci.m_tbsSize.size (); i++)
753  {
754  m_downlinkSpectrumPhy->AddExpectedTb (dci.m_rnti, dci.m_ndi.at (i), dci.m_tbsSize.at (i), dci.m_mcs.at (i), dlRb, i, dci.m_harqProcess, dci.m_rv.at (i), true /* DL */);
755  }
756 
757  SetSubChannelsForReception (dlRb);
758 
759 
760  }
761  else if (msg->GetMessageType () == LteControlMessage::UL_DCI)
762  {
763  // set the uplink bandwidht according to the UL-CQI
764  Ptr<UlDciLteControlMessage> msg2 = DynamicCast<UlDciLteControlMessage> (msg);
765  UlDciListElement_s dci = msg2->GetDci ();
766  if (dci.m_rnti != m_rnti)
767  {
768  // DCI not for me
769  continue;
770  }
771  NS_LOG_INFO (this << " UL DCI");
772  std::vector <int> ulRb;
773  for (int i = 0; i < dci.m_rbLen; i++)
774  {
775  ulRb.push_back (i + dci.m_rbStart);
776  //NS_LOG_DEBUG (this << " UE RB " << i + dci.m_rbStart);
777  }
778  QueueSubChannelsForTransmission (ulRb);
779  // fire trace of UL Tx PHY stats
780  HarqProcessInfoList_t harqInfoList = m_harqPhyModule->GetHarqProcessInfoUl (m_rnti, 0);
781  PhyTransmissionStatParameters params;
782  params.m_cellId = m_cellId;
783  params.m_imsi = 0; // it will be set by DlPhyTransmissionCallback in LteHelper
784  params.m_timestamp = Simulator::Now ().GetMilliSeconds () + UL_PUSCH_TTIS_DELAY;
785  params.m_rnti = m_rnti;
786  params.m_txMode = 0; // always SISO for UE
787  params.m_layer = 0;
788  params.m_mcs = dci.m_mcs;
789  params.m_size = dci.m_tbSize;
790  params.m_rv = harqInfoList.size ();
791  params.m_ndi = dci.m_ndi;
792  m_ulPhyTransmission (params);
793  // pass the info to the MAC
794  m_uePhySapUser->ReceiveLteControlMessage (msg);
795  }
796  else if (msg->GetMessageType () == LteControlMessage::RAR)
797  {
798  Ptr<RarLteControlMessage> rarMsg = DynamicCast<RarLteControlMessage> (msg);
799  if (rarMsg->GetRaRnti () == m_raRnti)
800  {
801  for (std::list<RarLteControlMessage::Rar>::const_iterator it = rarMsg->RarListBegin (); it != rarMsg->RarListEnd (); ++it)
802  {
803  if (it->rapId != m_raPreambleId)
804  {
805  // UL grant not for me
806  continue;
807  }
808  else
809  {
810  NS_LOG_INFO ("received RAR RNTI " << m_raRnti);
811  // set the uplink bandwidht according to the UL grant
812  std::vector <int> ulRb;
813  for (int i = 0; i < it->rarPayload.m_grant.m_rbLen; i++)
814  {
815  ulRb.push_back (i + it->rarPayload.m_grant.m_rbStart);
816  }
817 
818  QueueSubChannelsForTransmission (ulRb);
819  // pass the info to the MAC
820  m_uePhySapUser->ReceiveLteControlMessage (msg);
821  // reset RACH variables with out of range values
822  m_raPreambleId = 255;
823  m_raRnti = 11;
824  }
825  }
826  }
827  }
828  else if (msg->GetMessageType () == LteControlMessage::MIB)
829  {
830  NS_LOG_INFO ("received MIB");
831  Ptr<MibLteControlMessage> msg2 = DynamicCast<MibLteControlMessage> (msg);
832  m_ueCphySapUser->RecvMasterInformationBlock (msg2->GetMib ());
833  }
834  else
835  {
836  // pass the message to UE-MAC
837  m_uePhySapUser->ReceiveLteControlMessage (msg);
838  }
839 
840  }
841 
842 
843 }
844 
845 
846 void
847 LteUePhy::ReceivePss (uint16_t cellId, Ptr<SpectrumValue> p)
848 {
849  NS_LOG_FUNCTION (this << cellId << (*p));
850  if (!m_dlConfigured)
851  {
852  // LteUePhy not yet configured -> skip measurement
853  return;
854  }
855  m_pssReceived = true;
856  PssElement el;
857  el.cellId = cellId;
858  double sum = 0.0;
859  uint16_t nRB = 0;
860  Values::const_iterator itPi;
861  for (itPi = p->ConstValuesBegin (); itPi != p->ConstValuesEnd (); itPi++)
862  {
863  // convert PSD [W/Hz] to linear power [W] for the single RE
864  double powerTxW = ((*itPi) * 180000.0) / 12.0;
865  sum += powerTxW;
866  nRB++;
867  }
868  el.pssPsdSum = sum;
869  el.nRB = nRB;
870  m_pssList.push_back (el);
871 }
872 
873 
874 void
875 LteUePhy::QueueSubChannelsForTransmission (std::vector <int> rbMap)
876 {
877  m_subChannelsForTransmissionQueue.at (m_macChTtiDelay - 1) = rbMap;
878 }
879 
880 
881 void
882 LteUePhy::SubframeIndication (uint32_t frameNo, uint32_t subframeNo)
883 {
884  NS_LOG_FUNCTION (this << frameNo << subframeNo);
885 
886  NS_ASSERT_MSG (frameNo > 0, "the SRS index check code assumes that frameNo starts at 1");
887 
888  // refresh internal variables
889  m_rsReceivedPowerUpdated = false;
890  m_rsInterferencePowerUpdated = false;
891  m_pssReceived = false;
892 
893  if (m_ulConfigured)
894  {
895  // update uplink transmission mask according to previous UL-CQIs
896  SetSubChannelsForTransmission (m_subChannelsForTransmissionQueue.at (0));
897 
898  // shift the queue
899  for (uint8_t i = 1; i < m_macChTtiDelay; i++)
900  {
901  m_subChannelsForTransmissionQueue.at (i-1) = m_subChannelsForTransmissionQueue.at (i);
902  }
903  m_subChannelsForTransmissionQueue.at (m_macChTtiDelay-1).clear ();
904 
905  if (m_srsConfigured && (m_srsStartTime <= Simulator::Now ()))
906  {
907 
908  NS_ASSERT_MSG (subframeNo > 0 && subframeNo <= 10, "the SRS index check code assumes that subframeNo starts at 1");
909  if ((((frameNo-1)*10 + (subframeNo-1)) % m_srsPeriodicity) == m_srsSubframeOffset)
910  {
911  NS_LOG_INFO ("frame " << frameNo << " subframe " << subframeNo << " sending SRS (offset=" << m_srsSubframeOffset << ", period=" << m_srsPeriodicity << ")");
912  m_sendSrsEvent = Simulator::Schedule (UL_SRS_DELAY_FROM_SUBFRAME_START,
913  &LteUePhy::SendSrs,
914  this);
915  }
916  }
917 
918  std::list<Ptr<LteControlMessage> > ctrlMsg = GetControlMessages ();
919  // send packets in queue
920  NS_LOG_LOGIC (this << " UE - start slot for PUSCH + PUCCH - RNTI " << m_rnti << " CELLID " << m_cellId);
921  // send the current burts of packets
922  Ptr<PacketBurst> pb = GetPacketBurst ();
923  if (pb)
924  {
925  m_uplinkSpectrumPhy->StartTxDataFrame (pb, ctrlMsg, UL_DATA_DURATION);
926  }
927  else
928  {
929  // send only PUCCH (ideal: fake null bandwidth signal)
930  if (ctrlMsg.size ()>0)
931  {
932  NS_LOG_LOGIC (this << " UE - start TX PUCCH (NO PUSCH)");
933  std::vector <int> dlRb;
934  SetSubChannelsForTransmission (dlRb);
935  m_uplinkSpectrumPhy->StartTxDataFrame (pb, ctrlMsg, UL_DATA_DURATION);
936  }
937  else
938  {
939  NS_LOG_LOGIC (this << " UE - UL NOTHING TO SEND");
940  }
941  }
942  } // m_configured
943 
944  // trigger the MAC
945  m_uePhySapUser->SubframeIndication (frameNo, subframeNo);
946 
947  m_subframeNo = subframeNo;
948  ++subframeNo;
949  if (subframeNo > 10)
950  {
951  ++frameNo;
952  subframeNo = 1;
953  }
954 
955  // schedule next subframe indication
956  Simulator::Schedule (Seconds (GetTti ()), &LteUePhy::SubframeIndication, this, frameNo, subframeNo);
957 }
958 
959 void
960 LteUePhy::SendSrs ()
961 {
962  NS_LOG_FUNCTION (this << " UE " << m_rnti << " start tx SRS, cell Id " << (uint32_t) m_cellId);
963  NS_ASSERT (m_cellId > 0);
964  // set the current tx power spectral density (full bandwidth)
965  std::vector <int> dlRb;
966  for (uint8_t i = 0; i < m_ulBandwidth; i++)
967  {
968  dlRb.push_back (i);
969  }
970  SetSubChannelsForTransmission (dlRb);
971  m_uplinkSpectrumPhy->StartTxUlSrsFrame ();
972 }
973 
974 
975 void
976 LteUePhy::DoReset ()
977 {
978  NS_LOG_FUNCTION (this);
979 
980  m_rnti = 0;
981  m_transmissionMode = 0;
982  m_srsPeriodicity = 0;
983  m_srsConfigured = false;
984  m_dlConfigured = false;
985  m_ulConfigured = false;
986  m_raPreambleId = 255; // value out of range
987  m_raRnti = 11; // value out of range
988  m_rsrpSinrSampleCounter = 0;
989  m_p10CqiLast = Simulator::Now ();
990  m_a30CqiLast = Simulator::Now ();
991 
992  m_packetBurstQueue.clear ();
993  m_controlMessagesQueue.clear ();
994  m_subChannelsForTransmissionQueue.clear ();
995  for (int i = 0; i < m_macChTtiDelay; i++)
996  {
997  Ptr<PacketBurst> pb = CreateObject <PacketBurst> ();
998  m_packetBurstQueue.push_back (pb);
999  std::list<Ptr<LteControlMessage> > l;
1000  m_controlMessagesQueue.push_back (l);
1001  }
1002  std::vector <int> ulRb;
1003  m_subChannelsForTransmissionQueue.resize (m_macChTtiDelay, ulRb);
1004 
1005  m_sendSrsEvent.Cancel ();
1006  m_downlinkSpectrumPhy->Reset ();
1007  m_uplinkSpectrumPhy->Reset ();
1008 }
1009 
1010 void
1011 LteUePhy::DoSyncronizeWithEnb (uint16_t cellId, uint16_t dlEarfcn)
1012 {
1013  NS_LOG_FUNCTION (this << cellId);
1014  m_cellId = cellId;
1015  m_dlEarfcn = dlEarfcn;
1016  m_downlinkSpectrumPhy->SetCellId (cellId);
1017  m_uplinkSpectrumPhy->SetCellId (cellId);
1018 
1019  // configure DL for receing the BCH with the minimum bandwith
1020  m_dlBandwidth = 6;
1021  Ptr<SpectrumValue> noisePsd = LteSpectrumValueHelper::CreateNoisePowerSpectralDensity (m_dlEarfcn, m_dlBandwidth, m_noiseFigure);
1022  m_downlinkSpectrumPhy->SetNoisePowerSpectralDensity (noisePsd);
1023  m_downlinkSpectrumPhy->GetChannel ()->AddRx (m_downlinkSpectrumPhy);
1024 
1025  m_dlConfigured = false;
1026  m_ulConfigured = false;
1027 }
1028 
1029 void
1030 LteUePhy::DoSetDlBandwidth (uint8_t dlBandwidth)
1031 {
1032  NS_LOG_FUNCTION (this << (uint32_t) dlBandwidth);
1033  if (m_dlBandwidth != dlBandwidth or !m_dlConfigured)
1034  {
1035  m_dlBandwidth = dlBandwidth;
1036 
1037  int Type0AllocationRbg[4] = {
1038  10, // RGB size 1
1039  26, // RGB size 2
1040  63, // RGB size 3
1041  110 // RGB size 4
1042  }; // see table 7.1.6.1-1 of 36.213
1043  for (int i = 0; i < 4; i++)
1044  {
1045  if (dlBandwidth < Type0AllocationRbg[i])
1046  {
1047  m_rbgSize = i + 1;
1048  break;
1049  }
1050  }
1051 
1052  Ptr<SpectrumValue> noisePsd = LteSpectrumValueHelper::CreateNoisePowerSpectralDensity (m_dlEarfcn, m_dlBandwidth, m_noiseFigure);
1053  m_downlinkSpectrumPhy->SetNoisePowerSpectralDensity (noisePsd);
1054  m_downlinkSpectrumPhy->GetChannel ()->AddRx (m_downlinkSpectrumPhy);
1055  }
1056  m_dlConfigured = true;
1057 }
1058 
1059 
1060 void
1061 LteUePhy::DoConfigureUplink (uint16_t ulEarfcn, uint8_t ulBandwidth)
1062 {
1063  m_ulEarfcn = ulEarfcn;
1064  m_ulBandwidth = ulBandwidth;
1065  m_ulConfigured = true;
1066 }
1067 
1068 
1069 void
1070 LteUePhy::DoSetRnti (uint16_t rnti)
1071 {
1072  NS_LOG_FUNCTION (this << rnti);
1073  m_rnti = rnti;
1074 }
1075 
1076 void
1077 LteUePhy::DoSetTransmissionMode (uint8_t txMode)
1078 {
1079  NS_LOG_FUNCTION (this << (uint16_t)txMode);
1080  m_transmissionMode = txMode;
1081  m_downlinkSpectrumPhy->SetTransmissionMode (txMode);
1082 }
1083 
1084 void
1085 LteUePhy::DoSetSrsConfigurationIndex (uint16_t srcCi)
1086 {
1087  NS_LOG_FUNCTION (this << srcCi);
1088  m_srsPeriodicity = GetSrsPeriodicity (srcCi);
1089  m_srsSubframeOffset = GetSrsSubframeOffset (srcCi);
1090  m_srsConfigured = true;
1091 
1092  // a guard time is needed for the case where the SRS periodicity is changed dynamically at run time
1093  // if we use a static one, we can have a 0ms guard time
1094  m_srsStartTime = Simulator::Now () + MilliSeconds (0);
1095  NS_LOG_DEBUG (this << " UE SRS P " << m_srsPeriodicity << " RNTI " << m_rnti << " offset " << m_srsSubframeOffset << " cellId " << m_cellId << " CI " << srcCi);
1096 }
1097 
1098 
1099 void
1100 LteUePhy::SetTxMode1Gain (double gain)
1101 {
1102  SetTxModeGain (1, gain);
1103 }
1104 
1105 void
1106 LteUePhy::SetTxMode2Gain (double gain)
1107 {
1108  SetTxModeGain (2, gain);
1109 }
1110 
1111 void
1112 LteUePhy::SetTxMode3Gain (double gain)
1113 {
1114  SetTxModeGain (3, gain);
1115 }
1116 
1117 void
1118 LteUePhy::SetTxMode4Gain (double gain)
1119 {
1120  SetTxModeGain (4, gain);
1121 }
1122 
1123 void
1124 LteUePhy::SetTxMode5Gain (double gain)
1125 {
1126  SetTxModeGain (5, gain);
1127 }
1128 
1129 void
1130 LteUePhy::SetTxMode6Gain (double gain)
1131 {
1132  SetTxModeGain (6, gain);
1133 }
1134 
1135 void
1136 LteUePhy::SetTxMode7Gain (double gain)
1137 {
1138  SetTxModeGain (7, gain);
1139 }
1140 
1141 
1142 void
1143 LteUePhy::SetTxModeGain (uint8_t txMode, double gain)
1144 {
1145  NS_LOG_FUNCTION (this << gain);
1146  // convert to linear
1147  double gainLin = std::pow (10.0, (gain / 10.0));
1148  if (m_txModeGain.size () < txMode)
1149  {
1150  m_txModeGain.resize (txMode);
1151  }
1152  std::vector <double> temp;
1153  temp = m_txModeGain;
1154  m_txModeGain.clear ();
1155  for (uint8_t i = 0; i < temp.size (); i++)
1156  {
1157  if (i==txMode-1)
1158  {
1159  m_txModeGain.push_back (gainLin);
1160  }
1161  else
1162  {
1163  m_txModeGain.push_back (temp.at (i));
1164  }
1165  }
1166  // forward the info to DL LteSpectrumPhy
1167  m_downlinkSpectrumPhy->SetTxModeGain (txMode, gain);
1168 }
1169 
1170 
1171 
1172 void
1173 LteUePhy::ReceiveLteDlHarqFeedback (DlInfoListElement_s m)
1174 {
1175  NS_LOG_FUNCTION (this);
1176  // generate feedback to eNB and send it through ideal PUCCH
1177  Ptr<DlHarqFeedbackLteControlMessage> msg = Create<DlHarqFeedbackLteControlMessage> ();
1178  msg->SetDlHarqFeedback (m);
1179  SetControlMessages (msg);
1180 }
1181 
1182 void
1183 LteUePhy::SetHarqPhyModule (Ptr<LteHarqPhy> harq)
1184 {
1185  m_harqPhyModule = harq;
1186 }
1187 
1188 
1189 } // namespace ns3