A Discrete-Event Network Simulator
API
energy-model-with-harvesting-example.cc
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2014 Wireless Communications and Networking Group (WCNG),
4  * University of Rochester, Rochester, NY, USA.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation;
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18  *
19  * Author: Cristiano Tapparello <cristiano.tapparello@rochester.edu>
20  */
21 
50 #include <iostream>
51 #include <fstream>
52 #include <vector>
53 #include <string>
54 #include "ns3/core-module.h"
55 #include "ns3/network-module.h"
56 #include "ns3/mobility-module.h"
57 #include "ns3/config-store-module.h"
58 #include "ns3/energy-module.h"
59 #include "ns3/internet-module.h"
60 #include "ns3/yans-wifi-helper.h"
61 #include "ns3/wifi-radio-energy-model-helper.h"
62 
63 using namespace ns3;
64 
65 NS_LOG_COMPONENT_DEFINE ("EnergyWithHarvestingExample");
66 
67 static inline std::string
69 {
71 
72  std::ostringstream oss;
73  oss << "--\nReceived one packet! Socket: " << iaddr.GetIpv4 ()
74  << " port: " << iaddr.GetPort ()
75  << " at time = " << Simulator::Now ().GetSeconds ()
76  << "\n--";
77 
78  return oss.str ();
79 }
80 
86 void
88 {
89  Ptr<Packet> packet;
90  Address from;
91  while ((packet = socket->RecvFrom (from)))
92  {
93  if (packet->GetSize () > 0)
94  {
96  }
97  }
98 }
99 
109 static void
111  uint32_t pktCount, Time pktInterval)
112 {
113  if (pktCount > 0)
114  {
115  socket->Send (Create<Packet> (pktSize));
116  Simulator::Schedule (pktInterval, &GenerateTraffic, socket, pktSize, n,
117  pktCount - 1, pktInterval);
118  }
119  else
120  {
121  socket->Close ();
122  }
123 }
124 
126 void
127 RemainingEnergy (double oldValue, double remainingEnergy)
128 {
129  NS_LOG_UNCOND (Simulator::Now ().GetSeconds ()
130  << "s Current remaining energy = " << remainingEnergy << "J");
131 }
132 
134 void
135 TotalEnergy (double oldValue, double totalEnergy)
136 {
137  NS_LOG_UNCOND (Simulator::Now ().GetSeconds ()
138  << "s Total energy consumed by radio = " << totalEnergy << "J");
139 }
140 
142 void
143 HarvestedPower (double oldValue, double harvestedPower)
144 {
145  NS_LOG_UNCOND (Simulator::Now ().GetSeconds ()
146  << "s Current harvested power = " << harvestedPower << " W");
147 }
148 
150 void
152 {
153  NS_LOG_UNCOND (Simulator::Now ().GetSeconds ()
154  << "s Total energy harvested by harvester = "
155  << TotalEnergyHarvested << " J");
156 }
157 
158 
159 int
160 main (int argc, char *argv[])
161 {
162  std::string phyMode ("DsssRate1Mbps");
163  double Prss = -80; // dBm
164  uint32_t PacketSize = 200; // bytes
165  bool verbose = false;
166 
167  // simulation parameters
168  uint32_t numPackets = 10000; // number of packets to send
169  double interval = 1; // seconds
170  double startTime = 0.0; // seconds
171  double distanceToRx = 100.0; // meters
172 
173  // Energy Harvester variables
174  double harvestingUpdateInterval = 1; // seconds
175 
176  CommandLine cmd (__FILE__);
177  cmd.AddValue ("phyMode", "Wifi Phy mode", phyMode);
178  cmd.AddValue ("Prss", "Intended primary RSS (dBm)", Prss);
179  cmd.AddValue ("PacketSize", "size of application packet sent", PacketSize);
180  cmd.AddValue ("numPackets", "Total number of packets to send", numPackets);
181  cmd.AddValue ("startTime", "Simulation start time", startTime);
182  cmd.AddValue ("distanceToRx", "X-Axis distance between nodes", distanceToRx);
183  cmd.AddValue ("verbose", "Turn on all device log components", verbose);
184  cmd.Parse (argc, argv);
185 
186  // Convert to time object
187  Time interPacketInterval = Seconds (interval);
188 
189  // disable fragmentation for frames below 2200 bytes
190  Config::SetDefault ("ns3::WifiRemoteStationManager::FragmentationThreshold",
191  StringValue ("2200"));
192  // turn off RTS/CTS for frames below 2200 bytes
193  Config::SetDefault ("ns3::WifiRemoteStationManager::RtsCtsThreshold",
194  StringValue ("2200"));
195  // Fix non-unicast data rate to be the same as that of unicast
196  Config::SetDefault ("ns3::WifiRemoteStationManager::NonUnicastMode",
197  StringValue (phyMode));
198 
199  NodeContainer c;
200  c.Create (2); // create 2 nodes
201  NodeContainer networkNodes;
202  networkNodes.Add (c.Get (0));
203  networkNodes.Add (c.Get (1));
204 
205  // The below set of helpers will help us to put together the wifi NICs we want
207  if (verbose)
208  {
209  wifi.EnableLogComponents ();
210  }
211  wifi.SetStandard (WIFI_STANDARD_80211b);
212 
214  /***************************************************************************/
215  YansWifiPhyHelper wifiPhy;
216 
218  YansWifiChannelHelper wifiChannel;
219  wifiChannel.SetPropagationDelay ("ns3::ConstantSpeedPropagationDelayModel");
220  wifiChannel.AddPropagationLoss ("ns3::FriisPropagationLossModel");
221 
222  // create wifi channel
223  Ptr<YansWifiChannel> wifiChannelPtr = wifiChannel.Create ();
224  wifiPhy.SetChannel (wifiChannelPtr);
225 
227  // Add a MAC and disable rate control
228  WifiMacHelper wifiMac;
229  wifi.SetRemoteStationManager ("ns3::ConstantRateWifiManager", "DataMode",
230  StringValue (phyMode), "ControlMode",
231  StringValue (phyMode));
232  // Set it to ad-hoc mode
233  wifiMac.SetType ("ns3::AdhocWifiMac");
234 
236  NetDeviceContainer devices = wifi.Install (wifiPhy, wifiMac, networkNodes);
237 
240  Ptr<ListPositionAllocator> positionAlloc = CreateObject<ListPositionAllocator> ();
241  positionAlloc->Add (Vector (0.0, 0.0, 0.0));
242  positionAlloc->Add (Vector (2 * distanceToRx, 0.0, 0.0));
243  mobility.SetPositionAllocator (positionAlloc);
244  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
245  mobility.Install (c);
246 
248  /***************************************************************************/
249  /* energy source */
250  BasicEnergySourceHelper basicSourceHelper;
251  // configure energy source
252  basicSourceHelper.Set ("BasicEnergySourceInitialEnergyJ", DoubleValue (1.0));
253  // install source
254  EnergySourceContainer sources = basicSourceHelper.Install (c);
255  /* device energy model */
256  WifiRadioEnergyModelHelper radioEnergyHelper;
257  // configure radio energy model
258  radioEnergyHelper.Set ("TxCurrentA", DoubleValue (0.0174));
259  radioEnergyHelper.Set ("RxCurrentA", DoubleValue (0.0197));
260  // install device model
261  DeviceEnergyModelContainer deviceModels = radioEnergyHelper.Install (devices, sources);
262 
263  /* energy harvester */
264  BasicEnergyHarvesterHelper basicHarvesterHelper;
265  // configure energy harvester
266  basicHarvesterHelper.Set ("PeriodicHarvestedPowerUpdateInterval", TimeValue (Seconds (harvestingUpdateInterval)));
267  basicHarvesterHelper.Set ("HarvestablePower", StringValue ("ns3::UniformRandomVariable[Min=0.0|Max=0.1]"));
268  // install harvester on all energy sources
269  EnergyHarvesterContainer harvesters = basicHarvesterHelper.Install (sources);
270  /***************************************************************************/
271 
273  InternetStackHelper internet;
274  internet.Install (networkNodes);
275 
276  Ipv4AddressHelper ipv4;
277  NS_LOG_INFO ("Assign IP Addresses.");
278  ipv4.SetBase ("10.1.1.0", "255.255.255.0");
280 
281  TypeId tid = TypeId::LookupByName ("ns3::UdpSocketFactory");
282  Ptr<Socket> recvSink = Socket::CreateSocket (networkNodes.Get (1), tid); // node 1, Destination
284  recvSink->Bind (local);
286 
287  Ptr<Socket> source = Socket::CreateSocket (networkNodes.Get (0), tid); // node 0, Source
289  source->SetAllowBroadcast (true);
290  source->Connect (remote);
291 
293  /***************************************************************************/
294  // all traces are connected to node 1 (Destination)
295  // energy source
296  Ptr<BasicEnergySource> basicSourcePtr = DynamicCast<BasicEnergySource> (sources.Get (1));
297  basicSourcePtr->TraceConnectWithoutContext ("RemainingEnergy", MakeCallback (&RemainingEnergy));
298  // device energy model
299  Ptr<DeviceEnergyModel> basicRadioModelPtr =
300  basicSourcePtr->FindDeviceEnergyModels ("ns3::WifiRadioEnergyModel").Get (0);
301  NS_ASSERT (basicRadioModelPtr != 0);
302  basicRadioModelPtr->TraceConnectWithoutContext ("TotalEnergyConsumption", MakeCallback (&TotalEnergy));
303  // energy harvester
304  Ptr<BasicEnergyHarvester> basicHarvesterPtr = DynamicCast<BasicEnergyHarvester> (harvesters.Get (1));
305  basicHarvesterPtr->TraceConnectWithoutContext ("HarvestedPower", MakeCallback (&HarvestedPower));
306  basicHarvesterPtr->TraceConnectWithoutContext ("TotalEnergyHarvested", MakeCallback (&TotalEnergyHarvested));
307  /***************************************************************************/
308 
309 
311  // start traffic
312  Simulator::Schedule (Seconds (startTime), &GenerateTraffic, source, PacketSize,
313  networkNodes.Get (0), numPackets, interPacketInterval);
314 
315  Simulator::Stop (Seconds (10.0));
316  Simulator::Run ();
317 
318  for (DeviceEnergyModelContainer::Iterator iter = deviceModels.Begin (); iter != deviceModels.End (); iter ++)
319  {
320  double energyConsumed = (*iter)->GetTotalEnergyConsumption ();
321  NS_LOG_UNCOND ("End of simulation (" << Simulator::Now ().GetSeconds ()
322  << "s) Total energy consumed by radio = " << energyConsumed << "J");
323  NS_ASSERT (energyConsumed <= 1.0);
324  }
325 
327 
328  return 0;
329 }
ns3::DeviceEnergyModelContainer::End
Iterator End(void) const
Get an iterator which refers to the last DeviceEnergyModel pointer in the container.
Definition: device-energy-model-container.cc:67
ns3::NetDeviceContainer
holds a vector of ns3::NetDevice pointers
Definition: net-device-container.h:42
ns3::TypeId
a unique identifier for an interface.
Definition: type-id.h:59
ns3::DeviceEnergyModelHelper::Install
DeviceEnergyModelContainer Install(Ptr< NetDevice > device, Ptr< EnergySource > source) const
Definition: energy-model-helper.cc:91
NS_LOG_COMPONENT_DEFINE
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:205
ns3::InetSocketAddress
an Inet address class
Definition: inet-socket-address.h:41
ns3::YansWifiPhyHelper
Make it easy to create and manage PHY objects for the YANS model.
Definition: yans-wifi-helper.h:161
ns3::CommandLine
Parse command-line arguments.
Definition: command-line.h:228
ns3::Socket::SetAllowBroadcast
virtual bool SetAllowBroadcast(bool allowBroadcast)=0
Configure whether broadcast datagram transmissions are allowed.
ns3::ListPositionAllocator::Add
void Add(Vector v)
Add a position to the list of positions.
Definition: position-allocator.cc:70
NS_ASSERT
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file,...
Definition: assert.h:67
ns3::YansWifiChannelHelper::SetPropagationDelay
void SetPropagationDelay(std::string name, std::string n0="", const AttributeValue &v0=EmptyAttributeValue(), std::string n1="", const AttributeValue &v1=EmptyAttributeValue(), std::string n2="", const AttributeValue &v2=EmptyAttributeValue(), std::string n3="", const AttributeValue &v3=EmptyAttributeValue(), std::string n4="", const AttributeValue &v4=EmptyAttributeValue(), std::string n5="", const AttributeValue &v5=EmptyAttributeValue(), std::string n6="", const AttributeValue &v6=EmptyAttributeValue(), std::string n7="", const AttributeValue &v7=EmptyAttributeValue())
Definition: yans-wifi-helper.cc:75
ns3::DeviceEnergyModelContainer::Get
Ptr< DeviceEnergyModel > Get(uint32_t i) const
Get the i-th Ptr<DeviceEnergyModel> stored in this container.
Definition: device-energy-model-container.cc:81
ns3::Socket::Bind
virtual int Bind(const Address &address)=0
Allocate a local endpoint for this socket.
ns3::Packet::GetSize
uint32_t GetSize(void) const
Returns the the size in bytes of the packet (including the zero-filled initial payload).
Definition: packet.h:852
ns3::InetSocketAddress::GetPort
uint16_t GetPort(void) const
Definition: inet-socket-address.cc:65
ns3::EnergyHarvesterContainer::Get
Ptr< EnergyHarvester > Get(uint32_t i) const
Get the i-th Ptr<EnergyHarvester> stored in this container.
Definition: energy-harvester-container.cc:99
TotalEnergy
void TotalEnergy(double oldValue, double totalEnergy)
Trace function for total energy consumption at node.
Definition: energy-model-with-harvesting-example.cc:135
ns3::Simulator::Now
static Time Now(void)
Return the current simulation virtual time.
Definition: simulator.cc:195
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::Ipv4Address::GetBroadcast
static Ipv4Address GetBroadcast(void)
Definition: ipv4-address.cc:402
ns3::DeviceEnergyModelContainer::Begin
Iterator Begin(void) const
Get an iterator which refers to the first DeviceEnergyModel pointer in the container.
Definition: device-energy-model-container.cc:60
ns3::WifiHelper
helps to create WifiNetDevice objects
Definition: wifi-helper.h:323
ns3::Ipv4AddressHelper
A helper class to make life easier while doing simple IPv4 address assignment in scripts.
Definition: ipv4-address-helper.h:48
RemainingEnergy
void RemainingEnergy(double oldValue, double remainingEnergy)
Trace function for remaining energy at node.
Definition: energy-model-with-harvesting-example.cc:127
PrintReceivedPacket
static std::string PrintReceivedPacket(Address &from)
Definition: energy-model-with-harvesting-example.cc:68
ns3::YansWifiChannelHelper::AddPropagationLoss
void AddPropagationLoss(std::string name, std::string n0="", const AttributeValue &v0=EmptyAttributeValue(), std::string n1="", const AttributeValue &v1=EmptyAttributeValue(), std::string n2="", const AttributeValue &v2=EmptyAttributeValue(), std::string n3="", const AttributeValue &v3=EmptyAttributeValue(), std::string n4="", const AttributeValue &v4=EmptyAttributeValue(), std::string n5="", const AttributeValue &v5=EmptyAttributeValue(), std::string n6="", const AttributeValue &v6=EmptyAttributeValue(), std::string n7="", const AttributeValue &v7=EmptyAttributeValue())
Definition: yans-wifi-helper.cc:51
ns3::Simulator::Schedule
static EventId Schedule(Time const &delay, FUNC f, Ts &&... args)
Schedule an event to expire after delay.
Definition: simulator.h:556
ns3::YansWifiPhyHelper::SetChannel
void SetChannel(Ptr< YansWifiChannel > channel)
Definition: yans-wifi-helper.cc:135
first.devices
devices
Definition: first.py:39
ns3::InetSocketAddress::ConvertFrom
static InetSocketAddress ConvertFrom(const Address &address)
Returns an InetSocketAddress which corresponds to the input Address.
Definition: inet-socket-address.cc:126
ns3::DoubleValue
This class can be used to hold variables of floating point type such as 'double' or 'float'.
Definition: double.h:41
ns3::NodeContainer::Create
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
Definition: node-container.cc:98
ns3::BasicEnergySourceHelper::Set
void Set(std::string name, const AttributeValue &v)
Definition: basic-energy-source-helper.cc:36
startTime
double startTime
Definition: tcp-nsc-comparison.cc:45
ns3::NodeContainer::Add
void Add(NodeContainer other)
Append the contents of another NodeContainer to the end of this container.
Definition: node-container.cc:114
ns3::EnergySourceContainer
Holds a vector of ns3::EnergySource pointers.
Definition: energy-source-container.h:45
ns3::Ipv4AddressHelper::SetBase
void SetBase(Ipv4Address network, Ipv4Mask mask, Ipv4Address base="0.0.0.1")
Set the base network number, network mask and base address.
Definition: ipv4-address-helper.cc:64
ns3::EnergySourceHelper::Install
EnergySourceContainer Install(Ptr< Node > node) const
Definition: energy-model-helper.cc:35
third.wifi
wifi
Definition: third.py:96
ns3::Ptr< Socket >
HarvestedPower
void HarvestedPower(double oldValue, double harvestedPower)
Trace function for the power harvested by the energy harvester.
Definition: energy-model-with-harvesting-example.cc:143
ns3::EnergySourceContainer::Get
Ptr< EnergySource > Get(uint32_t i) const
Get the i-th Ptr<EnergySource> stored in this container.
Definition: energy-source-container.cc:88
ns3::Socket::Send
virtual int Send(Ptr< Packet > p, uint32_t flags)=0
Send data (or dummy data) to the remote host.
ns3::Socket::SetRecvCallback
void SetRecvCallback(Callback< void, Ptr< Socket > > receivedData)
Notify application when new data is available to be read.
Definition: socket.cc:128
ns3::YansWifiChannelHelper::Create
Ptr< YansWifiChannel > Create(void) const
Definition: yans-wifi-helper.cc:99
ns3::Simulator::Stop
static void Stop(void)
Tell the Simulator the calling event should be the last one executed.
Definition: simulator.cc:180
ns3::Address
a polymophic address class
Definition: address.h:91
ns3::BasicEnergySourceHelper
Creates a BasicEnergySource object.
Definition: basic-energy-source-helper.h:35
ns3::EnergyHarvesterContainer
Holds a vector of ns3::EnergyHarvester pointers.
Definition: energy-harvester-container.h:46
ns3::InternetStackHelper::Install
void Install(std::string nodeName) const
Aggregate implementations of the ns3::Ipv4, ns3::Ipv6, ns3::Udp, and ns3::Tcp classes onto the provid...
Definition: internet-stack-helper.cc:366
NS_LOG_INFO
#define NS_LOG_INFO(msg)
Use NS_LOG to output a message of level LOG_INFO.
Definition: log.h:281
ns3::Socket::RecvFrom
virtual Ptr< Packet > RecvFrom(uint32_t maxSize, uint32_t flags, Address &fromAddress)=0
Read a single packet from the socket and retrieve the sender address.
ns3::InetSocketAddress::GetIpv4
Ipv4Address GetIpv4(void) const
Definition: inet-socket-address.cc:71
ns3::BasicEnergyHarvesterHelper::Set
void Set(std::string name, const AttributeValue &v)
Definition: basic-energy-harvester-helper.cc:37
ns3::WifiRadioEnergyModelHelper
Assign WifiRadioEnergyModel to wifi devices.
Definition: wifi-radio-energy-model-helper.h:37
ReceivePacket
void ReceivePacket(Ptr< Socket > socket)
Definition: energy-model-with-harvesting-example.cc:87
ns3::DeviceEnergyModelContainer::Iterator
std::vector< Ptr< DeviceEnergyModel > >::const_iterator Iterator
Definition: device-energy-model-container.h:46
ns3::Ipv4InterfaceContainer
holds a vector of std::pair of Ptr<Ipv4> and interface index.
Definition: ipv4-interface-container.h:55
ns3::WIFI_STANDARD_80211b
@ WIFI_STANDARD_80211b
Definition: wifi-standards.h:128
ns3::NodeContainer::Get
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
Definition: node-container.cc:93
verbose
bool verbose
Definition: openflow-switch.cc:50
ns3::Time
Simulation virtual time values and global simulation resolution.
Definition: nstime.h:104
ns3::Socket::Close
virtual int Close(void)=0
Close a socket.
second.cmd
cmd
Definition: second.py:35
ns3::DeviceEnergyModelContainer
Holds a vector of ns3::DeviceEnergyModel pointers.
Definition: device-energy-model-container.h:44
NS_LOG_UNCOND
#define NS_LOG_UNCOND(msg)
Output the requested message unconditionally.
Definition: log-macros-enabled.h:269
TotalEnergyHarvested
void TotalEnergyHarvested(double oldValue, double TotalEnergyHarvested)
Trace function for the total energy harvested by the node.
Definition: energy-model-with-harvesting-example.cc:151
ns3::MakeCallback
Callback< R, Ts... > MakeCallback(R(T::*memPtr)(Ts...), OBJ objPtr)
Build Callbacks for class method members which take varying numbers of arguments and potentially retu...
Definition: callback.h:1642
ns3::Simulator::Run
static void Run(void)
Run the simulation.
Definition: simulator.cc:172
ns3::StringValue
Hold variables of type string.
Definition: string.h:41
ns3::EnergyHarvesterHelper::Install
EnergyHarvesterContainer Install(Ptr< EnergySource > source) const
Definition: energy-harvester-helper.cc:36
ns3::Ipv4Address::GetAny
static Ipv4Address GetAny(void)
Definition: ipv4-address.cc:395
ns3::BasicEnergyHarvesterHelper
Creates a BasicEnergyHarvester object.
Definition: basic-energy-harvester-helper.h:36
ns3::Socket::Connect
virtual int Connect(const Address &address)=0
Initiate a connection to a remote host.
ns3::Seconds
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1289
ns3::Ipv4AddressHelper::Assign
Ipv4InterfaceContainer Assign(const NetDeviceContainer &c)
Assign IP addresses to the net devices specified in the container based on the current network prefix...
Definition: ipv4-address-helper.cc:135
ns3::Simulator::Destroy
static void Destroy(void)
Execute the events scheduled with ScheduleDestroy().
Definition: simulator.cc:136
GenerateTraffic
static void GenerateTraffic(Ptr< Socket > socket, uint32_t pktSize, Ptr< Node > n, uint32_t pktCount, Time pktInterval)
Definition: energy-model-with-harvesting-example.cc:110
pktSize
uint32_t pktSize
packet size used for the simulation (in bytes)
Definition: wifi-bianchi.cc:86
ns3::TimeValue
AttributeValue implementation for Time.
Definition: nstime.h:1353
ns3::NodeContainer
keep track of a set of node pointers.
Definition: node-container.h:39
ns3::WifiMacHelper::SetType
void SetType(std::string type, Args &&... args)
Definition: wifi-mac-helper.h:130
ns3::Socket::CreateSocket
static Ptr< Socket > CreateSocket(Ptr< Node > node, TypeId tid)
This method wraps the creation of sockets that is performed on a given node by a SocketFactory specif...
Definition: socket.cc:71
ns3::YansWifiChannelHelper
manage and create wifi channel objects for the YANS model.
Definition: yans-wifi-helper.h:37
ns3::WifiMacHelper
create MAC layers for a ns3::WifiNetDevice.
Definition: wifi-mac-helper.h:48
ns3::Config::SetDefault
void SetDefault(std::string name, const AttributeValue &value)
Definition: config.cc:849
ns3::ObjectBase::TraceConnectWithoutContext
bool TraceConnectWithoutContext(std::string name, const CallbackBase &cb)
Connect a TraceSource to a Callback without a context.
Definition: object-base.cc:293
ns3::EnergySource::FindDeviceEnergyModels
DeviceEnergyModelContainer FindDeviceEnergyModels(TypeId tid)
Definition: energy-source.cc:78
ns3::InternetStackHelper
aggregate IP/TCP/UDP functionality to existing Nodes.
Definition: internet-stack-helper.h:88
ns3::TypeId::LookupByName
static TypeId LookupByName(std::string name)
Get a TypeId by name.
Definition: type-id.cc:830
ns3::MobilityHelper
Helper class used to assign positions and mobility models to nodes.
Definition: mobility-helper.h:43
ns3::Time::GetSeconds
double GetSeconds(void) const
Get an approximation of the time stored in this instance in the indicated unit.
Definition: nstime.h:380
sample-rng-plot.n
n
Definition: sample-rng-plot.py:37
third.mobility
mobility
Definition: third.py:108
ns3::WifiRadioEnergyModelHelper::Set
void Set(std::string name, const AttributeValue &v) override
Definition: wifi-radio-energy-model-helper.cc:40