How to Calculate Network Sum rate at each cell Level in Ns3

To calculate the network sum rate at each cell level in ns3, by measuring the total data rate in each cell which is achieved by all user equipment (UE). The sum rate can be calculated by summing the throughput of all UEs in a cell which is mainly useful for cellular networks such as LTE and 5G.

The following steps will guide on how to calculate the network sum rate at each cell level in ns3.

Step-by-Step Guide to Calculate Network Sum Rate at Each Cell Level in ns3

1. Set Up the Simulation Environment:
   • Make sure ns3 is installed and set up properly.
   • Include necessary modules for the simulation (e.g., LTE, EPC, Internet).
2. Create Network Topology:
   • Define nodes for the eNodeBs (base stations) and UEs.
   • Set up the cellular network with appropriate configurations.
3. Configure Applications:
   • Install traffic generating applications (e.g., UDP, TCP) on the UEs.
4. Enable Tracing and Metrics Collection:
   • Enable tracing to capture relevant metrics such as throughput for each UE.
5. Run the Simulation:
   • Execute the simulation and collect the trace data.
6. Analyze the Results:
   • Post-process the trace data to calculate the sum rate for each cell.

Example Code Snippet

Here’s a simple example of how to set up an LTE network, generate traffic, and calculate the sum rate for each cell:

#include “ns3/core-module.h”

#include “ns3/network-module.h”

#include “ns3/internet-module.h”

#include “ns3/point-to-point-module.h”

#include “ns3/applications-module.h”

#include “ns3/lte-module.h”

#include “ns3/epc-helper.h”

#include “ns3/mobility-module.h”

#include “ns3/flow-monitor-module.h”

using namespace ns3;

NS_LOG_COMPONENT_DEFINE (“LteSumRateExample”);

int main (int argc, char *argv[])

{

// Set up logging

LogComponentEnable (“UdpClient”, LOG_LEVEL_INFO);

LogComponentEnable (“UdpServer”, LOG_LEVEL_INFO);

// Create LTE network nodes

NodeContainer ueNodes;

NodeContainer enbNodes;

ueNodes.Create (4);

enbNodes.Create (2);

// Install Mobility model

MobilityHelper mobility;

mobility.SetMobilityModel (“ns3::ConstantPositionMobilityModel”);

mobility.Install (enbNodes);

mobility.SetPositionAllocator (“ns3::GridPositionAllocator”,

“MinX”, DoubleValue (10.0),

“MinY”, DoubleValue (10.0),

“DeltaX”, DoubleValue (20.0),

“DeltaY”, DoubleValue (20.0),

“GridWidth”, UintegerValue (2),

“LayoutType”, StringValue (“RowFirst”));

mobility.Install (ueNodes);

// Create LTE helper and EPC helper

Ptr<LteHelper> lteHelper = CreateObject<LteHelper> ();

Ptr<PointToPointEpcHelper> epcHelper = CreateObject<PointToPointEpcHelper> ();

lteHelper->SetEpcHelper (epcHelper);

// Install LTE devices to the nodes

NetDeviceContainer enbLteDevs = lteHelper->InstallEnbDevice (enbNodes);

NetDeviceContainer ueLteDevs = lteHelper->InstallUeDevice (ueNodes);

// Install Internet stack on UEs

InternetStackHelper internet;

internet.Install (ueNodes);

// Assign IP addresses to UEs

Ipv4InterfaceContainer ueIpIface;

ueIpIface = epcHelper->AssignUeIpv4Address (NetDeviceContainer (ueLteDevs));

// Attach UEs to eNodeBs

for (uint32_t i = 0; i < ueNodes.GetN (); ++i)

{

lteHelper->Attach (ueLteDevs.Get (i), enbLteDevs.Get (i % enbNodes.GetN ()));

}

// Install and start applications on UEs and remote host

uint16_t dlPort = 1234;

ApplicationContainer clientApps;

ApplicationContainer serverApps;

for (uint32_t i = 0; i < ueNodes.GetN (); ++i)

{

UdpServerHelper myServer (dlPort);

serverApps.Add (myServer.Install (ueNodes.Get (i)));

UdpClientHelper myClient (ueIpIface.GetAddress (i), dlPort);

myClient.SetAttribute (“MaxPackets”, UintegerValue (1000));

myClient.SetAttribute (“Interval”, TimeValue (MilliSeconds (100)));

myClient.SetAttribute (“PacketSize”, UintegerValue (1024));

clientApps.Add (myClient.Install (ueNodes.Get (i)));

}

serverApps.Start (Seconds (1.0));

serverApps.Stop (Seconds (10.0));

clientApps.Start (Seconds (2.0));

clientApps.Stop (Seconds (10.0));

// Set up FlowMonitor to collect performance metrics

FlowMonitorHelper flowmon;

Ptr<FlowMonitor> monitor = flowmon.InstallAll ();

// Run the simulation

Simulator::Stop (Seconds (11.0));

Simulator::Run ();

// Calculate sum rate for each eNodeB

monitor->CheckForLostPackets ();

Ptr<Ipv4FlowClassifier>classifier=DynamicCast<Ipv4FlowClassifier> (flowmon.GetClassifier ());

std::map<FlowId, FlowMonitor::FlowStats> stats = monitor->GetFlowStats ();

std::map<uint64_t, double> sumRatePerCell; // key: cellId, value: sumRate

for (std::map<FlowId, FlowMonitor::FlowStats>::const_iterator i = stats.begin (); i != stats.end (); ++i)

{

Ipv4FlowClassifier::FiveTuple t = classifier->FindFlow (i->first);

uint64_t cellId = t.sourceAddress.Get() % enbNodes.GetN(); // Assuming sourceAddress helps determine cell

double throughput = i->second.rxBytes * 8.0 /

(i->second.timeLastRxPacket.GetSeconds()-i->second.timeFirstTxPacket.GetSeconds ()) / 1000 / 1000;

sumRatePerCell[cellId] += throughput;

}

for (auto const &cell : sumRatePerCell)

{

NS_LOG_UNCOND (“Cell ” << cell.first << ” Sum Rate: ” << cell.second << ” Mbps”);

}

// Clean up

Simulator::Destroy ();

return 0;

}

Explanation:

1. Setup Logging:
   • Enable logging for the UDP applications to track their activities.
2. Create Nodes and Network:
   • Create nodes representing UEs and eNodeBs.
   • Configure mobility models for UEs and eNodeBs.
3. Install LTE and EPC Helper:
   • Create and configure LTE and EPC helpers.
   • Install LTE devices on the UEs and eNodeBs.
4. Install Internet Stack:
   • Install the Internet stack on UEs.
   • Assign IP addresses to the UEs.
5. Attach UEs to eNodeBs:
   • Attach each UE to an eNodeB. Here, a round-robin attachment is used for simplicity.
6. Install Applications:
   • Install UDP server applications on the UEs.
   • Install UDP client applications on the UEs, sending traffic to the server.
7. Flow Monitor:
   • Set up a FlowMonitor to collect and analyze flow statistics.
8. Run Simulation:
   • Run the simulation for the specified duration.
9. Calculate Sum Rate:
   • After the simulation, extract the flow statistics.
   • Calculate the throughput for each flow and sum the throughput for each cell.

Analyzing the Results:

• Sum Rate:
  • The sum rate for each cell is calculated by summing the throughput of all UEs connected to the respective eNodeB.
  • The throughput is calculated using the received bytes over time.

The above steps clearly explained that the sum rate can be calculated by calculating and summing the throughput for each flow and each cell using the received bytes.

For your project, we conduct a comparative analysis at the cell level in NS3 to calculate the network sum rate. This includes providing practical explanations of how the network operates.