A Discrete-Event Network Simulator
API
test-lte-antenna.cc
Go to the documentation of this file.
1 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2011, 2012 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: Manuel Requena <manuel.requena@cttc.es>
19  * Nicola Baldo <nbaldo@cttc.es>
20  */
21 
22 #include "ns3/simulator.h"
23 #include "ns3/log.h"
24 #include "ns3/string.h"
25 #include "ns3/double.h"
26 #include "ns3/enum.h"
27 #include "ns3/boolean.h"
28 #include "ns3/test.h"
29 #include "ns3/mobility-helper.h"
30 #include "ns3/lte-helper.h"
31 
32 #include "ns3/lte-ue-phy.h"
33 #include "ns3/lte-ue-net-device.h"
34 #include "ns3/lte-enb-phy.h"
35 #include "ns3/lte-enb-net-device.h"
36 #include "ns3/ff-mac-scheduler.h"
37 
38 #include "ns3/lte-global-pathloss-database.h"
39 
40 #include <ns3/lte-chunk-processor.h>
41 
42 
43 using namespace ns3;
44 
45 NS_LOG_COMPONENT_DEFINE ("LteAntennaTest");
46 
47 
58 {
59 public:
68  static std::string BuildNameString (double orientationDegrees, double beamwidthDegrees, double x, double y);
78  LteEnbAntennaTestCase (double orientationDegrees, double beamwidthDegrees, double x, double y, double antennaGainDb);
80  virtual ~LteEnbAntennaTestCase ();
81 
82 private:
83  virtual void DoRun (void);
84 
87  double m_x;
88  double m_y;
89  double m_antennaGainDb;
90 };
91 
92 
93 
94 
95 std::string LteEnbAntennaTestCase::BuildNameString (double orientationDegrees, double beamwidthDegrees, double x, double y)
96 {
97  std::ostringstream oss;
98  oss << "o=" << orientationDegrees
99  << ", bw=" << beamwidthDegrees
100  << ", x=" << x
101  << ", y=" << y;
102  return oss.str ();
103 }
104 
105 
106 LteEnbAntennaTestCase::LteEnbAntennaTestCase (double orientationDegrees, double beamwidthDegrees, double x, double y, double antennaGainDb)
107  : TestCase (BuildNameString (orientationDegrees, beamwidthDegrees, x, y)),
108  m_orientationDegrees (orientationDegrees),
109  m_beamwidthDegrees (beamwidthDegrees),
110  m_x (x),
111  m_y (y),
112  m_antennaGainDb (antennaGainDb)
113 {
114  NS_LOG_FUNCTION (this);
115 }
116 
118 {
119 }
120 
121 void
123 {
124  Config::Reset ();
125  Config::SetDefault ("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue (false));
126  Config::SetDefault ("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue (false));
127  Config::SetDefault ("ns3::LteHelper::UseIdealRrc", BooleanValue (true));
128 
129  //Disable Uplink Power Control
130  Config::SetDefault ("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue (false));
131 
132  Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();
133 
134  // use 0dB Pathloss, since we are testing only the antenna gain
135  lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::ConstantSpectrumPropagationLossModel"));
136  lteHelper->SetPathlossModelAttribute ("Loss", DoubleValue (0.0));
137 
138  // Create Nodes: eNodeB and UE
139  NodeContainer enbNodes;
140  NodeContainer ueNodes;
141  enbNodes.Create (1);
142  ueNodes.Create (1);
143  NodeContainer allNodes = NodeContainer ( enbNodes, ueNodes );
144 
145  // Install Mobility Model
146  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();
147  positionAlloc->Add (Vector (0.0, 0.0, 0.0)); // eNB
148  positionAlloc->Add (Vector (m_x, m_y, 0.0)); // UE
150  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
151  mobility.SetPositionAllocator (positionAlloc);
152  mobility.Install (allNodes);
153 
154  // Create Devices and install them in the Nodes (eNB and UE)
155  NetDeviceContainer enbDevs;
156  NetDeviceContainer ueDevs;
157  lteHelper->SetSchedulerType ("ns3::RrFfMacScheduler");
158  lteHelper->SetSchedulerAttribute ("UlCqiFilter", EnumValue (FfMacScheduler::PUSCH_UL_CQI));
159  lteHelper->SetEnbAntennaModelType ("ns3::CosineAntennaModel");
160  lteHelper->SetEnbAntennaModelAttribute ("Orientation", DoubleValue (m_orientationDegrees));
161  lteHelper->SetEnbAntennaModelAttribute ("Beamwidth", DoubleValue (m_beamwidthDegrees));
162  lteHelper->SetEnbAntennaModelAttribute ("MaxGain", DoubleValue (0.0));
163 
164  enbDevs = lteHelper->InstallEnbDevice (enbNodes);
165  ueDevs = lteHelper->InstallUeDevice (ueNodes);
166 
167  // Attach a UE to a eNB
168  lteHelper->Attach (ueDevs, enbDevs.Get (0));
169 
170  // Activate the default EPS bearer
171  enum EpsBearer::Qci q = EpsBearer::NGBR_VIDEO_TCP_DEFAULT;
172  EpsBearer bearer (q);
173  lteHelper->ActivateDataRadioBearer (ueDevs, bearer);
174 
175  // Use testing chunk processor in the PHY layer
176  // It will be used to test that the SNR is as intended
177  Ptr<LtePhy> uePhy = ueDevs.Get (0)->GetObject<LteUeNetDevice> ()->GetPhy ()->GetObject<LtePhy> ();
178  Ptr<LteChunkProcessor> testDlSinr = Create<LteChunkProcessor> ();
179  LteSpectrumValueCatcher dlSinrCatcher;
180  testDlSinr->AddCallback (MakeCallback (&LteSpectrumValueCatcher::ReportValue, &dlSinrCatcher));
181  uePhy->GetDownlinkSpectrumPhy ()->AddDataSinrChunkProcessor (testDlSinr);
182 
183  Ptr<LtePhy> enbphy = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ()->GetPhy ()->GetObject<LtePhy> ();
184  Ptr<LteChunkProcessor> testUlSinr = Create<LteChunkProcessor> ();
185  LteSpectrumValueCatcher ulSinrCatcher;
186  testUlSinr->AddCallback (MakeCallback (&LteSpectrumValueCatcher::ReportValue, &ulSinrCatcher));
187  enbphy->GetUplinkSpectrumPhy ()->AddDataSinrChunkProcessor (testUlSinr);
188 
189 
190  // keep track of all path loss values in two centralized objects
192  UplinkLteGlobalPathlossDatabase ulPathlossDb;
193  // we rely on the fact that LteHelper creates the DL channel object first, then the UL channel object,
194  // hence the former will have index 0 and the latter 1
195  Config::Connect ("/ChannelList/0/PathLoss",
196  MakeCallback (&DownlinkLteGlobalPathlossDatabase::UpdatePathloss, &dlPathlossDb));
197  Config::Connect ("/ChannelList/1/PathLoss",
198  MakeCallback (&UplinkLteGlobalPathlossDatabase::UpdatePathloss, &ulPathlossDb));
199 
200  Simulator::Stop (Seconds (0.035));
201  Simulator::Run ();
202 
203  const double enbTxPowerDbm = 30; // default eNB TX power over whole bandwidth
204  const double ueTxPowerDbm = 10; // default UE TX power over whole bandwidth
205  const double ktDbm = -174; // reference LTE noise PSD
206  const double noisePowerDbm = ktDbm + 10 * std::log10 (25 * 180000); // corresponds to kT*bandwidth in linear units
207  const double ueNoiseFigureDb = 9.0; // default UE noise figure
208  const double enbNoiseFigureDb = 5.0; // default eNB noise figure
209  double tolerance = (m_antennaGainDb != 0) ? std::abs (m_antennaGainDb) * 0.001 : 0.001;
210 
211  // first test with SINR from LteChunkProcessor
212  // this can only be done for not-too-bad SINR otherwise the measurement won't be available
213  double expectedSinrDl = enbTxPowerDbm + m_antennaGainDb - noisePowerDbm + ueNoiseFigureDb;
214  if (expectedSinrDl > 0)
215  {
216  double calculatedSinrDbDl = -INFINITY;
217  if (dlSinrCatcher.GetValue () != 0)
218  {
219  calculatedSinrDbDl = 10.0 * std::log10 (dlSinrCatcher.GetValue ()->operator[] (0));
220  }
221  // remember that propagation loss is 0dB
222  double calculatedAntennaGainDbDl = - (enbTxPowerDbm - calculatedSinrDbDl - noisePowerDbm - ueNoiseFigureDb);
223  NS_TEST_ASSERT_MSG_EQ_TOL (calculatedAntennaGainDbDl, m_antennaGainDb, tolerance, "Wrong DL antenna gain!");
224  }
225  double expectedSinrUl = ueTxPowerDbm + m_antennaGainDb - noisePowerDbm + enbNoiseFigureDb;
226  if (expectedSinrUl > 0)
227  {
228  double calculatedSinrDbUl = -INFINITY;
229  if (ulSinrCatcher.GetValue () != 0)
230  {
231  calculatedSinrDbUl = 10.0 * std::log10 (ulSinrCatcher.GetValue ()->operator[] (0));
232  }
233  double calculatedAntennaGainDbUl = - (ueTxPowerDbm - calculatedSinrDbUl - noisePowerDbm - enbNoiseFigureDb);
234  NS_TEST_ASSERT_MSG_EQ_TOL (calculatedAntennaGainDbUl, m_antennaGainDb, tolerance, "Wrong UL antenna gain!");
235  }
236 
237 
238  // repeat the same tests with the LteGlobalPathlossDatabases
239  double measuredLossDl = dlPathlossDb.GetPathloss (1, 1);
240  NS_TEST_ASSERT_MSG_EQ_TOL (measuredLossDl, -m_antennaGainDb, tolerance, "Wrong DL loss!");
241  double measuredLossUl = ulPathlossDb.GetPathloss (1, 1);
242  NS_TEST_ASSERT_MSG_EQ_TOL (measuredLossUl, -m_antennaGainDb, tolerance, "Wrong UL loss!");
243 
244 
245  Simulator::Destroy ();
246 }
247 
248 
256 {
257 public:
259 };
260 
261 
263  : TestSuite ("lte-antenna", SYSTEM)
264 {
265  NS_LOG_FUNCTION (this);
266 
267  // orientation beamwidth x y gain
268  AddTestCase (new LteEnbAntennaTestCase ( 0.0, 90.0, 1.0, 0.0, 0.0), TestCase::QUICK);
269  AddTestCase (new LteEnbAntennaTestCase ( 0.0, 90.0, 1.0, 1.0, -3.0), TestCase::QUICK);
270  AddTestCase (new LteEnbAntennaTestCase ( 0.0, 90.0, 1.0, -1.0, -3.0), TestCase::QUICK);
271  AddTestCase (new LteEnbAntennaTestCase ( 0.0, 90.0, -1.0, -1.0, -36.396), TestCase::QUICK);
272  AddTestCase (new LteEnbAntennaTestCase ( 0.0, 90.0, -1.0, -0.0, -1414.6), TestCase::QUICK);
273  AddTestCase (new LteEnbAntennaTestCase ( 0.0, 90.0, -1.0, 1.0, -36.396), TestCase::QUICK);
274  AddTestCase (new LteEnbAntennaTestCase ( 45.0, 90.0, 1.0, 1.0, 0.0), TestCase::QUICK);
275  AddTestCase (new LteEnbAntennaTestCase ( -45.0, 90.0, 1.0, -1.0, 0.0), TestCase::QUICK);
276  AddTestCase (new LteEnbAntennaTestCase ( 90.0, 90.0, 1.0, 1.0, -3.0), TestCase::QUICK);
277  AddTestCase (new LteEnbAntennaTestCase ( -90.0, 90.0, 1.0, -1.0, -3.0), TestCase::QUICK);
278 
279  AddTestCase (new LteEnbAntennaTestCase ( 0.0, 120.0, 1.0, 0.0, 0.0), TestCase::QUICK);
280  AddTestCase (new LteEnbAntennaTestCase ( 0.0, 120.0, 0.5, sin(M_PI/3), -3.0), TestCase::QUICK);
281  AddTestCase (new LteEnbAntennaTestCase ( 0.0, 120.0, 0.5, -sin(M_PI/3), -3.0), TestCase::QUICK);
282  AddTestCase (new LteEnbAntennaTestCase ( 0.0, 120.0, -1.0, -2.0, -13.410), TestCase::QUICK);
283  AddTestCase (new LteEnbAntennaTestCase ( 0.0, 120.0, -1.0, 1.0, -20.034), TestCase::QUICK);
284  AddTestCase (new LteEnbAntennaTestCase ( 60.0, 120.0, 0.5, sin(M_PI/3), 0.0), TestCase::QUICK);
285  AddTestCase (new LteEnbAntennaTestCase ( -60.0, 120.0, 0.5, -sin(M_PI/3), 0.0), TestCase::QUICK);
286  AddTestCase (new LteEnbAntennaTestCase ( -60.0, 120.0, 0.5, -sin(M_PI/3), 0.0), TestCase::QUICK);
287  AddTestCase (new LteEnbAntennaTestCase ( -120.0, 120.0, -0.5, -sin(M_PI/3), 0.0), TestCase::QUICK);
288  AddTestCase (new LteEnbAntennaTestCase ( -120.0, 120.0, 0.5, -sin(M_PI/3), -3.0), TestCase::QUICK);
289  AddTestCase (new LteEnbAntennaTestCase ( -120.0, 120.0, -1, 0, -3.0), TestCase::QUICK);
290  AddTestCase (new LteEnbAntennaTestCase ( -120.0, 120.0, -1, 2, -15.578), TestCase::QUICK);
291  AddTestCase (new LteEnbAntennaTestCase ( -120.0, 120.0, 1, 0, -14.457), TestCase::QUICK);
292  AddTestCase (new LteEnbAntennaTestCase ( -120.0, 120.0, 1, 2, -73.154), TestCase::QUICK);
293  AddTestCase (new LteEnbAntennaTestCase ( -120.0, 120.0, 1, -0.1, -12.754), TestCase::QUICK);
294 
295 
296 }
297 
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
#define NS_LOG_FUNCTION(parameters)
If log level LOG_FUNCTION is enabled, this macro will output all input parameters separated by "...
double m_antennaGainDb
antenna gain in dB
double m_x
x position of the UE
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
A suite of tests to run.
Definition: test.h:1342
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
double m_beamwidthDegrees
antenna beamwidth in degrees
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:204
Ptr< LteSpectrumPhy > GetUplinkSpectrumPhy()
Definition: lte-phy.cc:113
encapsulates test code
Definition: test.h:1155
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
Lte Enb Antenna Test Suite.
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
Hold variables of type enum.
Definition: enum.h:54
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:299
void SetSchedulerAttribute(std::string n, const AttributeValue &v)
Set an attribute for the scheduler to be created.
Definition: lte-helper.cc:293
holds a vector of ns3::NetDevice pointers
Callback< R > MakeCallback(R(T::*memPtr)(void), OBJ objPtr)
Definition: callback.h:1489
Tests that the propagation model and the antenna parameters are generate the correct values...
A sink to be plugged to the callback of LteChunkProcessor allowing to save and later retrieve the lat...
Ptr< LteSpectrumPhy > GetDownlinkSpectrumPhy()
Definition: lte-phy.cc:107
#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:380
void Connect(std::string path, const CallbackBase &cb)
Definition: config.cc:871
void SetEnbAntennaModelType(std::string type)
Set the type of antenna model to be used by eNodeB devices.
Definition: lte-helper.cc:408
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:459
double m_orientationDegrees
antenna orientation in degrees
Every class exported by the ns3 library is enclosed in the ns3 namespace.
keep track of a set of node pointers.
double m_y
y position of the UE
This class contains the specification of EPS Bearers.
Definition: eps-bearer.h:91
static std::string BuildNameString(double orientationDegrees, double beamwidthDegrees, double x, double y)
Build name string.
double GetPathloss(uint16_t cellId, uint64_t imsi)
void Reset(void)
Reset the initial value of every attribute as well as the value of every global to what they were bef...
Definition: config.cc:785
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.
static LteAntennaTestSuite lteAntennaTestSuite
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1062
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:810
void Add(Vector v)
Add a position to the list of positions.
void SetEnbAntennaModelAttribute(std::string n, const AttributeValue &v)
Set an attribute for the eNodeB antenna model to be created.
Definition: lte-helper.cc:415
Qci
QoS Class Indicator.
Definition: eps-bearer.h:106
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
virtual void DoRun(void)
Implementation to actually run this TestCase.
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:185
The eNodeB device implementation.
The LtePhy models the physical layer of LTE.
Definition: lte-phy.h:52
The LteUeNetDevice class implements the UE net device.