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
46using namespace ns3;
47
48NS_LOG_COMPONENT_DEFINE ("LtePathlossModelTest");
49
60void
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
176LtePathlossModelSystemTestCase::LtePathlossModelSystemTestCase (std::string name, double snrDb, double dist, uint16_t mcsIndex)
177: TestCase (name),
178m_snrDb (snrDb),
179m_distance (dist),
180m_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
193void
195{
196 Config::SetDefault ("ns3::MacStatsCalculator::DlOutputFilename", StringValue (CreateTempDirFilename ("DlMacStats.txt")));
197 Config::SetDefault ("ns3::MacStatsCalculator::UlOutputFilename", StringValue (CreateTempDirFilename ("UlMacStats.txt")));
198 Config::SetDefault ("ns3::RadioBearerStatsCalculator::DlRlcOutputFilename", StringValue (CreateTempDirFilename ("DlRlcStats.txt")));
199 Config::SetDefault ("ns3::RadioBearerStatsCalculator::UlRlcOutputFilename", StringValue (CreateTempDirFilename ("UlRlcStats.txt")));
203 //Disable Uplink Power Control
204 Config::SetDefault ("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue (false));
205
206 Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();
207 // lteHelper->EnableLogComponents ();
208 lteHelper->SetAttribute ("PathlossModel", StringValue ("ns3::HybridBuildingsPropagationLossModel"));
209
210 // set frequency. This is important because it changes the behavior of the path loss model
211 lteHelper->SetEnbDeviceAttribute ("DlEarfcn", UintegerValue (200));
212 lteHelper->SetEnbDeviceAttribute ("UlEarfcn", UintegerValue (18200));
213 lteHelper->SetUeDeviceAttribute ("DlEarfcn", UintegerValue (200));
214
215 // remove shadowing component
216 lteHelper->SetPathlossModelAttribute ("ShadowSigmaOutdoor", DoubleValue (0.0));
217 lteHelper->SetPathlossModelAttribute ("ShadowSigmaIndoor", DoubleValue (0.0));
218 lteHelper->SetPathlossModelAttribute ("ShadowSigmaExtWalls", DoubleValue (0.0));
219
220 // Create Nodes: eNodeB and UE
221 NodeContainer enbNodes;
222 NodeContainer ueNodes;
223 enbNodes.Create (1);
224 ueNodes.Create (1);
225 NodeContainer allNodes = NodeContainer ( enbNodes, ueNodes );
226
227 // Install Mobility Model
229 mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
230 mobility.Install (allNodes);
231 BuildingsHelper::Install (allNodes);
232
233
234 // Create Devices and install them in the Nodes (eNB and UE)
235 NetDeviceContainer enbDevs;
236 NetDeviceContainer ueDevs;
237 lteHelper->SetSchedulerType ("ns3::RrFfMacScheduler");
238 enbDevs = lteHelper->InstallEnbDevice (enbNodes);
239 ueDevs = lteHelper->InstallUeDevice (ueNodes);
240
241 Ptr<MobilityModel> mm_enb = enbNodes.Get (0)->GetObject<MobilityModel> ();
242 mm_enb->SetPosition (Vector (0.0, 0.0, 30.0));
243 Ptr<MobilityModel> mm_ue = ueNodes.Get (0)->GetObject<MobilityModel> ();
244 mm_ue->SetPosition (Vector (m_distance, 0.0, 1.0));
245
246 Ptr<LteEnbNetDevice> lteEnbDev = enbDevs.Get (0)->GetObject<LteEnbNetDevice> ();
247 Ptr<LteEnbPhy> enbPhy = lteEnbDev->GetPhy ();
248 enbPhy->SetAttribute ("TxPower", DoubleValue (30.0));
249 enbPhy->SetAttribute ("NoiseFigure", DoubleValue (5.0));
250
251 Ptr<LteUeNetDevice> lteUeDev = ueDevs.Get (0)->GetObject<LteUeNetDevice> ();
252 Ptr<LteUePhy> uePhy = lteUeDev->GetPhy ();
253 uePhy->SetAttribute ("TxPower", DoubleValue (23.0));
254 uePhy->SetAttribute ("NoiseFigure", DoubleValue (9.0));
255
256
257 // Attach a UE to a eNB
258 lteHelper->Attach (ueDevs, enbDevs.Get (0));
259
260 // Activate an EPS bearer
261 enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
262 EpsBearer bearer (q);
263 lteHelper->ActivateDataRadioBearer (ueDevs, bearer);
264
265 // Use testing chunk processor in the PHY layer
266 // It will be used to test that the SNR is as intended
267 //Ptr<LtePhy> uePhy = ueDevs.Get (0)->GetObject<LteUeNetDevice> ()->GetPhy ()->GetObject<LtePhy> ();
268 Ptr<LteChunkProcessor> testSinr = Create<LteChunkProcessor> ();
269 LteSpectrumValueCatcher sinrCatcher;
270 testSinr->AddCallback (MakeCallback (&LteSpectrumValueCatcher::ReportValue, &sinrCatcher));
271 uePhy->GetDownlinkSpectrumPhy ()->AddCtrlSinrChunkProcessor (testSinr);
272
273// Config::Connect ("/NodeList/0/DeviceList/0/LteEnbMac/DlScheduling",
274// MakeBoundCallback (&LteTestPathlossDlSchedCallback, this));
275
276 lteHelper->EnableMacTraces ();
277 lteHelper->EnableRlcTraces ();
278
279 Simulator::Stop (Seconds (0.035));
281
282 double calculatedSinrDb = 10.0 * std::log10 (sinrCatcher.GetValue ()->operator[] (0));
283 NS_LOG_INFO ("Distance " << m_distance << " Calculated SINR " << calculatedSinrDb << " ref " << m_snrDb);
284 Simulator::Destroy ();
285 NS_TEST_ASSERT_MSG_EQ_TOL (calculatedSinrDb, m_snrDb, 0.001, "Wrong SINR !");
286}
287
288
289void
291{
292 static bool firstTime = true;
293
294 if ( firstTime )
295 {
296 firstTime = false;
297 NS_LOG_INFO ("SNR\tRef_MCS\tCalc_MCS");
298 }
299
300
301 // need to allow for RRC connection establishment + SRS transmission
302 if (Simulator::Now () > MilliSeconds (21))
303 {
304 NS_LOG_INFO (m_snrDb << "\t" << m_mcsIndex << "\t" << (uint16_t)dlInfo.mcsTb1);
305
306 NS_TEST_ASSERT_MSG_EQ ((uint16_t)dlInfo.mcsTb1, m_mcsIndex, "Wrong MCS index");
307 }
308}
void Run(ObjectFactory &factory, uint32_t pop, uint32_t total, uint32_t runs, Ptr< RandomVariableStream > eventStream, bool calRev)
Perform the runs for a single scheduler type.
Tests that the BuildingPathlossModel works according to the expected theoretical values.
virtual void DoRun(void)
Implementation to actually run this TestCase.
void DlScheduling(DlSchedulingCallbackInfo dlInfo)
DL scheduling function.
Test 1.1 pathloss calculation.
AttributeValue implementation for Boolean.
Definition: boolean.h:37
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition: double.h:41
This class contains the specification of EPS Bearers.
Definition: eps-bearer.h:92
Qci
QoS Class Indicator.
Definition: eps-bearer.h:107
The eNodeB device implementation.
Ptr< LteEnbPhy > GetPhy(void) const
NetDeviceContainer InstallEnbDevice(NodeContainer c)
Create a set of eNodeB devices.
Definition: lte-helper.cc:474
void SetSchedulerType(std::string type)
Set the type of scheduler to be used by eNodeB devices.
Definition: lte-helper.cc:279
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:959
void SetPathlossModelAttribute(std::string n, const AttributeValue &v)
Set an attribute for the path loss models to be created.
Definition: lte-helper.cc:393
void EnableRlcTraces(void)
Enable trace sinks for RLC layer.
Definition: lte-helper.cc:1435
void SetEnbDeviceAttribute(std::string n, const AttributeValue &v)
Set an attribute for the eNodeB devices (LteEnbNetDevice) to be created.
Definition: lte-helper.cc:400
void ActivateDataRadioBearer(NetDeviceContainer ueDevices, EpsBearer bearer)
Activate a Data Radio Bearer on a given UE devices (for LTE-only simulation).
Definition: lte-helper.cc:1313
NetDeviceContainer InstallUeDevice(NodeContainer c)
Create a set of UE devices.
Definition: lte-helper.cc:489
void SetUeDeviceAttribute(std::string n, const AttributeValue &v)
Set an attribute for the UE devices (LteUeNetDevice) to be created.
Definition: lte-helper.cc:422
void EnableMacTraces(void)
Enable trace sinks for MAC layer.
Definition: lte-helper.cc:1529
A sink to be plugged to the callback of LteChunkProcessor allowing to save and later retrieve the lat...
Ptr< SpectrumValue > GetValue()
The LteUeNetDevice class implements the UE net device.
Helper class used to assign positions and mobility models to nodes.
Keep track of the current position and velocity of an object.
void SetPosition(const Vector &position)
holds a vector of ns3::NetDevice pointers
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr<NetDevice> stored in this container at a given index.
keep track of a set of node pointers.
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
void SetAttribute(std::string name, const AttributeValue &value)
Set a single attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:256
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:470
Hold variables of type string.
Definition: string.h:41
encapsulates test code
Definition: test.h:994
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:299
std::string CreateTempDirFilename(std::string filename)
Construct the full path to a file in a temporary directory.
Definition: test.cc:430
A suite of tests to run.
Definition: test.h:1188
Hold an unsigned integer type.
Definition: uinteger.h:44
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:849
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:281
Time Now(void)
create an ns3::Time instance which contains the current simulation time.
Definition: simulator.cc:287
#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:141
#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:323
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1245
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1253
void LteTestPathlossDlSchedCallback(LtePathlossModelSystemTestCase *testcase, std::string path, DlSchedulingCallbackInfo dlInfo)
Test 1.1 Pathloss compound test.
static LtePathlossModelTestSuite ltePathlossModelTestSuite
Every class exported by the ns3 library is enclosed in the ns3 namespace.
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:1648
mobility
Definition: third.py:98
DlSchedulingCallbackInfo structure.
Definition: lte-common.h:240