inet::physicallayer::InterpolatingAntenna::AntennaGain Class Reference

#include <InterpolatingAntenna.h>

Inheritance diagram for inet::physicallayer::InterpolatingAntenna::AntennaGain:

Public Member Functions
	AntennaGain (const char *elevation, const char *heading, const char *bank)
virtual double	getMinGain () const override
	Returns the minimum possible antenna gain independent of any direction. More...
virtual double	getMaxGain () const override
	Returns the maximum possible antenna gain independent of any direction. More...
virtual double	computeGain (const Quaternion &direction) const override
	Returns the antenna gain in the provided direction. More...
Public Member Functions inherited from inet::IPrintableObject
virtual	~IPrintableObject ()
virtual std::ostream &	printToStream (std::ostream &stream, int level, int evFlags=0) const
	Prints this object to the provided output stream. More...
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
Public Member Functions inherited from inet::IntrusivePtrCounter< IAntennaGain >
INET_ALWAYS_INLINE	IntrusivePtrCounter () noexcept
INET_ALWAYS_INLINE	IntrusivePtrCounter (IntrusivePtrCounter const &) noexcept
INET_ALWAYS_INLINE unsigned int	use_count () const noexcept
INET_ALWAYS_INLINE IntrusivePtrCounter &	operator= (IntrusivePtrCounter const &) noexcept
INET_ALWAYS_INLINE IntrusivePtr< IAntennaGain >	shared_from_this ()

Protected Member Functions
virtual void	parseMap (std::map< rad, double > &gainMap, const char *text)
virtual double	computeGain (const std::map< rad, double > &gainMap, rad angle) const
Protected Member Functions inherited from inet::IntrusivePtrCounter< IAntennaGain >
INET_ALWAYS_INLINE	~IntrusivePtrCounter ()=default

Protected Attributes
double	minGain
double	maxGain
std::map< rad, double >	elevationGainMap
std::map< rad, double >	headingGainMap
std::map< rad, double >	bankGainMap

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) }

Constructor & Destructor Documentation

AntennaGain()

inet::physicallayer::InterpolatingAntenna::AntennaGain::AntennaGain	(	const char *	elevation,
		const char *	heading,
		const char *	bank
	)

                                                                                                         :
    minGain(NaN), maxGain(NaN)
{
    parseMap(elevationGainMap, elevation);
    parseMap(headingGainMap, heading);
    parseMap(bankGainMap, bank);
}

Member Function Documentation

computeGain() [1/2]

double inet::physicallayer::InterpolatingAntenna::AntennaGain::computeGain ( const Quaternion &  direction ) const

overridevirtual

Returns the antenna gain in the provided direction.

The direction is determined by rotating the X axis using the given quaternion. The direction is to be interpreted in the local coordinate system of the radiation pattern. This way the gain depends only on the antenna radion pattern characteristics, and not on the antenna orientation determined by the antenna's mobility model.

For transmissions, it determines how well the antenna converts input power into radio waves headed in the specified direction. For receptions, it determines how well the antenna converts radio waves arriving from the specified direction.

Implements inet::physicallayer::IAntennaGain.

{
    auto eulerAngles = direction.toEulerAngles();
    return computeGain(headingGainMap, eulerAngles.alpha) *
           computeGain(elevationGainMap, eulerAngles.beta) *
           computeGain(bankGainMap, eulerAngles.gamma);
}

computeGain() [2/2]

double inet::physicallayer::InterpolatingAntenna::AntennaGain::computeGain ( const std::map< rad, double > &  gainMap, rad  angle  ) const

protectedvirtual

{
    angle = rad(fmod(rad(angle).get(), 2 * M_PI));
    if (angle < rad(0.0)) angle += rad(2 * M_PI);
    // NOTE: 0 and 2 * M_PI are always in the map
    std::map<rad, double>::const_iterator lowerBound = gainMap.lower_bound(angle);
    std::map<rad, double>::const_iterator upperBound = gainMap.upper_bound(angle);
    if (lowerBound->first != angle)
        lowerBound--;
    if (upperBound == gainMap.end())
        upperBound--;
    if (upperBound == lowerBound)
        return lowerBound->second;
    else {
        auto lowerAngle = lowerBound->first;
        auto upperAngle = upperBound->first;
        double lowerGain = lowerBound->second;
        double upperGain = upperBound->second;
        double alpha = unit((angle - lowerAngle) / (upperAngle - lowerAngle)).get();
        return (1 - alpha) * lowerGain + alpha * upperGain;
    }
}

getMaxGain()

virtual double inet::physicallayer::InterpolatingAntenna::AntennaGain::getMaxGain ( ) const

inlineoverridevirtual

Returns the maximum possible antenna gain independent of any direction.

Implements inet::physicallayer::IAntennaGain.

{ return maxGain; }

getMinGain()

virtual double inet::physicallayer::InterpolatingAntenna::AntennaGain::getMinGain ( ) const

inlineoverridevirtual

Returns the minimum possible antenna gain independent of any direction.

Implements inet::physicallayer::IAntennaGain.

{ return minGain; }

parseMap()

void inet::physicallayer::InterpolatingAntenna::AntennaGain::parseMap ( std::map< rad, double > &  gainMap, const char *  text  )

protectedvirtual

{
    cStringTokenizer tokenizer(text);
    const char *firstAngle = tokenizer.nextToken();
    if (!firstAngle)
        throw cRuntimeError("Insufficient number of values");
    if (strcmp(firstAngle, "0"))
        throw cRuntimeError("The first angle must be 0");
    const char *firstGain = tokenizer.nextToken();
    if (!firstGain)
        throw cRuntimeError("Insufficient number of values");
    gainMap.insert(std::pair<rad, double>(rad(0), math::dB2fraction(atof(firstGain))));
    gainMap.insert(std::pair<rad, double>(rad(2 * M_PI), math::dB2fraction(atof(firstGain))));
    while (tokenizer.hasMoreTokens()) {
        const char *angleString = tokenizer.nextToken();
        const char *gainString = tokenizer.nextToken();
        if (!angleString || !gainString)
            throw cRuntimeError("Insufficient number of values");
        auto angle = deg(atof(angleString));
        double gain = math::dB2fraction(atof(gainString));
        if (std::isnan(minGain) || gain < minGain)
            minGain = gain;
        if (std::isnan(maxGain) || gain > maxGain)
            maxGain = gain;
        gainMap.insert(std::pair<rad, double>(angle, gain));
    }
}

Referenced by AntennaGain().

Member Data Documentation

bankGainMap

std::map<rad, double> inet::physicallayer::InterpolatingAntenna::AntennaGain::bankGainMap

protected

Referenced by AntennaGain().

elevationGainMap

std::map<rad, double> inet::physicallayer::InterpolatingAntenna::AntennaGain::elevationGainMap

protected

Referenced by AntennaGain().

headingGainMap

std::map<rad, double> inet::physicallayer::InterpolatingAntenna::AntennaGain::headingGainMap

protected

Referenced by AntennaGain().

maxGain

double inet::physicallayer::InterpolatingAntenna::AntennaGain::maxGain

protected

minGain

double inet::physicallayer::InterpolatingAntenna::AntennaGain::minGain

protected

---

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

• InterpolatingAntenna.h
• InterpolatingAntenna.cc