inet::physicallayer::MediumLimitCache Class Reference

#include <MediumLimitCache.h>

Inheritance diagram for inet::physicallayer::MediumLimitCache:

Public Member Functions
	MediumLimitCache ()
virtual std::ostream &	printToStream (std::ostream &stream, int level) 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...
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::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 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 ()

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

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

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

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

protectedvirtual

Referenced by updateLimits().

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

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

protectedvirtual

Referenced by updateLimits().

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

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

protectedvirtual

Referenced by updateLimits().

{
    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;
}

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

protectedvirtual

Referenced by updateLimits().

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

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

protectedvirtual

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

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

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

protectedvirtual

Referenced by updateLimits().

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

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

protectedvirtual

Referenced by updateLimits().

{
    return par("maxTransmissionDuration").doubleValue();
}

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

protectedvirtual

Referenced by updateLimits().

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

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

protectedvirtual

Referenced by updateLimits().

{
    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;
}

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

protectedvirtual

Referenced by updateLimits().

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

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

protectedvirtual

Referenced by updateLimits().

{
    return par("minInterferenceTime").doubleValue();
}

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

protectedvirtual

Referenced by updateLimits().

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

std::ostream & inet::physicallayer::MediumLimitCache::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 << "RadioMediumLimits";
    if (level <= PRINT_LEVEL_TRACE)
        stream << ", minConstraintArea = " << minConstraintArea
               << ", maxConstraintArea = " << maxConstraintArea
               << ", maxSpeed = " << maxSpeed
               << ", maxTransmissionPower = " << maxTransmissionPower
               << ", minInterferencePower = " << minInterferencePower
               << ", minReceptionPower = " << minReceptionPower
               << ", maxAntennaGain = " << maxAntennaGain
               << ", minInterferenceTime = " << minInterferenceTime
               << ", maxTransmissionDuration = " << maxTransmissionDuration
               << ", maxCommunicationRange = " << maxCommunicationRange
               << ", maxInterferenceRange = " << maxInterferenceRange;
    return stream;
}

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

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

protectedvirtual

Referenced by addRadio(), and removeRadio().

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

Member Data Documentation

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().

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().

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().

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().

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().

simtime_t inet::physicallayer::MediumLimitCache::maxTransmissionDuration

protected

The maximum transmission duration of a radio signal.

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

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(), computeMaxTransmissionPower(), initialize(), printToStream(), and updateLimits().

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().

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().

simtime_t inet::physicallayer::MediumLimitCache::minInterferenceTime

protected

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

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

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(), computeMinReceptionPower(), getMaxCommunicationRange(), initialize(), printToStream(), and updateLimits().

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

protected

The corresponding radio medium is never nullptr.

Referenced by computeMaxRange(), and initialize().

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