inet::physicallayer::MediumLimitCache Class Reference

#include <MediumLimitCache.h>

Inheritance diagram for inet::physicallayer::MediumLimitCache:

Public Member Functions
Query limits
virtual Coord	getMinConstraintArea () const override
	Returns the minimum possible position among the radios, the coordinate values are in the range (-infinity, +infinity) or NaN if unspecified. More...
virtual Coord	getMaxConstraintArea () const override
	Returns the maximum possible position among the radios, the coordinate values are in the range (-infinity, +infinity) or NaN if unspecified. More...
virtual mps	getMaxSpeed () const override
	Returns the maximum possible speed among the radios, the value is in the range [0, +infinity) or NaN if unspecified. More...
virtual W	getMaxTransmissionPower () const override
	Returns the maximum possible transmission power among the radios, the value is in the range [0, +infinity) or NaN if unspecified. More...
virtual W	getMinInterferencePower () const override
	Returns the minimum possible interference power among the radios, the value is in the range [0, +infinity) or NaN if unspecified. More...
virtual W	getMinReceptionPower () const override
	Returns the minimum possible reception power among the radios, the value is in the range [0, +infinity) or NaN if unspecified. More...
virtual double	getMaxAntennaGain () const override
	Returns the maximum possible antenna gain among the radios, the value is in the range [1, +infinity) or NaN if unspecified. More...
virtual const simtime_t &	getMinInterferenceTime () const override
	Returns the minimum required signal interference time among the radios, the value is in the range [0, +infinity) or NaN if unspecified. More...
virtual const simtime_t &	getMaxTransmissionDuration () const override
	Returns the maximum possible transmission durations among the radios, the value is in the range [0, +infinity) or NaN if unspecified. More...
virtual m	getMaxCommunicationRange () const override
	Returns the maximum possible communication range among the radios, the value is in the range [0, +infinity) or NaN if unspecified. More...
virtual m	getMaxInterferenceRange () const override
	Returns the maximum possible interference range among the radios, the value is in the range [0, +infinity) or NaN if unspecified. More...
virtual m	getMaxCommunicationRange (const IRadio *radio) const override
	Returns the maximum possible communication range for a given radio, the value is in the range [0, +infinity) or NaN if unspecified. More...
virtual m	getMaxInterferenceRange (const IRadio *radio) const override
	Returns the maximum possible interference range for a given radio, the value is in the range [0, +infinity) or NaN if unspecified. 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 Attributes
const IRadioMedium *	radioMedium
	The corresponding radio medium is never nullptr. More...
std::vector< const IRadio * >	radios
	The list of communicating radios on the medium. More...

Various radio medium limits.
Coord	minConstraintArea
	The constraint area minimum among the radios is in the range [-infinity, +infinity] or NaN if unspecified. More...
Coord	maxConstraintArea
	The constraint area maximum among the radios is in the range [-infinity, +infinity] or NaN if unspecified. More...
mps	maxSpeed
	The maximum speed among the radios is in the range [0, +infinity) or NaN if unspecified. More...
W	maxTransmissionPower
	The maximum transmission power among the radio transmitters is in the range [0, +infinity) or NaN if unspecified. More...
W	minInterferencePower
	The minimum interference power among the radio receivers is in the range [0, +infinity) or NaN if unspecified. More...
W	minReceptionPower
	The minimum reception power among the radio receivers is in the range [0, +infinity) or NaN if unspecified. More...
double	maxAntennaGain
	The maximum gain among the radio antennas is in the range [1, +infinity). More...
simtime_t	minInterferenceTime
	The minimum overlapping in time needed to consider two transmissions interfering. More...
simtime_t	maxTransmissionDuration
	The maximum transmission duration of a radio signal. More...
m	maxCommunicationRange
	The maximum communication range where a transmission can still be potentially successfully received is in the range [0, +infinity) or NaN if unspecified. More...
m	maxInterferenceRange
	The maximum interference range where a transmission is still considered to some effect on other transmissions is in the range [0, +infinity) or NaN if unspecified. More...
virtual int	numInitStages () const override
virtual void	initialize (int stage) override

Compute limits
virtual Coord	computeMinConstraintArea () const
virtual Coord	computeMaxConstreaintArea () const
virtual mps	computeMaxSpeed () const
virtual W	computeMaxTransmissionPower () const
virtual W	computeMinInterferencePower () const
virtual W	computeMinReceptionPower () const
virtual double	computeMaxAntennaGain () const
virtual const simtime_t	computeMinInterferenceTime () const
virtual const simtime_t	computeMaxTransmissionDuration () const
virtual m	computeMaxRange (W maxTransmissionPower, W minReceptionPower) const
virtual m	computeMaxCommunicationRange () const
virtual m	computeMaxInterferenceRange () const
virtual void	updateLimits ()
	MediumLimitCache ()
virtual std::ostream &	printToStream (std::ostream &stream, int level, int evFlags=0) const override
	Prints this object to the provided output stream. More...
virtual void	addRadio (const IRadio *radio) override
	Notifies the cache when a radio is added to the medium. More...
virtual void	removeRadio (const IRadio *radio) override
	Notifies the cache when a radio is removed from the medium. More...

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

MediumLimitCache()

inet::physicallayer::MediumLimitCache::MediumLimitCache

(

)

                                   :
    radioMedium(nullptr),
    minConstraintArea(Coord::NIL),
    maxConstraintArea(Coord::NIL),
    maxSpeed(mps(NaN)),
    maxTransmissionPower(W(NaN)),
    minInterferencePower(W(NaN)),
    minReceptionPower(W(NaN)),
    maxAntennaGain(NaN),
    minInterferenceTime(NaN),
    maxTransmissionDuration(NaN),
    maxCommunicationRange(m(NaN)),
    maxInterferenceRange(m(NaN))
{
}

Member Function Documentation

addRadio()

void inet::physicallayer::MediumLimitCache::addRadio ( const IRadio *  radio )

overridevirtual

Notifies the cache when a radio is added to the medium.

Implements inet::physicallayer::IMediumLimitCache.

{
    radios.push_back(radio);
    updateLimits();
}

computeMaxAntennaGain()

double inet::physicallayer::MediumLimitCache::computeMaxAntennaGain ( ) const

protectedvirtual

{
    double maxAntennaGain = math::dB2fraction(par("maxAntennaGain"));
    for (const auto radio : radios) {
        if (radio != nullptr)
            maxAntennaGain = maxIgnoreNaN(maxAntennaGain, radio->getAntenna()->getGain()->getMaxGain());
    }
    return maxAntennaGain;
}

Referenced by updateLimits().

computeMaxCommunicationRange()

m inet::physicallayer::MediumLimitCache::computeMaxCommunicationRange ( ) const

protectedvirtual

{
    return maxIgnoreNaN(m(par("maxCommunicationRange")), computeMaxRange(maxTransmissionPower, minReceptionPower));
}

Referenced by updateLimits().

computeMaxConstreaintArea()

Coord inet::physicallayer::MediumLimitCache::computeMaxConstreaintArea ( ) const

protectedvirtual

{
    Coord maxConstraintArea = Coord::NIL;
    for (const auto radio : radios) {
        if (radio != nullptr) {
            const IMobility *mobility = radio->getAntenna()->getMobility();
            maxConstraintArea = maxConstraintArea.max(mobility->getConstraintAreaMax());
        }
    }
    return maxConstraintArea;
}

Referenced by updateLimits().

computeMaxInterferenceRange()

m inet::physicallayer::MediumLimitCache::computeMaxInterferenceRange ( ) const

protectedvirtual

{
    return maxIgnoreNaN(m(par("maxInterferenceRange")), computeMaxRange(maxTransmissionPower, minInterferencePower));
}

Referenced by updateLimits().

computeMaxRange()

m inet::physicallayer::MediumLimitCache::computeMaxRange ( W  maxTransmissionPower, W  minReceptionPower  ) const

protectedvirtual

{
    // TODO this is NaN by default
    Hz centerFrequency = Hz(par("centerFrequency"));
    double loss = unit(minReceptionPower / maxTransmissionPower).get() / maxAntennaGain / maxAntennaGain;
    return radioMedium->getPathLoss()->computeRange(radioMedium->getPropagation()->getPropagationSpeed(), centerFrequency, loss);
}

Referenced by computeMaxCommunicationRange(), computeMaxInterferenceRange(), getMaxCommunicationRange(), and getMaxInterferenceRange().

computeMaxSpeed()

mps inet::physicallayer::MediumLimitCache::computeMaxSpeed ( ) const

protectedvirtual

{
    mps maxSpeed = mps(par("maxSpeed"));
    for (const auto radio : radios) {
        if (radio != nullptr)
            maxSpeed = maxIgnoreNaN(maxSpeed, mps(radio->getAntenna()->getMobility()->getMaxSpeed()));
    }
    return maxSpeed;
}

Referenced by updateLimits().

computeMaxTransmissionDuration()

const simtime_t inet::physicallayer::MediumLimitCache::computeMaxTransmissionDuration ( ) const

protectedvirtual

{
    return simtime_t(par("maxTransmissionDuration"));
}

Referenced by updateLimits().

computeMaxTransmissionPower()

W inet::physicallayer::MediumLimitCache::computeMaxTransmissionPower ( ) const

protectedvirtual

{
    W maxTransmissionPower = W(par("maxTransmissionPower"));
    for (const auto radio : radios) {
        if (radio != nullptr)
            maxTransmissionPower = maxIgnoreNaN(maxTransmissionPower, radio->getTransmitter()->getMaxPower());
    }
    return maxTransmissionPower;
}

Referenced by updateLimits().

computeMinConstraintArea()

Coord inet::physicallayer::MediumLimitCache::computeMinConstraintArea ( ) const

protectedvirtual

{
    Coord minConstraintArea = Coord::NIL;
    for (const auto radio : radios) {
        if (radio != nullptr) {
            const IMobility *mobility = radio->getAntenna()->getMobility();
            minConstraintArea = minConstraintArea.min(mobility->getConstraintAreaMin());
        }
    }
    return minConstraintArea;
}

Referenced by updateLimits().

computeMinInterferencePower()

W inet::physicallayer::MediumLimitCache::computeMinInterferencePower ( ) const

protectedvirtual

{
    W minInterferencePower = mW(math::dBmW2mW(par("minInterferencePower")));
    for (const auto radio : radios) {
        if (radio != nullptr && radio->getReceiver() != nullptr)
            minInterferencePower = minIgnoreNaN(minInterferencePower, radio->getReceiver()->getMinInterferencePower());
    }
    return minInterferencePower;
}

Referenced by updateLimits().

computeMinInterferenceTime()

const simtime_t inet::physicallayer::MediumLimitCache::computeMinInterferenceTime ( ) const

protectedvirtual

{
    return simtime_t(par("minInterferenceTime"));
}

Referenced by updateLimits().

computeMinReceptionPower()

W inet::physicallayer::MediumLimitCache::computeMinReceptionPower ( ) const

protectedvirtual

{
    W minReceptionPower = mW(math::dBmW2mW(par("minReceptionPower")));
    for (const auto radio : radios) {
        if (radio != nullptr && radio->getReceiver() != nullptr)
            minReceptionPower = minIgnoreNaN(minReceptionPower, radio->getReceiver()->getMinReceptionPower());
    }
    return minReceptionPower;
}

Referenced by updateLimits().

getMaxAntennaGain()

virtual double inet::physicallayer::MediumLimitCache::getMaxAntennaGain ( ) const

inlineoverridevirtual

Returns the maximum possible antenna gain among the radios, the value is in the range [1, +infinity) or NaN if unspecified.

Implements inet::physicallayer::IMediumLimitCache.

{ return maxAntennaGain; }

getMaxCommunicationRange() [1/2]

virtual m inet::physicallayer::MediumLimitCache::getMaxCommunicationRange ( ) const

inlineoverridevirtual

Returns the maximum possible communication range among the radios, the value is in the range [0, +infinity) or NaN if unspecified.

Implements inet::physicallayer::IMediumLimitCache.

{ return maxCommunicationRange; }

getMaxCommunicationRange() [2/2]

m inet::physicallayer::MediumLimitCache::getMaxCommunicationRange ( const IRadio *  radio ) const

overridevirtual

Returns the maximum possible communication range for a given radio, the value is in the range [0, +infinity) or NaN if unspecified.

Implements inet::physicallayer::IMediumLimitCache.

{
    m maxCommunicationRange = computeMaxRange(radio->getTransmitter()->getMaxPower(), minReceptionPower);
    if (!std::isnan(maxCommunicationRange.get()))
        return maxCommunicationRange;
    return radio->getTransmitter()->getMaxCommunicationRange();
}

getMaxConstraintArea()

virtual Coord inet::physicallayer::MediumLimitCache::getMaxConstraintArea ( ) const

inlineoverridevirtual

Returns the maximum possible position among the radios, the coordinate values are in the range (-infinity, +infinity) or NaN if unspecified.

Implements inet::physicallayer::IMediumLimitCache.

{ return maxConstraintArea; }

getMaxInterferenceRange() [1/2]

virtual m inet::physicallayer::MediumLimitCache::getMaxInterferenceRange ( ) const

inlineoverridevirtual

Returns the maximum possible interference range among the radios, the value is in the range [0, +infinity) or NaN if unspecified.

Implements inet::physicallayer::IMediumLimitCache.

{ return maxInterferenceRange; }

getMaxInterferenceRange() [2/2]

m inet::physicallayer::MediumLimitCache::getMaxInterferenceRange ( const IRadio *  radio ) const

overridevirtual

Returns the maximum possible interference range for a given radio, the value is in the range [0, +infinity) or NaN if unspecified.

Implements inet::physicallayer::IMediumLimitCache.

{
    m maxInterferenceRange = computeMaxRange(radio->getTransmitter()->getMaxPower(), minInterferencePower);
    if (!std::isnan(maxInterferenceRange.get()))
        return maxInterferenceRange;
    return radio->getTransmitter()->getMaxInterferenceRange();
}

getMaxSpeed()

virtual mps inet::physicallayer::MediumLimitCache::getMaxSpeed ( ) const

inlineoverridevirtual

Returns the maximum possible speed among the radios, the value is in the range [0, +infinity) or NaN if unspecified.

Implements inet::physicallayer::IMediumLimitCache.

{ return maxSpeed; }

getMaxTransmissionDuration()

virtual const simtime_t& inet::physicallayer::MediumLimitCache::getMaxTransmissionDuration ( ) const

inlineoverridevirtual

Returns the maximum possible transmission durations among the radios, the value is in the range [0, +infinity) or NaN if unspecified.

Implements inet::physicallayer::IMediumLimitCache.

{ return maxTransmissionDuration; }

getMaxTransmissionPower()

virtual W inet::physicallayer::MediumLimitCache::getMaxTransmissionPower ( ) const

inlineoverridevirtual

Returns the maximum possible transmission power among the radios, the value is in the range [0, +infinity) or NaN if unspecified.

Implements inet::physicallayer::IMediumLimitCache.

{ return maxTransmissionPower; }

getMinConstraintArea()

virtual Coord inet::physicallayer::MediumLimitCache::getMinConstraintArea ( ) const

inlineoverridevirtual

Returns the minimum possible position among the radios, the coordinate values are in the range (-infinity, +infinity) or NaN if unspecified.

Implements inet::physicallayer::IMediumLimitCache.

{ return minConstraintArea; }

getMinInterferencePower()

virtual W inet::physicallayer::MediumLimitCache::getMinInterferencePower ( ) const

inlineoverridevirtual

Returns the minimum possible interference power among the radios, the value is in the range [0, +infinity) or NaN if unspecified.

Implements inet::physicallayer::IMediumLimitCache.

{ return minInterferencePower; }

getMinInterferenceTime()

virtual const simtime_t& inet::physicallayer::MediumLimitCache::getMinInterferenceTime ( ) const

inlineoverridevirtual

Returns the minimum required signal interference time among the radios, the value is in the range [0, +infinity) or NaN if unspecified.

Implements inet::physicallayer::IMediumLimitCache.

{ return minInterferenceTime; }

getMinReceptionPower()

virtual W inet::physicallayer::MediumLimitCache::getMinReceptionPower ( ) const

inlineoverridevirtual

Returns the minimum possible reception power among the radios, the value is in the range [0, +infinity) or NaN if unspecified.

Implements inet::physicallayer::IMediumLimitCache.

{ return minReceptionPower; }

initialize()

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

overrideprotectedvirtual

{
    if (stage == INITSTAGE_LOCAL) {
        radioMedium = check_and_cast<IRadioMedium *>(getParentModule());
        WATCH(minConstraintArea);
        WATCH(maxConstraintArea);
        WATCH(maxSpeed);
        WATCH(maxTransmissionPower);
        WATCH(minInterferencePower);
        WATCH(minReceptionPower);
        WATCH(maxAntennaGain);
        WATCH(minInterferenceTime);
        WATCH(maxTransmissionDuration);
        WATCH(maxCommunicationRange);
        WATCH(maxInterferenceRange);
    }
}

numInitStages()

virtual int inet::physicallayer::MediumLimitCache::numInitStages ( ) const

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

printToStream()

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

overridevirtual

Prints this object to the provided output stream.

Reimplemented from inet::IPrintableObject.

{
    stream << "RadioMediumLimits";
    if (level <= PRINT_LEVEL_TRACE)
        stream << EV_FIELD(minConstraintArea)
               << EV_FIELD(maxConstraintArea)
               << EV_FIELD(maxSpeed)
               << EV_FIELD(maxTransmissionPower)
               << EV_FIELD(minInterferencePower)
               << EV_FIELD(minReceptionPower)
               << EV_FIELD(maxAntennaGain)
               << EV_FIELD(minInterferenceTime)
               << EV_FIELD(maxTransmissionDuration)
               << EV_FIELD(maxCommunicationRange)
               << EV_FIELD(maxInterferenceRange);
    return stream;
}

removeRadio()

void inet::physicallayer::MediumLimitCache::removeRadio ( const IRadio *  radio )

overridevirtual

Notifies the cache when a radio is removed from the medium.

Implements inet::physicallayer::IMediumLimitCache.

{
    radios.erase(std::remove(radios.begin(), radios.end(), radio), radios.end());
    updateLimits();
}

updateLimits()

void inet::physicallayer::MediumLimitCache::updateLimits ( )

protectedvirtual

{
    minConstraintArea = computeMinConstraintArea();
    maxConstraintArea = computeMaxConstreaintArea();
    maxSpeed = computeMaxSpeed();
    maxTransmissionPower = computeMaxTransmissionPower();
    minInterferencePower = computeMinInterferencePower();
    minReceptionPower = computeMinReceptionPower();
    maxAntennaGain = computeMaxAntennaGain();
    minInterferenceTime = computeMinInterferenceTime();
    maxTransmissionDuration = computeMaxTransmissionDuration();
    maxCommunicationRange = computeMaxCommunicationRange();
    maxInterferenceRange = computeMaxInterferenceRange();
}

Referenced by addRadio(), and removeRadio().

Member Data Documentation

maxAntennaGain

double inet::physicallayer::MediumLimitCache::maxAntennaGain

protected

The maximum gain among the radio antennas is in the range [1, +infinity).

Referenced by computeMaxAntennaGain(), computeMaxRange(), initialize(), printToStream(), and updateLimits().

maxCommunicationRange

m inet::physicallayer::MediumLimitCache::maxCommunicationRange

protected

The maximum communication range where a transmission can still be potentially successfully received is in the range [0, +infinity) or NaN if unspecified.

Referenced by getMaxCommunicationRange(), initialize(), printToStream(), and updateLimits().

maxConstraintArea

Coord inet::physicallayer::MediumLimitCache::maxConstraintArea

protected

The constraint area maximum among the radios is in the range [-infinity, +infinity] or NaN if unspecified.

Referenced by computeMaxConstreaintArea(), initialize(), printToStream(), and updateLimits().

maxInterferenceRange

m inet::physicallayer::MediumLimitCache::maxInterferenceRange

protected

The maximum interference range where a transmission is still considered to some effect on other transmissions is in the range [0, +infinity) or NaN if unspecified.

Referenced by getMaxInterferenceRange(), initialize(), printToStream(), and updateLimits().

maxSpeed

mps inet::physicallayer::MediumLimitCache::maxSpeed

protected

The maximum speed among the radios is in the range [0, +infinity) or NaN if unspecified.

Referenced by computeMaxSpeed(), initialize(), printToStream(), and updateLimits().

maxTransmissionDuration

simtime_t inet::physicallayer::MediumLimitCache::maxTransmissionDuration

protected

The maximum transmission duration of a radio signal.

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

maxTransmissionPower

W inet::physicallayer::MediumLimitCache::maxTransmissionPower

protected

The maximum transmission power among the radio transmitters is in the range [0, +infinity) or NaN if unspecified.

Referenced by computeMaxCommunicationRange(), computeMaxInterferenceRange(), computeMaxRange(), computeMaxTransmissionPower(), initialize(), printToStream(), and updateLimits().

minConstraintArea

Coord inet::physicallayer::MediumLimitCache::minConstraintArea

protected

The constraint area minimum among the radios is in the range [-infinity, +infinity] or NaN if unspecified.

Referenced by computeMinConstraintArea(), initialize(), printToStream(), and updateLimits().

minInterferencePower

W inet::physicallayer::MediumLimitCache::minInterferencePower

protected

The minimum interference power among the radio receivers is in the range [0, +infinity) or NaN if unspecified.

Referenced by computeMaxInterferenceRange(), computeMinInterferencePower(), getMaxInterferenceRange(), initialize(), printToStream(), and updateLimits().

minInterferenceTime

simtime_t inet::physicallayer::MediumLimitCache::minInterferenceTime

protected

The minimum overlapping in time needed to consider two transmissions interfering.

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

minReceptionPower

W inet::physicallayer::MediumLimitCache::minReceptionPower

protected

The minimum reception power among the radio receivers is in the range [0, +infinity) or NaN if unspecified.

Referenced by computeMaxCommunicationRange(), computeMaxRange(), computeMinReceptionPower(), getMaxCommunicationRange(), initialize(), printToStream(), and updateLimits().

radioMedium

const IRadioMedium* inet::physicallayer::MediumLimitCache::radioMedium

protected

The corresponding radio medium is never nullptr.

Referenced by computeMaxRange(), and initialize().

radios

std::vector<const IRadio *> inet::physicallayer::MediumLimitCache::radios

protected

The list of communicating radios on the medium.

Referenced by addRadio(), computeMaxAntennaGain(), computeMaxConstreaintArea(), computeMaxSpeed(), computeMaxTransmissionPower(), computeMinConstraintArea(), computeMinInterferencePower(), computeMinReceptionPower(), and removeRadio().

---

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

• MediumLimitCache.h
• MediumLimitCache.cc