ns-3

https://www.nsnam.org/docs/release/3.38/doxygen/
Admin
ns-3 is a discrete-event network simulator used for research and education in computer networking,...
Tokens:19,741,675
Snippets:99,551
Trust Score:9.6
Update:1 year ago
Show doc for...
Tokens:
Raw
### Node and Network Stack Setup in ns-3

Source: https://www.nsnam.org/docs/release/3.38/doxygen/dc/d21/tcp-star-server_8cc_source

This snippet demonstrates the initial setup of nodes and the installation of the internet stack in an ns-3 simulation. It involves creating server and client nodes, grouping them, and then installing the necessary network protocols.

```c++
83 serverNode.Create(1);
84 clientNodes.Create(N - 1);
85 NodeContainer allNodes = NodeContainer(serverNode, clientNodes);
86
87 // Install network stacks on the nodes
88 InternetStackHelper internet;
89 internet.Install(allNodes);
```

--------------------------------

### ns-3 Python - Third Tutorial Example Configuration

Source: https://www.nsnam.org/docs/release/3.38/doxygen/d4/da7/third_8py

Configuration variables for the 'third.py' ns-3 tutorial example. This includes network setup, application installation, and simulation parameters.

```python
ns = third.address = ns.internet.Ipv4AddressHelper()
ns = third.apDevices = wifi.Install(phy, mac, wifiApNode)
ns = third.channel = ns.wifi.YansWifiChannelHelper.Default()
ns = third.clientApps = echoClient.Install(wifiStaNodes.Get (nWifi.value - 1))
ns = third.cmd = ns.CommandLine(__file__)
ns = third.csma = ns.csma.CsmaHelper()
ns = third.csmaDevices = csma.Install(csmaNodes)
ns = third.csmaInterfaces = address.Assign(csmaDevices)
ns = third.csmaNodes = ns.network.NodeContainer()
ns = third.echoClient = ns.applications.UdpEchoClientHelper(csmaInterfaces.GetAddress(nCsma.value).ConvertTo(), 9)
ns = third.echoServer = ns.applications.UdpEchoServerHelper(9)
ns = third.mac = ns.wifi.WifiMacHelper()
ns = third.mobility = ns.mobility.MobilityHelper()
c_int = third.nCsma = c_int(3)
c_int = third.nWifi = c_int(3)
ns = third.p2pDevices = pointToPoint.Install(p2pNodes)
ns = third.p2pInterfaces = address.Assign(p2pDevices)
ns = third.p2pNodes = ns.network.NodeContainer()
ns = third.phy = ns.wifi.YansWifiPhyHelper()
ns = third.pointToPoint = ns.point_to_point.PointToPointHelper()
ns = third.serverApps = echoServer.Install(csmaNodes.Get(nCsma.value))
ns = third.ssid = ns.wifi.Ssid ("ns-3-ssid")
ns = third.stack = ns.internet.InternetStackHelper()
ns = third.staDevices = wifi.Install(phy, mac, wifiStaNodes)
c_bool = third.tracing = c_bool(False)
c_bool = third.verbose = c_bool(True)
ns = third.wifi = ns.wifi.WifiHelper()
ns = third.wifiApNode = p2pNodes.Get(0)
ns = third.wifiStaNodes = ns.network.NodeContainer()
```

--------------------------------

### Install Application and Start Simulation (Python)

Source: https://www.nsnam.org/docs/release/3.38/doxygen/d1/da9/csma-bridge_8py_source

Installs a sink application on a specified node and starts its execution at time 0.0. This is a foundational step for network simulations in ns-3.

```python
app = sink.Install(ns.network.NodeContainer(terminals.Get(0)))
app.Start(ns.core.Seconds(0.0))
```

--------------------------------

### Install Network Applications - C++

Source: https://www.nsnam.org/docs/release/3.38/doxygen/d0/d24/class_dsdv_manet_example

Installs the necessary applications on the created nodes, including data sources and sinks. It configures OnOff applications for data transmission and sets their attributes like start time and total time. Relies on ns3::OnOffHelper and ns3::ApplicationContainer.

```cpp
void DsdvManetExample::InstallApplications()
{
    // ... application installation logic ...
    ns3::OnOffHelper onOff("ns3::UdpSocketFactory", InetSocketAddress(Ipv4Address::GetAny(), port));
    onOff.SetAttribute("PacketInterval", ns3::TimeValue(ns3::Seconds(1.0 / _rate)));
    onOff.SetAttribute("PacketSize", UintegerValue(packetSize));
    ns3::ApplicationContainer apps = onOff.Install(nodes.Get(i));
    apps.Start(ns3::Seconds(m_dataStart));
    apps.Stop(ns3::Seconds(m_totalTime));
    // ... sink setup ...
}
```

--------------------------------

### Install and Start Applications in ns-3

Source: https://www.nsnam.org/docs/release/3.38/doxygen/d2/d6c/wifi-tcp_8cc_source

Installs server applications on specified Wi-Fi nodes and starts them at defined simulation times. It also schedules a callback function to calculate throughput.

```cpp
ApplicationContainer serverApp = server.Install(staWifiNode);

/* Start Applications */
sinkApp.Start(Seconds(0.0));
serverApp.Start(Seconds(1.0));
Simulator::Schedule(Seconds(1.1), &CalculateThroughput);
```

--------------------------------

### Main Function Setup in C++

Source: https://www.nsnam.org/docs/release/3.38/doxygen/da/d91/virtual-net-device-example_8cc_source

Sets up the ns-3 simulation environment, including enabling packet printing, setting default packet size and data rate for OnOff applications, and parsing command-line arguments. It then creates the necessary nodes for the simulation.

```cpp
int
main(int argc, char* argv[])
{
  // Users may find it convenient to turn on explicit logging
  // for selected modules; the below lines suggest how to do this
#if 0
  LogComponentEnable ("VirtualNetDeviceExample", LOG_LEVEL_INFO);
#endif
  Packet::EnablePrinting();

  // Set up some default values for the simulation. Use the
  Config::SetDefault("ns3::OnOffApplication::PacketSize", UintegerValue(210));
  Config::SetDefault("ns3::OnOffApplication::DataRate", StringValue("448kb/s"));

  // Allow the user to override any of the defaults and the above
  // Config::SetDefault ()s at run-time, via command-line arguments
  CommandLine cmd(__FILE__);
  cmd.Parse(argc, argv);

  NS_LOG_INFO("Create nodes.");
  NodeContainer c;
  c.Create(4);

```

--------------------------------

### Setup OnOff Application in ns-3

Source: https://www.nsnam.org/docs/release/3.38/doxygen/d4/d43/nsclick-raw-wlan_8cc_source

Configures an OnOff application to send TCP data. It sets the on and off times for data transmission, specifies the remote address and port, and then installs and starts the application.

```cpp
OnOffHelper onOffHelper("ns3::TcpSocketFactory", Address());
onOffHelper.SetAttribute("OnTime", StringValue("ns3::ConstantRandomVariable[Constant=1]"));
onOffHelper.SetAttribute("OffTime", StringValue("ns3::ConstantRandomVariable[Constant=0]"));

ApplicationContainer appcont;

AddressValue remoteAddress(InetSocketAddress(Ipv4Address("172.16.1.2"), 50000));
onOffHelper.SetAttribute("Remote", remoteAddress);
appcont.Add(onOffHelper.Install(wifiNodes.Get(0)));

appcont.Start(Seconds(5.0));
appcont.Stop(Seconds(10.0));
```

--------------------------------

### Setup ns-3 Packet Sink Application

Source: https://www.nsnam.org/docs/release/3.38/doxygen/d6/d80/nms-p2p-nix-distributed_8cc_source

Configures and installs a UDP packet sink on a node. It binds to any address on a specified port and starts receiving packets. It also includes optional tracing for received packets.

```cpp
PacketSinkHelper sinkHelper("ns3::UdpSocketFactory",
InetSocketAddress(Ipv4Address::GetAny(), 9999));

ApplicationContainer sinkApp =
sinkHelper.Install(nodes_net3LAN[z][i][j].Get(0));
sinkApp.Start(Seconds(0.0));
if (testing)
{
sinkApp.Get(0)->TraceConnectWithoutContext(
"RxWithAddresses",
MakeCallback(&SinkTracer::SinkTrace));
}
```

--------------------------------

### Python Examples Configuration (examples-to-run.py)

Source: https://www.nsnam.org/docs/release/3.38/doxygen/d7/d16/src_2brite_2test_2examples-to-run_8py_source

This Python script defines lists of C++ and Python examples to be run for testing. It specifies whether each example should be run and, for C++ examples, whether it should be run with Valgrind. This ensures the examples remain buildable and runnable.

```python
#! /usr/bin/env python3


# A list of C++ examples to run in order to ensure that they remain
# buildable and runnable over time. Each tuple in the list contains
#
# (example_name, do_run, do_valgrind_run).
#
# See test.py for more information.
cpp_examples = [
 ("brite-generic-example", "ENABLE_BRITE == True", "False"),
]

# A list of Python examples to run in order to ensure that they remain
# runnable over time. Each tuple in the list contains
#
# (example_name, do_run).
#
# See test.py for more information.
python_examples = []
```

--------------------------------

### Main Simulation Setup - ns3

Source: https://www.nsnam.org/docs/release/3.38/doxygen/d1/d7b/examples_2tcp_2tcp-linux-reno_8cc_source

The main function sets up the simulation environment, parses command-line arguments for TCP and queue disc types, and configures network parameters. It creates nodes, installs internet stacks, assigns IP addresses, and populates routing tables.

```cpp
int
124main(int argc, char* argv[])
125{
126 uint32_t stream = 1;
127 std::string socketFactory = "ns3::TcpSocketFactory";
128 std::string tcpTypeId = "ns3::TcpLinuxReno";
129 std::string qdiscTypeId = "ns3::FifoQueueDisc";
130 bool isSack = true;
131 uint32_t delAckCount = 1;
132 std::string recovery = "ns3::TcpClassicRecovery";
133
134 CommandLine cmd;
135 cmd.AddValue("tcpTypeId",
136 "TCP variant to use (e.g., ns3::TcpNewReno, ns3::TcpLinuxReno, etc.)",
137 tcpTypeId);
138 cmd.AddValue("qdiscTypeId", "Queue disc for gateway (e.g., ns3::CoDelQueueDisc)", qdiscTypeId);
139 cmd.AddValue("segmentSize", "TCP segment size (bytes)", segmentSize);
140 cmd.AddValue("delAckCount", "Delayed ack count", delAckCount);
141 cmd.AddValue("enableSack", "Flag to enable/disable sack in TCP", isSack);
142 cmd.AddValue("stopTime",
143 "Stop time for applications / simulation time will be stopTime",
144 stopTime);
145 cmd.AddValue("recovery", "Recovery algorithm type to use (e.g., ns3::TcpPrrRecovery", recovery);
146 cmd.Parse(argc, argv);
147
148 TypeId qdTid;
149 NS_ABORT_MSG_UNLESS(TypeId::LookupByNameFailSafe(qdiscTypeId, &qdTid),
150 "TypeId " << qdiscTypeId << " not found");
151
152 // Set recovery algorithm and TCP variant
153 Config::SetDefault("ns3::TcpL4Protocol::RecoveryType",
154 TypeIdValue(TypeId::LookupByName(recovery)));
155 TypeId tcpTid;
156 NS_ABORT_MSG_UNLESS(TypeId::LookupByNameFailSafe(tcpTypeId, &tcpTid),
157 "TypeId " << tcpTypeId << " not found");
158 Config::SetDefault("ns3::TcpL4Protocol::SocketType",
159 TypeIdValue(TypeId::LookupByName(tcpTypeId)));
160
161 // Create nodes
162 NodeContainer leftNodes;
163 NodeContainer rightNodes;
164 NodeContainer routers;
165 routers.Create(2);
166 leftNodes.Create(1);
167 rightNodes.Create(1);
168
169 std::vector<NetDeviceContainer> leftToRouter;
170 std::vector<NetDeviceContainer> routerToRight;
171
172 // Create the point-to-point link helpers and connect two router nodes
173 PointToPointHelper pointToPointRouter;
174 pointToPointRouter.SetDeviceAttribute("DataRate", StringValue("1Mbps"));
175 pointToPointRouter.SetChannelAttribute("Delay", StringValue("10ms"));
176 NetDeviceContainer r1r2ND = pointToPointRouter.Install(routers.Get(0), routers.Get(1));
177
178 // Create the point-to-point link helpers and connect leaf nodes to router
179 PointToPointHelper pointToPointLeaf;
180 pointToPointLeaf.SetDeviceAttribute("DataRate", StringValue("10Mbps"));
181 pointToPointLeaf.SetChannelAttribute("Delay", StringValue("1ms"));
182 leftToRouter.push_back(pointToPointLeaf.Install(leftNodes.Get(0), routers.Get(0)));
183 routerToRight.push_back(pointToPointLeaf.Install(routers.Get(1), rightNodes.Get(0)));
184
185 InternetStackHelper internetStack;
186
187 internetStack.Install(leftNodes);
188 internetStack.Install(rightNodes);
189 internetStack.Install(routers);
190
191 // Assign IP addresses to all the network devices
192 Ipv4AddressHelper ipAddresses("10.0.0.0", "255.255.255.0");
193
194 Ipv4InterfaceContainer r1r2IPAddress = ipAddresses.Assign(r1r2ND);
195 ipAddresses.NewNetwork();
196
197 std::vector<Ipv4InterfaceContainer> leftToRouterIPAddress;
198 leftToRouterIPAddress.push_back(ipAddresses.Assign(leftToRouter[0]));
199 ipAddresses.NewNetwork();
200
201 std::vector<Ipv4InterfaceContainer> routerToRightIPAddress;
202 routerToRightIPAddress.push_back(ipAddresses.Assign(routerToRight[0]));
203
204 Ipv4GlobalRoutingHelper::PopulateRoutingTables();
205
206 // Set default sender and receiver buffer size as 1MB

```

--------------------------------

### Setup Packet Sink Application in ns-3

Source: https://www.nsnam.org/docs/release/3.38/doxygen/d4/d43/nsclick-raw-wlan_8cc_source

Configures a packet sink application to receive TCP traffic on a specific port. This involves creating a socket factory, installing the application on a node, and setting its start and stop times.

```cpp
Address LocalAddress(InetSocketAddress(Ipv4Address::GetAny(), 50000));
PacketSinkHelper packetSinkHelper("ns3::TcpSocketFactory", LocalAddress);
ApplicationContainer recvapp = packetSinkHelper.Install(wifiNodes.Get(1));
recvapp.Start(Seconds(5.0));
recvapp.Stop(Seconds(10.0));
```

--------------------------------

### Wi-Fi Simulation Setup with Command Line Parsing in C++

Source: https://www.nsnam.org/docs/release/3.38/doxygen/d0/d69/wifi-trans-example_8cc_source

This C++ code snippet demonstrates setting up a Wi-Fi simulation using `ns3`. It includes parsing command-line arguments to configure the Wi-Fi standard, bandwidth, transmit power, and verbosity. It then initializes `WifiHelper` and configures SSID, data rate, and frequency based on the chosen standard.

```cpp
#include "ns3/command-line.h"
#include "ns3/gnuplot.h"
#include "ns3/mobility-helper.h"
#include "ns3/spectrum-analyzer-helper.h"
#include "ns3/spectrum-channel.h"
#include "ns3/spectrum-helper.h"
#include "ns3/spectrum-wifi-helper.h"
#include "ns3/ssid.h"
#include "ns3/string.h"

using namespace ns3;

int
main(int argc, char** argv)
{
 std::string standard = "11a";
 int bw = 20;
 double pow = 23; // dBm
 bool verbose = false;
 CommandLine cmd(__FILE__);
 cmd.AddValue("standard",
 "OFDM-based Wi-Fi standard [11a, 11p_10MHZ, 11p_5MHZ, 11n_2_4GHZ, 11n_5GHZ, 11ac, "
 "11ax_2_4GHZ, 11ax_5GHZ]",
 standard);
 cmd.AddValue("bw", "Bandwidth (consistent with standard, in MHz)", bw);
 cmd.AddValue("txPower", "Transmit power (dBm)", pow);
 cmd.AddValue("verbose",
 "Display log messages for WifiSpectrumValueHelper and SpectrumWifiPhy",
 verbose);
 cmd.Parse(argc, argv);

 WifiHelper wifi;
 Ssid ssid;
 std::string dataRate;
 int freq;
 Time dataStartTime =
 MicroSeconds(800); // leaving enough time for beacon and association procedure
 Time dataDuration =
 MicroSeconds(300); // leaving enough time for data transfer (+ acknowledgment)
 if (standard == "11a")
 {
 wifi.SetStandard(WIFI_STANDARD_80211a);
 ssid = Ssid("ns380211a");
 dataRate = "OfdmRate6Mbps";
 freq = 5180;
 if (bw != 20)
 {
 // ... rest of the code
 }
 }
 // ... potentially more if/else if blocks for other standards
 return 0;
}

```

--------------------------------

### Install Internet Stack on Node in ns-3

Source: https://www.nsnam.org/docs/release/3.38/doxygen/dc/d71/fd-tap-ping_8cc_source

This example shows how to install the internet stack (IP, TCP, UDP) onto a node using the ns3::InternetStackHelper. This is a prerequisite for network communication.

```cpp
ns3::InternetStackHelper internetStack;
internetStack.Install(node);
```

--------------------------------

### Run ns-3 Simulation

Source: https://www.nsnam.org/docs/release/3.38/doxygen/d7/d40/mesh_8cc_source

Executes the ns-3 simulation. This method orchestrates the entire simulation process, including node creation, internet stack installation, application setup, scheduling a report, and managing the simulation's start and stop times.

```C++
int
MeshTest::Run()
{
  CreateNodes();
  InstallInternetStack();
  InstallApplication();
  Simulator::Schedule(Seconds(m_totalTime), &MeshTest::Report, this);
  Simulator::Stop(Seconds(m_totalTime + 2));
  Simulator::Run();
  Simulator::Destroy();
  std::cout << "UDP echo packets sent: " << g_udpTxCount << " received: " << g_udpRxCount
            << std::endl;
  return 0;
}

```

--------------------------------

### Setup and Run UDP Echo Applications

Source: https://www.nsnam.org/docs/release/3.38/doxygen/d5/d3a/lena-ipv6-addr-conf_8cc_source

This code installs and configures UDP echo server and client applications. It sets transmission parameters like packet size, interval, and duration, then starts and stops the applications at specified times.

```C++
// Install and start applications on UEs and remote host

UdpEchoServerHelper echoServer(9);

ApplicationContainer serverApps = echoServer.Install(remoteHost);

serverApps.Start(Seconds(4.0));
serverApps.Stop(Seconds(20.0));

UdpEchoClientHelper echoClient1(remoteHostAddr, 9);
UdpEchoClientHelper echoClient2(remoteHostAddr, 9);

echoClient1.SetAttribute("MaxPackets", UintegerValue(1000));
echoClient1.SetAttribute("Interval", TimeValue(Seconds(1.0)));
echoClient1.SetAttribute("PacketSize", UintegerValue(1024));

echoClient2.SetAttribute("MaxPackets", UintegerValue(1000));
echoClient2.SetAttribute("Interval", TimeValue(Seconds(1.0)));
echoClient2.SetAttribute("PacketSize", UintegerValue(1024));

ApplicationContainer clientApps1 = echoClient1.Install(ueNodes.Get(0));
ApplicationContainer clientApps2 = echoClient2.Install(ueNodes.Get(1));

clientApps1.Start(Seconds(4.0));
clientApps1.Stop(Seconds(14.0));

clientApps2.Start(Seconds(4.5));
clientApps2.Stop(Seconds(14.5));

LogComponentEnable("UdpEchoClientApplication", LOG_LEVEL_ALL);
LogComponentEnable("UdpEchoServerApplication", LOG_LEVEL_ALL);
```

--------------------------------

### StartApplication()

Source: https://www.nsnam.org/docs/release/3.38/doxygen/d4/dd2/classns3_1_1_bulk_send_application

Application-specific startup code. This method should be overridden by subclasses and is called at the start time specified by Start. It handles socket creation, binding, and connection setup.

```APIDOC
## StartApplication()

### Description
Application specific startup code. The StartApplication method is called at the start time specified by Start. This method should be overridden by all or most application subclasses.

### Method
`void StartApplication()`

### Endpoint
N/A (Class method)

### Parameters
None

### Request Example
```json
{}
```

### Response
#### Success Response (void)
N/A

#### Response Example
N/A
```

--------------------------------

### Setup and Install OnOff Application (C++)

Source: https://www.nsnam.org/docs/release/3.38/doxygen/de/df3/vanet-routing-compare_8cc_source

Sets up a UniformRandomVariable for randomizing application start times and then iterates to install an OnOff application on specified nodes. It configures the remote address and installs the application, controlling its start and stop times within the simulation.

```cpp
Ptr<UniformRandomVariable> var = CreateObject<UniformRandomVariable>();
int64_t stream = 2;
var->SetStream(stream);
for (uint32_t i = 0; i < m_nSinks; i++)
{
  if (m_protocol != 0)
  {
    Ptr<Socket> sink = SetupRoutingPacketReceive(adhocTxInterfaces.GetAddress(i), c.Get(i));
  }

  AddressValue remoteAddress(InetSocketAddress(adhocTxInterfaces.GetAddress(i), m_port));
  onoff1.SetAttribute("Remote", remoteAddress);

  ApplicationContainer temp = onoff1.Install(c.Get(i + m_nSinks));
  temp.Start(Seconds(var->GetValue(1.0, 2.0)));
  temp.Stop(Seconds(m_TotalSimTime));
}
```

--------------------------------

### ns-3 Tutorial Application Setup

Source: https://www.nsnam.org/docs/release/3.38/doxygen/d1/de6/tutorial-app_8cc_source

Configures a ns-3 tutorial application with necessary parameters such as the socket, destination address, packet size, number of packets, and data rate. This method prepares the application for execution.

```c++
void Setup(Ptr< Socket > socket, Address address, uint32_t packetSize, uint32_t nPackets, DataRate dataRate)
```

--------------------------------

### Command Line Argument Setup

Source: https://www.nsnam.org/docs/release/3.38/doxygen/de/d16/wifi-multirate_8cc_source

Parses command-line arguments to configure the experiment. This allows for flexible customization of simulation parameters without code modification.

```cpp
bool CommandSetup(int argc, char **argv)
```

--------------------------------

### Setup UDP OnOff and PacketSink Applications in ns-3

Source: https://www.nsnam.org/docs/release/3.38/doxygen/d9/d1c/static-routing-slash32_8cc_source

This snippet configures and installs UDP applications in ns-3. It sets up an `OnOffHelper` to send data at a constant rate and a `PacketSinkHelper` to receive the data on a specified port. Application start and stop times are also defined.

```c++
114 // Create the OnOff application to send UDP datagrams of size
115 // 210 bytes at a rate of 448 Kb/s
116 uint16_t port = 9; // Discard port (RFC 863)
117 OnOffHelper onoff("ns3::UdpSocketFactory",
118 Address(InetSocketAddress(ifInAddrC.GetLocal(), port)));
119 onoff.SetConstantRate(DataRate(6000));
120 ApplicationContainer apps = onoff.Install(nA);
121 apps.Start(Seconds(1.0));
122 apps.Stop(Seconds(10.0));

123 // Create a packet sink to receive these packets
124 PacketSinkHelper sink("ns3::UdpSocketFactory",
125 Address(InetSocketAddress(Ipv4Address::GetAny(), port)));
126 apps = sink.Install(nC);
127 apps.Start(Seconds(1.0));
128 apps.Stop(Seconds(10.0));
```

--------------------------------

### ns3::OnOffHelper Constructor and Installation

Source: https://www.nsnam.org/docs/release/3.38/doxygen/dd/da8/classns3_1_1_on_off_helper

Demonstrates the constructor for ns3::OnOffHelper and methods for installing OnOffApplications on nodes. It can take a protocol and address, or attributes can be set subsequently. Applications can be installed on individual nodes, node containers, or nodes specified by name.

```c++
#include "on-off-helper.h"

// Constructor example
Address address (InetSocketAddress (Ipv4Address::GetAny (), 10000));
OnOffHelper onOffHelper("ns3::UdpSocketFactory", address);

// Install on a NodeContainer
NodeContainer nodes;
// ... populate nodes ...
ApplicationContainer apps = onOffHelper.Install (nodes);

// Install on a single node
Ptr<Node> node = Create<Node> ();
ApplicationContainer singleApp = onOffHelper.Install (node);

// Install on a node by name
std::string nodeName = "node-0";
ApplicationContainer namedApp = onOffHelper.Install (nodeName);

```

```c++
// Set attributes using SetAttribute
onOffHelper.SetAttribute ("DataRate", StringValue ("1Mbps"));
onOffHelper.SetAttribute ("PacketSize", StringValue ("1024"));

// Set constant rate
onOffHelper.SetConstantRate (DataRate ("500Kbps"), 512);

```

--------------------------------

### Setup ns-3 OnOff Client Application

Source: https://www.nsnam.org/docs/release/3.38/doxygen/d6/d80/nms-p2p-nix-distributed_8cc_source

Configures and installs an OnOff client application on a node. It specifies the remote address and port for sending data and starts the application at a designated time. This snippet is used for both systemCount == 1 and when systemId matches the modulo of systemCount.

```cpp
r1 = 2 + (int)(4 * urng->GetValue());
r2 = 10 * urng->GetValue();
OnOffHelper client("ns3::UdpSocketFactory", Address());

AddressValue remoteAddress(
InetSocketAddress(ifs3LAN[z][i][j].GetAddress(0), 9999));

client.SetAttribute("Remote", remoteAddress);
ApplicationContainer clientApp;
clientApp.Add(client.Install(nodes_net1[x][r1].Get(0)));
clientApp.Start(Seconds(r2));
```

--------------------------------

### ns3 Energy Model Example: C++ Includes and Setup

Source: https://www.nsnam.org/docs/release/3.38/doxygen/da/d4c/energy-model-example_8cc

This snippet shows the necessary C++ includes and initial setup for the ns-3 energy model example. It includes headers for core ns-3 modules, energy and mobility modules, Wi-Fi helpers, and standard C++ libraries.

```cpp
#include "ns3/config-store-module.h"
#include "ns3/core-module.h"
#include "ns3/energy-module.h"
#include "ns3/internet-module.h"
#include "ns3/mobility-module.h"
#include "ns3/network-module.h"
#include "ns3/wifi-radio-energy-model-helper.h"
#include "ns3/yans-wifi-helper.h"
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
```

--------------------------------

### Install and Start UDP Applications

Source: https://www.nsnam.org/docs/release/3.38/doxygen/dd/dee/lena-x2-handover-measures_8cc_source

Installs and starts UDP client and server applications on UEs and a remote host for both downlink and uplink data transfer. It configures packet sinks and clients, assigns dedicated EPS bearers with specific Quality of Service (QoS) parameters, and randomizes application start times.

```cpp
uint16_t dlPort = 10000;
uint16_t ulPort = 20000;

Ptr<UniformRandomVariable> startTimeSeconds = CreateObject<UniformRandomVariable>();
startTimeSeconds->SetAttribute("Min", DoubleValue(0));
startTimeSeconds->SetAttribute("Max", DoubleValue(0.010));

for (uint32_t u = 0; u < numberOfUes; ++u)
{
    Ptr<Node> ue = ueNodes.Get(u);
    Ptr<Ipv4StaticRouting> ueStaticRouting = ipv4RoutingHelper.GetStaticRouting(ue->GetObject<Ipv4>());
    ueStaticRouting->SetDefaultRoute(epcHelper->GetUeDefaultGatewayAddress(), 1);

    for (uint32_t b = 0; b < numBearersPerUe; ++b)
    {
        ++dlPort;
        ++ulPort;

        ApplicationContainer clientApps;
        ApplicationContainer serverApps;

        // Install DL app
        UdpClientHelper dlClientHelper(ueIpIfaces.GetAddress(u), dlPort);
        clientApps.Add(dlClientHelper.Install(remoteHost));
        PacketSinkHelper dlPacketSinkHelper("ns3::UdpSocketFactory",
                                        InetSocketAddress(Ipv4Address::GetAny(), dlPort));
        serverApps.Add(dlPacketSinkHelper.Install(ue));

        // Install UL app
        UdpClientHelper ulClientHelper(remoteHostAddr, ulPort);
        clientApps.Add(ulClientHelper.Install(ue));
        PacketSinkHelper ulPacketSinkHelper("ns3::UdpSocketFactory",
                                        InetSocketAddress(Ipv4Address::GetAny(), ulPort));
        serverApps.Add(ulPacketSinkHelper.Install(remoteHost));

        Ptr<EpcTft> tft = Create<EpcTft>();
        EpcTft::PacketFilter dlpf;
        dlpf.localPortStart = dlPort;
        dlpf.localPortEnd = dlPort;
        tft->Add(dlpf);
        EpcTft::PacketFilter ulpf;
        ulpf.remotePortStart = ulPort;
        ulpf.remotePortEnd = ulPort;
        tft->Add(ulpf);
        EpsBearer bearer(EpsBearer::NGBR_VIDEO_TCP_DEFAULT);
        lteHelper->ActivateDedicatedEpsBearer(ueLteDevs.Get(u), bearer, tft);

        Time startTime = Seconds(startTimeSeconds->GetValue());
        serverApps.Start(startTime);
        clientApps.Start(startTime);
    }
}
```

--------------------------------

### StartApplication Method in ns3::ThreeGppHttpServer (C++)

Source: https://www.nsnam.org/docs/release/3.38/doxygen/dc/db0/classns3_1_1_three_gpp_http_server

The StartApplication method is responsible for the application-specific startup code. It is invoked at the specified start time and should be overridden by subclasses. This method initializes the server, binds sockets, and sets up callbacks for connections and data handling. Dependencies include ns3::Application, ns3::Socket, and various ns3 types.

```cpp
void ns3::ThreeGppHttpServer::StartApplication()
{
  // Application specific startup code.
  // The StartApplication method is called at the start time specified by Start
  // This method should be overridden by all or most application subclasses.
  // Reimplemented from ns3::Application.
  // Definition at line 186 of file three-gpp-http-server.cc.

  NS_LOG_FUNCTION (this);

  // If this is the first time the application is started, create the listening socket
  if (m_initialSocket == 0)
    {
      TypeId tid = TypeId::LookupByName ("ns3::TcpSocketFactory");
      m_initialSocket = Socket::CreateSocket (GetNode (), tid);

      // If the local address is specified, bind to it
      if (m_localAddress != Address::GetAny ()) {
        m_initialSocket->Bind (m_localAddress, m_localPort);
      } else {
        m_initialSocket->Bind (m_localPort);
      }

      m_initialSocket->Listen ();

      m_initialSocket->SetAcceptCallback (
        MakeCallback (&ThreeGppHttpServer::ConnectionMadeCallback), this);
      m_initialSocket->SetCloseCallback (
        MakeCallback (&ThreeGppHttpServer::NormalCloseCallback), this);
    }

  // Switch to the STARTED state
  SwitchToState (STARTED);
}
```

--------------------------------

### Install Internet Stack on Nodes (C++)

Source: https://www.nsnam.org/docs/release/3.38/doxygen/d5/d91/red-tests_8cc_source

Installs the internet stack on a given node container. This is a common setup step before configuring IP addressing and routing.

```C++
NS_LOG_INFO ("Install internet stack on all nodes.");
InternetStackHelper internet;
internet.Install (c);
```

--------------------------------

### WifiTxopTest::DoRun Setup (C++)

Source: https://www.nsnam.org/docs/release/3.38/doxygen/de/de5/wifi-txop-test_8cc_source

Sets up the Wi-Fi simulation environment within the DoRun method. This includes configuring random seed, creating nodes, setting up spectrum channel and propagation models, and initializing Wi-Fi helper objects.

```cpp
void
WifiTxopTest::DoRun()
{
  RngSeedManager::SetSeed(1);
  RngSeedManager::SetRun(40);
  int64_t streamNumber = 100;

  NodeContainer wifiApNode;
  wifiApNode.Create(1);

  NodeContainer wifiStaNodes;
  wifiStaNodes.Create(m_nStations);

  Ptr<SingleModelSpectrumChannel> spectrumChannel = CreateObject<SingleModelSpectrumChannel>();
  Ptr<FriisPropagationLossModel> lossModel = CreateObject<FriisPropagationLossModel>();
  spectrumChannel->AddPropagationLossModel(lossModel);
  Ptr<ConstantSpeedPropagationDelayModel> delayModel =
      CreateObject<ConstantSpeedPropagationDelayModel>();
  spectrumChannel->SetPropagationDelayModel(delayModel);

  SpectrumWifiPhyHelper phy;
  phy.SetChannel(spectrumChannel);

  Config::SetDefault("ns3::QosFrameExchangeManager::PifsRecovery", BooleanValue(m_pifsRecovery));
  Config::SetDefault("ns3::WifiRemoteStationManager::RtsCtsThreshold", UintegerValue(1900));

  WifiHelper wifi;
  wifi.SetStandard(WIFI_STANDARD_80211a);
  wifi.SetRemoteStationManager("ns3::ConstantRateWifiManager",
                             "DataMode",
                             StringValue("OfdmRate12Mbps"),
                             "ControlMode",
                             StringValue("OfdmRate6Mbps"));

  WifiMacHelper mac;
  mac.SetType("ns3::StaWifiMac",
              "QosSupported",
              BooleanValue(true),
              "Ssid",
              SsidValue(Ssid("non-existent-ssid")));

  m_staDevices = wifi.Install(phy, mac, wifiStaNodes);

  mac.SetType("ns3::ApWifiMac",
              "QosSupported",
              BooleanValue(true),
              "Ssid",
              SsidValue(Ssid("wifi-txop-ssid")),
              "BeaconInterval",
              TimeValue(MicroSeconds(102400)),
              "EnableBeaconJitter",
              BooleanValue(false));

  m_apDevices = wifi.Install(phy, mac, wifiApNode);

  // schedule association requests at different times. One station's SSID is
  // set to the correct value before initialization, so that such a station
  // starts the scanning procedure by looking for the correct SSID
  Ptr<WifiNetDevice> dev = DynamicCast<WifiNetDevice>(m_staDevices.Get(0));
  dev->GetMac()->SetSsid(Ssid("wifi-txop-ssid"));

  for (uint16_t i = 1; i < m_nStations; i++)
  {
    dev = DynamicCast<WifiNetDevice>(m_staDevices.Get(i));
    Simulator::Schedule(i * MicroSeconds(102400),
                        &WifiMac::SetSsid,
                        dev->GetMac(),
                        Ssid("wifi-txop-ssid"));
  }

  // Assign fixed streams to random variables in use
  wifi.AssignStreams(m_apDevices, streamNumber);

  MobilityHelper mobility;
  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator>();

  positionAlloc->Add(Vector(0.0, 0.0, 0.0));
  positionAlloc->Add(Vector(1.0, 0.0, 0.0));
  positionAlloc->Add(Vector(0.0, 1.0, 0.0));
}
```

--------------------------------

### Start ns-3 Tutorial Application

Source: https://www.nsnam.org/docs/release/3.38/doxygen/d8/d80/tutorial-app_8h_source

The StartApplication method contains the application-specific startup code for the ns-3 Tutorial Application. It is an override of the base class method and is essential for initiating application behavior within the simulation environment.

```cpp
void ns3::TutorialApp::StartApplication()
{
  // Application specific startup code
  // ... (implementation details would follow)
}
```

--------------------------------

### Setup UDP Client-Server Communication

Source: https://www.nsnam.org/docs/release/3.38/doxygen/d2/d7f/wimax-ipv4_8cc_source

This code configures and installs UDP server and client applications on the subscriber stations. It iterates through half of the subscriber stations to set up pairs of servers and clients, defining their ports, packet transmission intervals, and sizes. The applications are then started and stopped according to the simulation duration.

```C++
UdpServerHelper* udpServer = new UdpServerHelper[nbSS / 2];
ApplicationContainer* serverApps = new ApplicationContainer[nbSS / 2];
UdpClientHelper* udpClient = new UdpClientHelper[nbSS / 2];
ApplicationContainer* clientApps = new ApplicationContainer[nbSS / 2];

for (int i = 0; i < nbSS / 2; i++)
{
  // set server port to 100+(i*10)
  udpServer[i] = UdpServerHelper(100 + (i * 10));
  serverApps[i] = udpServer[i].Install(ssNodes.Get(i));
  serverApps[i].Start(Seconds(6));
  serverApps[i].Stop(Seconds(duration));

  udpClient[i] = UdpClientHelper(SSinterfaces.GetAddress(i), 100 + (i * 10));
  udpClient[i].SetAttribute("MaxPackets", UintegerValue(1200));
  udpClient[i].SetAttribute("Interval", TimeValue(Seconds(0.12)));
  udpClient[i].SetAttribute("PacketSize", UintegerValue(800));

  clientApps[i] = udpClient[i].Install(ssNodes.Get(i + (nbSS / 2)));
  clientApps[i].Start(Seconds(6));
  clientApps[i].Stop(Seconds(duration));
}
```

--------------------------------

### Ns3 Wifi Adhoc Experiment Setup

Source: https://www.nsnam.org/docs/release/3.38/doxygen/d7/d28/wifi-adhoc_8cc_source

This C++ code defines the Experiment class for the ns-3 wifi-adhoc example. It includes constructors for experiment initialization and a 'Run' method to configure and execute the Wi-Fi ad-hoc simulation. The 'Run' method takes Wi-Fi helper objects as input to set up the simulation environment.

```cpp
#include "ns3/command-line.h"
#include "ns3/config.h"
#include "ns3/gnuplot.h"
#include "ns3/ipv4-address-helper.h"
#include "ns3/log.h"
#include "ns3/mobility-helper.h"
#include "ns3/mobility-model.h"
#include "ns3/on-off-helper.h"
#include "ns3/packet-socket-address.h"
#include "ns3/packet-socket-helper.h"
#include "ns3/string.h"
#include "ns3/uinteger.h"
#include "ns3/yans-wifi-channel.h"
#include "ns3/yans-wifi-helper.h"

using namespace ns3;

NS_LOG_COMPONENT_DEFINE("Wifi-Adhoc");

class Experiment
{
 public:
  Experiment();
  Experiment(std::string name);

  Gnuplot2dDataset Run(const WifiHelper& wifi,
                     const YansWifiPhyHelper& wifiPhy,
                     const WifiMacHelper& wifiMac,
                     const YansWifiChannelHelper& wifiChannel);

 private:
  void ReceivePacket(Ptr<Socket> socket);
  void SetPosition(Ptr<Node> node, Vector position);
};

```

--------------------------------

### Start and Run ns-3 Simulation

Source: https://www.nsnam.org/docs/release/3.38/doxygen/dd/d07/lena-simple-epc-backhaul_8cc_source

This code segment initiates the execution of the ns-3 simulation. It starts the installed applications and then runs the simulation until the specified stop time, followed by cleanup.

```c++
239 serverApps.Start(MilliSeconds(500));
240 clientApps.Start(MilliSeconds(500));
241 lteHelper->EnableTraces();
242 // Uncomment to enable PCAP tracing
243 // p2ph.EnablePcapAll("lena-simple-epc-backhaul");
244
245 Simulator::Stop(simTime);
246 Simulator::Run();
247
248 /*GtkConfigStore config;
249 config.ConfigureAttributes();*/
250
251 Simulator::Destroy();
252 return 0;
253}
```

--------------------------------

### ns3::ClickRouting Example Network Setup (C++)

Source: https://www.nsnam.org/docs/release/3.38/doxygen/d0/de9/nsclick-routing_8cc_source

This C++ code snippet demonstrates the setup of a network topology for the ns3::ClickRouting example. It includes creating nodes, installing Click-based internet stacks, and defining routing table elements for each node. The ClickInternetStackHelper is used to configure Click files for individual nodes, specifying their roles as end hosts or routers.

```cpp
/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 * 
 * Authors: Lalith Suresh <suresh.lalith@gmail.com>
 */

// Network topology
//
//
// 172.16.1.0/24
// (1.1) (1.2) (2.1) (2.2)
//
// eth0 eth0 eth1 eth0
// n0 ========= n1 ========= n2
// LAN 1 LAN 2
//
// - UDP flows from n0 to n2 via n1.
// - All nodes are Click based.
//

#include "ns3/applications-module.h"
#include "ns3/click-internet-stack-helper.h"
#include "ns3/core-module.h"
#include "ns3/csma-module.h"
#include "ns3/internet-module.h"
#include "ns3/ipv4-click-routing.h"
#include "ns3/ipv4-l3-click-protocol.h"
#include "ns3/network-module.h"

using namespace ns3;

NS_LOG_COMPONENT_DEFINE("NsclickRouting");

int
main(int argc, char* argv[])
{
#ifdef NS3_CLICK
  std::string clickConfigFolder = "src/click/examples";

  CommandLine cmd(__FILE__);
  cmd.AddValue("clickConfigFolder",
               "Base folder for click configuration files",
               clickConfigFolder);
  cmd.Parse(argc, argv);

  // 
  // Explicitly create the nodes required by the topology (shown above).
  // 
  NS_LOG_INFO("Create nodes.");
  NodeContainer n;
  n.Create(3);

  // 
  // Install Click on the nodes
  // 
  ClickInternetStackHelper clickinternet;
  clickinternet.SetClickFile(n.Get(0), clickConfigFolder + "/nsclick-routing-node0.click");
  clickinternet.SetClickFile(n.Get(1), clickConfigFolder + "/nsclick-ip-router.click");
  clickinternet.SetClickFile(n.Get(2), clickConfigFolder + "/nsclick-routing-node2.click");
  clickinternet.SetRoutingTableElement(n.Get(0), "kernel/rt");
  clickinternet.SetRoutingTableElement(n.Get(1), "u/rt");
  clickinternet.SetRoutingTableElement(n.Get(2), "kernel/rt");
  clickinternet.Install(n);

  NS_LOG_INFO("Create channels.");
  // 

```

--------------------------------

### ns3::OnOffHelper: Install Methods

Source: https://www.nsnam.org/docs/release/3.38/doxygen/da/d90/classns3_1_1_on_off_helper-members

Demonstrates different ways to install the OnOff application on nodes using the OnOffHelper. This includes installing on a NodeContainer, a single Ptr<Node>, or by node name.

```cpp
void AssignStreams(NodeContainer c, int64_t stream);
void Install(NodeContainer c) const;
void Install(Ptr< Node > node) const;
void Install(std::string nodeName) const;
```

--------------------------------

### Install Applications in Aodv Example (C++)

Source: https://www.nsnam.org/docs/release/3.38/doxygen/d4/d41/class_aodv_example

This function installs simulation applications, specifically Ping, on the created nodes. It configures Ping attributes and schedules the applications to start and stop at specified times.

```C++
void
AodvExample::InstallApplications (void)
{
  Ptr<Node> src = nodes.Get (0);
  Ptr<Node> dst = nodes.Get (size - 1);
  Ptr<Ipv4> ipv4Src = src->GetObject<Ipv4Manager> ()->GetIpv4 ();
  Ptr<Ipv4> ipv4Dst = dst->GetObject<Ipv4Manager> ()->GetIpv4 ();

  // IP address
  Ipv4Address srcAddress = ipv4Src->GetAddress (1, 0);
  Ipv4Address dstAddress = ipv4Dst->GetAddress (1, 0);

  PingHelper ping (dstAddress, ipv4Src);
  ping.SetTimes (1000);
  ping.SetAttribute ("Interval", TimeValue (Seconds (0.1)));

  ApplicationContainer apps = ping.Install (nodes.Get (0));
  apps.Start (Seconds (1.0));
  apps.Stop (totalTime - Seconds (1.0));
}
```

--------------------------------

### Setup ns-3 Tutorial Application Socket

Source: https://www.nsnam.org/docs/release/3.38/doxygen/d8/d80/tutorial-app_8h_source

The Setup function initializes the socket for the ns-3 Tutorial Application. It takes parameters for the socket, destination address, packet size, number of packets, and data rate. This is crucial for configuring network communication within the simulation.

```cpp
void ns3::TutorialApp::Setup(Ptr< Socket > socket, Address address, uint32_t packetSize, uint32_t nPackets, DataRate dataRate)
{
  m_socket = socket;
  m_peer = address;
  m_packetSize = packetSize;
  m_nPackets = nPackets;
  m_dataRate = dataRate;
}
```

--------------------------------

### VirtualNetDevice Installation and Configuration

Source: https://www.nsnam.org/docs/release/3.38/doxygen/da/d91/virtual-net-device-example_8cc_source

Installs IP, TCP, and UDP functionality onto nodes. This helper class simplifies the aggregation of network protocols.

```c++
ns3::InternetStackHelper::Install(std::string nodeName) const
// Aggregate implementations of the ns3::Ipv4, ns3::Ipv6, ns3::Udp, and ns3::Tcp classes onto the provid...ns3::internet-stack-helper.cc:376
```

--------------------------------

### ns-3 TCP Application Setup for Client and Server (C++)

Source: https://www.nsnam.org/docs/release/3.38/doxygen/dc/df8/brite-_m_p_i-example_8cc_source

This code snippet configures and installs TCP applications for a client and a server within the ns-3 simulation. It sets up a packet sink on the server and an OnOff application on the client, defining their start and stop times for data transfer. Dependencies include ns-3 application helpers and socket factories.

```cpp
    ApplicationContainer sinkApps;

    if (systemId == 1)
    {
        Address sinkLocalAddress(InetSocketAddress(Ipv4Address::GetAny(), port));
        PacketSinkHelper packetSinkHelper("ns3::TcpSocketFactory", sinkLocalAddress);
        sinkApps.Add(packetSinkHelper.Install(server.Get(0)));
        sinkApps.Start(Seconds(0.0));
        sinkApps.Stop(Seconds(10.0));
    }

    if (systemId == 0)
    {
        OnOffHelper clientHelper("ns3::TcpSocketFactory", Address());
        clientHelper.SetAttribute("OnTime", StringValue("ns3::ConstantRandomVariable[Constant=1]"));
        clientHelper.SetAttribute("OffTime",
        StringValue("ns3::ConstantRandomVariable[Constant=0]"));

        ApplicationContainer clientApps;
        AddressValue remoteAddress(InetSocketAddress(serverInterfaces.GetAddress(0), port));
        clientHelper.SetAttribute("Remote", remoteAddress);
        clientApps.Add(clientHelper.Install(client.Get(0)));
        clientApps.Start(Seconds(1.0)); 
        clientApps.Stop(Seconds(9.0)); 
    }

    if (!nix)
    {
        Ipv4GlobalRoutingHelper::PopulateRoutingTables();
    }
```
Tokens:
Raw