A Discrete-Event Network Simulator
API
lte-test-pathloss-model.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: Marco Miozzo <marco.miozzo@cttc.es>
19  */
20 
21 #include "ns3/simulator.h"
22 #include "ns3/log.h"
23 #include "ns3/spectrum-test.h"
24 #include "ns3/lte-phy-tag.h"
25 #include "ns3/lte-chunk-processor.h"
26 #include <ns3/hybrid-buildings-propagation-loss-model.h>
27 #include <ns3/node-container.h>
28 #include <ns3/mobility-helper.h>
29 #include <ns3/buildings-helper.h>
30 #include <ns3/lte-helper.h>
31 #include <ns3/single-model-spectrum-channel.h>
32 #include "ns3/string.h"
33 #include "ns3/double.h"
34 #include <ns3/boolean.h>
35 #include <ns3/building.h>
36 #include <ns3/enum.h>
37 #include <ns3/net-device-container.h>
38 #include <ns3/lte-ue-net-device.h>
39 #include <ns3/lte-enb-net-device.h>
40 #include <ns3/lte-ue-rrc.h>
41 #include <ns3/lte-enb-phy.h>
42 #include <ns3/lte-ue-phy.h>
43 #include "lte-test-ue-phy.h"
45 
46 using namespace ns3;
47 
48 NS_LOG_COMPONENT_DEFINE ("LtePathlossModelTest");
49 
60 void
63 {
64  testcase->DlScheduling (dlInfo);
65 }
66 
67 
68 
70  : TestSuite ("lte-pathloss-model", SYSTEM)
71 {
72  // LogLevel logLevel = (LogLevel)(LOG_PREFIX_FUNC | LOG_PREFIX_TIME | LOG_LEVEL_ALL);
73  // LogComponentEnable ("LteHelper", logLevel);
74  // LogComponentEnable ("LtePathlossModelTest", logLevel);
75  // LogComponentEnable ("BuildingsPropagationLossModel", logLevel);
76  // LogComponentEnable ("LteInterference", logLevel);
77  // LogComponentEnable ("LteSpectrumValueHelper", logLevel);
78  // LogComponentEnable ("LteEnbNetDevice", logLevel);
79 
80  struct SnrEfficiencyMcs
81  {
82  double snrDb;
83  double efficiency;
84  int mcsIndex;
85  };
86 
91  SnrEfficiencyMcs snrEfficiencyMcs[] = {
92  { -5.00000, 0.08024, -1},
93  { -4.00000, 0.10030, -1},
94  { -3.00000, 0.12518, -1},
95  { -2.00000, 0.15589, 0},
96  { -1.00000, 0.19365, 0},
97  { 0.00000, 0.23983, 2},
98  { 1.00000, 0.29593, 2},
99  { 2.00000, 0.36360, 2},
100  { 3.00000, 0.44451, 4},
101  { 4.00000, 0.54031, 4},
102  { 5.00000, 0.65251, 6},
103  { 6.00000, 0.78240, 6},
104  { 7.00000, 0.93086, 8},
105  { 8.00000, 1.09835, 8},
106  { 9.00000, 1.28485, 10},
107  { 10.00000, 1.48981, 12},
108  { 11.00000, 1.71229, 12},
109  { 12.00000, 1.95096, 14},
110  { 13.00000, 2.20429, 14},
111  { 14.00000, 2.47062, 16},
112  { 15.00000, 2.74826, 18},
113  { 16.00000, 3.03560, 18},
114  { 17.00000, 3.33115, 20},
115  { 18.00000, 3.63355, 20},
116  { 19.00000, 3.94163, 22},
117  { 20.00000, 4.25439, 22},
118  { 21.00000, 4.57095, 24},
119  { 22.00000, 4.89060, 24},
120  { 23.00000, 5.21276, 26},
121  { 24.00000, 5.53693, 26},
122  { 25.00000, 5.86271, 28},
123  { 26.00000, 6.18980, 28},
124  { 27.00000, 6.51792, 28},
125  { 28.00000, 6.84687, 28},
126  { 29.00000, 7.17649, 28},
127  { 30.00000, 7.50663, 28},
128  };
129 
130 
131  double txPowerDbm = 30; // default eNB TX power over whole bandwidth
132  double txPowerLin = std::pow (10, (txPowerDbm - 30)/10);
133  double ktDbm = -174; // reference LTE noise PSD
134  double noisePowerDbm = ktDbm + 10 * std::log10 (25 * 180000); // corresponds to kT*bandwidth in linear units
135  double receiverNoiseFigureDb = 9.0; // default UE noise figure
136  double noiseLin = std::pow (10, (noisePowerDbm-30+receiverNoiseFigureDb)/10);
137 
138  // reference values obtained with the octave script src/lte/test/reference/lte_pathloss.m
139 
140  double loss[] = {81.062444, 134.078605, 144.259958};
141  double dist[] = {100.0, 500.0, 1500};
142 
143  int numOfTests = sizeof (loss) / sizeof (double);
144  for ( int i = 0 ; i < numOfTests; i++ )
145  {
146  // double lossDb = txPowerDbm - snrEfficiencyMcs[i].snrDb - noisePowerDbm - receiverNoiseFigureDb;
147  double sinrLin = (txPowerLin/(pow(10, loss[i]/10))) / noiseLin;
148  // double sinrDb = txPowerDbm- noisePowerDbm - receiverNoiseFigureDb - loss[i];
149  double sinrDb = 10 * std::log10 (sinrLin);
150  NS_LOG_INFO (" Ptx " << txPowerDbm << " Pn " << noisePowerDbm << " Fn " << receiverNoiseFigureDb << " Pl " << loss[i] << " dist " << dist[i]);
151 
152  int mcs = -1;
153  int numSnrEfficiencyMcsEntries = sizeof (snrEfficiencyMcs) / sizeof (SnrEfficiencyMcs);
154  for (int j = 0; j < numSnrEfficiencyMcsEntries && snrEfficiencyMcs[j].snrDb < sinrDb; ++j)
155  {
156  mcs = snrEfficiencyMcs[j].mcsIndex;
157  }
158 
159  std::ostringstream name;
160  name << " snr= " << sinrDb << " dB, "
161  << " mcs= " << snrEfficiencyMcs[i].mcsIndex;
162  AddTestCase (new LtePathlossModelSystemTestCase (name.str (), sinrDb, dist[i], mcs), TestCase::QUICK);
163  }
164 
165 
166 
167 
168 
169 }
170 
172 
173 
174 
175 
176 LtePathlossModelSystemTestCase::LtePathlossModelSystemTestCase (std::string name, double snrDb, double dist, uint16_t mcsIndex)
177 : TestCase (name),
178 m_snrDb (snrDb),
179 m_distance (dist),
180 m_mcsIndex (mcsIndex)
181 {
182  std::ostringstream sstream1, sstream2;
183  sstream1 << " snr=" << snrDb
184  << " mcs=" << mcsIndex << " distance=" << dist;
185 
186  NS_LOG_INFO ("Creating LtePathlossModelSystemTestCase: " + sstream1.str ());
187 }
188 
190 {
191 }
192 
193 void
195 {
199  //Disable Uplink Power Control
200  Config::SetDefault ("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue (false));
201 
202  Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();
203  // lteHelper->EnableLogComponents ();
204  lteHelper->EnableMacTraces ();
205  lteHelper->EnableRlcTraces ();
206  lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::HybridBuildingsPropagationLossModel"));
207 
208  // set frequency. This is important because it changes the behavior of the path loss model
209  lteHelper->SetEnbDeviceAttribute ("DlEarfcn", UintegerValue (200));
210  lteHelper->SetEnbDeviceAttribute ("UlEarfcn", UintegerValue (18200));
211  lteHelper->SetUeDeviceAttribute ("DlEarfcn", UintegerValue (200));
212 
213  // remove shadowing component
214  lteHelper->SetPathlossModelAttribute ("ShadowSigmaOutdoor", DoubleValue (0.0));
215  lteHelper->SetPathlossModelAttribute ("ShadowSigmaIndoor", DoubleValue (0.0));
216  lteHelper->SetPathlossModelAttribute ("ShadowSigmaExtWalls", DoubleValue (0.0));
217 
218  // Create Nodes: eNodeB and UE
219  NodeContainer enbNodes;
220  NodeContainer ueNodes;
221  enbNodes.Create (1);
222  ueNodes.Create (1);
223  NodeContainer allNodes = NodeContainer ( enbNodes, ueNodes );
224 
225  // Install Mobility Model
227  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
228  mobility.Install (allNodes);
229  BuildingsHelper::Install (allNodes);
230 
231 
232  // Create Devices and install them in the Nodes (eNB and UE)
233  NetDeviceContainer enbDevs;
234  NetDeviceContainer ueDevs;
235  lteHelper->SetSchedulerType ("ns3::RrFfMacScheduler");
236  enbDevs = lteHelper->InstallEnbDevice (enbNodes);
237  ueDevs = lteHelper->InstallUeDevice (ueNodes);
238 
239  Ptr<MobilityModel> mm_enb = enbNodes.Get (0)->GetObject<MobilityModel> ();
240  mm_enb->SetPosition (Vector (0.0, 0.0, 30.0));
241  Ptr<MobilityModel> mm_ue = ueNodes.Get (0)->GetObject<MobilityModel> ();
242  mm_ue->SetPosition (Vector (m_distance, 0.0, 1.0));
243 
244  Ptr<LteEnbNetDevice> lteEnbDev = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ();
245  Ptr<LteEnbPhy> enbPhy = lteEnbDev->GetPhy ();
246  enbPhy->SetAttribute ("TxPower", DoubleValue (30.0));
247  enbPhy->SetAttribute ("NoiseFigure", DoubleValue (5.0));
248 
249  Ptr<LteUeNetDevice> lteUeDev = ueDevs.Get (0)->GetObject<LteUeNetDevice> ();
250  Ptr<LteUePhy> uePhy = lteUeDev->GetPhy ();
251  uePhy->SetAttribute ("TxPower", DoubleValue (23.0));
252  uePhy->SetAttribute ("NoiseFigure", DoubleValue (9.0));
253 
254 
255  // Attach a UE to a eNB
256  lteHelper->Attach (ueDevs, enbDevs.Get (0));
257 
258  // Activate an EPS bearer
259  enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
260  EpsBearer bearer (q);
261  lteHelper->ActivateDataRadioBearer (ueDevs, bearer);
262 
263  // Use testing chunk processor in the PHY layer
264  // It will be used to test that the SNR is as intended
265  //Ptr<LtePhy> uePhy = ueDevs.Get (0)->GetObject<LteUeNetDevice> ()->GetPhy ()->GetObject<LtePhy> ();
266  Ptr<LteChunkProcessor> testSinr = Create<LteChunkProcessor> ();
267  LteSpectrumValueCatcher sinrCatcher;
268  testSinr->AddCallback (MakeCallback (&LteSpectrumValueCatcher::ReportValue, &sinrCatcher));
269  uePhy->GetDownlinkSpectrumPhy ()->AddCtrlSinrChunkProcessor (testSinr);
270 
271 // Config::Connect ("/NodeList/0/DeviceList/0/LteEnbMac/DlScheduling",
272 // MakeBoundCallback (&LteTestPathlossDlSchedCallback, this));
273 
274  Simulator::Stop (Seconds (0.035));
275  Simulator::Run ();
276 
277  double calculatedSinrDb = 10.0 * std::log10 (sinrCatcher.GetValue ()->operator[] (0));
278  NS_LOG_INFO ("Distance " << m_distance << " Calculated SINR " << calculatedSinrDb << " ref " << m_snrDb);
279  Simulator::Destroy ();
280  NS_TEST_ASSERT_MSG_EQ_TOL (calculatedSinrDb, m_snrDb, 0.001, "Wrong SINR !");
281 }
282 
283 
284 void
286 {
287  static bool firstTime = true;
288 
289  if ( firstTime )
290  {
291  firstTime = false;
292  NS_LOG_INFO ("SNR\tRef_MCS\tCalc_MCS");
293  }
294 
295 
296  // need to allow for RRC connection establishment + SRS transmission
297  if (Simulator::Now () > MilliSeconds (21))
298  {
299  NS_LOG_INFO (m_snrDb << "\t" << m_mcsIndex << "\t" << (uint16_t)dlInfo.mcsTb1);
300 
301  NS_TEST_ASSERT_MSG_EQ ((uint16_t)dlInfo.mcsTb1, m_mcsIndex, "Wrong MCS index");
302  }
303 }
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr<NetDevice> stored in this container at a given index.
void SetPathlossModelAttribute(std::string n, const AttributeValue &v)
Set an attribute for the path loss models to be created.
Definition: lte-helper.cc:393
AttributeValue implementation for Boolean.
Definition: boolean.h:36
NetDeviceContainer InstallEnbDevice(NodeContainer c)
Create a set of eNodeB devices.
Definition: lte-helper.cc:474
Hold variables of type string.
Definition: string.h:41
void DlScheduling(DlSchedulingCallbackInfo dlInfo)
DL scheduling function.
A suite of tests to run.
Definition: test.h:1343
void LteTestPathlossDlSchedCallback(LtePathlossModelSystemTestCase *testcase, std::string path, DlSchedulingCallbackInfo dlInfo)
Test 1.1 Pathloss compound test.
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
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1078
void EnableRlcTraces(void)
Enable trace sinks for RLC layer.
Definition: lte-helper.cc:1436
void SetUeDeviceAttribute(std::string n, const AttributeValue &v)
Set an attribute for the UE devices (LteUeNetDevice) to be created.
Definition: lte-helper.cc:422
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:281
encapsulates test code
Definition: test.h:1153
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
static LtePathlossModelTestSuite ltePathlossModelTestSuite
void SetSchedulerType(std::string type)
Set the type of scheduler to be used by eNodeB devices.
Definition: lte-helper.cc:279
mobility
Definition: third.py:108
Keep track of the current position and velocity of an object.
Test 1.1 pathloss calculation.
virtual void AddCallback(LteChunkProcessorCallback c)
Add callback to list.
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:299
Hold an unsigned integer type.
Definition: uinteger.h:44
#define NS_TEST_ASSERT_MSG_EQ(actual, limit, msg)
Test that an actual and expected (limit) value are equal and report and abort if not.
Definition: test.h:166
holds a vector of ns3::NetDevice pointers
Callback< R > MakeCallback(R(T::*memPtr)(void), OBJ objPtr)
Definition: callback.h:1610
A sink to be plugged to the callback of LteChunkProcessor allowing to save and later retrieve the lat...
Ptr< LteEnbPhy > GetPhy(void) const
#define NS_TEST_ASSERT_MSG_EQ_TOL(actual, limit, tol, msg)
Test that actual and expected (limit) values are equal to plus or minus some tolerance and report and...
Definition: test.h:378
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:464
Every class exported by the ns3 library is enclosed in the ns3 namespace.
keep track of a set of node pointers.
Ptr< LteUePhy > GetPhy(void) const
Get the Phy.
This class contains the specification of EPS Bearers.
Definition: eps-bearer.h:91
void SetPosition(const Vector &position)
Tests that the BuildingPathlossModel works according to the expected theoretical values.
NetDeviceContainer InstallUeDevice(NodeContainer c)
Create a set of UE devices.
Definition: lte-helper.cc:489
Helper class used to assign positions and mobility models to nodes.
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1070
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:812
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
virtual void DoRun(void)
Implementation to actually run this TestCase.
Qci
QoS Class Indicator.
Definition: eps-bearer.h:106
Time Now(void)
create an ns3::Time instance which contains the current simulation time.
Definition: simulator.cc:309
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
void EnableMacTraces(void)
Enable trace sinks for MAC layer.
Definition: lte-helper.cc:1530
DlSchedulingCallbackInfo structure.
Definition: lte-common.h:239
This class can be used to hold variables of floating point type such as &#39;double&#39; or &#39;float&#39;...
Definition: double.h:41
void SetAttribute(std::string name, const AttributeValue &value)
Set a single attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:187
The eNodeB device implementation.
void SetEnbDeviceAttribute(std::string n, const AttributeValue &v)
Set an attribute for the eNodeB devices (LteEnbNetDevice) to be created.
Definition: lte-helper.cc:400
The LteUeNetDevice class implements the UE net device.