// Added for Two-Ray Ground Model - tomhewer@mac.com

class TwoRayGroundPropagationLossModelTestCase : public TestCase

{

public:

  TwoRayGroundPropagationLossModelTestCase ();

  virtual ~TwoRayGroundPropagationLossModelTestCase ();

private:

  virtual bool DoRun (void);

  typedef struct {

    Vector m_position;

    double m_pt;  // dBm

    double m_pr;  // W

    double m_tolerance;

  } TestVector;

  TestVectors<TestVector> m_testVectors;

};

TwoRayGroundPropagationLossModelTestCase::TwoRayGroundPropagationLossModelTestCase ()

: TestCase ("Check to see that the ns-3 TwoRayGround propagation loss model provides correct received power"), m_testVectors ()

{

}

TwoRayGroundPropagationLossModelTestCase::~TwoRayGroundPropagationLossModelTestCase ()

{

}

bool

TwoRayGroundPropagationLossModelTestCase::DoRun (void)

{

  // wavelength at 2.4 GHz is 0.125m

  Config::SetDefault ("ns3::TwoRayGroundPropagationLossModel::Lambda", DoubleValue (0.125));

  Config::SetDefault ("ns3::TwoRayGroundPropagationLossModel::SystemLoss", DoubleValue (1.0));

  // set antenna height to 1.5m above z coordinate

  Config::SetDefault ("ns3::TwoRayGroundPropagationLossModel::HeightAboveZ", DoubleValue (1.5));

  // Select a reference transmit power of 17.0206 dBm

  // Pt = 10^(17.0206/10)/10^3 = .05035702 W

  double txPowerW = 0.05035702;

  double txPowerdBm = 10 * log10 (txPowerW) + 30;

  //

  // As with the Friis tests above, we want to test the propagation loss 

  // model calculations at a few chosen distances and compare the results 

  // to those we can manually calculate. Let us test the ns-3 calculated 

  // value for agreement to be within 5e-16, as above.

  //

  TestVector testVector;

  // Below the Crossover distance use Friis so this test should be the same as that above

  // Crossover = (4 * PI * TxAntennaHeight * RxAntennaHeight) / Lamdba

  // Crossover = (4 * PI * 1.5 * 1.5) / 0.125 = 226.1946m

  testVector.m_position = Vector (100, 0, 0);

  testVector.m_pt = txPowerdBm;

  testVector.m_pr = 4.98265e-10;

  testVector.m_tolerance = 5e-16;

  m_testVectors.Add (testVector);

  // These values are above the crossover distance and therefore use the Two Ray calculation

  testVector.m_position = Vector (500, 0, 0);

  testVector.m_pt = txPowerdBm;

  testVector.m_pr = 4.07891862e-12;

  testVector.m_tolerance = 5e-16;

  m_testVectors.Add (testVector);

  testVector.m_position = Vector (1000, 0, 0);

  testVector.m_pt = txPowerdBm;

  testVector.m_pr = 2.5493241375e-13;

  testVector.m_tolerance = 5e-16;

  m_testVectors.Add (testVector);

  testVector.m_position = Vector (2000, 0, 0);

  testVector.m_pt = txPowerdBm;

  testVector.m_pr = 1.593327585938e-14;

  testVector.m_tolerance = 5e-16;

  m_testVectors.Add (testVector);

  // Repeat the tests for non-zero z coordinates

  // Pr = (0.05035702 * (1.5*1.5) * (2.5*2.5)) / (500*500*500*500) = 1.13303295e-11

  // dCross = (4 * pi * 1.5 * 2.5) / 0.125 = 376.99m

  testVector.m_position = Vector (500, 0, 1);

  testVector.m_pt = txPowerdBm;

  testVector.m_pr = 1.13303295e-11;

  testVector.m_tolerance = 5e-16;

  m_testVectors.Add (testVector);

  // Pr = (0.05035702 * (1.5*1.5) * (5.5*5.5)) / (1000*1000*1000*1000) = 3.42742467375e-12

  // dCross = (4 * pi * 1.5 * 5.5) / 0.125 = 829.38m

  testVector.m_position = Vector (1000, 0, 4);

  testVector.m_pt = txPowerdBm;

  testVector.m_pr = 3.42742467375e-12;

  testVector.m_tolerance = 5e-16;

  m_testVectors.Add (testVector);

  // Pr = (0.05035702 * (1.5*1.5) * (11.5*11.5)) / (2000*2000*2000*2000) = 9.36522547734e-13

  // dCross = (4 * pi * 1.5 * 11.5) / 0.125 = 1734.15m

  testVector.m_position = Vector (2000, 0, 10);

  testVector.m_pt = txPowerdBm;

  testVector.m_pr = 9.36522547734e-13;

  testVector.m_tolerance = 5e-16;

  m_testVectors.Add (testVector);

  // Now, check that the received power values are expected

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

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

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

  Ptr<TwoRayGroundPropagationLossModel> lossModel = CreateObject<TwoRayGroundPropagationLossModel> (); 

  for (uint32_t i = 0; i < m_testVectors.GetN (); ++i)

  {

    testVector = m_testVectors.Get (i);

    b->SetPosition (testVector.m_position);

    double resultdBm = lossModel->CalcRxPower (testVector.m_pt, a, b);

    double resultW =   pow (10.0, resultdBm/10.0)/1000;

    NS_TEST_EXPECT_MSG_EQ_TOL (resultW, testVector.m_pr, testVector.m_tolerance, "Got unexpected rcv power");

  }

  return GetErrorStatus ();

}

  AddTestCase (new TwoRayGroundPropagationLossModelTestCase);

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

}

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

// -- 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;

  }

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

};

/*

 *

 * \brief a Two-Ray Ground propagation loss model ported from NS2

 *

 * Two-ray ground reflection model.

 *

 * \f$ Pr = \frac{Pt * Gt * Gr * (ht^2 * hr^2)}{d^4 * L} \f$

 *

 * The original equation in Rappaport's book assumes L = 1.

 * To be consistant with the free space equation, L is added here.	 

 *

 * Ht and Hr are set at the respective nodes z coordinate plus a model parameter

 * set via SetHeightAboveZ.

 *

 * The two-ray model does not give a good result for short distances, due to the

 * oscillation caused by constructive and destructive combination of the two

 * rays. Instead the Friis free-space model is used for small distances. 

 *

 * The crossover distance, below which Friis is used, is calculated as follows:

 *

 * \f$ dCross = \frac{(4 * pi * Ht * Hr)}{lambda} \f$

 */

class TwoRayGroundPropagationLossModel : public PropagationLossModel

{

public:

  static TypeId GetTypeId (void);

  TwoRayGroundPropagationLossModel ();

  /**

   * \param frequency (Hz)

   * \param speed (m/s)

   *

   * Set the main wavelength used in the TwoRayGround model 

   * calculation.

   */

  void SetLambda (double frequency, double speed);

  /**

   * \param lambda (m) the wavelength

   *

   * Set the main wavelength used in the TwoRayGround model 

   * calculation.

   */

  void SetLambda (double lambda);

  /**

   * \param systemLoss (dimension-less)

   *

   * Set the system loss used by the TwoRayGround propagation model.

   */

  void SetSystemLoss (double systemLoss);

  /**

   * \param minDistance the minimum distance

   *

   * Below this distance, the txpower is returned

   * unmodified as the rxpower.

   */

  void SetMinDistance (double minDistance);

  /**

   * \returns the minimum distance.

   */

  double GetMinDistance (void) const;

  /**

   * \returns the current wavelength (m)

   */

  double GetLambda (void) const;

  /**

   * \returns the current system loss (dimention-less)

   */

  double GetSystemLoss (void) const;

  /**

   * \Set the model antenna height above the node's Z coordinate

   */

  void SetHeightAboveZ (double heightAboveZ);

private:

  TwoRayGroundPropagationLossModel (const TwoRayGroundPropagationLossModel &o);

  TwoRayGroundPropagationLossModel & operator = (const TwoRayGroundPropagationLossModel &o);

  virtual double DoCalcRxPower (double txPowerDbm,

                                Ptr<MobilityModel> a,

                                Ptr<MobilityModel> b) const;

  double DbmToW (double dbm) const;

  double DbmFromW (double w) const;

  static const double PI;

  double m_lambda;

  double m_systemLoss;

  double m_minDistance;

  double m_heightAboveZ;