#include <InterpolatingAntenna.h>

Inheritance diagram for inet::physicallayer::InterpolatingAntenna:

Public Member Functions
	InterpolatingAntenna ()

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

virtual double	getMinGain () const

virtual double	getMaxGain () const override
	Returns the maximum possible antenna gain independent of any direction. More...

virtual double	computeGain (const EulerAngles direction) const override
	Returns the antenna gain in the provided direction. More...

Public Member Functions inherited from inet::physicallayer::AntennaBase
	AntennaBase ()

virtual IMobility *	getMobility () const override
	Returns the mobility of this antenna that describes its position and orientation over time. More...

virtual int	getNumAntennas () const override
	Returns the number of antennas in the array. 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

virtual void	parseMap (std::map< double, double > &gainMap, const char *text)

virtual double	computeGain (const std::map< double, double > &gainMap, double angle) const

Protected Attributes
double	minGain

double	maxGain

std::map< double, double >	elevationGainMap

std::map< double, double >	headingGainMap

std::map< double, double >	bankGainMap

Protected Attributes inherited from inet::physicallayer::AntennaBase
IMobility *	mobility

int	numAntennas

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 }

Constructor & Destructor Documentation

inet::physicallayer::InterpolatingAntenna::InterpolatingAntenna ( )

                                            :
     AntennaBase(),
     minGain(NaN),
     maxGain(NaN)
 {
 }

Member Function Documentation

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

protectedvirtual

Referenced by computeGain().

 {
     angle = fmod(angle, 2 * M_PI);
     if (angle < 0.0) angle += 2 * M_PI;
     // NOTE: 0 and 2 * M_PI are always in the map
     std::map<double, double>::const_iterator lowerBound = gainMap.lower_bound(angle);
     std::map<double, 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 {
         double lowerAngle = lowerBound->first;
         double upperAngle = upperBound->first;
         double lowerGain = lowerBound->second;
         double upperGain = upperBound->second;
         double alpha = (angle - lowerAngle) / (upperAngle - lowerAngle);
         return (1 - alpha) * lowerGain + alpha * upperGain;
     }
 }

double inet::physicallayer::InterpolatingAntenna::computeGain ( const EulerAngles direction ) const

overridevirtual

Returns the antenna gain in the provided direction.

The direction is relative to the antenna geometry, so the result depends only on the antenna characteristics. 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 the specified direction.

Implements inet::physicallayer::IAntenna.

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

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

inlineoverridevirtual

Returns the maximum possible antenna gain independent of any direction.

Implements inet::physicallayer::IAntenna.

46 { return maxGain; }

inet::physicallayer::InterpolatingAntenna::maxGain

double maxGain

Definition: InterpolatingAntenna.h:31

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

inlinevirtual

45 { return minGain; }

inet::physicallayer::InterpolatingAntenna::minGain

double minGain

Definition: InterpolatingAntenna.h:30

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

overrideprotectedvirtual

Reimplemented from inet::physicallayer::AntennaBase.

 {
     AntennaBase::initialize(stage);
     if (stage == INITSTAGE_LOCAL) {
         parseMap(elevationGainMap, par("elevationGains"));
         parseMap(headingGainMap, par("headingGains"));
         parseMap(bankGainMap, par("bankGains"));
     }
 }

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

protectedvirtual

Referenced by initialize().

 {
     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<double, double>(0, math::dB2fraction(atof(firstGain))));
     gainMap.insert(std::pair<double, double>(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");
         double angle = atof(angleString) * M_PI / 180;
         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<double, double>(angle, gain));
     }
 }

std::ostream & inet::physicallayer::InterpolatingAntenna::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::AntennaBase.

 {
     stream << "InterpolatingAntenna";
     if (level <= PRINT_LEVEL_DETAIL)
         stream << ", maxGain = " << maxGain;
     return AntennaBase::printToStream(stream, level);
 }