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

/*

 * Copyright (c) 2005,2006,2007 INRIA

 *

 * 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: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>

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

 * Contributions: Tom Hewer <tomhewer@mac.com> for Two Ray Ground Model

 *                Pavel Boyko <boyko@iitp.ru> for matrix

 */

#include "propagation-loss-model.h"

#include "ns3/log.h"

#include "ns3/mobility-model.h"

#include "ns3/boolean.h"

#include "ns3/double.h"

#include <math.h>

NS_LOG_COMPONENT_DEFINE ("PropagationLossModel");

namespace ns3 {

// ------------------------------------------------------------------------- //

NS_OBJECT_ENSURE_REGISTERED (PropagationLossModel);

TypeId 

PropagationLossModel::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::PropagationLossModel")

    .SetParent<Object> ()

  ;

  return tid;

}

PropagationLossModel::PropagationLossModel ()

  : m_next (0)

{

}

PropagationLossModel::~PropagationLossModel ()

{

}

void

PropagationLossModel::SetNext (Ptr<PropagationLossModel> next)

{

  m_next = next;

}

double

PropagationLossModel::CalcRxPower (double txPowerDbm,

                                   Ptr<MobilityModel> a,

                                   Ptr<MobilityModel> b) const

{

  double self = DoCalcRxPower (txPowerDbm, a, b);

  if (m_next != 0)

    {

      self = m_next->CalcRxPower (self, a, b);

    }

  return self;

}

// ------------------------------------------------------------------------- //

NS_OBJECT_ENSURE_REGISTERED (RandomPropagationLossModel);

TypeId 

RandomPropagationLossModel::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::RandomPropagationLossModel")

    .SetParent<PropagationLossModel> ()

    .AddConstructor<RandomPropagationLossModel> ()

    .AddAttribute ("Variable", "The random variable used to pick a loss everytime CalcRxPower is invoked.",

  ;

  return tid;

}

RandomPropagationLossModel::RandomPropagationLossModel ()

  : PropagationLossModel ()

{

}

RandomPropagationLossModel::~RandomPropagationLossModel ()

{

}

double

RandomPropagationLossModel::DoCalcRxPower (double txPowerDbm,

                                           Ptr<MobilityModel> a,

                                           Ptr<MobilityModel> b) const

{

  NS_LOG_DEBUG ("attenuation coefficent="<<rxc<<"Db");

  return txPowerDbm + rxc;

}

// ------------------------------------------------------------------------- //

NS_OBJECT_ENSURE_REGISTERED (FriisPropagationLossModel);

const double FriisPropagationLossModel::PI = 3.14159265358979323846;

TypeId 

FriisPropagationLossModel::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::FriisPropagationLossModel")

    .SetParent<PropagationLossModel> ()

    .AddConstructor<FriisPropagationLossModel> ()

    .AddAttribute ("Lambda", 

                   "The wavelength  (default is 5.15 GHz at 300 000 km/s).",

                   DoubleValue (300000000.0 / 5.150e9),

                   MakeDoubleAccessor (&FriisPropagationLossModel::m_lambda),

                   MakeDoubleChecker<double> ())

    .AddAttribute ("SystemLoss", "The system loss",

                   DoubleValue (1.0),

                   MakeDoubleAccessor (&FriisPropagationLossModel::m_systemLoss),

                   MakeDoubleChecker<double> ())

    .AddAttribute ("MinDistance", 

                   "The distance under which the propagation model refuses to give results (m)",

                   DoubleValue (0.5),

                   MakeDoubleAccessor (&FriisPropagationLossModel::SetMinDistance,

                                       &FriisPropagationLossModel::GetMinDistance),

                   MakeDoubleChecker<double> ())

  ;

  return tid;

}

FriisPropagationLossModel::FriisPropagationLossModel ()

{

}

void

FriisPropagationLossModel::SetSystemLoss (double systemLoss)

{

  m_systemLoss = systemLoss;

}

double

FriisPropagationLossModel::GetSystemLoss (void) const

{

  return m_systemLoss;

}

void

FriisPropagationLossModel::SetMinDistance (double minDistance)

{

  m_minDistance = minDistance;

}

double

FriisPropagationLossModel::GetMinDistance (void) const

{

  return m_minDistance;

}

void

FriisPropagationLossModel::SetLambda (double frequency, double speed)

{

  m_lambda = speed / frequency;

}

void

FriisPropagationLossModel::SetLambda (double lambda)

{

  m_lambda = lambda;

}

double

FriisPropagationLossModel::GetLambda (void) const

{

  return m_lambda;

}

double

FriisPropagationLossModel::DbmToW (double dbm) const

{

  double mw = pow (10.0,dbm/10.0);

  return mw / 1000.0;

}

double

FriisPropagationLossModel::DbmFromW (double w) const

{

  double dbm = log10 (w * 1000.0) * 10.0;

  return dbm;

}

double 

FriisPropagationLossModel::DoCalcRxPower (double txPowerDbm,

                                          Ptr<MobilityModel> a,

                                          Ptr<MobilityModel> b) const

{

  /*

   * Friis free space equation:

   * where Pt, Gr, Gr and P are in Watt units

   * L is in meter units.

   *

   *    P     Gt * Gr * (lambda^2)

   *   --- = ---------------------

   *    Pt     (4 * pi * d)^2 * L

   *

   * Gt: tx gain (unit-less)

   * Gr: rx gain (unit-less)

   * Pt: tx power (W)

   * d: distance (m)

   * L: system loss

   * lambda: wavelength (m)

   *

   * Here, we ignore tx and rx gain and the input and output values 

   * are in dB or dBm:

   *

   *                           lambda^2

   * rx = tx +  10 log10 (-------------------)

   *                       (4 * pi * d)^2 * L

   *

   * rx: rx power (dB)

   * tx: tx power (dB)

   * d: distance (m)

   * L: system loss (unit-less)

   * lambda: wavelength (m)

   */

  double distance = a->GetDistanceFrom (b);

  if (distance <= m_minDistance)

    {

      return txPowerDbm;

    }

  double numerator = m_lambda * m_lambda;

  double denominator = 16 * PI * PI * distance * distance * m_systemLoss;

  double pr = 10 * log10 (numerator / denominator);

  NS_LOG_DEBUG ("distance="<<distance<<"m, attenuation coefficient="<<pr<<"dB");

  return txPowerDbm + pr;

}

// ------------------------------------------------------------------------- //

// -- Two-Ray Ground Model ported from NS-2 -- tomhewer@mac.com -- Nov09 //

NS_OBJECT_ENSURE_REGISTERED (TwoRayGroundPropagationLossModel);

const double TwoRayGroundPropagationLossModel::PI = 3.14159265358979323846;

TypeId 

TwoRayGroundPropagationLossModel::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::TwoRayGroundPropagationLossModel")

    .SetParent<PropagationLossModel> ()

    .AddConstructor<TwoRayGroundPropagationLossModel> ()

    .AddAttribute ("Lambda",

                   "The wavelength  (default is 5.15 GHz at 300 000 km/s).",

                   DoubleValue (300000000.0 / 5.150e9),

                   MakeDoubleAccessor (&TwoRayGroundPropagationLossModel::m_lambda),

                   MakeDoubleChecker<double> ())

    .AddAttribute ("SystemLoss", "The system loss",

                   DoubleValue (1.0),

                   MakeDoubleAccessor (&TwoRayGroundPropagationLossModel::m_systemLoss),

                   MakeDoubleChecker<double> ())

    .AddAttribute ("MinDistance",

                   "The distance under which the propagation model refuses to give results (m)",

                   DoubleValue (0.5),

                   MakeDoubleAccessor (&TwoRayGroundPropagationLossModel::SetMinDistance,

                                       &TwoRayGroundPropagationLossModel::GetMinDistance),

                   MakeDoubleChecker<double> ())

    .AddAttribute ("HeightAboveZ",

                   "The height of the antenna (m) above the node's Z coordinate",

                   DoubleValue (0),

                   MakeDoubleAccessor (&TwoRayGroundPropagationLossModel::m_heightAboveZ),

                   MakeDoubleChecker<double> ())

  ;

  return tid;

}

TwoRayGroundPropagationLossModel::TwoRayGroundPropagationLossModel ()

{

}

void

TwoRayGroundPropagationLossModel::SetSystemLoss (double systemLoss)

{

  m_systemLoss = systemLoss;

}

double

TwoRayGroundPropagationLossModel::GetSystemLoss (void) const

{

  return m_systemLoss;

}

void

TwoRayGroundPropagationLossModel::SetMinDistance (double minDistance)

{

  m_minDistance = minDistance;

}

double

TwoRayGroundPropagationLossModel::GetMinDistance (void) const

{

  return m_minDistance;

}

void

TwoRayGroundPropagationLossModel::SetHeightAboveZ (double heightAboveZ)

{

  m_heightAboveZ = heightAboveZ;

}

void 

TwoRayGroundPropagationLossModel::SetLambda (double frequency, double speed)

{

  m_lambda = speed / frequency;

}

void 

TwoRayGroundPropagationLossModel::SetLambda (double lambda)

{

  m_lambda = lambda;

}

double 

TwoRayGroundPropagationLossModel::GetLambda (void) const

{

  return m_lambda;

}

double 

TwoRayGroundPropagationLossModel::DbmToW (double dbm) const

{

  double mw = pow (10.0,dbm / 10.0);

  return mw / 1000.0;

}

double

TwoRayGroundPropagationLossModel::DbmFromW (double w) const

{

  double dbm = log10 (w * 1000.0) * 10.0;

  return dbm;

}

double 

TwoRayGroundPropagationLossModel::DoCalcRxPower (double txPowerDbm,

                                                 Ptr<MobilityModel> a,

                                                 Ptr<MobilityModel> b) const

{

  /*

   * Two-Ray Ground equation:

   *

   * where Pt, Gt and Gr are in dBm units

   * L, Ht and Hr are in meter units.

   *

   *   Pr      Gt * Gr * (Ht^2 * Hr^2)

   *   -- =  (-------------------------)

   *   Pt            d^4 * L

   *

   * Gt: tx gain (unit-less)

   * Gr: rx gain (unit-less)

   * Pt: tx power (dBm)

   * d: distance (m)

   * L: system loss

   * Ht: Tx antenna height (m)

   * Hr: Rx antenna height (m)

   * lambda: wavelength (m)

   *

   * As with the Friis model we ignore tx and rx gain and output values

   * are in dB or dBm

   *

   *                      (Ht * Ht) * (Hr * Hr)

   * rx = tx + 10 log10 (-----------------------)

   *                      (d * d * d * d) * L

   */

  double distance = a->GetDistanceFrom (b);

  if (distance <= m_minDistance)

    {

      return txPowerDbm;

    }

  // Set the height of the Tx and Rx antennae

  double txAntHeight = a->GetPosition ().z + m_heightAboveZ;

  double rxAntHeight = b->GetPosition ().z + m_heightAboveZ;

  // Calculate a crossover distance, under which we use Friis

  /*

   * 

   * dCross = (4 * pi * Ht * Hr) / lambda

   *

   */

  double dCross = (4 * PI * txAntHeight * rxAntHeight) / GetLambda ();

  double tmp = 0;

  if (distance <= dCross)

    {

      // We use Friis

      double numerator = m_lambda * m_lambda;

      tmp = PI * distance;

      double denominator = 16 * tmp * tmp * m_systemLoss;

      double pr = 10 * log10 (numerator / denominator);

      NS_LOG_DEBUG ("Receiver within crossover (" << dCross << "m) for Two_ray path; using Friis");

      NS_LOG_DEBUG ("distance=" << distance << "m, attenuation coefficient=" << pr << "dB");

      return txPowerDbm + pr;

    }

  else   // Use Two-Ray Pathloss

    {

      tmp = txAntHeight * rxAntHeight;

      double rayNumerator = tmp * tmp;

      tmp = distance * distance;

      double rayDenominator = tmp * tmp * m_systemLoss;

      double rayPr = 10 * log10 (rayNumerator / rayDenominator);

      NS_LOG_DEBUG ("distance=" << distance << "m, attenuation coefficient=" << rayPr << "dB");

      return txPowerDbm + rayPr;

    }

}

// ------------------------------------------------------------------------- //

NS_OBJECT_ENSURE_REGISTERED (LogDistancePropagationLossModel);

TypeId

LogDistancePropagationLossModel::GetTypeId (void)

{

  static TypeId tid = TypeId ("ns3::LogDistancePropagationLossModel")

    .SetParent<PropagationLossModel> ()

    .AddConstructor<LogDistancePropagationLossModel> ()

    .AddAttribute ("Exponent",

                   "The exponent of the Path Loss propagation model",

                   DoubleValue (3.0),

                   MakeDoubleAccessor (&LogDistancePropagationLossModel::m_exponent),

                   MakeDoubleChecker<double> ())

    .AddAttribute ("ReferenceDistance",

                   "The distance at which the reference loss is calculated (m)",

                   DoubleValue (1.0),

                   MakeDoubleAccessor (&LogDistancePropagationLossModel::m_referenceDistance),

                   MakeDoubleChecker<double> ())

    .AddAttribute ("ReferenceLoss",

                   "The reference loss at reference distance (dB). (Default is Friis at 1m with 5.15 GHz)",

                   DoubleValue (46.6777),

                   MakeDoubleAccessor (&LogDistancePropagationLossModel::m_referenceLoss),

                   MakeDoubleChecker<double> ())

  ;

  return tid;

}

LogDistancePropagationLossModel::LogDistancePropagationLossModel ()

{

}

void

LogDistancePropagationLossModel::SetPathLossExponent (double n)

{

  m_exponent = n;

}

void

LogDistancePropagationLossModel::SetReference (double referenceDistance, double referenceLoss)

{

  m_referenceDistance = referenceDistance;

  m_referenceLoss = referenceLoss;

}

double

LogDistancePropagationLossModel::GetPathLossExponent (void) const

{

  return m_exponent;

}

double

LogDistancePropagationLossModel::DoCalcRxPower (double txPowerDbm,

                                                Ptr<MobilityModel> a,

                                                Ptr<MobilityModel> b) const

{

  double distance = a->GetDistanceFrom (b);

  if (distance <= m_referenceDistance)