/* 

  * Instructions:

  * ./waf --run multi-rate-second

  * gnuplot multi-rate-second.plt 

  *

  * Output: multi-rate-second.eps 

  *

  */

 #include "ns3/core-module.h"

 #include "ns3/common-module.h"

 #include "ns3/node-module.h"

 #include "ns3/helper-module.h"

 #include "ns3/mobility-module.h"

 #include "ns3/contrib-module.h"

 #include <iostream>

 #include <fstream>

 #include <vector>

 #include <string>

 NS_LOG_COMPONENT_DEFINE ("Main");

 using namespace ns3;

 class Experiment

 {

 public:

   Experiment ();

   Experiment (std::string name);

   Gnuplot2dDataset Run (const WifiHelper &wifi, const YansWifiPhyHelper &wifiPhy,

                         const NqosWifiMacHelper &wifiMac, const YansWifiChannelHelper &wifiChannel);

 private:

   void ReceivePacket (Ptr<Socket> socket);

   void SetPosition (Ptr<Node> node, Vector position);

   Vector GetPosition (Ptr<Node> node);

   Ptr<Socket> SetupPacketReceive (Ptr<Node> node);

   void GenerateTraffic (Ptr<Socket> socket, uint32_t pktSize, 

                         uint32_t pktCount, Time pktInterval , Ptr<Node> node);

   uint32_t m_pktsTotal;

   Gnuplot2dDataset m_output;

   bool advanceStep; 

 };

 Experiment::Experiment ()

 {

   advanceStep= true;

 }

 Experiment::Experiment (std::string name)

   : m_output (name)

 {

   m_output.SetStyle (Gnuplot2dDataset::LINES);

 }

 void

 Experiment::SetPosition (Ptr<Node> node, Vector position)

 {

   Ptr<MobilityModel> mobility = node->GetObject<MobilityModel> ();

   mobility->SetPosition (position);

 }

 Vector

 Experiment::GetPosition (Ptr<Node> node)

 {

   Ptr<MobilityModel> mobility = node->GetObject<MobilityModel> ();

   return mobility->GetPosition ();

 }

 void

 Experiment::ReceivePacket (Ptr<Socket> socket)

 {

   Ptr<Packet> packet;

   while (packet = socket->Recv ())

     {

       m_pktsTotal ++;

     }

 }

 Ptr<Socket>

 Experiment::SetupPacketReceive (Ptr<Node> node)

 {

   TypeId tid = TypeId::LookupByName ("ns3::UdpSocketFactory");

   Ptr<Socket> sink = Socket::CreateSocket (node, tid);

   InetSocketAddress local = InetSocketAddress (Ipv4Address::GetAny (), 80);

   sink->Bind (local);

   sink->SetRecvCallback (MakeCallback (&Experiment::ReceivePacket, this));

   return sink;

 }

 void

 Experiment::GenerateTraffic (Ptr<Socket> socket, uint32_t pktSize, 

                              uint32_t pktCount, Time pktInterval, Ptr<Node> node )

 {

   Vector pos = GetPosition(node);

   ///to offset the start time

   double offSetTime = 100;

   if (pktCount > 0)

     {

       ///To simulate nodes moving in and out of transmission constantly

       if(pos.x <= 305 && advanceStep)

         {

           ///keep moving away

           pos.x += .1;

           SetPosition(node, pos);

         }

       else

         {

           if(pos.x < 150)

 	    {

               advanceStep=true;

             }

           else

             {

               advanceStep = false;

             }			

           ///moving back in

           pos.x -= .1;

           SetPosition(node, pos);

         }

       socket->Send (Create<Packet> (pktSize));

       Simulator::Schedule (pktInterval, &Experiment::GenerateTraffic, this, 

                            socket, pktSize,pktCount-1, pktInterval, node);

     }

   else

     {

       m_output.Add((Simulator::Now()).GetSeconds() - offSetTime , m_pktsTotal); 

     }

 }

 Gnuplot2dDataset

 Experiment::Run (const WifiHelper &wifi, const YansWifiPhyHelper &wifiPhy,

                  const NqosWifiMacHelper &wifiMac, const YansWifiChannelHelper &wifiChannel)

 {

   m_pktsTotal = 0;

   NodeContainer c;

   c.Create (2);

   YansWifiPhyHelper phy = wifiPhy;

   phy.SetChannel (wifiChannel.Create ());

   NqosWifiMacHelper mac = wifiMac;

   NetDeviceContainer devices = wifi.Install (phy, mac, c);

   MobilityHelper mobility;

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

   positionAlloc->Add (Vector (0.0, 0.0, 0.0));

   positionAlloc->Add (Vector (5.0, 0.0, 0.0));

   mobility.SetPositionAllocator (positionAlloc);

   mobility.SetMobilityModel ("ns3::ConstantPositionMobilityModel");

   mobility.Install (c);

   InternetStackHelper internet;

   internet.Install (c);

   Ipv4AddressHelper ipv4;

   NS_LOG_INFO ("Assign IP Addresses.");

   ipv4.SetBase ("10.1.1.0", "255.255.255.0");

   Ipv4InterfaceContainer wifiNodesInterface = ipv4.Assign (devices);

   Ptr<Socket> recvSink = SetupPacketReceive (c.Get (0));

   TypeId tid = TypeId::LookupByName ("ns3::UdpSocketFactory");

   Ptr<Socket> source = Socket::CreateSocket (c.Get (1), tid);

   InetSocketAddress remote = InetSocketAddress (Ipv4Address ("255.255.255.255"), 80);

   source->Connect (remote);

   uint32_t packetSize = 1014;

   uint32_t maxPacketCount = 1000;

   Time interPacketInterval = Seconds (.1);

   Ptr<Node> n1 = c.Get(0);

   Ptr<Ipv4> ipv41 = n1->GetObject<Ipv4> ();

   for (int i= 1; i <= 100; i++) 

     {

       Simulator::Schedule (Seconds (i), &Experiment::GenerateTraffic,

                            this, source, packetSize, maxPacketCount,interPacketInterval, c.Get(1));

       if( i % 5 == 0 )

         {

           ///bring a network interface down 

           Simulator::Schedule (Seconds (i+.5), &Ipv4::SetDown, ipv41, 1); 

           i++;

           Simulator::Schedule (Seconds (i), &Experiment::GenerateTraffic,

                                this, source, packetSize, maxPacketCount,interPacketInterval, c.Get(1));

           ///bring a network interface up

           Simulator::Schedule (Seconds (i+.2), &Ipv4::SetUp, ipv41, 1); 

           i++;

           Simulator::Schedule (Seconds (i), &Experiment::GenerateTraffic,

                                this, source, packetSize, maxPacketCount,interPacketInterval, c.Get(1));

         }

     }

   Simulator::Run ();

   Simulator::Destroy ();

   return m_output;

 }

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

 {

   std::vector <std::string> ratesControl;

   ratesControl.push_back ("Ideal");

   ratesControl.push_back ("Minstrel");

   std::vector <std::string> wifiManager;

   wifiManager.push_back("ns3::IdealWifiManager");

   wifiManager.push_back("ns3::MinstrelWifiManager");

   // disable fragmentation

   Config::SetDefault ("ns3::WifiRemoteStationManager::FragmentationThreshold", StringValue ("2200"));

   Config::SetDefault ("ns3::WifiRemoteStationManager::RtsCtsThreshold", StringValue ("2200"));

   CommandLine cmd;

   cmd.Parse (argc, argv);

   Gnuplot gnuplot = Gnuplot ("multi-rate-second.eps");

   for (uint32_t i = 0; i < ratesControl.size(); i++)

   {

     Gnuplot2dDataset dataset (ratesControl[i]);

     dataset.SetStyle (Gnuplot2dDataset::LINES);

     Experiment experiment;

     WifiHelper wifi = WifiHelper::Default ();

     NqosWifiMacHelper wifiMac = NqosWifiMacHelper::Default ();

     YansWifiPhyHelper wifiPhy = YansWifiPhyHelper::Default ();

     YansWifiChannelHelper wifiChannel  = YansWifiChannelHelper::Default ();

     wifiMac.SetType ("ns3::AdhocWifiMac");

     NS_LOG_DEBUG (ratesControl[i]);

     experiment = Experiment (ratesControl[i]);

     dataset = experiment.Run (wifi, wifiPhy, wifiMac, wifiChannel);

     gnuplot.AddDataset (dataset);

   }

   gnuplot.SetTerminal ("postscript eps color enh \"Times-BoldItalic\"");

   gnuplot.SetLegend ("Time (Seconds)", "Number of packets received");

   gnuplot.SetExtra  ("set xrange [0:100]");

   gnuplot.GenerateOutput (std::cout);

   return 0;

 }