This class implements the empirical Stanford University Interim path loss model. More...

#include <SUIPathLoss.h>

Inheritance diagram for inet::physicallayer::SUIPathLoss:

Public Member Functions
	SUIPathLoss ()

virtual std::ostream &	printToStream (std::ostream &stream, int level) const override
	Prints this object to the provided output stream. More...

virtual double	computePathLoss (mps propagationSpeed, Hz frequency, m distance) const override
	Returns the loss factor as a function of propagation speed, carrier frequency and distance. More...

virtual m	computeRange (mps propagationSpeed, Hz frequency, double loss) const override
	Returns the range for the given loss factor. More...

Public Member Functions inherited from inet::physicallayer::PathLossBase
virtual double	computePathLoss (const ITransmission transmission, const IArrival arrival) const override
	Returns the loss factor for the provided transmission and arrival. More...

Public Member Functions inherited from inet::physicallayer::IPrintableObject
virtual	~IPrintableObject ()

virtual std::string	getInfoStringRepresentation () const

virtual std::string	getDetailStringRepresentation () const

virtual std::string	getDebugStringRepresentation () const

virtual std::string	getTraceStringRepresentation () const

virtual std::string	getCompleteStringRepresentation () const

Protected Member Functions
virtual void	initialize (int stage) override

Protected Attributes
m	ht
	Transmitter antenna high. More...

m	hr
	Receiver antenna high. More...

double	a

double	b

double	c

double	d

double	s

Additional Inherited Members
Public Types inherited from inet::physicallayer::IPrintableObject
enum	PrintLevel { PRINT_LEVEL_TRACE, PRINT_LEVEL_DEBUG, PRINT_LEVEL_DETAIL, PRINT_LEVEL_INFO, PRINT_LEVEL_COMPLETE = INT_MIN }

Detailed Description

This class implements the empirical Stanford University Interim path loss model.

Author: Konrad Polys, Krzysztof Grochla

Constructor & Destructor Documentation

inet::physicallayer::SUIPathLoss::SUIPathLoss ( )

                          :
     ht(m(0)),
     hr(m(0)),
     a(0),
     b(0),
     c(0),
     d(0),
     s(0)
 {
 }

Member Function Documentation

double inet::physicallayer::SUIPathLoss::computePathLoss	(	mps	propagationSpeed,
		Hz	frequency,
		m	distance
	)		const

overridevirtual

Returns the loss factor as a function of propagation speed, carrier frequency and distance.

The value is in the range [0, 1] where 1 means no loss at all and 0 means all power is lost.

Implements inet::physicallayer::PathLossBase.

 {
     m R = distance;
     m R0 = m(100.0);
     m lambda = propagationSpeed / frequency;
     double L = 0.0;    // [dBm]
     double f = frequency.get() / 1000000000.0;    // [GHz]
     double alpha = 0.0;
     double gamma = a - b * ht.get() + c / ht.get();
     double Xf = 6 * log10(f / 2);
     double Xh = -d *log10(hr.get() / 2);
     m R0p = R0 * pow(10.0, -((Xf + Xh) / (10 * gamma)));
     if (R > R0p) {
         alpha = 20 * log10(unit(4 * M_PI * R0p / lambda).get());
         L = alpha + 10 * gamma * log10(unit(R / R0).get()) + Xf + Xh + s;
     }
     else {
         L = 20 * log10(unit(4 * M_PI * R / lambda).get()) + s;
     }
     return math::dB2fraction(-L);
 }

virtual m inet::physicallayer::SUIPathLoss::computeRange	(	mps	propagationSpeed,
		Hz	frequency,
		double	loss
	)		const

inlineoverridevirtual

Returns the range for the given loss factor.

The value is in the range [0, +infinity) or NaN if unspecified.

Implements inet::physicallayer::IPathLoss.

50 { return m(NaN); }

NaN

#define NaN

Definition: INETMath.h:103

inet::units::values::m

value< double, units::m > m

Definition: Units.h:1047

void inet::physicallayer::SUIPathLoss::initialize ( int stage )

overrideprotectedvirtual

Terrain A - Highest path loss. Dense populated urban area. Terrain B - Intermediate path loss. Suburban area. Terrain C - Minimum path loss. Flat areas or rural with light vegetation.

 {
     if (stage == INITSTAGE_LOCAL) {
         ht = m(par("transmitterAntennaHeight"));
         hr = m(par("receiverAntennaHeight"));
         const char *terrain = par("terrain").stringValue();
         if (!strcmp(terrain, "TerrainA")) {
             a = 4.6;
             b = 0.0075;
             c = 12.6;
             d = 10.8;
             s = 10.6;
         }
         else if (!strcmp(terrain, "TerrainB")) {
             a = 4.0;
             b = 0.0065;
             c = 17.1;
             d = 10.8;
             s = 9.6;
         }
         else if (!strcmp(terrain, "TerrainC")) {
             a = 3.6;
             b = 0.0050;
             c = 20.0;
             d = 20.0;
             s = 8.2;
         }
         else
             throw cRuntimeError("Unknown terrain");
     }
 }

std::ostream & inet::physicallayer::SUIPathLoss::printToStream	(	std::ostream &	stream,
		int	level
	)		const

overridevirtual

Prints this object to the provided output stream.

Function calls to operator<< with pointers or references either const or not are all forwarded to this function.

Reimplemented from inet::physicallayer::IPrintableObject.

 {
     stream << "SUIPathLoss";
     if (level <= PRINT_LEVEL_TRACE)
         stream << ", ht = " << ht
                << ", hr = " << hr;
     return stream;
 }