Implementation of a breakpoint path loss model. More...

#include <BreakpointPathLoss.h>

Inheritance diagram for inet::physicallayer::BreakpointPathLoss:

Public Member Functions
	BreakpointPathLoss ()

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
double	l01
	initial path loss More...

double	l02

double	alpha1
	pathloss exponents More...

double	alpha2

m	breakpointDistance
	Breakpoint distance squared. More...

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

Implementation of a breakpoint path loss model.

Constructor & Destructor Documentation

inet::physicallayer::BreakpointPathLoss::BreakpointPathLoss ( )

                                        :
     l01(NaN),
     l02(NaN),
     alpha1(NaN),
     alpha2(NaN),
     breakpointDistance(m(NaN))
 {
 }

Member Function Documentation

double inet::physicallayer::BreakpointPathLoss::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.

 {
     // PL(d) = PL0 + 10 alpha log10 (d/d0)
     // 10 ^ { PL(d)/10 } = 10 ^{PL0 + 10 alpha log10 (d/d0)}/10
     // 10 ^ { PL(d)/10 } = 10 ^ PL0/10 * 10 ^ { 10 log10 (d/d0)^alpha }/10
     // 10 ^ { PL(d)/10 } = 10 ^ PL0/10 * 10 ^ { log10 (d/d0)^alpha }
     // 10 ^ { PL(d)/10 } = 10 ^ PL0/10 * (d/d0)^alpha
     if (distance < breakpointDistance)
         return 1 / (l01 * pow(distance.get(), alpha1));
     else
         return 1 / (l02 * pow(unit(distance / breakpointDistance).get(), alpha2));
 }

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

overridevirtual

Returns the range for the given loss factor.

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

Implements inet::physicallayer::IPathLoss.

 {
     // this assumes the path loss is a continuous function
     // the result should be the same for the second case including l02 and alpha2
     double breakpointPathLoss = 1 / (l01 * pow(breakpointDistance.get(), alpha1));
 
     if(loss < breakpointPathLoss) {
         // the allowed loss factor is smaller than the one faced at the breakpoint distance
         // -> range is higher than breakpointDistance
         // loss = 1 / (l02 * (d / d0)^alpha2)
         // (d / d0)^alpha2 = 1 / (loss * l02)
         // (d / d0) = 1 / ((loss * l02)^(1/alpha2))
         // d = d0 / ((loss * l02)^(1/alpha2))
         return breakpointDistance / (pow(loss * l02, 1/alpha2));
     }
     else {
         return m(1) / (pow(loss * l01, 1/alpha1));
     }
 }

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

overrideprotectedvirtual

 {
     if (stage == INITSTAGE_LOCAL) {
         l01 = math::dB2fraction(par("l01"));
         l02 = math::dB2fraction(par("l02"));
         alpha1 = par("alpha1");
         alpha2 = par("alpha2");
         breakpointDistance = m(par("breakpointDistance"));
     }
 }

std::ostream & inet::physicallayer::BreakpointPathLoss::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 << "BreakpointPathLoss";
     if (level <= PRINT_LEVEL_TRACE)
         stream << ", L01 = " << l01
                << ", L02 = " << l02
                << ", alpha1 = " << alpha1
                << ", alpha2 = " << alpha2
                << ", breakpointDistance = " << breakpointDistance;
     return stream;
 }