How to Calculate Network Carrier to Interference Ratio in ns3

To calculate the network carrier to interference ratio (CIR) in ns3 needs to calculate the ratio of the received carrier signal power to the interference power and this is critical for simulating the quality of the communication link in a network.

Here is the procedure on how to implement the CIR in ns3:

Step-by-Step Guide to Calculate Network CIR in ns3

1. Set Up the Simulation Environment:
   • Download and configure ns3 in the computer.
   • Include necessary modules for your simulation (e.g., LTE, Internet, Mobility).
2. Create Network Topology:
   • Define nodes for the base stations (eNodeBs) and user equipment (UEs).
   • Set up the wireless 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 received signal power and interference power.
5. Run the Simulation:
   • Execute the simulation and collect the trace data.
6. Analyze the Results:
   • Post-process the trace data to calculate and log the CIR values.

Example Code Snippet for LTE Network

Here is a sample snippet to set up an LTE network, generate traffic, and capture CIR values in ns-3:

#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/config-store.h”

using namespace ns3;

 

NS_LOG_COMPONENT_DEFINE (“LteCIRExample”);

// Function to calculate and log CIR

void CalculateCIR (Ptr<LtePhy> phy, Ptr<OutputStreamWrapper> stream)

{

double signalPower = phy->GetCurrentTxPower (); // Current transmission power

double interferencePower = phy->GetInterferencePower (); // Get the interference power

double cir = signalPower / interferencePower;

*stream->GetStream () << Simulator::Now ().GetSeconds () << “\t” << signalPower << “\t” << interferencePower << “\t” << cir << std::endl;

// Schedule the function to run again

Simulator::Schedule (Seconds (1.0), &CalculateCIR, phy, stream);

}

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 (10);

enbNodes.Create (3);

// Install Mobility model

MobilityHelper mobility;

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

mobility.Install (enbNodes);

mobility.SetPositionAllocator (“ns3::GridPositionAllocator”,

“MinX”, DoubleValue (0.0),

“MinY”, DoubleValue (0.0),

“DeltaX”, DoubleValue (50.0),

“DeltaY”, DoubleValue (50.0),

“GridWidth”, UintegerValue (3),

“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));

// Create output stream for logging CIR

AsciiTraceHelper ascii;

Ptr<OutputStreamWrapper> stream = ascii.CreateFileStream (“cir-trace.txt”);

*stream->GetStream () << “Time(s)\tSignalPower(dBm)\tInterferencePower(dBm)\tCIR\n”;

// Connect to trace sources

Ptr<LteEnbPhy> enbPhy = enbLteDevs.Get (0)->GetObject<LteEnbNetDevice> ()->GetPhy ()->GetObject<LteEnbPhy> ();

Simulator::Schedule (Seconds (1.0), &CalculateCIR, enbPhy, stream);

// Run the simulation

Simulator::Stop (Seconds (11.0));

Simulator::Run ();

// 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. Connect to Trace Sources:
   • Create an output stream for logging CIR values.
   • Connect to the trace source for calculating CIR.
8. Run Simulation:
   • Run the simulation for the specified duration.
9. Calculate and Log CIR:
   • The CalculateCIR function calculates the CIR periodically during the simulation.
   • The CIR is calculated as the ratio of the signal power to the interference power.

CIR=Signal PowerInterference Power\text{CIR} = \frac{\text{Signal Power}}{\text{Interference Power}}CIR=Interference PowerSignal Power​

Analysing the Results:

• CIR:
  • The CIR values for each eNodeB are logged along with the simulation time, signal power, and interference power.
  • These metrics provide an indication of the signal quality and interference levels in the network.

Network carriers to interference ratio is to capture applicable metrics for instance received signal power and interference power and gather the data and executed by ns3 simulation. We can provide the more information regarding to CIR.

By analysing your parameters we share valuable suggestions on Network Carrier to Interference Ratio (CIR) get in touch with us.