Attachment #712 for bug #787

View | Details | Raw Unified | Return to bug 787
Collapse All | Expand All




  return GetErrorStatus ();
}

// Added for Two-Ray Ground Model - T.Hewer@cs.ucl.ac.uk

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));
	
	// 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 * RxAntennaHeight * 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);
	
	// 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 ();
}


class LogDistancePropagationLossModelTestCase : public TestCase
{
public:

  : TestSuite ("propagation-loss-model", UNIT)
{
  AddTestCase (new FriisPropagationLossModelTestCase);
  AddTestCase (new TwoRayGroundPropagationLossModelTestCase);
  AddTestCase (new LogDistancePropagationLossModelTestCase);
}





 *
 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
 * Contributions: Timo Bingmann <timo.bingmann@student.kit.edu>
 * Contributions: Tom Hewer <t.hewer@cs.ucl.ac.uk> for Two Ray Ground Model
 */

#include "propagation-loss-model.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.",
					   RandomVariableValue (ConstantVariable (1.0)),
					   MakeRandomVariableAccessor (&RandomPropagationLossModel::m_variable),
					   MakeRandomVariableChecker ())
		;
		return tid;
	}
	RandomPropagationLossModel::RandomPropagationLossModel ()
	: PropagationLossModel ()
	{}
	
	RandomPropagationLossModel::~RandomPropagationLossModel ()
	{}
	
	double 
	RandomPropagationLossModel::DoCalcRxPower (double txPowerDbm,
											   Ptr<MobilityModel> a,
											   Ptr<MobilityModel> b) const
	{
		double rxc = -m_variable.GetValue ();
		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 -- T.Hewer@cs.ucl.ac.uk -- 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 ("TxAntHeight", 
					   "The height of the transmitting antenna (m)",
					   DoubleValue (1.5),
					   MakeDoubleAccessor (&TwoRayGroundPropagationLossModel::m_txAntHeight),
					   MakeDoubleChecker<double> ())
		.AddAttribute ("RxAntHeight", 
					   "The height of the receiving antenna (m)",
					   DoubleValue (1.5),
					   MakeDoubleAccessor (&TwoRayGroundPropagationLossModel::m_rxAntHeight),
					   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::SetTxAntHeight (double txAntHeight)
	{
		m_txAntHeight = txAntHeight;
	}
	void
	TwoRayGroundPropagationLossModel::SetRxAntHeight (double rxAntHeight)
	{
		m_rxAntHeight = rxAntHeight;
	}
	double 
	TwoRayGroundPropagationLossModel::GetTxAntHeight (void) const
	{
		return m_txAntHeight;
	}
	double 
	TwoRayGroundPropagationLossModel::GetRxAntHeight (void) const
	{
		return m_rxAntHeight;
	}
	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;
		}
		
		// Calculate a crossover distance, under which we use Friis
		/*
		 * 
		 * dCross = (4 * pi * Ht * Hr) / lambda
		 *
		 */
		
		double dCross = (4 * PI * m_txAntHeight * m_rxAntHeight) / GetLambda();
		
		if (distance <= dCross) {
			// We use Friis
			double numerator = m_lambda * m_lambda;
			double denominator = 16 * PI * PI * distance * distance * 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		
			double rayNumerator = (m_txAntHeight * m_txAntHeight) * 
			(m_rxAntHeight * m_rxAntHeight);
			double rayDenominator = (distance * distance * distance * distance) * 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)
		{
			return txPowerDbm;
		}
		/**
		 * The formula is:
		 * rx = 10 * log (Pr0(tx)) - n * 10 * log (d/d0)
		 *
		 * Pr0: rx power at reference distance d0 (W)
		 * d0: reference distance: 1.0 (m)
		 * d: distance (m)
		 * tx: tx power (dB)
		 * rx: dB
		 *
		 * Which, in our case is:
		 *
		 * rx = rx0(tx) - 10 * n * log (d/d0)
		 */
		double pathLossDb = 10 * m_exponent * log10 (distance / m_referenceDistance);
		double rxc = -m_referenceLoss - pathLossDb;
		NS_LOG_DEBUG ("distance="<<distance<<"m, reference-attenuation="<<-m_referenceLoss<<"dB, "<<
					  "attenuation coefficient="<<rxc<<"db");
		return txPowerDbm + rxc;
	}
	
	// ------------------------------------------------------------------------- //
	
	NS_OBJECT_ENSURE_REGISTERED (ThreeLogDistancePropagationLossModel);
	
	TypeId
	ThreeLogDistancePropagationLossModel::GetTypeId (void)
	{
		static TypeId tid = TypeId ("ns3::ThreeLogDistancePropagationLossModel")
		.SetParent<PropagationLossModel> ()
		.AddConstructor<ThreeLogDistancePropagationLossModel> ()
		.AddAttribute ("Distance0",
					   "Beginning of the first (near) distance field",
					   DoubleValue (1.0),
					   MakeDoubleAccessor (&ThreeLogDistancePropagationLossModel::m_distance0),
					   MakeDoubleChecker<double> ())
		.AddAttribute ("Distance1",
					   "Beginning of the second (middle) distance field.",
					   DoubleValue (200.0),
					   MakeDoubleAccessor (&ThreeLogDistancePropagationLossModel::m_distance1),
					   MakeDoubleChecker<double> ())
		.AddAttribute ("Distance2",
					   "Beginning of the third (far) distance field.",
					   DoubleValue (500.0),
					   MakeDoubleAccessor (&ThreeLogDistancePropagationLossModel::m_distance2),
					   MakeDoubleChecker<double> ())
		.AddAttribute ("Exponent0",
					   "The exponent for the first field.",
					   DoubleValue (1.9),
					   MakeDoubleAccessor (&ThreeLogDistancePropagationLossModel::m_exponent0),
					   MakeDoubleChecker<double> ())
		.AddAttribute ("Exponent1",
					   "The exponent for the second field.",
					   DoubleValue (3.8),
					   MakeDoubleAccessor (&ThreeLogDistancePropagationLossModel::m_exponent1),
					   MakeDoubleChecker<double> ())
		.AddAttribute ("Exponent2",
					   "The exponent for the third field.",
					   DoubleValue (3.8),
					   MakeDoubleAccessor (&ThreeLogDistancePropagationLossModel::m_exponent2),
					   MakeDoubleChecker<double> ())
		.AddAttribute ("ReferenceLoss",
					   "The reference loss at distance d0 (dB). (Default is Friis at 1m with 5.15 GHz)",
					   DoubleValue (46.6777),
					   MakeDoubleAccessor (&ThreeLogDistancePropagationLossModel::m_referenceLoss),
					   MakeDoubleChecker<double> ())
		;
		return tid;
		
	}
	
	ThreeLogDistancePropagationLossModel::ThreeLogDistancePropagationLossModel ()
	{
	}
	
	double 
	ThreeLogDistancePropagationLossModel::DoCalcRxPower (double txPowerDbm,
														 Ptr<MobilityModel> a,
														 Ptr<MobilityModel> b) const
	{
		double distance = a->GetDistanceFrom (b);
		NS_ASSERT(distance >= 0);
		
		// See doxygen comments for the formula and explanation
		
		double pathLossDb;
		
		if (distance < m_distance0)
		{
			pathLossDb = 0;
		}
		else if (distance < m_distance1)
		{
			pathLossDb = m_referenceLoss
			+ 10 * m_exponent0 * log10(distance / m_distance0);
		}
		else if (distance < m_distance2)
		{
			pathLossDb = m_referenceLoss
			+ 10 * m_exponent0 * log10(m_distance1 / m_distance0)
			+ 10 * m_exponent1 * log10(distance / m_distance1);
		}
		else
		{
			pathLossDb = m_referenceLoss
			+ 10 * m_exponent0 * log10(m_distance1 / m_distance0)
			+ 10 * m_exponent1 * log10(m_distance2 / m_distance1)
			+ 10 * m_exponent2 * log10(distance / m_distance2);
		}
		
		NS_LOG_DEBUG ("ThreeLogDistance distance=" << distance << "m, " <<
					  "attenuation=" << pathLossDb << "dB");
		
		return txPowerDbm - pathLossDb;
	}
	
	// ------------------------------------------------------------------------- //
	
	NS_OBJECT_ENSURE_REGISTERED (NakagamiPropagationLossModel);
	
	TypeId
	NakagamiPropagationLossModel::GetTypeId (void)
	{
		static TypeId tid = TypeId ("ns3::NakagamiPropagationLossModel")
		.SetParent<PropagationLossModel> ()
		.AddConstructor<NakagamiPropagationLossModel> ()
		.AddAttribute ("Distance1",
					   "Beginning of the second distance field. Default is 80m.",
					   DoubleValue (80.0),
					   MakeDoubleAccessor (&NakagamiPropagationLossModel::m_distance1),
					   MakeDoubleChecker<double> ())
		.AddAttribute ("Distance2",
					   "Beginning of the third distance field. Default is 200m.",
					   DoubleValue (200.0),
					   MakeDoubleAccessor (&NakagamiPropagationLossModel::m_distance2),
					   MakeDoubleChecker<double> ())
		.AddAttribute ("m0",
					   "m0 for distances smaller than Distance1. Default is 1.5.",
					   DoubleValue (1.5),
					   MakeDoubleAccessor (&NakagamiPropagationLossModel::m_m0),
					   MakeDoubleChecker<double> ())
		.AddAttribute ("m1",
					   "m1 for distances smaller than Distance2. Default is 0.75.",
					   DoubleValue (0.75),
					   MakeDoubleAccessor (&NakagamiPropagationLossModel::m_m1),
					   MakeDoubleChecker<double> ())
		.AddAttribute ("m2",
					   "m2 for distances greater than Distance2. Default is 0.75.",
					   DoubleValue (0.75),
					   MakeDoubleAccessor (&NakagamiPropagationLossModel::m_m2),
					   MakeDoubleChecker<double> ())
		;
		return tid;
		
	}
	
	NakagamiPropagationLossModel::NakagamiPropagationLossModel ()
	{}
	
	double 
	NakagamiPropagationLossModel::DoCalcRxPower (double txPowerDbm,
												 Ptr<MobilityModel> a,
												 Ptr<MobilityModel> b) const
	{
		// select m parameter
		
		double distance = a->GetDistanceFrom (b);
		NS_ASSERT(distance >= 0);
		
		double m;
		if (distance < m_distance1)
		{
			m = m_m0;
		}
		else if (distance < m_distance2)
		{
			m = m_m1;
		}
		else
		{
			m = m_m2;
		}
		
		// the current power unit is dBm, but Watt is put into the Nakagami /
		// Rayleigh distribution.
		double powerW = pow(10, (txPowerDbm - 30) / 10);
		
		double resultPowerW;
		
		// switch between Erlang- and Gamma distributions: this is only for
		// speed. (Gamma is equal to Erlang for any positive integer m.)
		unsigned int int_m = static_cast<unsigned int>(floor(m));
		
		if (int_m == m)
		{
			resultPowerW = m_erlangRandomVariable.GetValue(int_m, powerW / m);
		}
		else
		{
			resultPowerW = m_gammaRandomVariable.GetValue(m, powerW / m);
		}
		
		double resultPowerDbm = 10 * log10(resultPowerW) + 30;
		
		NS_LOG_DEBUG ("Nakagami distance=" << distance << "m, " <<
					  "power=" << powerW <<"W, " <<
					  "resultPower=" << resultPowerW << "W=" << resultPowerDbm << "dBm");
		
		return resultPowerDbm;
	}
	
	// ------------------------------------------------------------------------- //
	
	NS_OBJECT_ENSURE_REGISTERED (FixedRssLossModel);
	
	TypeId 
	FixedRssLossModel::GetTypeId (void)
	{
		static TypeId tid = TypeId ("ns3::FixedRssLossModel")
		.SetParent<PropagationLossModel> ()
		.AddConstructor<FixedRssLossModel> ()
		.AddAttribute ("Rss", "The fixed receiver Rss.",
					   DoubleValue (-150.0),
					   MakeDoubleAccessor (&FixedRssLossModel::m_rss),
					   MakeDoubleChecker<double> ())
		;
		return tid;
	}
	FixedRssLossModel::FixedRssLossModel ()
	: PropagationLossModel ()
	{}
	
	FixedRssLossModel::~FixedRssLossModel ()
	{}
	
	void 
	FixedRssLossModel::SetRss (double rss)
	{
		m_rss = rss;
	}
	
	double 
	FixedRssLossModel::DoCalcRxPower (double txPowerDbm,
									  Ptr<MobilityModel> a,
									  Ptr<MobilityModel> b) const
	{
		return m_rss;
	}
	
	// ------------------------------------------------------------------------- //
	
} // namespace ns3




 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
 * Contributions: Timo Bingmann <timo.bingmann@student.kit.edu>
 * Contributions: Gary Pei <guangyu.pei@boeing.com> for fixed RSS
 * Contributions: Tom Hewer <t.hewer@cs.ucl.ac.uk> for porting Two Ray Ground
 */

#ifndef PROPAGATION_LOSS_MODEL_H

  double m_systemLoss;
  double m_minDistance;
};
/************************************************************************************
	 *
	 * \brief a Two-Ray Ground propagation loss model ported from NS2
	 *
	 *  Two-ray ground reflection model.
	 *
	 *	     Pt * Gt * Gr * (ht^2 * hr^2)
	 *  Pr = ----------------------------
	 *           d^4 * L
	 *
	 * 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 by default to 1.5m
	 *
	 * 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-sapce model is used for small distances. */
	
	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 Tx antenna height
		 */
		void SetTxAntHeight (double txAntHeight);
		/**
		 * \Set the Rx antenna height
		 */
		void SetRxAntHeight (double rxAntHeight);
		/**
		 * \Returns the Tx antenna height
		 */
		double GetTxAntHeight (void) const;
		/**
		 * \Returns the Rx antenna height
		 */
		double GetRxAntHeight (void) const;
		
	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_txAntHeight;
		double m_rxAntHeight;
	};
/****************************************************************************************************************	
 * \brief a log distance propagation model.
 *
 * This model calculates the reception power with a so-called

Return to bug 787