/* -*-  Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */

/*

 * Copyright (c) 2008 Timo Bingmann

 *

 * 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

 *

 * Author: Timo Bingmann <timo.bingmann@student.kit.edu>

 */

#include "ns3/propagation-loss-model.h"

#include "ns3/jakes-propagation-loss-model.h"

#include "ns3/constant-position-mobility-model.h"

#include "ns3/config.h"

#include "ns3/string.h"

#include "ns3/boolean.h"

#include "ns3/double.h"

#include "ns3/gnuplot.h"

#include "ns3/simulator.h"

#include <map>

using namespace ns3;

/// Round a double number to the given precision. e.g. dround(0.234, 0.1) = 0.2

/// and dround(0.257, 0.1) = 0.3

static double dround(double number, double precision)

{

  number /= precision;

  if (number >= 0)

    {

      number = floor(number + 0.5);

    }

  else

    {

      number = ceil(number - 0.5);

    }

  number *= precision;

  return number;

}

static Gnuplot

TestDeterministic (Ptr<PropagationLossModel> model)

{

  Ptr<ConstantPositionMobilityModel> a = CreateObject<ConstantPositionMobilityModel> ();

  Ptr<ConstantPositionMobilityModel> b = CreateObject<ConstantPositionMobilityModel> ();

  Gnuplot plot;

  plot.AppendExtra("set xlabel 'Distance'");

  plot.AppendExtra("set ylabel 'rxPower (dBm)'");

  plot.AppendExtra("set key top right");

  double txPowerDbm = +20; // dBm

  Gnuplot2dDataset dataset;

  dataset.SetStyle(Gnuplot2dDataset::LINES);

  {

    a->SetPosition (Vector (0.0, 0.0, 0.0));

    for (double distance = 0.0; distance < 2500.0; distance += 10.0)

      {

        b->SetPosition (Vector (distance, 0.0, 0.0));

        // CalcRxPower() returns dBm.

        double rxPowerDbm = model->CalcRxPower (txPowerDbm, a, b);

        dataset.Add(distance, rxPowerDbm);

        Simulator::Stop (Seconds (1.0));

        Simulator::Run ();

      }

  }

  std::ostringstream os;

  os << "txPower " << txPowerDbm << "dBm";

  dataset.SetTitle(os.str());

  plot.AddDataset(dataset);

  plot.AddDataset( Gnuplot2dFunction("-94 dBm CSThreshold", "-94.0") );

  return plot;

}

static Gnuplot

TestProbabilistic (Ptr<PropagationLossModel> model, unsigned int samples = 100000)

{

  Ptr<ConstantPositionMobilityModel> a = CreateObject<ConstantPositionMobilityModel> ();

  Ptr<ConstantPositionMobilityModel> b = CreateObject<ConstantPositionMobilityModel> ();

  Gnuplot plot;

  plot.AppendExtra("set xlabel 'Distance'");

  plot.AppendExtra("set ylabel 'rxPower (dBm)'");

  plot.AppendExtra("set zlabel 'Probability' offset 0,+10");

  plot.AppendExtra("set view 50, 120, 1.0, 1.0");

  plot.AppendExtra("set key top right");

  plot.AppendExtra("set ticslevel 0");

  plot.AppendExtra("set xtics offset -0.5,0");

  plot.AppendExtra("set ytics offset 0,-0.5");

  plot.AppendExtra("set xrange [100:]");

  double txPowerDbm = +20; // dBm

  Gnuplot3dDataset dataset;

  dataset.SetStyle("with linespoints");

  dataset.SetExtra("pointtype 3 pointsize 0.5");

  typedef std::map<double, unsigned int> rxPowerMapType;

  // Take given number of samples from CalcRxPower() and show probability

  // density for discrete distances.

  {

    a->SetPosition (Vector (0.0, 0.0, 0.0));

    for (double distance = 100.0; distance < 2500.0; distance += 100.0)

      {

        b->SetPosition (Vector (distance, 0.0, 0.0));

        rxPowerMapType rxPowerMap;

        for (unsigned int samp = 0; samp < samples; ++samp)

          {

            // CalcRxPower() returns dBm.

            double rxPowerDbm = model->CalcRxPower (txPowerDbm, a, b);

            rxPowerDbm = dround(rxPowerDbm, 1.0);

            rxPowerMap[ rxPowerDbm ] ++;

            Simulator::Stop (Seconds (0.01));

            Simulator::Run ();

          }

        for (rxPowerMapType::const_iterator i = rxPowerMap.begin();

             i != rxPowerMap.end(); ++i)

          {

            dataset.Add(distance, i->first, (double)i->second / (double)samples);

          }

        dataset.AddEmptyLine();

      }

  }

  std::ostringstream os;

  os << "txPower " << txPowerDbm << "dBm";

  dataset.SetTitle(os.str());

  plot.AddDataset(dataset);

  return plot;

}

static Gnuplot

TestDeterministicByTime (Ptr<PropagationLossModel> model,

                         Time timeStep = Seconds(0.001),

                         Time timeTotal = Seconds(1.0),

                         double distance = 100.0)

{

  Ptr<ConstantPositionMobilityModel> a = CreateObject<ConstantPositionMobilityModel> ();

  Ptr<ConstantPositionMobilityModel> b = CreateObject<ConstantPositionMobilityModel> ();

  Gnuplot plot;

  plot.AppendExtra("set xlabel 'Time (s)'");

  plot.AppendExtra("set ylabel 'rxPower (dBm)'");

  plot.AppendExtra("set key center right");

  double txPowerDbm = +20; // dBm

  Gnuplot2dDataset dataset;

  dataset.SetStyle(Gnuplot2dDataset::LINES);

  {

    a->SetPosition (Vector (0.0, 0.0, 0.0));

    b->SetPosition (Vector (distance, 0.0, 0.0));

    Time start = Simulator::Now();

    while( Simulator::Now() < start + timeTotal )

      {

        // CalcRxPower() returns dBm.

        double rxPowerDbm = model->CalcRxPower (txPowerDbm, a, b);

        Time elapsed = Simulator::Now() - start;

        dataset.Add(elapsed.GetSeconds(), rxPowerDbm);

        Simulator::Stop (timeStep);

        Simulator::Run ();

      }

  }

  std::ostringstream os;

  os << "txPower " << txPowerDbm << "dBm";

  dataset.SetTitle(os.str());

  plot.AddDataset(dataset);

  plot.AddDataset( Gnuplot2dFunction("-94 dBm CSThreshold", "-94.0") );

  return plot;

}

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

{

  GnuplotCollection gnuplots("main-propagation-loss.pdf");

  {

    Ptr<FriisPropagationLossModel> friis = CreateObject<FriisPropagationLossModel> ();

    Gnuplot plot = TestDeterministic(friis);

    plot.SetTitle("ns3::FriisPropagationLossModel (Default Parameters)");

    gnuplots.AddPlot(plot);

  }

  {

    Ptr<LogDistancePropagationLossModel> log = CreateObject<LogDistancePropagationLossModel> ();

    log->SetAttribute("Exponent", DoubleValue (2.5));

    Gnuplot plot = TestDeterministic(log);

    plot.SetTitle("ns3::LogDistancePropagationLossModel (Exponent = 2.5)");

    gnuplots.AddPlot(plot);

  }

  {

    Ptr<RandomPropagationLossModel> random = CreateObject<RandomPropagationLossModel> ();

    random->SetAttribute("Variable", RandomVariableValue(ExponentialVariable(50.0)));

    Gnuplot plot = TestDeterministic(random);

    plot.SetTitle("ns3::RandomPropagationLossModel with Exponential Distribution");

    gnuplots.AddPlot(plot);

  }

  {

    Ptr<JakesPropagationLossModel> jakes = CreateObject<JakesPropagationLossModel> ();

    // doppler frequency shift for 5.15 GHz at 100 km/h

    jakes->SetAttribute("DopplerFreq", DoubleValue(477.9));

    Gnuplot plot = TestDeterministicByTime (jakes, Seconds(0.001), Seconds(1.0));

    plot.SetTitle("ns3::JakesPropagationLossModel (with 477.9 Hz shift and 1 millisec resolution)");

    gnuplots.AddPlot(plot);

  }

  {

    Ptr<JakesPropagationLossModel> jakes = CreateObject<JakesPropagationLossModel> ();

    // doppler frequency shift for 5.15 GHz at 100 km/h

    jakes->SetAttribute("DopplerFreq", DoubleValue(477.9));

    Gnuplot plot = TestDeterministicByTime (jakes, Seconds(0.0001), Seconds(0.1));

    plot.SetTitle("ns3::JakesPropagationLossModel (with 477.9 Hz shift and 0.1 millisec resolution)");

    gnuplots.AddPlot(plot);

  }

  {

    Ptr<ThreeLogDistancePropagationLossModel> log3 = CreateObject<ThreeLogDistancePropagationLossModel> ();

    Gnuplot plot = TestDeterministic(log3);

    plot.SetTitle("ns3::ThreeLogDistancePropagationLossModel (Defaults)");

    gnuplots.AddPlot(plot);

  }

  {

    Ptr<ThreeLogDistancePropagationLossModel> log3 = CreateObject<ThreeLogDistancePropagationLossModel> ();

    // more prominent example values:

    log3->SetAttribute("Exponent0", DoubleValue(1.0));

    log3->SetAttribute("Exponent1", DoubleValue(3.0));

    log3->SetAttribute("Exponent2", DoubleValue(10.0));

    Gnuplot plot = TestDeterministic(log3);

    plot.SetTitle("ns3::ThreeLogDistancePropagationLossModel (Exponents 1.0, 3.0 and 10.0)");

    gnuplots.AddPlot(plot);

  }

  {

    Ptr<NakagamiPropagationLossModel> nak = CreateObject<NakagamiPropagationLossModel> ();

    Gnuplot plot = TestProbabilistic(nak);

    plot.SetTitle("ns3::NakagamiPropagationLossModel (Default Parameters)");

    gnuplots.AddPlot(plot);

  }

  {

    Ptr<ThreeLogDistancePropagationLossModel> log3 = CreateObject<ThreeLogDistancePropagationLossModel> ();

    Ptr<NakagamiPropagationLossModel> nak = CreateObject<NakagamiPropagationLossModel> ();

    log3->SetNext(nak);

    Gnuplot plot = TestProbabilistic(log3);

    plot.SetTitle("ns3::ThreeLogDistancePropagationLossModel and ns3::NakagamiPropagationLossModel (Default Parameters)");

    gnuplots.AddPlot(plot);

  }

  gnuplots.GenerateOutput(std::cout);

  return 0;

}