A Discrete-Event Network Simulator
API
adhoc-aloha-ideal-phy-matrix-propagation-loss-model.cc
Go to the documentation of this file.
1 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2010 CTTC
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation;
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  * Author: Nicola Baldo <nbaldo@cttc.es>
19  */
20 
21 
22 
23 #include <iostream>
24 
25 #include <ns3/core-module.h>
26 #include <ns3/network-module.h>
27 #include <ns3/spectrum-model-ism2400MHz-res1MHz.h>
28 #include <ns3/spectrum-model-300kHz-300GHz-log.h>
29 #include <ns3/wifi-spectrum-value-helper.h>
30 #include <ns3/single-model-spectrum-channel.h>
31 #include <ns3/waveform-generator.h>
32 #include <ns3/spectrum-analyzer.h>
33 #include <ns3/log.h>
34 #include <string>
35 #include <iomanip>
36 #include <ns3/friis-spectrum-propagation-loss.h>
37 #include <ns3/propagation-delay-model.h>
38 #include <ns3/mobility-module.h>
39 #include <ns3/spectrum-helper.h>
40 #include <ns3/applications-module.h>
41 #include <ns3/adhoc-aloha-noack-ideal-phy-helper.h>
42 
43 
44 using namespace ns3;
45 
46 NS_LOG_COMPONENT_DEFINE ("TestAdhocOfdmAloha");
47 
48 static bool g_verbose = false;
49 static uint64_t g_rxBytes;
50 
51 void
52 PhyRxEndOkTrace (std::string context, Ptr<const Packet> p)
53 {
54  if (g_verbose)
55  {
56  std::cout << context << " PHY RX END OK p:" << p << std::endl;
57  }
58  g_rxBytes += p->GetSize ();
59 }
60 
61 
62 
72 {
73 public:
74 
83  void UpdatePathloss (std::string context, Ptr<SpectrumPhy> txPhy, Ptr<SpectrumPhy> rxPhy, double lossDb);
84 
89  void Print ();
90 
91 private:
92  std::map<uint32_t, std::map<uint32_t, double> > m_pathlossMap;
93 };
94 
95 void
97  Ptr<SpectrumPhy> txPhy,
98  Ptr<SpectrumPhy> rxPhy,
99  double lossDb)
100 {
101  uint32_t txNodeId = txPhy->GetMobility ()->GetObject<Node> ()->GetId ();
102  uint32_t rxNodeId = rxPhy->GetMobility ()->GetObject<Node> ()->GetId ();
103  m_pathlossMap[txNodeId][rxNodeId] = lossDb;
104 }
105 
106 void
108 {
109  for (std::map<uint32_t, std::map<uint32_t, double> >::const_iterator txit = m_pathlossMap.begin ();
110  txit != m_pathlossMap.end ();
111  ++txit)
112  {
113  for (std::map<uint32_t, double>::const_iterator rxit = txit->second.begin ();
114  rxit != txit->second.end ();
115  ++rxit)
116  {
117  std::cout << txit->first << " --> " << rxit->first << " : " << rxit->second << " dB" << std::endl;
118  }
119  }
120 }
121 
122 
123 
124 int main (int argc, char** argv)
125 {
127  double lossDb = 130;
128  double txPowerW = 0.1;
129  uint64_t phyRate = 500000;
130  uint32_t pktSize = 1000;
131  double simDuration = 0.5;
132  std::string channelType ("ns3::SingleModelSpectrumChannel");
133  cmd.AddValue ("verbose", "Print trace information if true", g_verbose);
134  cmd.AddValue ("lossDb", "link loss in dB", lossDb);
135  cmd.AddValue ("txPowerW", "txPower in Watts", txPowerW);
136  cmd.AddValue ("phyRate", "PHY rate in bps", phyRate);
137  cmd.AddValue ("pktSize", "packet size in bytes", pktSize);
138  cmd.AddValue ("simDuration", "duration of the simulation in seconds", simDuration);
139  cmd.AddValue ("channelType", "which SpectrumChannel implementation to be used", channelType);
140  cmd.Parse (argc, argv);
141 
142  NodeContainer c;
143  c.Create (2);
144 
146  mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");
147  mobility.Install (c);
148  // the actual positions are irrelevant, since we use MatrixPropagationLossModel
149 
150 
151  SpectrumChannelHelper channelHelper;
152  channelHelper.SetChannel (channelType);
153  channelHelper.SetPropagationDelay ("ns3::ConstantSpeedPropagationDelayModel");
154  Ptr<MatrixPropagationLossModel> propLoss = CreateObject<MatrixPropagationLossModel> ();
155  propLoss->SetLoss (c.Get (0)->GetObject<MobilityModel> (), c.Get (1)->GetObject<MobilityModel> (), lossDb, true);
156  channelHelper.AddPropagationLoss (propLoss);
157  Ptr<SpectrumChannel> channel = channelHelper.Create ();
158 
159 
161 
162  uint32_t channelNumber = 1;
163  Ptr<SpectrumValue> txPsd = sf.CreateTxPowerSpectralDensity (txPowerW, channelNumber);
164 
165  // for the noise, we use the Power Spectral Density of thermal noise
166  // at room temperature. The value of the PSD will be constant over the band of interest.
167  const double k = 1.381e-23; //Boltzmann's constant
168  const double T = 290; // temperature in Kelvin
169  double noisePsdValue = k * T; // watts per hertz
170  Ptr<SpectrumValue> noisePsd = sf.CreateConstant (noisePsdValue);
171 
172  AdhocAlohaNoackIdealPhyHelper deviceHelper;
173  deviceHelper.SetChannel (channel);
174  deviceHelper.SetTxPowerSpectralDensity (txPsd);
175  deviceHelper.SetNoisePowerSpectralDensity (noisePsd);
176  deviceHelper.SetPhyAttribute ("Rate", DataRateValue (DataRate (phyRate)));
177  NetDeviceContainer devices = deviceHelper.Install (c);
178 
179  PacketSocketHelper packetSocket;
180  packetSocket.Install (c);
181 
182  PacketSocketAddress socket;
183  socket.SetSingleDevice (devices.Get (0)->GetIfIndex ());
184  socket.SetPhysicalAddress (devices.Get (1)->GetAddress ());
185  socket.SetProtocol (1);
186 
187  OnOffHelper onoff ("ns3::PacketSocketFactory", Address (socket));
188  onoff.SetConstantRate (DataRate (2*phyRate));
189  onoff.SetAttribute ("PacketSize", UintegerValue (pktSize));
190 
191  ApplicationContainer apps = onoff.Install (c.Get (0));
192  apps.Start (Seconds (0.0));
193  apps.Stop (Seconds (simDuration));
194 
195  Config::Connect ("/NodeList/*/DeviceList/*/Phy/RxEndOk", MakeCallback (&PhyRxEndOkTrace));
196 
197  GlobalPathlossDatabase globalPathlossDatabase;
198  Config::Connect ("/ChannelList/*/PropagationLoss",
199  MakeCallback (&GlobalPathlossDatabase::UpdatePathloss, &globalPathlossDatabase));
200 
201  g_rxBytes = 0;
202  Simulator::Stop (Seconds (simDuration + 0.000001));
203  Simulator::Run ();
204 
205  if (g_verbose)
206  {
207  globalPathlossDatabase.Print ();
208 
209  double throughputBps = (g_rxBytes * 8.0) / simDuration;
210  std::cout << "throughput: " << throughputBps << std::endl;
211  std::cout << "throughput: " << std::setw (20) << std::fixed << throughputBps << " bps" << std::endl;
212  std::cout << "phy rate : " << std::setw (20) << std::fixed << phyRate*1.0 << " bps" << std::endl;
213  double rxPowerW = txPowerW / (std::pow (10.0, lossDb/10.0));
214  double capacity = 20e6*log2 (1.0 + (rxPowerW/20.0e6)/noisePsdValue);
215  std::cout << "shannon capacity: " << std::setw (20) << std::fixed << capacity << " bps" << std::endl;
216 
217  }
218 
219 
220 
222  return 0;
223 }
holds a vector of ns3::Application pointers.
void SetTxPowerSpectralDensity(Ptr< SpectrumValue > txPsd)
uint32_t GetSize(void) const
Returns the the size in bytes of the packet (including the zero-filled initial payload).
Definition: packet.h:852
void SetPhyAttribute(std::string name, const AttributeValue &v)
an address for a packet socket
static void Run(void)
Run the simulation.
Definition: simulator.cc:170
#define NS_LOG_COMPONENT_DEFINE(name)
Define a Log component with a specific name.
Definition: log.h:204
cmd
Definition: second.py:35
virtual Ptr< MobilityModel > GetMobility()=0
Get the associated MobilityModel instance.
A helper to make it easier to instantiate an ns3::OnOffApplication on a set of nodes.
Definition: on-off-helper.h:42
Give ns3::PacketSocket powers to ns3::Node.
void SetSingleDevice(uint32_t device)
Set the address to match only a specified NetDevice.
a polymophic address class
Definition: address.h:90
channel
Definition: third.py:92
mobility
Definition: third.py:108
Class for representing data rates.
Definition: data-rate.h:88
Keep track of the current position and velocity of an object.
void Print()
print the stored pathloss values to standard output
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())
Hold an unsigned integer type.
Definition: uinteger.h:44
void UpdatePathloss(std::string context, Ptr< SpectrumPhy > txPhy, Ptr< SpectrumPhy > rxPhy, double lossDb)
update the pathloss value
holds a vector of ns3::NetDevice pointers
Callback< R > MakeCallback(R(T::*memPtr)(void), OBJ objPtr)
Definition: callback.h:1489
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())
void Start(Time start)
Arrange for all of the Applications in this container to Start() at the Time given as a parameter...
Parse command-line arguments.
Definition: command-line.h:213
void Connect(std::string path, const CallbackBase &cb)
Definition: config.cc:871
static void Destroy(void)
Execute the events scheduled with ScheduleDestroy().
Definition: simulator.cc:134
Ptr< T > GetObject(void) const
Get a pointer to the requested aggregated Object.
Definition: object.h:459
virtual Ptr< SpectrumValue > CreateTxPowerSpectralDensity(double txPower, uint8_t channel)
Creates a SpectrumValue instance that represents the TX Power Spectral Density of a wifi device corre...
Every class exported by the ns3 library is enclosed in the ns3 namespace.
void SetPhysicalAddress(const Address address)
Set the destination address.
Store the last pathloss value for each TX-RX pair.
keep track of a set of node pointers.
virtual Ptr< SpectrumValue > CreateConstant(double psd)
Creates a SpectrumValue instance with a constant value for all frequencies.
void SetChannel(std::string type, 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())
void PhyRxEndOkTrace(std::string context, Ptr< const Packet > p)
Helper class used to assign positions and mobility models to nodes.
void Stop(Time stop)
Arrange for all of the Applications in this container to Stop() at the Time given as a parameter...
AttributeValue implementation for DataRate.
Definition: data-rate.h:242
static void Stop(void)
Tell the Simulator the calling event should be the last one executed.
Definition: simulator.cc:178
A network Node.
Definition: node.h:56
void Print(ComponentCarrier cc)
Time Seconds(double value)
Construct a Time in the indicated unit.
Definition: nstime.h:1062
void SetProtocol(uint16_t protocol)
Set the protocol.
void SetLoss(Ptr< MobilityModel > a, Ptr< MobilityModel > b, double loss, bool symmetric=true)
Set loss (in dB, positive) between pair of ns-3 objects (typically, nodes).
void SetChannel(Ptr< SpectrumChannel > channel)
set the SpectrumChannel that will be used by SpectrumPhy instances created by this helper ...
Ptr< Node > Get(uint32_t i) const
Get the Ptr<Node> stored in this container at a given index.
void Install(Ptr< Node > node) const
Aggregate an instance of a ns3::PacketSocketFactory onto the provided node.
std::map< uint32_t, std::map< uint32_t, double > > m_pathlossMap
Path loss map.
void Create(uint32_t n)
Create n nodes and append pointers to them to the end of this NodeContainer.
Setup a SpectrumChannel.
devices
Definition: first.py:32
Implements Wifi SpectrumValue for the 2.4 GHz ISM band only, with a 5 MHz spectrum resolution...
NetDeviceContainer Install(NodeContainer c) const
Ptr< SpectrumChannel > Create(void) const
void SetNoisePowerSpectralDensity(Ptr< SpectrumValue > noisePsd)