A Discrete-Event Network Simulator
API
lena-distributed-ffr.cc
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2014 Piotr Gawlowicz
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: Piotr Gawlowicz <gawlowicz.p@gmail.com>
18  *
19  */
20 
21 #include "ns3/applications-module.h"
22 #include "ns3/core-module.h"
23 #include "ns3/internet-module.h"
24 #include "ns3/log.h"
25 #include "ns3/lte-module.h"
26 #include "ns3/mobility-module.h"
27 #include "ns3/network-module.h"
28 #include "ns3/point-to-point-epc-helper.h"
29 #include "ns3/point-to-point-module.h"
30 #include "ns3/spectrum-module.h"
31 #include <ns3/buildings-helper.h>
32 
33 using namespace ns3;
34 
35 NS_LOG_COMPONENT_DEFINE("LenaDistributedFrequencyReuse");
36 
37 void
38 PrintGnuplottableUeListToFile(std::string filename)
39 {
40  std::ofstream outFile;
41  outFile.open(filename, std::ios_base::out | std::ios_base::trunc);
42  if (!outFile.is_open())
43  {
44  NS_LOG_ERROR("Can't open file " << filename);
45  return;
46  }
47  for (auto it = NodeList::Begin(); it != NodeList::End(); ++it)
48  {
49  Ptr<Node> node = *it;
50  int nDevs = node->GetNDevices();
51  for (int j = 0; j < nDevs; j++)
52  {
53  Ptr<LteUeNetDevice> uedev = node->GetDevice(j)->GetObject<LteUeNetDevice>();
54  if (uedev)
55  {
56  Vector pos = node->GetObject<MobilityModel>()->GetPosition();
57  outFile << "set label \"" << uedev->GetImsi() << "\" at " << pos.x << "," << pos.y
58  << " left font \"Helvetica,4\" textcolor rgb \"grey\" front point pt 1 ps "
59  "0.3 lc rgb \"grey\" offset 0,0"
60  << std::endl;
61  }
62  }
63  }
64 }
65 
66 void
67 PrintGnuplottableEnbListToFile(std::string filename)
68 {
69  std::ofstream outFile;
70  outFile.open(filename, std::ios_base::out | std::ios_base::trunc);
71  if (!outFile.is_open())
72  {
73  NS_LOG_ERROR("Can't open file " << filename);
74  return;
75  }
76  for (auto it = NodeList::Begin(); it != NodeList::End(); ++it)
77  {
78  Ptr<Node> node = *it;
79  int nDevs = node->GetNDevices();
80  for (int j = 0; j < nDevs; j++)
81  {
82  Ptr<LteEnbNetDevice> enbdev = node->GetDevice(j)->GetObject<LteEnbNetDevice>();
83  if (enbdev)
84  {
85  Vector pos = node->GetObject<MobilityModel>()->GetPosition();
86  outFile << "set label \"" << enbdev->GetCellId() << "\" at " << pos.x << ","
87  << pos.y
88  << " left font \"Helvetica,4\" textcolor rgb \"white\" front point pt 2 "
89  "ps 0.3 lc rgb \"white\" offset 0,0"
90  << std::endl;
91  }
92  }
93  }
94 }
95 
96 int
97 main(int argc, char* argv[])
98 {
99  Config::SetDefault("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue(true));
100  Config::SetDefault("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue(true));
101  Config::SetDefault("ns3::LteHelper::UseIdealRrc", BooleanValue(true));
102  Config::SetDefault("ns3::LteHelper::UsePdschForCqiGeneration", BooleanValue(true));
103 
104  // Uplink Power Control
105  Config::SetDefault("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue(true));
106  Config::SetDefault("ns3::LteUePowerControl::ClosedLoop", BooleanValue(true));
107  Config::SetDefault("ns3::LteUePowerControl::AccumulationEnabled", BooleanValue(false));
108 
109  uint32_t runId = 3;
110  uint16_t numberOfRandomUes = 0;
111  double simTime = 5.000;
112  bool generateSpectrumTrace = false;
113  bool generateRem = false;
114  int32_t remRbId = -1;
115  uint16_t bandwidth = 25;
116  double distance = 1000;
117  Box macroUeBox =
118  Box(-distance * 0.5, distance * 1.5, -distance * 0.5, distance * 1.5, 1.5, 1.5);
119 
120  // Command line arguments
121  CommandLine cmd(__FILE__);
122  cmd.AddValue("numberOfUes", "Number of UEs", numberOfRandomUes);
123  cmd.AddValue("simTime", "Total duration of the simulation (in seconds)", simTime);
124  cmd.AddValue("generateSpectrumTrace",
125  "if true, will generate a Spectrum Analyzer trace",
126  generateSpectrumTrace);
127  cmd.AddValue("generateRem",
128  "if true, will generate a REM and then abort the simulation",
129  generateRem);
130  cmd.AddValue("remRbId",
131  "Resource block Id, for which REM will be generated,"
132  "default value is -1, what means REM will be averaged from all RBs",
133  remRbId);
134  cmd.AddValue("runId", "runId", runId);
135  cmd.Parse(argc, argv);
136 
138  RngSeedManager::SetRun(runId);
139 
140  Ptr<LteHelper> lteHelper = CreateObject<LteHelper>();
141  Ptr<PointToPointEpcHelper> epcHelper = CreateObject<PointToPointEpcHelper>();
142  lteHelper->SetEpcHelper(epcHelper);
143  lteHelper->SetHandoverAlgorithmType("ns3::NoOpHandoverAlgorithm"); // disable automatic handover
144 
145  Ptr<Node> pgw = epcHelper->GetPgwNode();
146 
147  // Create a single RemoteHost
148  NodeContainer remoteHostContainer;
149  remoteHostContainer.Create(1);
150  Ptr<Node> remoteHost = remoteHostContainer.Get(0);
152  internet.Install(remoteHostContainer);
153 
154  // Create the Internet
155  PointToPointHelper p2ph;
156  p2ph.SetDeviceAttribute("DataRate", DataRateValue(DataRate("100Gb/s")));
157  p2ph.SetDeviceAttribute("Mtu", UintegerValue(1500));
158  p2ph.SetChannelAttribute("Delay", TimeValue(Seconds(0.010)));
159  NetDeviceContainer internetDevices = p2ph.Install(pgw, remoteHost);
160  Ipv4AddressHelper ipv4h;
161  ipv4h.SetBase("1.0.0.0", "255.0.0.0");
162  Ipv4InterfaceContainer internetIpIfaces = ipv4h.Assign(internetDevices);
163  Ipv4Address remoteHostAddr = internetIpIfaces.GetAddress(1);
164 
165  // Routing of the Internet Host (towards the LTE network)
166  Ipv4StaticRoutingHelper ipv4RoutingHelper;
167  Ptr<Ipv4StaticRouting> remoteHostStaticRouting =
168  ipv4RoutingHelper.GetStaticRouting(remoteHost->GetObject<Ipv4>());
169  // interface 0 is localhost, 1 is the p2p device
170  remoteHostStaticRouting->AddNetworkRouteTo(Ipv4Address("7.0.0.0"), Ipv4Mask("255.0.0.0"), 1);
171 
172  // Create Nodes: eNodeB and UE
173  NodeContainer enbNodes;
174  NodeContainer randomUeNodes;
175  enbNodes.Create(3);
176  randomUeNodes.Create(numberOfRandomUes);
177 
178  /* the topology is the following:
179  * eNB3
180  * / \
181  * / \
182  * / \
183  * / \
184  * distance / \ distance
185  * / UEs \
186  * / \
187  * / \
188  * / \
189  * / \
190  * eNB1-------------------------eNB2
191  * distance
192  */
193 
194  // Install Mobility Model
195  Ptr<ListPositionAllocator> enbPositionAlloc = CreateObject<ListPositionAllocator>();
196  enbPositionAlloc->Add(Vector(0.0, 0.0, 0.0)); // eNB1
197  enbPositionAlloc->Add(Vector(distance, 0.0, 0.0)); // eNB2
198  enbPositionAlloc->Add(Vector(distance * 0.5, distance * 0.866, 0.0)); // eNB3
200  mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
201  mobility.SetPositionAllocator(enbPositionAlloc);
202  mobility.Install(enbNodes);
203 
204  Ptr<RandomBoxPositionAllocator> randomUePositionAlloc =
205  CreateObject<RandomBoxPositionAllocator>();
206  Ptr<UniformRandomVariable> xVal = CreateObject<UniformRandomVariable>();
207  xVal->SetAttribute("Min", DoubleValue(macroUeBox.xMin));
208  xVal->SetAttribute("Max", DoubleValue(macroUeBox.xMax));
209  randomUePositionAlloc->SetAttribute("X", PointerValue(xVal));
210  Ptr<UniformRandomVariable> yVal = CreateObject<UniformRandomVariable>();
211  yVal->SetAttribute("Min", DoubleValue(macroUeBox.yMin));
212  yVal->SetAttribute("Max", DoubleValue(macroUeBox.yMax));
213  randomUePositionAlloc->SetAttribute("Y", PointerValue(yVal));
214  Ptr<UniformRandomVariable> zVal = CreateObject<UniformRandomVariable>();
215  zVal->SetAttribute("Min", DoubleValue(macroUeBox.zMin));
216  zVal->SetAttribute("Max", DoubleValue(macroUeBox.zMax));
217  randomUePositionAlloc->SetAttribute("Z", PointerValue(zVal));
218  mobility.SetPositionAllocator(randomUePositionAlloc);
219  mobility.Install(randomUeNodes);
220 
221  // Create Devices and install them in the Nodes (eNB and UE)
222  NetDeviceContainer enbDevs;
223  NetDeviceContainer randomUeDevs;
224  lteHelper->SetSchedulerType("ns3::PfFfMacScheduler");
225  lteHelper->SetSchedulerAttribute("HarqEnabled", BooleanValue(true));
226 
227  lteHelper->SetEnbDeviceAttribute("DlBandwidth", UintegerValue(bandwidth));
228  lteHelper->SetEnbDeviceAttribute("UlBandwidth", UintegerValue(bandwidth));
229 
230  lteHelper->SetFfrAlgorithmType("ns3::LteFfrDistributedAlgorithm");
231  lteHelper->SetFfrAlgorithmAttribute("CalculationInterval", TimeValue(MilliSeconds(200)));
232  lteHelper->SetFfrAlgorithmAttribute("RsrpDifferenceThreshold", UintegerValue(5));
233  lteHelper->SetFfrAlgorithmAttribute("RsrqThreshold", UintegerValue(25));
234  lteHelper->SetFfrAlgorithmAttribute("EdgeRbNum", UintegerValue(6));
235  lteHelper->SetFfrAlgorithmAttribute("CenterPowerOffset",
237  lteHelper->SetFfrAlgorithmAttribute("EdgePowerOffset",
239 
240  lteHelper->SetFfrAlgorithmAttribute("CenterAreaTpc", UintegerValue(0));
241  lteHelper->SetFfrAlgorithmAttribute("EdgeAreaTpc", UintegerValue(3));
242 
243  // ns3::LteFfrDistributedAlgorithm works with Absolute Mode Uplink Power Control
244  Config::SetDefault("ns3::LteUePowerControl::AccumulationEnabled", BooleanValue(false));
245 
246  enbDevs = lteHelper->InstallEnbDevice(enbNodes);
247  randomUeDevs = lteHelper->InstallUeDevice(randomUeNodes);
248 
249  // Add X2 interface
250  lteHelper->AddX2Interface(enbNodes);
251 
252  NodeContainer ueNodes;
253  ueNodes.Add(randomUeNodes);
254  NetDeviceContainer ueDevs;
255  ueDevs.Add(randomUeDevs);
256 
257  // Install the IP stack on the UEs
258  internet.Install(ueNodes);
259  Ipv4InterfaceContainer ueIpIfaces;
260  ueIpIfaces = epcHelper->AssignUeIpv4Address(NetDeviceContainer(ueDevs));
261 
262  // Attach a UE to a eNB
263  lteHelper->AttachToClosestEnb(ueDevs, enbDevs);
264 
265  // Install and start applications on UEs and remote host
266  uint16_t dlPort = 10000;
267  uint16_t ulPort = 20000;
268 
269  // randomize a bit start times to avoid simulation artifacts
270  // (e.g., buffer overflows due to packet transmissions happening
271  // exactly at the same time)
272  Ptr<UniformRandomVariable> startTimeSeconds = CreateObject<UniformRandomVariable>();
273  startTimeSeconds->SetAttribute("Min", DoubleValue(0));
274  startTimeSeconds->SetAttribute("Max", DoubleValue(0.010));
275 
276  for (uint32_t u = 0; u < ueNodes.GetN(); ++u)
277  {
278  Ptr<Node> ue = ueNodes.Get(u);
279  // Set the default gateway for the UE
280  Ptr<Ipv4StaticRouting> ueStaticRouting =
281  ipv4RoutingHelper.GetStaticRouting(ue->GetObject<Ipv4>());
282  ueStaticRouting->SetDefaultRoute(epcHelper->GetUeDefaultGatewayAddress(), 1);
283 
284  for (uint32_t b = 0; b < 1; ++b)
285  {
286  ++dlPort;
287  ++ulPort;
288 
291 
292  UdpClientHelper dlClientHelper(ueIpIfaces.GetAddress(u), dlPort);
293  dlClientHelper.SetAttribute("MaxPackets", UintegerValue(1000000));
294  dlClientHelper.SetAttribute("Interval", TimeValue(MilliSeconds(1.0)));
295  clientApps.Add(dlClientHelper.Install(remoteHost));
296  PacketSinkHelper dlPacketSinkHelper("ns3::UdpSocketFactory",
298  serverApps.Add(dlPacketSinkHelper.Install(ue));
299 
300  UdpClientHelper ulClientHelper(remoteHostAddr, ulPort);
301  ulClientHelper.SetAttribute("MaxPackets", UintegerValue(1000000));
302  ulClientHelper.SetAttribute("Interval", TimeValue(MilliSeconds(1.0)));
303  clientApps.Add(ulClientHelper.Install(ue));
304  PacketSinkHelper ulPacketSinkHelper("ns3::UdpSocketFactory",
306  serverApps.Add(ulPacketSinkHelper.Install(remoteHost));
307 
308  Ptr<EpcTft> tft = Create<EpcTft>();
310  dlpf.localPortStart = dlPort;
311  dlpf.localPortEnd = dlPort;
312  tft->Add(dlpf);
314  ulpf.remotePortStart = ulPort;
315  ulpf.remotePortEnd = ulPort;
316  tft->Add(ulpf);
318  lteHelper->ActivateDedicatedEpsBearer(ueDevs.Get(u), bearer, tft);
319 
320  Time startTime = Seconds(startTimeSeconds->GetValue());
321  serverApps.Start(startTime);
322  clientApps.Start(startTime);
323  }
324  }
325 
326  // Spectrum analyzer
327  NodeContainer spectrumAnalyzerNodes;
328  spectrumAnalyzerNodes.Create(1);
329  SpectrumAnalyzerHelper spectrumAnalyzerHelper;
330 
331  if (generateSpectrumTrace)
332  {
333  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();
334  // position of Spectrum Analyzer
335  positionAlloc->Add(Vector(0.0, 0.0, 0.0)); // eNB1
336  // positionAlloc->Add (Vector (distance, 0.0, 0.0)); // eNB2
337  // positionAlloc->Add (Vector (distance*0.5, distance*0.866, 0.0)); // eNB3
338 
340  mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
341  mobility.SetPositionAllocator(positionAlloc);
342  mobility.Install(spectrumAnalyzerNodes);
343 
344  Ptr<LteSpectrumPhy> enbDlSpectrumPhy = enbDevs.Get(0)
345  ->GetObject<LteEnbNetDevice>()
346  ->GetPhy()
347  ->GetDownlinkSpectrumPhy()
349  Ptr<SpectrumChannel> dlChannel = enbDlSpectrumPhy->GetChannel();
350 
351  spectrumAnalyzerHelper.SetChannel(dlChannel);
353  spectrumAnalyzerHelper.SetRxSpectrumModel(sm);
354  spectrumAnalyzerHelper.SetPhyAttribute("Resolution", TimeValue(MicroSeconds(10)));
355  spectrumAnalyzerHelper.SetPhyAttribute("NoisePowerSpectralDensity",
356  DoubleValue(1e-15)); // -120 dBm/Hz
357  spectrumAnalyzerHelper.EnableAsciiAll("spectrum-analyzer-output");
358  spectrumAnalyzerHelper.Install(spectrumAnalyzerNodes);
359  }
360 
362  if (generateRem)
363  {
364  PrintGnuplottableEnbListToFile("enbs.txt");
366 
367  remHelper = CreateObject<RadioEnvironmentMapHelper>();
368  Ptr<LteSpectrumPhy> enbDlSpectrumPhy = enbDevs.Get(0)
369  ->GetObject<LteEnbNetDevice>()
370  ->GetPhy()
371  ->GetDownlinkSpectrumPhy()
373  Ptr<SpectrumChannel> dlChannel = enbDlSpectrumPhy->GetChannel();
374  uint32_t dlChannelId = dlChannel->GetId();
375  NS_LOG_INFO("DL ChannelId: " << dlChannelId);
376  remHelper->SetAttribute("Channel", PointerValue(dlChannel));
377  remHelper->SetAttribute("OutputFile", StringValue("lena-distributed-ffr.rem"));
378  remHelper->SetAttribute("XMin", DoubleValue(macroUeBox.xMin));
379  remHelper->SetAttribute("XMax", DoubleValue(macroUeBox.xMax));
380  remHelper->SetAttribute("YMin", DoubleValue(macroUeBox.yMin));
381  remHelper->SetAttribute("YMax", DoubleValue(macroUeBox.yMax));
382  remHelper->SetAttribute("Z", DoubleValue(1.5));
383  remHelper->SetAttribute("XRes", UintegerValue(500));
384  remHelper->SetAttribute("YRes", UintegerValue(500));
385 
386  if (remRbId >= 0)
387  {
388  remHelper->SetAttribute("UseDataChannel", BooleanValue(true));
389  remHelper->SetAttribute("RbId", IntegerValue(remRbId));
390  }
391 
392  remHelper->Install();
393  // simulation will stop right after the REM has been generated
394  }
395  else
396  {
397  Simulator::Stop(Seconds(simTime));
398  }
399 
400  Simulator::Run();
402  return 0;
403 }
holds a vector of ns3::Application pointers.
a 3d box
Definition: box.h:35
double yMax
The y coordinate of the top bound of the box.
Definition: box.h:116
double xMin
The x coordinate of the left bound of the box.
Definition: box.h:110
double yMin
The y coordinate of the bottom bound of the box.
Definition: box.h:114
double xMax
The x coordinate of the right bound of the box.
Definition: box.h:112
double zMin
The z coordinate of the down bound of the box.
Definition: box.h:118
double zMax
The z coordinate of the up bound of the box.
Definition: box.h:120
Parse command-line arguments.
Definition: command-line.h:232
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition: double.h:42
This class contains the specification of EPS Bearers.
Definition: eps-bearer.h:91
@ NGBR_VIDEO_TCP_DEFAULT
Non-GBR TCP-based Video (Buffered Streaming, e.g., www, e-mail...)
Definition: eps-bearer.h:126
an Inet address class
Hold a signed integer type.
Definition: integer.h:45
aggregate IP/TCP/UDP functionality to existing Nodes.
A helper class to make life easier while doing simple IPv4 address assignment in scripts.
void SetBase(Ipv4Address network, Ipv4Mask mask, Ipv4Address base="0.0.0.1")
Set the base network number, network mask and base address.
Ipv4InterfaceContainer Assign(const NetDeviceContainer &c)
Assign IP addresses to the net devices specified in the container based on the current network prefix...
Ipv4 addresses are stored in host order in this class.
Definition: ipv4-address.h:42
static Ipv4Address GetAny()
Access to the IPv4 forwarding table, interfaces, and configuration.
Definition: ipv4.h:80
holds a vector of std::pair of Ptr<Ipv4> and interface index.
Ipv4Address GetAddress(uint32_t i, uint32_t j=0) const
a class to represent an Ipv4 address mask
Definition: ipv4-address.h:257
Helper class that adds ns3::Ipv4StaticRouting objects.
Ptr< Ipv4StaticRouting > GetStaticRouting(Ptr< Ipv4 > ipv4) const
Try and find the static routing protocol as either the main routing protocol or in the list of routin...
The eNodeB device implementation.
uint16_t GetCellId() const
void SetFfrAlgorithmType(std::string type)
Set the type of FFR algorithm to be used by eNodeB devices.
Definition: lte-helper.cc:319
void SetEpcHelper(Ptr< EpcHelper > h)
Set the EpcHelper to be used to setup the EPC network in conjunction with the setup of the LTE radio ...
Definition: lte-helper.cc:285
void SetSchedulerAttribute(std::string n, const AttributeValue &v)
Set an attribute for the scheduler to be created.
Definition: lte-helper.cc:306
NetDeviceContainer InstallEnbDevice(NodeContainer c)
Create a set of eNodeB devices.
Definition: lte-helper.cc:485
void SetHandoverAlgorithmType(std::string type)
Set the type of handover algorithm to be used by eNodeB devices.
Definition: lte-helper.cc:340
void SetFfrAlgorithmAttribute(std::string n, const AttributeValue &v)
Set an attribute for the FFR algorithm to be created.
Definition: lte-helper.cc:327
void SetSchedulerType(std::string type)
Set the type of scheduler to be used by eNodeB devices.
Definition: lte-helper.cc:292
void SetEnbDeviceAttribute(std::string n, const AttributeValue &v)
Set an attribute for the eNodeB devices (LteEnbNetDevice) to be created.
Definition: lte-helper.cc:412
NetDeviceContainer InstallUeDevice(NodeContainer c)
Create a set of UE devices.
Definition: lte-helper.cc:500
void AddX2Interface(NodeContainer enbNodes)
Create an X2 interface between all the eNBs in a given set.
Definition: lte-helper.cc:1313
void AttachToClosestEnb(NetDeviceContainer ueDevices, NetDeviceContainer enbDevices)
Manual attachment of a set of UE devices to the network via the closest eNodeB (with respect to dista...
Definition: lte-helper.cc:1122
uint8_t ActivateDedicatedEpsBearer(NetDeviceContainer ueDevices, EpsBearer bearer, Ptr< EpcTft > tft)
Activate a dedicated EPS bearer on a given set of UE devices.
Definition: lte-helper.cc:1154
The LteSpectrumPhy models the physical layer of LTE.
static Ptr< SpectrumModel > GetSpectrumModel(uint32_t earfcn, uint16_t bandwidth)
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.
holds a vector of ns3::NetDevice pointers
void Add(NetDeviceContainer other)
Append the contents of another NetDeviceContainer to the end of this container.
Ptr< NetDevice > Get(uint32_t i) const
Get the Ptr<NetDevice> stored in this container at a given index.
Ptr< Node > GetPgwNode() const override
Get the PGW node.
Ipv4Address GetUeDefaultGatewayAddress() override
Ipv4InterfaceContainer AssignUeIpv4Address(NetDeviceContainer ueDevices) override
Assign IPv4 addresses to UE devices.
keep track of a set of node pointers.
uint32_t GetN() const
Get the number of Ptr<Node> stored in this container.
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
void Add(const NodeContainer &nc)
Append the contents of another NodeContainer to the end of this container.
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
uint32_t GetNDevices() const
Definition: node.cc:162
Ptr< NetDevice > GetDevice(uint32_t index) const
Retrieve the index-th NetDevice associated to this node.
Definition: node.cc:152
static Iterator Begin()
Definition: node-list.cc:237
static Iterator End()
Definition: node-list.cc:244
void SetAttribute(std::string name, const AttributeValue &value)
Set a single attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:204
Ptr< T > GetObject() const
Get a pointer to the requested aggregated Object.
Definition: object.h:471
A helper to make it easier to instantiate an ns3::PacketSinkApplication on a set of nodes.
Build a set of PointToPointNetDevice objects.
void SetDeviceAttribute(std::string name, const AttributeValue &value)
Set an attribute value to be propagated to each NetDevice created by the helper.
void SetChannelAttribute(std::string name, const AttributeValue &value)
Set an attribute value to be propagated to each Channel created by the helper.
NetDeviceContainer Install(NodeContainer c)
Hold objects of type Ptr<T>.
Definition: pointer.h:37
static void SetRun(uint64_t run)
Set the run number of simulation.
static void SetSeed(uint32_t seed)
Set the seed.
static void Destroy()
Execute the events scheduled with ScheduleDestroy().
Definition: simulator.cc:142
static void Run()
Run the simulation.
Definition: simulator.cc:178
static void Stop()
Tell the Simulator the calling event should be the last one executed.
Definition: simulator.cc:186
Class to allow the Spectrum Analysis.
NetDeviceContainer Install(NodeContainer c) const
void SetPhyAttribute(std::string name, const AttributeValue &v)
void SetChannel(Ptr< SpectrumChannel > channel)
Set the SpectrumChannel that will be used by SpectrumPhy instances created by this helper.
void EnableAsciiAll(std::string prefix)
Enable ASCII output.
void SetRxSpectrumModel(Ptr< SpectrumModel > m)
Set the spectrum model used by the created SpectrumAnalyzer instances to represent incoming signals.
Hold variables of type string.
Definition: string.h:56
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:105
Create a client application which sends UDP packets carrying a 32bit sequence number and a 64 bit tim...
Hold an unsigned integer type.
Definition: uinteger.h:45
double GetValue(double min, double max)
Get the next random value drawn from the distribution.
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:890
#define NS_LOG_ERROR(msg)
Use NS_LOG to output a message of level LOG_ERROR.
Definition: log.h:254
#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
void(* DataRate)(DataRate oldValue, DataRate newValue)
TracedValue callback signature for DataRate.
Definition: data-rate.h:327
Time MicroSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1350
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1326
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition: nstime.h:1338
void PrintGnuplottableEnbListToFile(std::string filename)
void PrintGnuplottableUeListToFile(std::string filename)
serverApps
Definition: first.py:54
clientApps
Definition: first.py:64
Every class exported by the ns3 library is enclosed in the ns3 namespace.
cmd
Definition: second.py:40
mobility
Definition: third.py:105
Implement the data structure representing a TrafficFlowTemplate Packet Filter.
Definition: epc-tft.h:71
uint16_t localPortEnd
end of the port number range of the UE
Definition: epc-tft.h:132
uint16_t remotePortEnd
end of the port number range of the remote host
Definition: epc-tft.h:130
uint16_t remotePortStart
start of the port number range of the remote host
Definition: epc-tft.h:129
uint16_t localPortStart
start of the port number range of the UE
Definition: epc-tft.h:131