inet::physicallayer::TwoRayInterference Class Reference

Two-Ray interference model borrowed from Veins (default parameterization) More...

#include <TwoRayInterference.h>

Inheritance diagram for inet::physicallayer::TwoRayInterference:

Public Member Functions
	TwoRayInterference ()
	Literature referenced here: Rappaport, Theodore: Wireless Communications - Principles and Practice, 2nd edition, 2002 Jakes, William C. More...
void	initialize (int stage) override
double	computePathLoss (const ITransmission *, const IArrival *) const override
	Returns the loss factor for the provided transmission and arrival. More...
double	computePathLoss (mps propagation, Hz frequency, m distance) const override
	Returns the loss factor as a function of propagation speed, carrier frequency and distance. More...
m	computeRange (mps propagation, Hz frequency, double loss) const override
	Returns the range for the given loss factor. More...
std::ostream &	printToStream (std::ostream &, int level, int evFlags=0) const override
	Prints this object to the provided output stream. More...
Public Member Functions inherited from inet::IPrintableObject
virtual	~IPrintableObject ()
virtual std::string	printToString () const
virtual std::string	printToString (int level, int evFlags=0) const
virtual std::string	getInfoStringRepresentation (int evFlags=0) const
virtual std::string	getDetailStringRepresentation (int evFlags=0) const
virtual std::string	getDebugStringRepresentation (int evFlags=0) const
virtual std::string	getTraceStringRepresentation (int evFlags=0) const
virtual std::string	getCompleteStringRepresentation (int evFlags=0) const

Protected Member Functions
virtual double	computeTwoRayInterference (const Coord &posTx, const Coord &posRx, m waveLength) const
virtual double	reflectionCoefficient (double cos_theta, double sin_theta) const

Protected Attributes
double	epsilon_r
char	polarization

Additional Inherited Members
Public Types inherited from inet::IPrintableObject
enum	PrintLevel {   PRINT_LEVEL_TRACE, PRINT_LEVEL_DEBUG, PRINT_LEVEL_DETAIL, PRINT_LEVEL_INFO,   PRINT_LEVEL_COMPLETE = INT_MIN }
enum	PrintFlag { PRINT_FLAG_FORMATTED = (1 << 0), PRINT_FLAG_MULTILINE = (1 << 1) }

Detailed Description

Two-Ray interference model borrowed from Veins (default parameterization)

See "Using the Right Two-Way Model? A Measurement-based Evaluation of PHY Models in VANETs" by C. Sommer and F. Dressler (2011) or "On the Applicability of Two-Ray Path Loss Models for Vehicular Network Simulation" by C. Sommer, S. Joerer and F. Dressler (2012)

Constructor & Destructor Documentation

TwoRayInterference()

inet::physicallayer::TwoRayInterference::TwoRayInterference

(

)

Literature referenced here: Rappaport, Theodore: Wireless Communications - Principles and Practice, 2nd edition, 2002 Jakes, William C.

: "Microwave Mobile Communications", 1974

                                       :
    epsilon_r(1.0), polarization('h')
{
}

Member Function Documentation

computePathLoss() [1/2]

double inet::physicallayer::TwoRayInterference::computePathLoss ( const ITransmission *  transmission, const IArrival *  arrival  ) const

overridevirtual

Returns the loss factor for the provided transmission and arrival.

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::IPathLoss.

{
    auto radioMedium = transmission->getMedium();
    auto narrowbandSignalAnalogModel = check_and_cast<const INarrowbandSignal *>(transmission->getAnalogModel());
    mps propagationSpeed = radioMedium->getPropagation()->getPropagationSpeed();
    Hz centerFrequency = Hz(narrowbandSignalAnalogModel->getCenterFrequency());
    const m waveLength = propagationSpeed / centerFrequency;
 
    return computeTwoRayInterference(transmission->getStartPosition(), arrival->getStartPosition(), waveLength);
}

computePathLoss() [2/2]

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

{
    return NaN;
}

computeRange()

m inet::physicallayer::TwoRayInterference::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.

{
    return m(NaN);
}

computeTwoRayInterference()

double inet::physicallayer::TwoRayInterference::computeTwoRayInterference ( const Coord &  posTx, const Coord &  posRx, m  waveLength  ) const

protectedvirtual

{
    const double h_sum = pos_t.z + pos_r.z;
    const double h_diff = pos_t.z - pos_r.z;
 
    // direct line of sight between Tx and Rx antenna
    const double d_los = pos_r.distance(pos_t);
    // distance on flat ground between Tx and Rx
    const double d_grnd = sqrt(squared(d_los) - squared(h_diff));
    // length of reflection path between antennas
    const double d_refl = sqrt(squared(d_grnd) + squared(h_sum));
 
    // phi is phase difference of LOS and reflected signal
    const double phi = 2.0 * M_PI * (d_refl - d_los) / lambda.get();
    // theta is the angle between reflected ray and ground (angle of incidence)
    const double sin_theta = h_sum / d_refl;
    const double cos_theta = d_grnd / d_refl;
    // reflection coefficient depending on polarization and relative permittivity (epsilon_r)
    const double Gamma = reflectionCoefficient(cos_theta, sin_theta);
 
    /*
     * Original equation from Jakes (eq 2.1-2) adapted to our variable names:
     *
     * P_r = P_t * G_t * G_r * (lambda / (4*pi*d_los))^2 * |1 + Gamma * e^(i phi)|^2
     *
     * Notes:
     * - return value by IPathLoss equals P_r / (P_t * G_t * G_r)
     * - (lambda / (4*pi*d_los))^2 is the free space path loss (part of Friis equation)
     * - squared absolute value term could be named "interference term"
     *   - "1" accounts for direct wave (LOS)
     *   - "Gamma * e^(i phi)" accounts for ground reflected wave
     *
     * |1 + Gamma * e^(i phi)|^2 = (applying Euler's formula)
     * (1 + Gamma * cos(phi))^2 - Gamma^2 * sin(phi)^2
     */
 
    const double friis_term = squared(lambda.get() / (4.0 * M_PI * d_los));
    const double interference_term = squared(1.0 + Gamma * cos(phi)) + squared(Gamma * sin(phi));
    return friis_term * interference_term;
}

Referenced by computePathLoss().

initialize()

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

override

{
    if (stage == INITSTAGE_LOCAL) {
        epsilon_r = par("epsilon_r");
        const std::string polarization_str = par("polarization");
        if (polarization_str == "horizontal") {
            polarization = 'h';
        }
        else if (polarization_str == "vertical") {
            polarization = 'v';
        }
        else {
            throw cRuntimeError("Invalid antenna polarization %s", polarization_str.c_str());
        }
    }
}

printToStream()

std::ostream & inet::physicallayer::TwoRayInterference::printToStream ( std::ostream &  stream, int  level, int  evFlags = 0  ) const

overridevirtual

Prints this object to the provided output stream.

Reimplemented from inet::IPrintableObject.

{
    os << "TwoRayInterference";
    if (level >= PRINT_LEVEL_TRACE)
        os << ", epsilon_r = " << epsilon_r << EV_FIELD(polarization);
    return os;
}

reflectionCoefficient()

double inet::physicallayer::TwoRayInterference::reflectionCoefficient ( double  cos_theta, double  sin_theta  ) const

protectedvirtual

{
    double Gamma = 0.0;
    // sqrt_term is named "z" by Jakes (eq 2.1-3)
    const double sqrt_term = sqrt(epsilon_r - squared(cos_theta));
    switch (polarization) {
        case 'h':
            // equation 4.25 in Rappaport (Gamma orthogonal)
            Gamma = (sin_theta - sqrt_term) / (sin_theta + sqrt_term);
            break;
        case 'v':
            // equation 4.24 in Rappaport (Gamma parallel)
            Gamma = (-epsilon_r * sin_theta + sqrt_term) / (epsilon_r * sin_theta + sqrt_term);
            break;
        default:
            throw cRuntimeError("Unknown polarization");
    }
    return Gamma;
}

Referenced by computeTwoRayInterference().

Member Data Documentation

epsilon_r

double inet::physicallayer::TwoRayInterference::epsilon_r

protected

Referenced by initialize(), printToStream(), and reflectionCoefficient().

polarization

char inet::physicallayer::TwoRayInterference::polarization

protected

Referenced by initialize(), printToStream(), and reflectionCoefficient().

---

The documentation for this class was generated from the following files:

• TwoRayInterference.h
• TwoRayInterference.cc