A Discrete-Event Network Simulator
API
Loading...
Searching...
No Matches
lena-distributed-ffr.cc
Go to the documentation of this file.
1/*
2 * Copyright (c) 2014 Piotr Gawlowicz
3 *
4 * SPDX-License-Identifier: GPL-2.0-only
5 *
6 * Author: Piotr Gawlowicz <gawlowicz.p@gmail.com>
7 *
8 */
9
10#include "ns3/applications-module.h"
11#include "ns3/core-module.h"
12#include "ns3/internet-module.h"
13#include "ns3/log.h"
14#include "ns3/lte-module.h"
15#include "ns3/mobility-module.h"
16#include "ns3/network-module.h"
17#include "ns3/point-to-point-epc-helper.h"
18#include "ns3/point-to-point-module.h"
19#include "ns3/spectrum-module.h"
20#include <ns3/buildings-helper.h>
21
22using namespace ns3;
23
24NS_LOG_COMPONENT_DEFINE("LenaDistributedFrequencyReuse");
25
26void
27PrintGnuplottableUeListToFile(std::string filename)
28{
29 std::ofstream outFile;
30 outFile.open(filename, std::ios_base::out | std::ios_base::trunc);
31 if (!outFile.is_open())
32 {
33 NS_LOG_ERROR("Can't open file " << filename);
34 return;
35 }
36 for (auto it = NodeList::Begin(); it != NodeList::End(); ++it)
37 {
38 Ptr<Node> node = *it;
39 int nDevs = node->GetNDevices();
40 for (int j = 0; j < nDevs; j++)
41 {
42 Ptr<LteUeNetDevice> uedev = node->GetDevice(j)->GetObject<LteUeNetDevice>();
43 if (uedev)
44 {
45 Vector pos = node->GetObject<MobilityModel>()->GetPosition();
46 outFile << "set label \"" << uedev->GetImsi() << "\" at " << pos.x << "," << pos.y
47 << " left font \"Helvetica,4\" textcolor rgb \"grey\" front point pt 1 ps "
48 "0.3 lc rgb \"grey\" offset 0,0"
49 << std::endl;
50 }
51 }
52 }
53}
54
55void
56PrintGnuplottableEnbListToFile(std::string filename)
57{
58 std::ofstream outFile;
59 outFile.open(filename, std::ios_base::out | std::ios_base::trunc);
60 if (!outFile.is_open())
61 {
62 NS_LOG_ERROR("Can't open file " << filename);
63 return;
64 }
65 for (auto it = NodeList::Begin(); it != NodeList::End(); ++it)
66 {
67 Ptr<Node> node = *it;
68 int nDevs = node->GetNDevices();
69 for (int j = 0; j < nDevs; j++)
70 {
71 Ptr<LteEnbNetDevice> enbdev = node->GetDevice(j)->GetObject<LteEnbNetDevice>();
72 if (enbdev)
73 {
74 Vector pos = node->GetObject<MobilityModel>()->GetPosition();
75 outFile << "set label \"" << enbdev->GetCellId() << "\" at " << pos.x << ","
76 << pos.y
77 << " left font \"Helvetica,4\" textcolor rgb \"white\" front point pt 2 "
78 "ps 0.3 lc rgb \"white\" offset 0,0"
79 << std::endl;
80 }
81 }
82 }
83}
84
85int
86main(int argc, char* argv[])
87{
88 Config::SetDefault("ns3::LteSpectrumPhy::CtrlErrorModelEnabled", BooleanValue(true));
89 Config::SetDefault("ns3::LteSpectrumPhy::DataErrorModelEnabled", BooleanValue(true));
90 Config::SetDefault("ns3::LteHelper::UseIdealRrc", BooleanValue(true));
91 Config::SetDefault("ns3::LteHelper::UsePdschForCqiGeneration", BooleanValue(true));
92
93 // Uplink Power Control
94 Config::SetDefault("ns3::LteUePhy::EnableUplinkPowerControl", BooleanValue(true));
95 Config::SetDefault("ns3::LteUePowerControl::ClosedLoop", BooleanValue(true));
96 Config::SetDefault("ns3::LteUePowerControl::AccumulationEnabled", BooleanValue(false));
97
98 uint32_t runId = 3;
99 uint16_t numberOfRandomUes = 0;
100 double simTime = 5.000;
101 bool generateSpectrumTrace = false;
102 bool generateRem = false;
103 int32_t remRbId = -1;
104 uint16_t bandwidth = 25;
105 double distance = 1000;
106 Box macroUeBox =
107 Box(-distance * 0.5, distance * 1.5, -distance * 0.5, distance * 1.5, 1.5, 1.5);
108
109 // Command line arguments
110 CommandLine cmd(__FILE__);
111 cmd.AddValue("numberOfUes", "Number of UEs", numberOfRandomUes);
112 cmd.AddValue("simTime", "Total duration of the simulation (in seconds)", simTime);
113 cmd.AddValue("generateSpectrumTrace",
114 "if true, will generate a Spectrum Analyzer trace",
115 generateSpectrumTrace);
116 cmd.AddValue("generateRem",
117 "if true, will generate a REM and then abort the simulation",
118 generateRem);
119 cmd.AddValue("remRbId",
120 "Resource block Id, for which REM will be generated,"
121 "default value is -1, what means REM will be averaged from all RBs",
122 remRbId);
123 cmd.AddValue("runId", "runId", runId);
124 cmd.Parse(argc, argv);
125
128
131 lteHelper->SetEpcHelper(epcHelper);
132 lteHelper->SetHandoverAlgorithmType("ns3::NoOpHandoverAlgorithm"); // disable automatic handover
133
134 Ptr<Node> pgw = epcHelper->GetPgwNode();
135
136 // Create a single RemoteHost
137 NodeContainer remoteHostContainer;
138 remoteHostContainer.Create(1);
139 Ptr<Node> remoteHost = remoteHostContainer.Get(0);
141 internet.Install(remoteHostContainer);
142
143 // Create the Internet
145 p2ph.SetDeviceAttribute("DataRate", DataRateValue(DataRate("100Gb/s")));
146 p2ph.SetDeviceAttribute("Mtu", UintegerValue(1500));
147 p2ph.SetChannelAttribute("Delay", TimeValue(Seconds(0.010)));
148 NetDeviceContainer internetDevices = p2ph.Install(pgw, remoteHost);
149 Ipv4AddressHelper ipv4h;
150 ipv4h.SetBase("1.0.0.0", "255.0.0.0");
151 Ipv4InterfaceContainer internetIpIfaces = ipv4h.Assign(internetDevices);
152 Ipv4Address remoteHostAddr = internetIpIfaces.GetAddress(1);
153
154 // Routing of the Internet Host (towards the LTE network)
155 Ipv4StaticRoutingHelper ipv4RoutingHelper;
156 Ptr<Ipv4StaticRouting> remoteHostStaticRouting =
157 ipv4RoutingHelper.GetStaticRouting(remoteHost->GetObject<Ipv4>());
158 // interface 0 is localhost, 1 is the p2p device
159 remoteHostStaticRouting->AddNetworkRouteTo(Ipv4Address("7.0.0.0"), Ipv4Mask("255.0.0.0"), 1);
160
161 // Create Nodes: eNodeB and UE
162 NodeContainer enbNodes;
163 NodeContainer randomUeNodes;
164 enbNodes.Create(3);
165 randomUeNodes.Create(numberOfRandomUes);
166
167 /* the topology is the following:
168 * eNB3
169 * / \
170 * / \
171 * / \
172 * / \
173 * distance / \ distance
174 * / UEs \
175 * / \
176 * / \
177 * / \
178 * / \
179 * eNB1-------------------------eNB2
180 * distance
181 */
182
183 // Install Mobility Model
185 enbPositionAlloc->Add(Vector(0.0, 0.0, 0.0)); // eNB1
186 enbPositionAlloc->Add(Vector(distance, 0.0, 0.0)); // eNB2
187 enbPositionAlloc->Add(Vector(distance * 0.5, distance * 0.866, 0.0)); // eNB3
189 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
190 mobility.SetPositionAllocator(enbPositionAlloc);
191 mobility.Install(enbNodes);
192
193 Ptr<RandomBoxPositionAllocator> randomUePositionAlloc =
196 xVal->SetAttribute("Min", DoubleValue(macroUeBox.xMin));
197 xVal->SetAttribute("Max", DoubleValue(macroUeBox.xMax));
198 randomUePositionAlloc->SetAttribute("X", PointerValue(xVal));
200 yVal->SetAttribute("Min", DoubleValue(macroUeBox.yMin));
201 yVal->SetAttribute("Max", DoubleValue(macroUeBox.yMax));
202 randomUePositionAlloc->SetAttribute("Y", PointerValue(yVal));
204 zVal->SetAttribute("Min", DoubleValue(macroUeBox.zMin));
205 zVal->SetAttribute("Max", DoubleValue(macroUeBox.zMax));
206 randomUePositionAlloc->SetAttribute("Z", PointerValue(zVal));
207 mobility.SetPositionAllocator(randomUePositionAlloc);
208 mobility.Install(randomUeNodes);
209
210 // Create Devices and install them in the Nodes (eNB and UE)
211 NetDeviceContainer enbDevs;
212 NetDeviceContainer randomUeDevs;
213 lteHelper->SetSchedulerType("ns3::PfFfMacScheduler");
214 lteHelper->SetSchedulerAttribute("HarqEnabled", BooleanValue(true));
215
216 lteHelper->SetEnbDeviceAttribute("DlBandwidth", UintegerValue(bandwidth));
217 lteHelper->SetEnbDeviceAttribute("UlBandwidth", UintegerValue(bandwidth));
218
219 lteHelper->SetFfrAlgorithmType("ns3::LteFfrDistributedAlgorithm");
220 lteHelper->SetFfrAlgorithmAttribute("CalculationInterval", TimeValue(MilliSeconds(200)));
221 lteHelper->SetFfrAlgorithmAttribute("RsrpDifferenceThreshold", UintegerValue(5));
222 lteHelper->SetFfrAlgorithmAttribute("RsrqThreshold", UintegerValue(25));
223 lteHelper->SetFfrAlgorithmAttribute("EdgeRbNum", UintegerValue(6));
224 lteHelper->SetFfrAlgorithmAttribute("CenterPowerOffset",
226 lteHelper->SetFfrAlgorithmAttribute("EdgePowerOffset",
228
229 lteHelper->SetFfrAlgorithmAttribute("CenterAreaTpc", UintegerValue(0));
230 lteHelper->SetFfrAlgorithmAttribute("EdgeAreaTpc", UintegerValue(3));
231
232 // ns3::LteFfrDistributedAlgorithm works with Absolute Mode Uplink Power Control
233 Config::SetDefault("ns3::LteUePowerControl::AccumulationEnabled", BooleanValue(false));
234
235 enbDevs = lteHelper->InstallEnbDevice(enbNodes);
236 randomUeDevs = lteHelper->InstallUeDevice(randomUeNodes);
237
238 // Add X2 interface
239 lteHelper->AddX2Interface(enbNodes);
240
241 NodeContainer ueNodes;
242 ueNodes.Add(randomUeNodes);
243 NetDeviceContainer ueDevs;
244 ueDevs.Add(randomUeDevs);
245
246 // Install the IP stack on the UEs
247 internet.Install(ueNodes);
248 Ipv4InterfaceContainer ueIpIfaces;
249 ueIpIfaces = epcHelper->AssignUeIpv4Address(NetDeviceContainer(ueDevs));
250
251 // Attach a UE to a eNB
252 lteHelper->AttachToClosestEnb(ueDevs, enbDevs);
253
254 // Install and start applications on UEs and remote host
255 uint16_t dlPort = 10000;
256 uint16_t ulPort = 20000;
257
258 // randomize a bit start times to avoid simulation artifacts
259 // (e.g., buffer overflows due to packet transmissions happening
260 // exactly at the same time)
262 startTimeSeconds->SetAttribute("Min", DoubleValue(0));
263 startTimeSeconds->SetAttribute("Max", DoubleValue(0.010));
264
265 for (uint32_t u = 0; u < ueNodes.GetN(); ++u)
266 {
267 Ptr<Node> ue = ueNodes.Get(u);
268 // Set the default gateway for the UE
269 Ptr<Ipv4StaticRouting> ueStaticRouting =
270 ipv4RoutingHelper.GetStaticRouting(ue->GetObject<Ipv4>());
271 ueStaticRouting->SetDefaultRoute(epcHelper->GetUeDefaultGatewayAddress(), 1);
272
273 for (uint32_t b = 0; b < 1; ++b)
274 {
275 ++dlPort;
276 ++ulPort;
277
280
281 UdpClientHelper dlClientHelper(ueIpIfaces.GetAddress(u), dlPort);
282 dlClientHelper.SetAttribute("MaxPackets", UintegerValue(1000000));
283 dlClientHelper.SetAttribute("Interval", TimeValue(MilliSeconds(1.0)));
284 clientApps.Add(dlClientHelper.Install(remoteHost));
285 PacketSinkHelper dlPacketSinkHelper("ns3::UdpSocketFactory",
287 serverApps.Add(dlPacketSinkHelper.Install(ue));
288
289 UdpClientHelper ulClientHelper(remoteHostAddr, ulPort);
290 ulClientHelper.SetAttribute("MaxPackets", UintegerValue(1000000));
291 ulClientHelper.SetAttribute("Interval", TimeValue(MilliSeconds(1.0)));
292 clientApps.Add(ulClientHelper.Install(ue));
293 PacketSinkHelper ulPacketSinkHelper("ns3::UdpSocketFactory",
295 serverApps.Add(ulPacketSinkHelper.Install(remoteHost));
296
299 dlpf.localPortStart = dlPort;
300 dlpf.localPortEnd = dlPort;
301 tft->Add(dlpf);
303 ulpf.remotePortStart = ulPort;
304 ulpf.remotePortEnd = ulPort;
305 tft->Add(ulpf);
307 lteHelper->ActivateDedicatedEpsBearer(ueDevs.Get(u), bearer, tft);
308
309 Time startTime = Seconds(startTimeSeconds->GetValue());
310 serverApps.Start(startTime);
311 clientApps.Start(startTime);
312 }
313 }
314
315 // Spectrum analyzer
316 NodeContainer spectrumAnalyzerNodes;
317 spectrumAnalyzerNodes.Create(1);
318 SpectrumAnalyzerHelper spectrumAnalyzerHelper;
319
320 if (generateSpectrumTrace)
321 {
323 // position of Spectrum Analyzer
324 positionAlloc->Add(Vector(0.0, 0.0, 0.0)); // eNB1
325 // positionAlloc->Add (Vector (distance, 0.0, 0.0)); // eNB2
326 // positionAlloc->Add (Vector (distance*0.5, distance*0.866, 0.0)); // eNB3
327
329 mobility.SetMobilityModel("ns3::ConstantPositionMobilityModel");
330 mobility.SetPositionAllocator(positionAlloc);
331 mobility.Install(spectrumAnalyzerNodes);
332
333 Ptr<LteSpectrumPhy> enbDlSpectrumPhy = enbDevs.Get(0)
334 ->GetObject<LteEnbNetDevice>()
335 ->GetPhy()
336 ->GetDownlinkSpectrumPhy()
338 Ptr<SpectrumChannel> dlChannel = enbDlSpectrumPhy->GetChannel();
339
340 spectrumAnalyzerHelper.SetChannel(dlChannel);
342 spectrumAnalyzerHelper.SetRxSpectrumModel(sm);
343 spectrumAnalyzerHelper.SetPhyAttribute("Resolution", TimeValue(MicroSeconds(10)));
344 spectrumAnalyzerHelper.SetPhyAttribute("NoisePowerSpectralDensity",
345 DoubleValue(1e-15)); // -120 dBm/Hz
346 spectrumAnalyzerHelper.EnableAsciiAll("spectrum-analyzer-output");
347 spectrumAnalyzerHelper.Install(spectrumAnalyzerNodes);
348 }
349
351 if (generateRem)
352 {
355
357 Ptr<LteSpectrumPhy> enbDlSpectrumPhy = enbDevs.Get(0)
358 ->GetObject<LteEnbNetDevice>()
359 ->GetPhy()
360 ->GetDownlinkSpectrumPhy()
362 Ptr<SpectrumChannel> dlChannel = enbDlSpectrumPhy->GetChannel();
363 uint32_t dlChannelId = dlChannel->GetId();
364 NS_LOG_INFO("DL ChannelId: " << dlChannelId);
365 remHelper->SetAttribute("Channel", PointerValue(dlChannel));
366 remHelper->SetAttribute("OutputFile", StringValue("lena-distributed-ffr.rem"));
367 remHelper->SetAttribute("XMin", DoubleValue(macroUeBox.xMin));
368 remHelper->SetAttribute("XMax", DoubleValue(macroUeBox.xMax));
369 remHelper->SetAttribute("YMin", DoubleValue(macroUeBox.yMin));
370 remHelper->SetAttribute("YMax", DoubleValue(macroUeBox.yMax));
371 remHelper->SetAttribute("Z", DoubleValue(1.5));
372 remHelper->SetAttribute("XRes", UintegerValue(500));
373 remHelper->SetAttribute("YRes", UintegerValue(500));
374
375 if (remRbId >= 0)
376 {
377 remHelper->SetAttribute("UseDataChannel", BooleanValue(true));
378 remHelper->SetAttribute("RbId", IntegerValue(remRbId));
379 }
380
381 remHelper->Install();
382 // simulation will stop right after the REM has been generated
383 }
384 else
385 {
386 Simulator::Stop(Seconds(simTime));
387 }
388
391 return 0;
392}
holds a vector of ns3::Application pointers.
AttributeValue implementation for Boolean.
Definition boolean.h:26
a 3d box
Definition box.h:24
double yMax
The y coordinate of the top bound of the box.
Definition box.h:105
double xMin
The x coordinate of the left bound of the box.
Definition box.h:99
double yMin
The y coordinate of the bottom bound of the box.
Definition box.h:103
double xMax
The x coordinate of the right bound of the box.
Definition box.h:101
double zMin
The z coordinate of the down bound of the box.
Definition box.h:107
double zMax
The z coordinate of the up bound of the box.
Definition box.h:109
Parse command-line arguments.
Class for representing data rates.
Definition data-rate.h:78
AttributeValue implementation for DataRate.
Definition data-rate.h:285
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition double.h:31
This class contains the specification of EPS Bearers.
Definition eps-bearer.h:80
@ NGBR_VIDEO_TCP_DEFAULT
Non-GBR TCP-based Video (Buffered Streaming, e.g., www, e-mail...)
Definition eps-bearer.h:115
an Inet address class
Hold a signed integer type.
Definition integer.h:34
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.
static Ipv4Address GetAny()
Access to the IPv4 forwarding table, interfaces, and configuration.
Definition ipv4.h:69
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
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.
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.
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.
static Iterator Begin()
Definition node-list.cc:226
static Iterator End()
Definition node-list.cc:233
Ptr< T > GetObject() const
Get a pointer to the requested aggregated Object.
Definition object.h:511
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)
AttributeValue implementation for Pointer.
Smart pointer class similar to boost::intrusive_ptr.
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:131
static void Run()
Run the simulation.
Definition simulator.cc:167
static void Stop()
Tell the Simulator the calling event should be the last one executed.
Definition simulator.cc:175
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:45
Simulation virtual time values and global simulation resolution.
Definition nstime.h:94
AttributeValue implementation for Time.
Definition nstime.h:1395
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:34
void SetDefault(std::string name, const AttributeValue &value)
Definition config.cc:883
#define NS_LOG_ERROR(msg)
Use NS_LOG to output a message of level LOG_ERROR.
Definition log.h:243
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition log.h:191
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition log.h:264
Ptr< T > CreateObject(Args &&... args)
Create an object by type, with varying number of constructor parameters.
Definition object.h:619
Ptr< T > Create(Ts &&... args)
Create class instances by constructors with varying numbers of arguments and return them by Ptr.
Definition ptr.h:436
Time MicroSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition nstime.h:1332
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition nstime.h:1308
Time MilliSeconds(uint64_t value)
Construct a Time in the indicated unit.
Definition nstime.h:1320
void PrintGnuplottableEnbListToFile(std::string filename)
void PrintGnuplottableUeListToFile(std::string filename)
serverApps
Definition first.py:43
clientApps
Definition first.py:53
Every class exported by the ns3 library is enclosed in the ns3 namespace.
mobility
Definition third.py:92
Implement the data structure representing a TrafficFlowTemplate Packet Filter.
Definition epc-tft.h:60
uint16_t localPortEnd
end of the port number range of the UE
Definition epc-tft.h:121
uint16_t remotePortEnd
end of the port number range of the remote host
Definition epc-tft.h:119
uint16_t remotePortStart
start of the port number range of the remote host
Definition epc-tft.h:118
uint16_t localPortStart
start of the port number range of the UE
Definition epc-tft.h:120