A Discrete-Event Network Simulator
API
lte-test-phy-error-model.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2011-2013 Centre Tecnologic de Telecomunicacions de Catalunya (CTTC)
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation;
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 *
17 * Author: Marco Miozzo <marco.miozzo@cttc.es>
18 * Nicola Baldo <nbaldo@cttc.es>
19 */
20
22
23#include <ns3/boolean.h>
24#include <ns3/buildings-helper.h>
25#include <ns3/config.h>
26#include <ns3/double.h>
27#include <ns3/enum.h>
28#include <ns3/eps-bearer.h>
29#include <ns3/ff-mac-scheduler.h>
30#include <ns3/hybrid-buildings-propagation-loss-model.h>
31#include <ns3/integer.h>
32#include <ns3/log.h>
33#include <ns3/lte-enb-net-device.h>
34#include <ns3/lte-enb-phy.h>
35#include <ns3/lte-helper.h>
36#include <ns3/lte-ue-net-device.h>
37#include <ns3/lte-ue-phy.h>
38#include <ns3/lte-ue-rrc.h>
39#include <ns3/mobility-building-info.h>
40#include <ns3/mobility-helper.h>
41#include <ns3/net-device-container.h>
42#include <ns3/node-container.h>
43#include <ns3/object.h>
44#include <ns3/packet.h>
45#include <ns3/ptr.h>
46#include <ns3/radio-bearer-stats-calculator.h>
47#include <ns3/simulator.h>
48#include <ns3/spectrum-error-model.h>
49#include <ns3/spectrum-interference.h>
50#include <ns3/string.h>
51#include <ns3/test.h>
52
53#include <iostream>
54
55using namespace ns3;
56
57NS_LOG_COMPONENT_DEFINE("LteTestPhyErrorModel");
58
60 : TestSuite("lte-phy-error-model", SYSTEM)
61{
62 NS_LOG_INFO("creating LenaTestPhyErrorModelTestCase");
63
64 for (uint32_t rngRun = 1; rngRun <= 3; ++rngRun)
65 {
66 // Tests on DL Control Channels (PCFICH+PDCCH)
67 // the tolerance is calculated with the following octave code:
68 //
69 // n = 1000; # TX packets
70 // for p=1-[0.007 0.045 0.206 0.343]
71 // tol = n*p - binoinv(0.001, n, p)
72 // endfor
73
74 // 1 interfering eNB SINR -2.0 BLER 0.007 TB size 217
75 AddTestCase(new LenaDlCtrlPhyErrorModelTestCase(2, 1078, 0.007, 9, Seconds(0.04), rngRun),
76 (rngRun == 1) ? TestCase::QUICK : TestCase::TAKES_FOREVER);
77 // 2 interfering eNBs SINR -4.0 BLER 0.037 TB size 217
78 AddTestCase(new LenaDlCtrlPhyErrorModelTestCase(3, 1040, 0.045, 21, Seconds(0.04), rngRun),
79 (rngRun == 1) ? TestCase::EXTENSIVE : TestCase::TAKES_FOREVER);
80 // 3 interfering eNBs SINR -6.0 BLER 0.21 TB size 133
81 AddTestCase(new LenaDlCtrlPhyErrorModelTestCase(4, 1250, 0.206, 40, Seconds(0.12), rngRun),
82 (rngRun == 1) ? TestCase::EXTENSIVE : TestCase::TAKES_FOREVER);
83 // 4 interfering eNBs SINR -7.0 BLER 0.34 TB size 133
84 AddTestCase(new LenaDlCtrlPhyErrorModelTestCase(5, 1260, 0.343, 47, Seconds(0.12), rngRun),
85 (rngRun == 1) ? TestCase::EXTENSIVE : TestCase::TAKES_FOREVER);
86
87 // Tests on DL Data channels (PDSCH)
88 // the tolerance is calculated with the following octave code:
89 //
90 // n = 1000; # TX packets
91 // for p=1-[0.33 0.11 0.2 0.3 0.55 0.14]
92 // tol = n*p - binoinv(0.005, n, p)
93 // endfor
94
95 // MCS 2 TB size of 256 bits BLER 0.33 SINR -5.51
96 AddTestCase(new LenaDataPhyErrorModelTestCase(4, 1800, 0.33, 39, Seconds(0.04), rngRun),
97 (rngRun == 1) ? TestCase::QUICK : TestCase::TAKES_FOREVER);
98 // MCS 2 TB size of 528 bits BLER 0.11 SINR -5.51
99 AddTestCase(new LenaDataPhyErrorModelTestCase(2, 1800, 0.11, 26, Seconds(0.04), rngRun),
100 (rngRun == 1) ? TestCase::EXTENSIVE : TestCase::TAKES_FOREVER);
101 // MCS 2 TB size of 1088 bits BLER 0.02 SINR -5.51
102 AddTestCase(new LenaDataPhyErrorModelTestCase(1, 1800, 0.02, 33, Seconds(0.04), rngRun),
103 (rngRun == 1) ? TestCase::EXTENSIVE : TestCase::TAKES_FOREVER);
104 // MCS 12 TB size of 4800 bits BLER 0.3 SINR 4.43
105 AddTestCase(new LenaDataPhyErrorModelTestCase(1, 600, 0.3, 38, Seconds(0.04), rngRun),
106 (rngRun == 1) ? TestCase::EXTENSIVE : TestCase::TAKES_FOREVER);
107 // MCS 12 TB size of 1632 bits BLER 0.55 SINR 4.43
108 AddTestCase(new LenaDataPhyErrorModelTestCase(3, 600, 0.55, 40, Seconds(0.04), rngRun),
109 (rngRun == 1) ? TestCase::EXTENSIVE : TestCase::TAKES_FOREVER);
110 // MCS 16 TB size of 7272 bits (3648 x 3584) BLER 0.14 SINR 8.48
111 // BLER 0.14 = 1 - ((1-0.075)*(1-0.075))
112 AddTestCase(new LenaDataPhyErrorModelTestCase(1, 470, 0.14, 29, Seconds(0.04), rngRun),
113 (rngRun == 1) ? TestCase::EXTENSIVE : TestCase::TAKES_FOREVER);
114 }
115}
116
118
119std::string
120LenaDataPhyErrorModelTestCase::BuildNameString(uint16_t nUser, uint16_t dist, uint32_t rngRun)
121{
122 std::ostringstream oss;
123 oss << "DataPhyErrorModel " << nUser << " UEs, distance " << dist << " m, RngRun " << rngRun;
124 return oss.str();
125}
126
128 uint16_t dist,
129 double blerRef,
130 uint16_t toleranceRxPackets,
131 Time statsStartTime,
132 uint32_t rngRun)
133 : TestCase(BuildNameString(nUser, dist, rngRun)),
134 m_nUser(nUser),
135 m_dist(dist),
136 m_blerRef(blerRef),
137 m_toleranceRxPackets(toleranceRxPackets),
138 m_statsStartTime(statsStartTime),
139 m_rngRun(rngRun)
140{
141}
142
144{
145}
146
147void
149{
150 double ber = 0.03;
151 Config::SetDefault("ns3::LteAmc::Ber", DoubleValue(ber));
152 Config::SetDefault("ns3::LteAmc::AmcModel", EnumValue(LteAmc::PiroEW2010));
153 Config::SetDefault("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue(false));
154 Config::SetDefault("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue(true));
155 Config::SetDefault("ns3::RrFfMacScheduler::HarqEnabled", BooleanValue(false));
157
158 // Disable Uplink Power Control
159 Config::SetDefault("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue(false));
160
161 /*
162 * Initialize Simulation Scenario: 1 eNB and m_nUser UEs
163 */
164
165 int64_t stream = 1;
166 Ptr<LteHelper> lena = CreateObject<LteHelper>();
167
168 // Create Nodes: eNodeB and UE
169 NodeContainer enbNodes;
170 NodeContainer ueNodes;
171 enbNodes.Create(1);
172 ueNodes.Create(m_nUser);
173
174 // Install Mobility Model
176 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
177 mobility.Install(enbNodes);
178 BuildingsHelper::Install(enbNodes);
179 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
180 mobility.Install(ueNodes);
181 BuildingsHelper::Install(ueNodes);
182
183 // remove random shadowing component
184 lena->SetAttribute("PathlossModel", StringValue("ns3::HybridBuildingsPropagationLossModel"));
185 lena->SetPathlossModelAttribute("ShadowSigmaOutdoor", DoubleValue(0.0));
186 lena->SetPathlossModelAttribute("ShadowSigmaIndoor", DoubleValue(0.0));
187 lena->SetPathlossModelAttribute("ShadowSigmaExtWalls", DoubleValue(0.0));
188
189 // Create Devices and install them in the Nodes (eNB and UE)
190 NetDeviceContainer enbDevs;
191 NetDeviceContainer ueDevs;
192 lena->SetSchedulerType("ns3::RrFfMacScheduler");
193 lena->SetSchedulerAttribute("UlCqiFilter", EnumValue(FfMacScheduler::PUSCH_UL_CQI));
194
195 enbDevs = lena->InstallEnbDevice(enbNodes);
196 stream += lena->AssignStreams(enbDevs, stream);
197 ueDevs = lena->InstallUeDevice(ueNodes);
198 stream += lena->AssignStreams(ueDevs, stream);
199
200 // Attach a UE to a eNB
201 lena->Attach(ueDevs, enbDevs.Get(0));
202
203 // Activate an EPS bearer
204 enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
205 EpsBearer bearer(q);
206 lena->ActivateDataRadioBearer(ueDevs, bearer);
207
208 Ptr<LteEnbNetDevice> lteEnbDev = enbDevs.Get(0)->GetObject<LteEnbNetDevice>();
209 Ptr<LteEnbPhy> enbPhy = lteEnbDev->GetPhy();
210 enbPhy->SetAttribute("TxPower", DoubleValue(43.0));
211 enbPhy->SetAttribute("NoiseFigure", DoubleValue(5.0));
212 // place the HeNB over the default rooftop level (20 mt.)
213 Ptr<MobilityModel> mm = enbNodes.Get(0)->GetObject<MobilityModel>();
214 mm->SetPosition(Vector(0.0, 0.0, 30.0));
215
216 // Set UEs' position and power
217 for (int i = 0; i < m_nUser; i++)
218 {
219 Ptr<MobilityModel> mm1 = ueNodes.Get(i)->GetObject<MobilityModel>();
220 mm1->SetPosition(Vector(m_dist, 0.0, 1.0));
221 Ptr<LteUeNetDevice> lteUeDev = ueDevs.Get(i)->GetObject<LteUeNetDevice>();
222 Ptr<LteUePhy> uePhy = lteUeDev->GetPhy();
223 uePhy->SetAttribute("TxPower", DoubleValue(23.0));
224 uePhy->SetAttribute("NoiseFigure", DoubleValue(9.0));
225 }
226
227 Time statsDuration = Seconds(1.0);
228 Simulator::Stop(m_statsStartTime + statsDuration - Seconds(0.0001));
229
230 lena->EnableRlcTraces();
232 rlcStats->SetAttribute("StartTime", TimeValue(m_statsStartTime));
233 rlcStats->SetAttribute("EpochDuration", TimeValue(statsDuration));
234
235 Simulator::Run();
236
237 NS_LOG_INFO("\tTest downlink data shared channels (PDSCH)");
238 NS_LOG_INFO("Test with " << m_nUser << " user(s) at distance " << m_dist << " expected BLER "
239 << m_blerRef);
240 for (int i = 0; i < m_nUser; i++)
241 {
242 // get the imsi
243 uint64_t imsi = ueDevs.Get(i)->GetObject<LteUeNetDevice>()->GetImsi();
244 uint8_t lcId = 3;
245
246 double dlRxPackets = rlcStats->GetDlRxPackets(imsi, lcId);
247 double dlTxPackets = rlcStats->GetDlTxPackets(imsi, lcId);
248 double dlBler [[maybe_unused]] = 1.0 - (dlRxPackets / dlTxPackets);
249 double expectedDlRxPackets = dlTxPackets - dlTxPackets * m_blerRef;
250 NS_LOG_INFO("\tUser " << i << " imsi " << imsi << " DOWNLINK"
251 << " pkts rx " << dlRxPackets << " tx " << dlTxPackets << " BLER "
252 << dlBler << " Err " << std::fabs(m_blerRef - dlBler)
253 << " expected rx " << expectedDlRxPackets << " difference "
254 << std::abs(expectedDlRxPackets - dlRxPackets) << " tolerance "
256
257 // sanity check for whether the tx packets reported by the stats are correct
258 // we expect one packet per TTI
259 double expectedDlTxPackets = static_cast<double>(statsDuration.GetMilliSeconds());
260 NS_TEST_ASSERT_MSG_EQ_TOL(dlTxPackets,
261 expectedDlTxPackets,
262 expectedDlTxPackets * 0.005,
263 " too different DL TX packets reported");
264
265 // this is the main test condition: check that the RX packets are within the expected range
266 NS_TEST_ASSERT_MSG_EQ_TOL(dlRxPackets,
267 expectedDlRxPackets,
269 " too different DL RX packets reported");
270 }
271
272 Simulator::Destroy();
273}
274
275std::string
277{
278 std::ostringstream oss;
279 oss << "DlCtrlPhyErrorModel " << nEnb << " eNBs, distance " << dist << " m, RngRun " << rngRun;
280 return oss.str();
281}
282
284 uint16_t dist,
285 double blerRef,
286 uint16_t toleranceRxPackets,
287 Time statsStartTime,
288 uint32_t rngRun)
289 : TestCase(BuildNameString(nEnb, dist, rngRun)),
290 m_nEnb(nEnb),
291 m_dist(dist),
292 m_blerRef(blerRef),
293 m_toleranceRxPackets(toleranceRxPackets),
294 m_statsStartTime(statsStartTime),
295 m_rngRun(rngRun)
296{
297}
298
300{
301}
302
303void
305{
306 double ber = 0.03;
307 Config::SetDefault("ns3::LteAmc::Ber", DoubleValue(ber));
308 Config::SetDefault("ns3::LteAmc::AmcModel", EnumValue(LteAmc::PiroEW2010));
309 Config::SetDefault("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue(true));
310 Config::SetDefault("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue(false));
311 Config::SetDefault("ns3::RrFfMacScheduler::HarqEnabled", BooleanValue(false));
313
314 Config::SetDefault("ns3::RadioBearerStatsCalculator::DlRlcOutputFilename",
315 StringValue(CreateTempDirFilename("DlRlcStats.txt")));
316 Config::SetDefault("ns3::RadioBearerStatsCalculator::UlRlcOutputFilename",
317 StringValue(CreateTempDirFilename("UlRlcStats.txt")));
318
319 // Disable Uplink Power Control
320 Config::SetDefault("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue(false));
321
322 /*
323 * Initialize Simulation Scenario: 1 eNB and m_nUser UEs
324 */
325
326 int64_t stream = 1;
327 Ptr<LteHelper> lena = CreateObject<LteHelper>();
328
329 // Create Nodes: eNodeB and UE
330 NodeContainer enbNodes;
331 NodeContainer ueNodes;
332 enbNodes.Create(m_nEnb);
333 ueNodes.Create(1);
334
335 // Install Mobility Model
337 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
338 mobility.Install(enbNodes);
339 BuildingsHelper::Install(enbNodes);
340 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
341 mobility.Install(ueNodes);
342 BuildingsHelper::Install(ueNodes);
343
344 // remove random shadowing component
345 lena->SetAttribute("PathlossModel", StringValue("ns3::HybridBuildingsPropagationLossModel"));
346 lena->SetPathlossModelAttribute("ShadowSigmaOutdoor", DoubleValue(0.0));
347 lena->SetPathlossModelAttribute("ShadowSigmaIndoor", DoubleValue(0.0));
348 lena->SetPathlossModelAttribute("ShadowSigmaExtWalls", DoubleValue(0.0));
349
350 // Create Devices and install them in the Nodes (eNB and UE)
351 NetDeviceContainer enbDevs;
352 NetDeviceContainer ueDevs;
353 lena->SetSchedulerType("ns3::RrFfMacScheduler");
354 lena->SetSchedulerAttribute("UlCqiFilter", EnumValue(FfMacScheduler::PUSCH_UL_CQI));
355
356 enbDevs = lena->InstallEnbDevice(enbNodes);
357 stream += lena->AssignStreams(enbDevs, stream);
358 ueDevs = lena->InstallUeDevice(ueNodes);
359 stream += lena->AssignStreams(ueDevs, stream);
360
361 // Attach a UE to one eNB (the others are interfering ones)
362 lena->Attach(ueDevs, enbDevs.Get(0));
363
364 // Activate an EPS bearer
365 enum EpsBearer::Qci q = EpsBearer::GBR_CONV_VOICE;
366 EpsBearer bearer(q);
367 lena->ActivateDataRadioBearer(ueDevs, bearer);
368
369 // Set UEs' position and power
370 for (int i = 0; i < m_nEnb; i++)
371 {
372 // place the HeNB over the default rooftop level (20 mt.)
373 Ptr<MobilityModel> mm = enbNodes.Get(i)->GetObject<MobilityModel>();
374 mm->SetPosition(Vector(0.0, 0.0, 30.0));
375 Ptr<LteEnbNetDevice> lteEnbDev = enbDevs.Get(i)->GetObject<LteEnbNetDevice>();
376 Ptr<LteEnbPhy> enbPhy = lteEnbDev->GetPhy();
377 enbPhy->SetAttribute("TxPower", DoubleValue(43.0));
378 enbPhy->SetAttribute("NoiseFigure", DoubleValue(5.0));
379 }
380
381 // Set UEs' position and power
382 Ptr<MobilityModel> mm = ueNodes.Get(0)->GetObject<MobilityModel>();
383 mm->SetPosition(Vector(m_dist, 0.0, 1.0));
384 Ptr<LteUeNetDevice> lteUeDev = ueDevs.Get(0)->GetObject<LteUeNetDevice>();
385 Ptr<LteUePhy> uePhy = lteUeDev->GetPhy();
386 uePhy->SetAttribute("TxPower", DoubleValue(23.0));
387 uePhy->SetAttribute("NoiseFigure", DoubleValue(9.0));
388
389 Time statsDuration = Seconds(1.0);
390 Simulator::Stop(m_statsStartTime + statsDuration - Seconds(0.0001));
391
392 lena->EnableRlcTraces();
394 rlcStats->SetAttribute("StartTime", TimeValue(m_statsStartTime));
395 rlcStats->SetAttribute("EpochDuration", TimeValue(statsDuration));
396
397 Simulator::Run();
398
399 NS_LOG_INFO("\tTest downlink control channels (PCFICH+PDCCH)");
400 NS_LOG_INFO("Test with " << m_nEnb << " eNB(s) at distance " << m_dist << " expected BLER "
401 << m_blerRef);
402 int nUser = 1;
403 for (int i = 0; i < nUser; i++)
404 {
405 // get the imsi
406 uint64_t imsi = ueDevs.Get(i)->GetObject<LteUeNetDevice>()->GetImsi();
407 uint8_t lcId = 3;
408 double dlRxPackets = rlcStats->GetDlRxPackets(imsi, lcId);
409 double dlTxPackets = rlcStats->GetDlTxPackets(imsi, lcId);
410 double dlBler [[maybe_unused]] = 1.0 - (dlRxPackets / dlTxPackets);
411 double expectedDlRxPackets = dlTxPackets - dlTxPackets * m_blerRef;
412 NS_LOG_INFO("\tUser " << i << " imsi " << imsi << " DOWNLINK"
413 << " pkts rx " << dlRxPackets << " tx " << dlTxPackets << " BLER "
414 << dlBler << " Err " << std::fabs(m_blerRef - dlBler)
415 << " expected rx " << expectedDlRxPackets << " difference "
416 << std::abs(expectedDlRxPackets - dlRxPackets) << " tolerance "
418
419 // sanity check for whether the tx packets reported by the stats are correct
420 // we expect one packet per TTI
421 double expectedDlTxPackets = static_cast<double>(statsDuration.GetMilliSeconds());
422 NS_TEST_ASSERT_MSG_EQ_TOL(dlTxPackets,
423 expectedDlTxPackets,
424 expectedDlTxPackets * 0.005,
425 " too different DL TX packets reported");
426
427 // this is the main test condition: check that the RX packets are within the expected range
428 NS_TEST_ASSERT_MSG_EQ_TOL(dlRxPackets,
429 expectedDlRxPackets,
431 "too different DL RX packets reported");
432 }
433
434 Simulator::Destroy();
435}
This system test program creates different test cases with a single eNB and several UEs,...
LenaDataPhyErrorModelTestCase(uint16_t nUser, uint16_t dist, double blerRef, uint16_t toleranceRxPackets, Time statsStartTime, uint32_t rngRun)
Constructor.
static std::string BuildNameString(uint16_t nUser, uint16_t dist, uint32_t rngRun)
Builds the test name string based on provided parameter values.
uint16_t m_nUser
number of UE nodes
double m_dist
the distance between nodes
void DoRun() override
Implementation to actually run this TestCase.
uint16_t m_toleranceRxPackets
receive packet tolerance loss
Time m_statsStartTime
Extra time in the beginning of simulation to allow RRC connection establishment + SRS.
Lena Dl Ctrl Phy Error Model Test Case.
LenaDlCtrlPhyErrorModelTestCase(uint16_t nEnb, uint16_t dist, double blerRef, uint16_t toleranceRxPackets, Time statsStartTime, uint32_t rngRun)
Constructor.
uint16_t m_nEnb
the number of ENB nodes
static std::string BuildNameString(uint16_t nUser, uint16_t dist, uint32_t rngRun)
Build name string.
void DoRun() override
Implementation to actually run this TestCase.
Time m_statsStartTime
Extra time in the beginning of simulation to allow RRC connection establishment + SRS.
double m_dist
the distance between nodes
uint16_t m_toleranceRxPackets
receive packet tolerance loss
Lena Test Phy Error Model Suite.
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:42
Hold variables of type enum.
Definition: enum.h:56
This class contains the specification of EPS Bearers.
Definition: eps-bearer.h:91
Qci
QoS Class Indicator.
Definition: eps-bearer.h:106
The eNodeB device implementation.
Ptr< LteEnbPhy > GetPhy() const
Ptr< RadioBearerStatsCalculator > GetRlcStats()
Definition: lte-helper.cc:1708
void SetSchedulerAttribute(std::string n, const AttributeValue &v)
Set an attribute for the scheduler to be created.
Definition: lte-helper.cc:303
NetDeviceContainer InstallEnbDevice(NodeContainer c)
Create a set of eNodeB devices.
Definition: lte-helper.cc:482
void SetSchedulerType(std::string type)
Set the type of scheduler to be used by eNodeB devices.
Definition: lte-helper.cc:289
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:1044
void SetPathlossModelAttribute(std::string n, const AttributeValue &v)
Set an attribute for the path loss models to be created.
Definition: lte-helper.cc:402
void EnableRlcTraces()
Enable trace sinks for RLC layer.
Definition: lte-helper.cc:1563
void ActivateDataRadioBearer(NetDeviceContainer ueDevices, EpsBearer bearer)
Activate a Data Radio Bearer on a given UE devices (for LTE-only simulation).
Definition: lte-helper.cc:1441
NetDeviceContainer InstallUeDevice(NodeContainer c)
Create a set of UE devices.
Definition: lte-helper.cc:497
int64_t AssignStreams(NetDeviceContainer c, int64_t stream)
Assign a fixed random variable stream number to the random variables used.
Definition: lte-helper.cc:1572
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:258
Ptr< T > GetObject() const
Get a pointer to the requested aggregated Object.
Definition: object.h:471
Hold variables of type string.
Definition: string.h:42
encapsulates test code
Definition: test.h:1060
void AddTestCase(TestCase *testCase, TestDuration duration=QUICK)
Add an individual child TestCase to this test suite.
Definition: test.cc:305
std::string CreateTempDirFilename(std::string filename)
Construct the full path to a file in a temporary directory.
Definition: test.cc:442
A suite of tests to run.
Definition: test.h:1256
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:105
int64_t GetMilliSeconds() const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:407
AttributeValue implementation for Time.
Definition: nstime.h:1425
Hold an unsigned integer type.
Definition: uinteger.h:45
void SetGlobal(std::string name, const AttributeValue &value)
Definition: config.cc:937
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:891
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:202
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:275
#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:337
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1338
static LenaTestPhyErrorModelSuite lenaTestPhyErrorModelSuite
Every class exported by the ns3 library is enclosed in the ns3 namespace.
mobility
Definition: third.py:96