inet::physicallayer::RadioMedium Class Reference

The default implementation of the radio medium interface. More...

#include <RadioMedium.h>

Inheritance diagram for inet::physicallayer::RadioMedium:

Public Member Functions
	RadioMedium ()
virtual	~RadioMedium ()
virtual std::ostream &	printToStream (std::ostream &stream, int level) const override
	Prints this object to the provided output stream. More...
virtual const IMaterial *	getMaterial () const override
	Returns the material of the radio medium. More...
virtual const IPropagation *	getPropagation () const override
	Returns the radio signal propagation model of this radio medium. More...
virtual const IPathLoss *	getPathLoss () const override
	Returns the radio signal path loss model of this radio medium. More...
virtual const IObstacleLoss *	getObstacleLoss () const override
	Returns the radio signal obstacle loss model of this radio medium. More...
virtual const IAnalogModel *	getAnalogModel () const override
	Returns the radio signal analog model of this radio medium. More...
virtual const IBackgroundNoise *	getBackgroundNoise () const override
	Returns the background noise model of this radio medium. More...
virtual const IPhysicalEnvironment *	getPhysicalEnvironment () const override
	Returns the physical environment model of this radio medium. More...
virtual const IMediumLimitCache *	getMediumLimitCache () const override
virtual const INeighborCache *	getNeighborCache () const override
virtual const ICommunicationCache *	getCommunicationCache () const override
virtual void	addRadio (const IRadio *radio) override
	Adds a new radio to the radio medium. More...
virtual void	removeRadio (const IRadio *radio) override
	Removes a radio from the radio medium. More...
virtual void	sendToRadio (IRadio *trasmitter, const IRadio *receiver, const IRadioFrame *frame)
virtual IRadioFrame *	transmitPacket (const IRadio *transmitter, cPacket *macFrame) override
	Returns a new radio frame containing the radio signal transmission that represents the provided MAC frame. More...
virtual cPacket *	receivePacket (const IRadio *receiver, IRadioFrame *radioFrame) override
	Returns the MAC frame that was transmitted in the provided radio frame. More...
virtual const IListeningDecision *	listenOnMedium (const IRadio *receiver, const IListening *listening) const override
	Returns the listening decision that describes what the receiver detects on the radio medium. More...
virtual const IArrival *	getArrival (const IRadio *receiver, const ITransmission *transmission) const override
	Returns the space and time coordinates of the transmission arriving at the provided receiver. More...
virtual const IListening *	getListening (const IRadio *receiver, const ITransmission *transmission) const override
	Returns how the radio is listening on the medium when the transmission arrives at the provided receiver. More...
virtual const IReception *	getReception (const IRadio *receiver, const ITransmission *transmission) const override
	Returns the reception of the transmission arriving at the provided receiver. More...
virtual const IInterference *	getInterference (const IRadio *receiver, const ITransmission *transmission) const override
	Returns the interference of the transmission arriving at the provided receiver. More...
virtual const IInterference *	getInterference (const IRadio *receiver, const IListening *listening, const ITransmission *transmission) const
virtual const INoise *	getNoise (const IRadio *receiver, const ITransmission *transmission) const override
	Returns the total noise computed from the interference of the transmission arriving at the provided receiver. More...
virtual const ISNIR *	getSNIR (const IRadio *receiver, const ITransmission *transmission) const override
	Returns the signal to noise and interference ratio of the transmission arriving at the provided receiver. More...
virtual bool	isReceptionPossible (const IRadio *receiver, const ITransmission *transmission, IRadioSignal::SignalPart part) const override
	Returns true when the reception is possible of the transmission part. More...
virtual bool	isReceptionAttempted (const IRadio *receiver, const ITransmission *transmission, IRadioSignal::SignalPart part) const override
	Returns true when the reception is attempted of the transmission part. More...
virtual bool	isReceptionSuccessful (const IRadio *receiver, const ITransmission *transmission, IRadioSignal::SignalPart part) const override
	Returns true when the reception is successful of the transmission part. More...
virtual const IReceptionDecision *	getReceptionDecision (const IRadio *receiver, const IListening *listening, const ITransmission *transmission, IRadioSignal::SignalPart part) const override
	Returns the reception decision for the transmission part that specifies whether the reception is possible, attempted, and successful. More...
virtual const IReceptionResult *	getReceptionResult (const IRadio *receiver, const IListening *listening, const ITransmission *transmission) const override
	Returns the reception result for the transmission that describes the end result of the reception process. More...
virtual void	receiveSignal (cComponent *source, simsignal_t signal, long value, cObject *details) override
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 Types
enum	RangeFilterKind { RANGE_FILTER_ANYWHERE, RANGE_FILTER_INTERFERENCE_RANGE, RANGE_FILTER_COMMUNICATION_RANGE }

Protected Member Functions
Module
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	finish () override
virtual void	handleMessage (cMessage *message) override
Transmission
virtual void	addTransmission (const IRadio *transmitter, const ITransmission *transmission)
	Adds a new transmission to the radio medium. More...
virtual IRadioFrame *	createTransmitterRadioFrame (const IRadio *radio, cPacket *macFrame)
	Creates a new radio frame for the transmitter. More...
virtual IRadioFrame *	createReceiverRadioFrame (const ITransmission *transmission)
	Creates a new radio frame for a receiver. More...
virtual void	sendToAffectedRadios (IRadio *transmitter, const IRadioFrame *frame)
	Sends a copy of the provided radio frame to all affected receivers on the radio medium. More...
virtual void	sendToAllRadios (IRadio *transmitter, const IRadioFrame *frame)
	Sends a copy of the provided radio frame to all receivers on the radio medium. More...
Reception
virtual bool	isRadioMacAddress (const IRadio *radio, const MACAddress address) const
virtual bool	isPotentialReceiver (const IRadio *receiver, const ITransmission *transmission) const
	Returns true if the radio can potentially receive the transmission successfully. More...
virtual bool	isInCommunicationRange (const ITransmission *transmission, const Coord startPosition, const Coord endPosition) const
virtual bool	isInInterferenceRange (const ITransmission *transmission, const Coord startPosition, const Coord endPosition) const
virtual bool	isInterferingTransmission (const ITransmission *transmission, const IListening *listening) const
virtual bool	isInterferingTransmission (const ITransmission *transmission, const IReception *reception) const
virtual void	removeNonInterferingTransmissions ()
	Removes all cached data related to past transmissions that don't have any effect on any ongoing transmission. More...
virtual const std::vector< const IReception * > *	computeInterferingReceptions (const IListening *listening, const std::vector< const ITransmission * > *transmissions) const
virtual const std::vector< const IReception * > *	computeInterferingReceptions (const IReception *reception, const std::vector< const ITransmission * > *transmissions) const
virtual const IReception *	computeReception (const IRadio *receiver, const ITransmission *transmission) const
virtual const IInterference *	computeInterference (const IRadio *receiver, const IListening *listening, const std::vector< const ITransmission * > *transmissions) const
virtual const IInterference *	computeInterference (const IRadio *receiver, const IListening *listening, const ITransmission *transmission, const std::vector< const ITransmission * > *transmissions) const
virtual const IReceptionDecision *	computeReceptionDecision (const IRadio *receiver, const IListening *listening, const ITransmission *transmission, IRadioSignal::SignalPart part, const std::vector< const ITransmission * > *transmissions) const
virtual const IReceptionResult *	computeReceptionResult (const IRadio *receiver, const IListening *listening, const ITransmission *transmission, const std::vector< const ITransmission * > *transmissions) const
virtual const IListeningDecision *	computeListeningDecision (const IRadio *receiver, const IListening *listening, const std::vector< const ITransmission * > *transmissions) const

Protected Attributes
Parameters and other models that control the behavior of the radio medium.
const IPropagation *	propagation
	The propagation model is never nullptr. More...
const IPathLoss *	pathLoss
	The path loss model is never nullptr. More...
const IObstacleLoss *	obstacleLoss
	The obstacle loss model or nullptr if unused. More...
const IAnalogModel *	analogModel
	The analog model is never nullptr. More...
const IBackgroundNoise *	backgroundNoise
	The background noise model or nullptr if unused. More...
const IPhysicalEnvironment *	physicalEnvironment
	The physical environment model or nullptr if unused. More...
const IMaterial *	material
	The physical material of the medium is never nullptr. More...
RangeFilterKind	rangeFilter
	The radio medium doesn't send radio frames to a radio if it's outside the range provided by the selected range filter. More...
bool	radioModeFilter
	True means the radio medium doesn't send radio frames to a radio if it's neither in receiver nor in transceiver mode. More...
bool	listeningFilter
	True means the radio medium doesn't send radio frames to a radio if it listens on the medium in incompatible mode (e.g. More...
bool	macAddressFilter
	True means the radio medium doesn't send radio frames to a radio if the mac address of the destination is different. More...
bool	recordCommunicationLog
	Records all transmissions and receptions into a separate trace file. More...
Timer
cMessage *	removeNonInterferingTransmissionsTimer
	The message that is used to purge the internal state of the medium. More...
State
std::vector< const IRadio * >	radios
	The list of radios that can transmit and receive radio signals on the radio medium. More...
std::vector< const ITransmission * >	transmissions
	The list of ongoing transmissions on the radio medium. More...
Cache
IMediumLimitCache *	mediumLimitCache
	Caches various medium limits among all radios. More...
INeighborCache *	neighborCache
	Caches neighbors for all radios or nullptr if turned off. More...
ICommunicationCache *	communicationCache
	Caches intermediate results of the ongoing communication for all radios. More...
Logging
CommunicationLog	communicationLog
	The communication log output recorder. More...
Statistics
long	transmissionCount
	Total number of transmissions. More...
long	radioFrameSendCount
	Total number of radio frame sends. More...
long	receptionComputationCount
	Total number of reception computations. More...
long	interferenceComputationCount
	Total number of interference computations. More...
long	receptionDecisionComputationCount
	Total number of data reception decision computations. More...
long	receptionResultComputationCount
	Total number of data reception result computations. More...
long	listeningDecisionComputationCount
	Total number of listening decision computations. More...
long	cacheReceptionGetCount
	Total number of reception cache queries. More...
long	cacheReceptionHitCount
	Total number of reception cache hits. More...
long	cacheInterferenceGetCount
	Total number of interference cache queries. More...
long	cacheInterferenceHitCount
	Total number of interference cache hits. More...
long	cacheNoiseGetCount
	Total number of noise cache queries. More...
long	cacheNoiseHitCount
	Total number of noise cache hits. More...
long	cacheSNIRGetCount
	Total number of SNIR cache queries. More...
long	cacheSNIRHitCount
	Total number of SNIR cache hits. More...
long	cacheDecisionGetCount
	Total number of reception decision cache queries. More...
long	cacheDecisionHitCount
	Total number of reception decision cache hits. More...
long	cacheResultGetCount
	Total number of reception result cache queries. More...
long	cacheResultHitCount
	Total number of reception result cache hits. More...

Private Attributes
friend	Radio

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 }
Static Public Attributes inherited from inet::physicallayer::IRadioMedium
static simsignal_t	radioAddedSignal = cComponent::registerSignal("radioAdded")
static simsignal_t	radioRemovedSignal = cComponent::registerSignal("radioRemoved")
static simsignal_t	transmissionAddedSignal = cComponent::registerSignal("transmissionAdded")
static simsignal_t	transmissionRemovedSignal = cComponent::registerSignal("transmissionRemoved")
static simsignal_t	transmissionStartedSignal = cComponent::registerSignal("transmissionStarted")
static simsignal_t	transmissionEndedSignal = cComponent::registerSignal("transmissionEnded")
static simsignal_t	receptionStartedSignal = cComponent::registerSignal("receptionStarted")
static simsignal_t	receptionEndedSignal = cComponent::registerSignal("receptionEnded")

Detailed Description

The default implementation of the radio medium interface.

Member Enumeration Documentation

enum inet::physicallayer::RadioMedium::RangeFilterKind

protected

Enumerator
RANGE_FILTER_ANYWHERE
RANGE_FILTER_INTERFERENCE_RANGE
RANGE_FILTER_COMMUNICATION_RANGE

                         {
        RANGE_FILTER_ANYWHERE,
        RANGE_FILTER_INTERFERENCE_RANGE,
        RANGE_FILTER_COMMUNICATION_RANGE,
    };

Constructor & Destructor Documentation

inet::physicallayer::RadioMedium::RadioMedium

(

)

                         :
    propagation(nullptr),
    pathLoss(nullptr),
    obstacleLoss(nullptr),
    analogModel(nullptr),
    backgroundNoise(nullptr),
    physicalEnvironment(nullptr),
    material(nullptr),
    rangeFilter(RANGE_FILTER_ANYWHERE),
    radioModeFilter(false),
    listeningFilter(false),
    macAddressFilter(false),
    recordCommunicationLog(false),
    removeNonInterferingTransmissionsTimer(nullptr),
    mediumLimitCache(nullptr),
    neighborCache(nullptr),
    communicationCache(nullptr),
    transmissionCount(0),
    radioFrameSendCount(0),
    receptionComputationCount(0),
    interferenceComputationCount(0),
    receptionDecisionComputationCount(0),
    receptionResultComputationCount(0),
    listeningDecisionComputationCount(0),
    cacheReceptionGetCount(0),
    cacheReceptionHitCount(0),
    cacheInterferenceGetCount(0),
    cacheInterferenceHitCount(0),
    cacheNoiseGetCount(0),
    cacheNoiseHitCount(0),
    cacheSNIRGetCount(0),
    cacheSNIRHitCount(0),
    cacheDecisionGetCount(0),
    cacheDecisionHitCount(0),
    cacheResultGetCount(0),
    cacheResultHitCount(0)
{
}

inet::physicallayer::RadioMedium::~RadioMedium ( )

virtual

{
    cancelAndDelete(removeNonInterferingTransmissionsTimer);
    for (const auto transmission : transmissions) {
        delete communicationCache->getCachedFrame(transmission);
        delete transmission;
    }
    if (recordCommunicationLog)
        communicationLog.close();
}

Member Function Documentation

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

overridevirtual

Adds a new radio to the radio medium.

An exception is thrown if the radio is already added. The radio may immediately start new transmissions and will potentially receive all ongoing and further transmissions.

Implements inet::physicallayer::IRadioMedium.

{
    radios.push_back(radio);
    communicationCache->addRadio(radio);
    if (neighborCache)
        neighborCache->addRadio(radio);
    mediumLimitCache->addRadio(radio);
    for (const auto transmission : transmissions) {
        const IArrival *arrival = propagation->computeArrival(transmission, radio->getAntenna()->getMobility());
        const IListening *listening = radio->getReceiver()->createListening(radio, arrival->getStartTime(), arrival->getEndTime(), arrival->getStartPosition(), arrival->getEndPosition());
        communicationCache->setCachedArrival(radio, transmission, arrival);
        communicationCache->setCachedListening(radio, transmission, listening);
    }
    cModule *radioModule = const_cast<cModule *>(check_and_cast<const cModule *>(radio));
    if (radioModeFilter)
        radioModule->subscribe(IRadio::radioModeChangedSignal, this);
    if (listeningFilter)
        radioModule->subscribe(IRadio::listeningChangedSignal, this);
    if (macAddressFilter)
        getContainingNode(radioModule)->subscribe(NF_INTERFACE_CONFIG_CHANGED, this);
    emit(radioAddedSignal, radioModule);
}

void inet::physicallayer::RadioMedium::addTransmission ( const IRadio *  transmitter, const ITransmission *  transmission  )

protectedvirtual

Adds a new transmission to the radio medium.

Referenced by transmitPacket().

{
    transmissionCount++;
    transmissions.push_back(transmission);
    communicationCache->addTransmission(transmission);
    simtime_t maxArrivalEndTime = transmission->getEndTime();
    for (const auto receiverRadio : radios) {
        if (receiverRadio != nullptr && receiverRadio != transmitterRadio) {
            const IArrival *arrival = propagation->computeArrival(transmission, receiverRadio->getAntenna()->getMobility());
            const Interval *interval = new Interval(arrival->getStartTime(), arrival->getEndTime(), (void *)transmission);
            const IListening *listening = receiverRadio->getReceiver()->createListening(receiverRadio, arrival->getStartTime(), arrival->getEndTime(), arrival->getStartPosition(), arrival->getEndPosition());
            const simtime_t arrivalEndTime = arrival->getEndTime();
            if (arrivalEndTime > maxArrivalEndTime)
                maxArrivalEndTime = arrivalEndTime;
            communicationCache->setCachedArrival(receiverRadio, transmission, arrival);
            communicationCache->setCachedInterval(receiverRadio, transmission, interval);
            communicationCache->setCachedListening(receiverRadio, transmission, listening);
        }
    }
    communicationCache->setCachedInterferenceEndTime(transmission, maxArrivalEndTime + mediumLimitCache->getMaxTransmissionDuration());
    if (!removeNonInterferingTransmissionsTimer->isScheduled()) {
        Enter_Method_Silent();
        scheduleAt(communicationCache->getCachedInterferenceEndTime(transmissions[0]), removeNonInterferingTransmissionsTimer);
    }
    emit(transmissionAddedSignal, check_and_cast<const cObject *>(transmission));
}

const IInterference * inet::physicallayer::RadioMedium::computeInterference ( const IRadio *  receiver, const IListening *  listening, const std::vector< const ITransmission * > *  transmissions  ) const

protectedvirtual

Referenced by computeListeningDecision(), getInterference(), isReceptionAttempted(), isReceptionPossible(), and isReceptionSuccessful().

{
    interferenceComputationCount++;
    const INoise *noise = backgroundNoise ? backgroundNoise->computeNoise(listening) : nullptr;
    const std::vector<const IReception *> *interferingReceptions = computeInterferingReceptions(listening, transmissions);
    return new Interference(noise, interferingReceptions);
}

const IInterference * inet::physicallayer::RadioMedium::computeInterference ( const IRadio *  receiver, const IListening *  listening, const ITransmission *  transmission, const std::vector< const ITransmission * > *  transmissions  ) const

protectedvirtual

{
    interferenceComputationCount++;
    const IReception *reception = getReception(receiver, transmission);
    const INoise *noise = backgroundNoise ? backgroundNoise->computeNoise(listening) : nullptr;
    const std::vector<const IReception *> *interferingReceptions = computeInterferingReceptions(reception, transmissions);
    return new Interference(noise, interferingReceptions);
}

const std::vector< const IReception * > * inet::physicallayer::RadioMedium::computeInterferingReceptions ( const IListening *  listening, const std::vector< const ITransmission * > *  transmissions  ) const

protectedvirtual

Referenced by computeInterference().

{
    const IRadio *radio = listening->getReceiver();
    std::vector<const ITransmission *> *interferingTransmissions = communicationCache->computeInterferingTransmissions(radio, listening->getStartTime(), listening->getEndTime());
    std::vector<const IReception *> *interferingReceptions = new std::vector<const IReception *>();
    for (const auto interferingTransmission : *interferingTransmissions)
        if (isInterferingTransmission(interferingTransmission, listening))
            interferingReceptions->push_back(getReception(radio, interferingTransmission));
    delete interferingTransmissions;
    return interferingReceptions;
}

const std::vector< const IReception * > * inet::physicallayer::RadioMedium::computeInterferingReceptions ( const IReception *  reception, const std::vector< const ITransmission * > *  transmissions  ) const

protectedvirtual

{
    const IRadio *radio = reception->getReceiver();
    const ITransmission *transmission = reception->getTransmission();
    std::vector<const ITransmission *> *interferingTransmissions = communicationCache->computeInterferingTransmissions(radio, reception->getStartTime(), reception->getEndTime());
    std::vector<const IReception *> *interferingReceptions = new std::vector<const IReception *>();
    for (const auto interferingTransmission : *interferingTransmissions)
        if (transmission != interferingTransmission && isInterferingTransmission(interferingTransmission, reception))
            interferingReceptions->push_back(getReception(radio, interferingTransmission));
    delete interferingTransmissions;
    return interferingReceptions;
}

const IListeningDecision * inet::physicallayer::RadioMedium::computeListeningDecision ( const IRadio *  receiver, const IListening *  listening, const std::vector< const ITransmission * > *  transmissions  ) const

protectedvirtual

Referenced by listenOnMedium().

{
    listeningDecisionComputationCount++;
    const IInterference *interference = computeInterference(radio, listening, transmissions);
    const IListeningDecision *decision = radio->getReceiver()->computeListeningDecision(listening, interference);
    delete interference;
    return decision;
}

const IReception * inet::physicallayer::RadioMedium::computeReception ( const IRadio *  receiver, const ITransmission *  transmission  ) const

protectedvirtual

Referenced by getReception().

{
    receptionComputationCount++;
    return analogModel->computeReception(radio, transmission, getArrival(radio, transmission));
}

const IReceptionDecision * inet::physicallayer::RadioMedium::computeReceptionDecision ( const IRadio *  receiver, const IListening *  listening, const ITransmission *  transmission, IRadioSignal::SignalPart  part, const std::vector< const ITransmission * > *  transmissions  ) const

protectedvirtual

Referenced by getReceptionDecision().

{
    receptionDecisionComputationCount++;
    const IReception *reception = getReception(radio, transmission);
    const IInterference *interference = getInterference(radio, listening, transmission);
    const ISNIR *snir = getSNIR(radio, transmission);
    return radio->getReceiver()->computeReceptionDecision(listening, reception, part, interference, snir);
}

const IReceptionResult * inet::physicallayer::RadioMedium::computeReceptionResult ( const IRadio *  receiver, const IListening *  listening, const ITransmission *  transmission, const std::vector< const ITransmission * > *  transmissions  ) const

protectedvirtual

Referenced by getReceptionResult().

{
    receptionResultComputationCount++;
    const IReception *reception = getReception(radio, transmission);
    const IInterference *interference = getInterference(radio, listening, transmission);
    const ISNIR *snir = getSNIR(radio, transmission);
    return radio->getReceiver()->computeReceptionResult(listening, reception, interference, snir);
}

IRadioFrame * inet::physicallayer::RadioMedium::createReceiverRadioFrame ( const ITransmission *  transmission )

protectedvirtual

Creates a new radio frame for a receiver.

Referenced by receiveSignal(), and sendToRadio().

{
    auto radioFrame = new RadioFrame(transmission);
    auto phyFrame = const_cast<cPacket *>(transmission->getPhyFrame());
    auto macFrame = const_cast<cPacket *>(transmission->getMacFrame());
    auto encapsulatedFrame = phyFrame != nullptr ? phyFrame : macFrame;
    radioFrame->setName(encapsulatedFrame->getName());
    radioFrame->setDuration(transmission->getDuration());
    radioFrame->encapsulate(encapsulatedFrame->dup());
    return radioFrame;
}

IRadioFrame * inet::physicallayer::RadioMedium::createTransmitterRadioFrame ( const IRadio *  radio, cPacket *  macFrame  )

protectedvirtual

Creates a new radio frame for the transmitter.

Referenced by transmitPacket().

{
    Enter_Method_Silent();
    take(macFrame);
    auto transmission = radio->getTransmitter()->createTransmission(radio, macFrame, simTime());
    auto radioFrame = new RadioFrame(transmission);
    auto phyFrame = const_cast<cPacket *>(transmission->getPhyFrame());
    auto encapsulatedFrame = phyFrame != nullptr ? phyFrame : macFrame;
    radioFrame->setName(encapsulatedFrame->getName());
    radioFrame->setDuration(transmission->getDuration());
    radioFrame->encapsulate(encapsulatedFrame);
    return radioFrame;
}

void inet::physicallayer::RadioMedium::finish ( )

overrideprotectedvirtual

{
    double receptionCacheHitPercentage = 100 * (double)cacheReceptionHitCount / (double)cacheReceptionGetCount;
    double interferenceCacheHitPercentage = 100 * (double)cacheInterferenceHitCount / (double)cacheInterferenceGetCount;
    double noiseCacheHitPercentage = 100 * (double)cacheNoiseHitCount / (double)cacheNoiseGetCount;
    double snirCacheHitPercentage = 100 * (double)cacheSNIRHitCount / (double)cacheSNIRGetCount;
    double decisionCacheHitPercentage = 100 * (double)cacheDecisionHitCount / (double)cacheDecisionGetCount;
    double resultCacheHitPercentage = 100 * (double)cacheResultHitCount / (double)cacheResultGetCount;
    EV_INFO << "Transmission count = " << transmissionCount << endl;
    EV_INFO << "Radio frame send count = " << radioFrameSendCount << endl;
    EV_INFO << "Reception computation count = " << receptionComputationCount << endl;
    EV_INFO << "Interference computation count = " << interferenceComputationCount << endl;
    EV_INFO << "Reception decision computation count = " << receptionDecisionComputationCount << endl;
    EV_INFO << "Listening decision computation count = " << listeningDecisionComputationCount << endl;
    EV_INFO << "Reception cache hit = " << receptionCacheHitPercentage << " %" << endl;
    EV_INFO << "Interference cache hit = " << interferenceCacheHitPercentage << " %" << endl;
    EV_INFO << "Noise cache hit = " << noiseCacheHitPercentage << " %" << endl;
    EV_INFO << "SNIR cache hit = " << snirCacheHitPercentage << " %" << endl;
    EV_INFO << "Reception decision cache hit = " << decisionCacheHitPercentage << " %" << endl;
    EV_INFO << "Reception result cache hit = " << resultCacheHitPercentage << " %" << endl;
    recordScalar("transmission count", transmissionCount);
    recordScalar("radio frame send count", radioFrameSendCount);
    recordScalar("reception computation count", receptionComputationCount);
    recordScalar("interference computation count", interferenceComputationCount);
    recordScalar("reception decision computation count", receptionDecisionComputationCount);
    recordScalar("listening decision computation count", listeningDecisionComputationCount);
    recordScalar("reception cache hit", receptionCacheHitPercentage, "%");
    recordScalar("interference cache hit", interferenceCacheHitPercentage, "%");
    recordScalar("noise cache hit", noiseCacheHitPercentage, "%");
    recordScalar("snir cache hit", snirCacheHitPercentage, "%");
    recordScalar("reception decision cache hit", decisionCacheHitPercentage, "%");
    recordScalar("reception result cache hit", resultCacheHitPercentage, "%");
}

virtual const IAnalogModel* inet::physicallayer::RadioMedium::getAnalogModel ( ) const

inlineoverridevirtual

Returns the radio signal analog model of this radio medium.

This function never returns nullptr.

Implements inet::physicallayer::IRadioMedium.

{ return analogModel; }

const IArrival * inet::physicallayer::RadioMedium::getArrival ( const IRadio *  receiver, const ITransmission *  transmission  ) const

overridevirtual

Returns the space and time coordinates of the transmission arriving at the provided receiver.

This function never returns nullptr as long as the transmission is live on the radio medium.

Implements inet::physicallayer::IRadioMedium.

Referenced by computeReception(), isInterferingTransmission(), isPotentialReceiver(), receiveSignal(), and sendToRadio().

{
    return communicationCache->getCachedArrival(receiver, transmission);
}

virtual const IBackgroundNoise* inet::physicallayer::RadioMedium::getBackgroundNoise ( ) const

inlineoverridevirtual

Returns the background noise model of this radio medium.

This function may return nullptr if there's no background noise model.

Implements inet::physicallayer::IRadioMedium.

{ return backgroundNoise; }

virtual const ICommunicationCache* inet::physicallayer::RadioMedium::getCommunicationCache ( ) const

inlineoverridevirtual

Implements inet::physicallayer::IRadioMedium.

{ return communicationCache; }

const IInterference * inet::physicallayer::RadioMedium::getInterference ( const IRadio *  receiver, const ITransmission *  transmission  ) const

overridevirtual

Returns the interference of the transmission arriving at the provided receiver.

This function never returns nullptr as long as the transmission is live on the radio medium.

Implements inet::physicallayer::IRadioMedium.

Referenced by computeReceptionDecision(), computeReceptionResult(), and getNoise().

{
    return getInterference(receiver, communicationCache->getCachedListening(receiver, transmission), transmission);
}

const IInterference * inet::physicallayer::RadioMedium::getInterference ( const IRadio *  receiver, const IListening *  listening, const ITransmission *  transmission  ) const

virtual

{
    cacheInterferenceGetCount++;
    const IInterference *interference = communicationCache->getCachedInterference(receiver, transmission);
    if (interference)
        cacheInterferenceHitCount++;
    else {
        interference = computeInterference(receiver, listening, transmission, const_cast<const std::vector<const ITransmission *> *>(&transmissions));
        communicationCache->setCachedInterference(receiver, transmission, interference);
    }
    return interference;
}

const IListening * inet::physicallayer::RadioMedium::getListening ( const IRadio *  receiver, const ITransmission *  transmission  ) const

overridevirtual

Returns how the radio is listening on the medium when the transmission arrives at the provided receiver.

This function never returns nullptr as long as the transmission is live on the radio medium.

Implements inet::physicallayer::IRadioMedium.

Referenced by isPotentialReceiver(), isReceptionAttempted(), isReceptionPossible(), and isReceptionSuccessful().

{
    return communicationCache->getCachedListening(receiver, transmission);
}

virtual const IMaterial* inet::physicallayer::RadioMedium::getMaterial ( ) const

inlineoverridevirtual

Returns the material of the radio medium.

This function never returns nullptr.

Implements inet::physicallayer::IRadioMedium.

{ return material; }

virtual const IMediumLimitCache* inet::physicallayer::RadioMedium::getMediumLimitCache ( ) const

inlineoverridevirtual

Implements inet::physicallayer::IRadioMedium.

Referenced by inet::physicallayer::GridNeighborCache::addRadio(), inet::physicallayer::NeighborListNeighborCache::addRadio(), inet::physicallayer::QuadTreeNeighborCache::addRadio(), inet::physicallayer::NeighborListNeighborCache::initialize(), inet::physicallayer::GridNeighborCache::initialize(), inet::physicallayer::QuadTreeNeighborCache::initialize(), inet::physicallayer::GridNeighborCache::removeRadio(), inet::physicallayer::NeighborListNeighborCache::removeRadio(), and inet::physicallayer::QuadTreeNeighborCache::removeRadio().

{ return mediumLimitCache; }

virtual const INeighborCache* inet::physicallayer::RadioMedium::getNeighborCache ( ) const

inlineoverridevirtual

Implements inet::physicallayer::IRadioMedium.

{ return neighborCache; }

const INoise * inet::physicallayer::RadioMedium::getNoise ( const IRadio *  receiver, const ITransmission *  transmission  ) const

overridevirtual

Returns the total noise computed from the interference of the transmission arriving at the provided receiver.

This function never returns nullptr as long as the transmission is live on the radio medium.

Implements inet::physicallayer::IRadioMedium.

Referenced by getSNIR().

{
    cacheNoiseGetCount++;
    const INoise *noise = communicationCache->getCachedNoise(receiver, transmission);
    if (noise)
        cacheNoiseHitCount++;
    else {
        const IListening *listening = communicationCache->getCachedListening(receiver, transmission);
        const IInterference *interference = getInterference(receiver, transmission);
        noise = analogModel->computeNoise(listening, interference);
        communicationCache->setCachedNoise(receiver, transmission, noise);
    }
    return noise;
}

virtual const IObstacleLoss* inet::physicallayer::RadioMedium::getObstacleLoss ( ) const

inlineoverridevirtual

Returns the radio signal obstacle loss model of this radio medium.

This function may return nullptr if there's no obstacle loss model.

Implements inet::physicallayer::IRadioMedium.

{ return obstacleLoss; }

virtual const IPathLoss* inet::physicallayer::RadioMedium::getPathLoss ( ) const

inlineoverridevirtual

Returns the radio signal path loss model of this radio medium.

This function never returns nullptr.

Implements inet::physicallayer::IRadioMedium.

{ return pathLoss; }

virtual const IPhysicalEnvironment* inet::physicallayer::RadioMedium::getPhysicalEnvironment ( ) const

inlineoverridevirtual

Returns the physical environment model of this radio medium.

This function may return nullptr if there's no physical environment model.

Implements inet::physicallayer::IRadioMedium.

{ return physicalEnvironment; }

virtual const IPropagation* inet::physicallayer::RadioMedium::getPropagation ( ) const

inlineoverridevirtual

Returns the radio signal propagation model of this radio medium.

This function never returns nullptr.

Implements inet::physicallayer::IRadioMedium.

{ return propagation; }

const IReception * inet::physicallayer::RadioMedium::getReception ( const IRadio *  receiver, const ITransmission *  transmission  ) const

overridevirtual

Returns the reception of the transmission arriving at the provided receiver.

This function never returns nullptr as long as the transmission is live on the radio medium.

Implements inet::physicallayer::IRadioMedium.

Referenced by computeInterference(), computeInterferingReceptions(), computeReceptionDecision(), computeReceptionResult(), getSNIR(), isReceptionAttempted(), isReceptionPossible(), and isReceptionSuccessful().

{
    cacheReceptionGetCount++;
    const IReception *reception = communicationCache->getCachedReception(receiver, transmission);
    if (reception)
        cacheReceptionHitCount++;
    else {
        reception = computeReception(receiver, transmission);
        communicationCache->setCachedReception(receiver, transmission, reception);
        EV_DEBUG << "Receiving " << transmission << " from medium by " << receiver << " arrives as " << reception << endl;
    }
    return reception;
}

const IReceptionDecision * inet::physicallayer::RadioMedium::getReceptionDecision ( const IRadio *  receiver, const IListening *  listening, const ITransmission *  transmission, IRadioSignal::SignalPart  part  ) const

overridevirtual

Returns the reception decision for the transmission part that specifies whether the reception is possible, attempted, and successful.

Implements inet::physicallayer::IRadioMedium.

{
    cacheDecisionGetCount++;
    const IReceptionDecision *decision = communicationCache->getCachedReceptionDecision(radio, transmission, part);
    if (decision)
        cacheDecisionHitCount++;
    else {
        decision = computeReceptionDecision(radio, listening, transmission, part, const_cast<const std::vector<const ITransmission *> *>(&transmissions));
        communicationCache->setCachedReceptionDecision(radio, transmission, part, decision);
        EV_DEBUG << "Receiving " << transmission << " from medium by " << radio << " arrives as " << decision->getReception() << " and results in " << decision << endl;
    }
    return decision;
}

const IReceptionResult * inet::physicallayer::RadioMedium::getReceptionResult ( const IRadio *  receiver, const IListening *  listening, const ITransmission *  transmission  ) const

overridevirtual

Returns the reception result for the transmission that describes the end result of the reception process.

Implements inet::physicallayer::IRadioMedium.

Referenced by receivePacket().

{
    cacheResultGetCount++;
    const IReceptionResult *result = communicationCache->getCachedReceptionResult(radio, transmission);
    if (result)
        cacheResultHitCount++;
    else {
        result = computeReceptionResult(radio, listening, transmission, const_cast<const std::vector<const ITransmission *> *>(&transmissions));
        communicationCache->setCachedReceptionResult(radio, transmission, result);
        EV_DEBUG << "Receiving " << transmission << " from medium by " << radio << " arrives as " << result->getReception() << " and results in " << result << endl;
    }
    return result;
}

const ISNIR * inet::physicallayer::RadioMedium::getSNIR ( const IRadio *  receiver, const ITransmission *  transmission  ) const

overridevirtual

Returns the signal to noise and interference ratio of the transmission arriving at the provided receiver.

This function never returns nullptr as long as the transmission is live on the radio medium.

Implements inet::physicallayer::IRadioMedium.

Referenced by computeReceptionDecision(), computeReceptionResult(), and isReceptionSuccessful().

{
    cacheSNIRGetCount++;
    const ISNIR *snir = communicationCache->getCachedSNIR(receiver, transmission);
    if (snir)
        cacheSNIRHitCount++;
    else {
        const IReception *reception = getReception(receiver, transmission);
        const INoise *noise = getNoise(receiver, transmission);
        snir = analogModel->computeSNIR(reception, noise);
        communicationCache->setCachedSNIR(receiver, transmission, snir);
    }
    return snir;
}

void inet::physicallayer::RadioMedium::handleMessage ( cMessage *  message )

overrideprotectedvirtual

{
    if (message == removeNonInterferingTransmissionsTimer)
        removeNonInterferingTransmissions();
    else
        throw cRuntimeError("Unknown message");
}

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

overrideprotectedvirtual

{
    if (stage == INITSTAGE_LOCAL) {
        // initialize parameters
        propagation = check_and_cast<IPropagation *>(getSubmodule("propagation"));
        pathLoss = check_and_cast<IPathLoss *>(getSubmodule("pathLoss"));
        obstacleLoss = dynamic_cast<IObstacleLoss *>(getSubmodule("obstacleLoss"));
        analogModel = check_and_cast<IAnalogModel *>(getSubmodule("analogModel"));
        backgroundNoise = dynamic_cast<IBackgroundNoise *>(getSubmodule("backgroundNoise"));
        mediumLimitCache = check_and_cast<IMediumLimitCache *>(getSubmodule("mediumLimitCache"));
        neighborCache = dynamic_cast<INeighborCache *>(getSubmodule("neighborCache"));
        communicationCache = check_and_cast<ICommunicationCache *>(getSubmodule("communicationCache"));
        physicalEnvironment = dynamic_cast<IPhysicalEnvironment *>(getModuleByPath(par("physicalEnvironmentModule")));
        material = physicalEnvironment != nullptr ? physicalEnvironment->getMaterialRegistry()->getMaterial("air") : nullptr;
        const char *rangeFilterString = par("rangeFilter");
        if (!strcmp(rangeFilterString, ""))
            rangeFilter = RANGE_FILTER_ANYWHERE;
        else if (!strcmp(rangeFilterString, "interferenceRange"))
            rangeFilter = RANGE_FILTER_INTERFERENCE_RANGE;
        else if (!strcmp(rangeFilterString, "communicationRange"))
            rangeFilter = RANGE_FILTER_COMMUNICATION_RANGE;
        else
            throw cRuntimeError("Unknown range filter: '%s'", rangeFilter);
        radioModeFilter = par("radioModeFilter");
        listeningFilter = par("listeningFilter");
        macAddressFilter = par("macAddressFilter");
        // initialize timers
        removeNonInterferingTransmissionsTimer = new cMessage("removeNonInterferingTransmissions");
        // initialize logging
        recordCommunicationLog = par("recordCommunicationLog");
        if (recordCommunicationLog)
            communicationLog.open();
    }
    else if (stage == INITSTAGE_LAST)
        EV_INFO << "Initialized " << getCompleteStringRepresentation() << endl;
}

bool inet::physicallayer::RadioMedium::isInCommunicationRange ( const ITransmission *  transmission, const Coord  startPosition, const Coord  endPosition  ) const

protectedvirtual

Referenced by isPotentialReceiver().

{
    m maxCommunicationRange = mediumLimitCache->getMaxCommunicationRange();
    return std::isnan(maxCommunicationRange.get()) ||
           (transmission->getStartPosition().distance(startPosition) < maxCommunicationRange.get() &&
            transmission->getEndPosition().distance(endPosition) < maxCommunicationRange.get());
}

bool inet::physicallayer::RadioMedium::isInInterferenceRange ( const ITransmission *  transmission, const Coord  startPosition, const Coord  endPosition  ) const

protectedvirtual

Referenced by isInterferingTransmission(), and isPotentialReceiver().

{
    m maxInterferenceRange = mediumLimitCache->getMaxInterferenceRange();
    return std::isnan(maxInterferenceRange.get()) ||
           (transmission->getStartPosition().distance(startPosition) < maxInterferenceRange.get() &&
            transmission->getEndPosition().distance(endPosition) < maxInterferenceRange.get());
}

bool inet::physicallayer::RadioMedium::isInterferingTransmission ( const ITransmission *  transmission, const IListening *  listening  ) const

protectedvirtual

Referenced by computeInterferingReceptions().

{
    const IRadio *transmitter = transmission->getTransmitter();
    const IRadio *receiver = listening->getReceiver();
    const IArrival *arrival = getArrival(receiver, transmission);
    const simtime_t& minInterferenceTime = mediumLimitCache->getMinInterferenceTime();
    return transmitter != receiver &&
           arrival->getEndTime() >= listening->getStartTime() + minInterferenceTime &&
           arrival->getStartTime() <= listening->getEndTime() - minInterferenceTime &&
           isInInterferenceRange(transmission, listening->getStartPosition(), listening->getEndPosition());
}

bool inet::physicallayer::RadioMedium::isInterferingTransmission ( const ITransmission *  transmission, const IReception *  reception  ) const

protectedvirtual

{
    const IRadio *transmitter = transmission->getTransmitter();
    const IRadio *receiver = reception->getReceiver();
    const IArrival *arrival = getArrival(receiver, transmission);
    const simtime_t& minInterferenceTime = mediumLimitCache->getMinInterferenceTime();
    return transmitter != receiver &&
           arrival->getEndTime() > reception->getStartTime() + minInterferenceTime &&
           arrival->getStartTime() < reception->getEndTime() - minInterferenceTime &&
           isInInterferenceRange(transmission, reception->getStartPosition(), reception->getEndPosition());
}

bool inet::physicallayer::RadioMedium::isPotentialReceiver ( const IRadio *  receiver, const ITransmission *  transmission  ) const

protectedvirtual

Returns true if the radio can potentially receive the transmission successfully.

If this function returns false then the radio medium doesn't send a radio frame to this receiver.

Referenced by receiveSignal(), and sendToRadio().

{
    const Radio *receiverRadio = check_and_cast<const Radio *>(radio);
    if (radioModeFilter && receiverRadio->getRadioMode() != IRadio::RADIO_MODE_RECEIVER && receiverRadio->getRadioMode() != IRadio::RADIO_MODE_TRANSCEIVER)
        return false;
    else if (listeningFilter && !radio->getReceiver()->computeIsReceptionPossible(getListening(radio, transmission), transmission))
        return false;
    else if (macAddressFilter && !isRadioMacAddress(radio, check_and_cast<const IMACFrame *>(transmission->getMacFrame())->getReceiverAddress()))
        return false;
    else if (rangeFilter == RANGE_FILTER_INTERFERENCE_RANGE) {
        const IArrival *arrival = getArrival(radio, transmission);
        return isInInterferenceRange(transmission, arrival->getStartPosition(), arrival->getEndPosition());
    }
    else if (rangeFilter == RANGE_FILTER_COMMUNICATION_RANGE) {
        const IArrival *arrival = getArrival(radio, transmission);
        return isInCommunicationRange(transmission, arrival->getStartPosition(), arrival->getEndPosition());
    }
    else
        return true;
}

bool inet::physicallayer::RadioMedium::isRadioMacAddress ( const IRadio *  radio, const MACAddress  address  ) const

protectedvirtual

Referenced by isPotentialReceiver().

{
    cModule *host = getContainingNode(check_and_cast<const cModule *>(radio));
    IInterfaceTable *interfaceTable = check_and_cast<IInterfaceTable *>(host->getSubmodule("interfaceTable"));
    for (int i = 0; i < interfaceTable->getNumInterfaces(); i++) {
        const InterfaceEntry *interface = interfaceTable->getInterface(i);
        if (interface && interface->getMacAddress() == address)
            return true;
    }
    return false;
}

bool inet::physicallayer::RadioMedium::isReceptionAttempted ( const IRadio *  receiver, const ITransmission *  transmission, IRadioSignal::SignalPart  part  ) const

overridevirtual

Returns true when the reception is attempted of the transmission part.

Implements inet::physicallayer::IRadioMedium.

{
    const IReception *reception = getReception(receiver, transmission);
    const IListening *listening = getListening(receiver, transmission);
    // TODO: why compute?
    const IInterference *interference = computeInterference(receiver, listening, transmission, const_cast<const std::vector<const ITransmission *> *>(&transmissions));
    bool isReceptionAttempted = receiver->getReceiver()->computeIsReceptionAttempted(listening, reception, part, interference);
    delete interference;
    return isReceptionAttempted;
}

bool inet::physicallayer::RadioMedium::isReceptionPossible ( const IRadio *  receiver, const ITransmission *  transmission, IRadioSignal::SignalPart  part  ) const

overridevirtual

Returns true when the reception is possible of the transmission part.

Implements inet::physicallayer::IRadioMedium.

{
    const IReception *reception = getReception(receiver, transmission);
    const IListening *listening = getListening(receiver, transmission);
    // TODO: why compute?
    const IInterference *interference = computeInterference(receiver, listening, transmission, const_cast<const std::vector<const ITransmission *> *>(&transmissions));
    bool isReceptionPossible = receiver->getReceiver()->computeIsReceptionAttempted(listening, reception, part, interference);
    delete interference;
    return isReceptionPossible;
}

bool inet::physicallayer::RadioMedium::isReceptionSuccessful ( const IRadio *  receiver, const ITransmission *  transmission, IRadioSignal::SignalPart  part  ) const

overridevirtual

Returns true when the reception is successful of the transmission part.

Implements inet::physicallayer::IRadioMedium.

{
    const IReception *reception = getReception(receiver, transmission);
    const IListening *listening = getListening(receiver, transmission);
    // TODO: why compute?
    const IInterference *interference = computeInterference(receiver, listening, transmission, const_cast<const std::vector<const ITransmission *> *>(&transmissions));
    const ISNIR *snir = getSNIR(receiver, transmission);
    bool isReceptionSuccessful = receiver->getReceiver()->computeIsReceptionSuccessful(listening, reception, part, interference, snir);
    delete interference;
    return isReceptionSuccessful;
}

const IListeningDecision * inet::physicallayer::RadioMedium::listenOnMedium ( const IRadio *  receiver, const IListening *  listening  ) const

overridevirtual

Returns the listening decision that describes what the receiver detects on the radio medium.

Implements inet::physicallayer::IRadioMedium.

{
    const IListeningDecision *decision = computeListeningDecision(radio, listening, const_cast<const std::vector<const ITransmission *> *>(&transmissions));
    EV_DEBUG << "Listening with " << listening << " on medium by " << radio << " results in " << decision << endl;
    return decision;
}

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

std::ostream & inet::physicallayer::RadioMedium::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 << static_cast<const cSimpleModule *>(this);
    if (level <= PRINT_LEVEL_TRACE) {
        stream << ", propagation = " << printObjectToString(propagation, level + 1)
               << ", pathLoss = " << printObjectToString(pathLoss, level + 1)
               << ", analogModel = " << printObjectToString(analogModel, level + 1)
               << ", obstacleLoss = " << printObjectToString(obstacleLoss, level + 1)
               << ", backgroundNoise = " << printObjectToString(backgroundNoise, level + 1)
               << ", mediumLimitCache = " << printObjectToString(mediumLimitCache, level + 1)
               << ", neighborCache = " << printObjectToString(neighborCache, level + 1)
               << ", communicationCache = " << printObjectToString(communicationCache, level + 1) ;
    }
    return stream;
}

cPacket * inet::physicallayer::RadioMedium::receivePacket ( const IRadio *  receiver, IRadioFrame *  radioFrame  )

overridevirtual

Returns the MAC frame that was transmitted in the provided radio frame.

The MAC frame control info will be an instance of the ReceptionIndication class.

Implements inet::physicallayer::IRadioMedium.

{
    const ITransmission *transmission = radioFrame->getTransmission();
    const IListening *listening = communicationCache->getCachedListening(radio, transmission);
    if (recordCommunicationLog)
        communicationLog.writeReception(radio, radioFrame);
    const IReceptionResult *result = getReceptionResult(radio, listening, transmission);
    communicationCache->removeCachedReceptionResult(radio, transmission);
    cPacket *macFrame = const_cast<cPacket *>(result->getMacFrame()->dup());
    macFrame->setControlInfo(const_cast<ReceptionIndication *>(result->getIndication()));
    delete result;
    return macFrame;
}

void inet::physicallayer::RadioMedium::receiveSignal ( cComponent *  source, simsignal_t  signal, long  value, cObject *  details  )

overridevirtual

{
    if (signal == IRadio::radioModeChangedSignal || signal == IRadio::listeningChangedSignal || signal == NF_INTERFACE_CONFIG_CHANGED) {
        const Radio *receiverRadio = check_and_cast<const Radio *>(source);
        for (const auto transmission : transmissions) {
            const Radio *transmitterRadio = check_and_cast<const Radio *>(transmission->getTransmitter());
            if (signal == IRadio::listeningChangedSignal) {
                const IArrival *arrival = getArrival(receiverRadio, transmission);
                const IListening *listening = receiverRadio->getReceiver()->createListening(receiverRadio, arrival->getStartTime(), arrival->getEndTime(), arrival->getStartPosition(), arrival->getEndPosition());
                delete communicationCache->getCachedListening(receiverRadio, transmission);
                communicationCache->setCachedListening(receiverRadio, transmission, listening);
            }
            if (communicationCache->getCachedFrame(receiverRadio, transmission) == nullptr &&
                receiverRadio != transmitterRadio && isPotentialReceiver(receiverRadio, transmission))
            {
                const IArrival *arrival = getArrival(receiverRadio, transmission);
                if (arrival->getEndTime() >= simTime()) {
                    cMethodCallContextSwitcher contextSwitcher(transmitterRadio);
                    contextSwitcher.methodCallSilent();
                    const cPacket *macFrame = transmission->getMacFrame();
                    EV_DEBUG << "Picking up " << macFrame << " originally sent "
                             << " from " << (IRadio *)transmitterRadio << " at " << transmission->getStartPosition()
                             << " to " << (IRadio *)receiverRadio << " at " << arrival->getStartPosition()
                             << " in " << arrival->getStartPropagationTime() * 1E+6 << " us propagation time." << endl;
                    auto radioFrame = static_cast<RadioFrame *>(createReceiverRadioFrame(transmission));
                    simtime_t delay = arrival->getStartTime() - simTime();
                    simtime_t duration = delay > 0 ? radioFrame->getDuration() : radioFrame->getDuration() + delay;
                    cGate *gate = receiverRadio->getRadioGate()->getPathStartGate();
                    ASSERT(dynamic_cast<IRadio *>(getSimulation()->getContextModule()) != nullptr);
                    const_cast<Radio *>(transmitterRadio)->sendDirect(radioFrame, delay > 0 ? delay : 0, duration, gate);
                    communicationCache->setCachedFrame(receiverRadio, transmission, radioFrame);
                    radioFrameSendCount++;
                }
            }
        }
    }
}

void inet::physicallayer::RadioMedium::removeNonInterferingTransmissions ( )

protectedvirtual

Removes all cached data related to past transmissions that don't have any effect on any ongoing transmission.

Note that it's possible that a transmission is in the past but it's still needed to compute the total interference for another.

Referenced by handleMessage().

{
    const simtime_t now = simTime();
    size_t transmissionIndex = 0;
    while (transmissionIndex < transmissions.size() && communicationCache->getCachedInterferenceEndTime(transmissions[transmissionIndex]) <= now)
        transmissionIndex++;
    EV_DEBUG << "Removing " << transmissionIndex << " non interfering transmissions\n";
    for (auto it = transmissions.cbegin(); it != transmissions.cbegin() + transmissionIndex; it++) {
        const ITransmission *transmission = *it;
        const IRadioFrame *radioFrame = communicationCache->getCachedFrame(transmission);
        communicationCache->removeCachedFrame(transmission);
        communicationCache->removeTransmission(transmission);
        emit(transmissionRemovedSignal, check_and_cast<const cObject *>(transmission));
        delete radioFrame;
        delete transmission;
    }
    transmissions.erase(transmissions.begin(), transmissions.begin() + transmissionIndex);
    communicationCache->removeNonInterferingTransmissions();
    if (transmissions.size() > 0)
        scheduleAt(communicationCache->getCachedInterferenceEndTime(transmissions[0]), removeNonInterferingTransmissionsTimer);
}

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

overridevirtual

Removes a radio from the radio medium.

An exception is thrown if the radio is not yet added. The radio cannot start new transmissions and will not receive any further transmission including the ongoing ones.

Implements inet::physicallayer::IRadioMedium.

{
    int radioIndex = radio->getId() - radios[0]->getId();
    radios[radioIndex] = nullptr;
    int radioCount = 0;
    while (radios[radioCount] == nullptr && radioCount < (int)radios.size())
        radioCount++;
    if (radioCount != 0)
        radios.erase(radios.begin(), radios.begin() + radioCount);
    communicationCache->removeRadio(radio);
    if (neighborCache)
        neighborCache->removeRadio(radio);
    mediumLimitCache->removeRadio(radio);
    cModule *radioModule = const_cast<cModule *>(check_and_cast<const cModule *>(radio));
    if (radioModeFilter)
        radioModule->unsubscribe(IRadio::radioModeChangedSignal, this);
    if (listeningFilter)
        radioModule->unsubscribe(IRadio::listeningChangedSignal, this);
    if (macAddressFilter)
        getContainingNode(radioModule)->unsubscribe(NF_INTERFACE_CONFIG_CHANGED, this);
    emit(radioRemovedSignal, radioModule);
}

void inet::physicallayer::RadioMedium::sendToAffectedRadios ( IRadio *  transmitter, const IRadioFrame *  frame  )

protectedvirtual

Sends a copy of the provided radio frame to all affected receivers on the radio medium.

Referenced by transmitPacket().

{
    const RadioFrame *radioFrame = check_and_cast<const RadioFrame *>(frame);
    EV_DEBUG << "Sending " << frame << " with " << radioFrame->getBitLength() << " bits in " << radioFrame->getDuration() * 1E+6 << " us transmission duration"
             << " from " << radio << " on " << (IRadioMedium *)this << "." << endl;
    if (neighborCache && rangeFilter != RANGE_FILTER_ANYWHERE)
    {
        double range;
        if (rangeFilter == RANGE_FILTER_COMMUNICATION_RANGE)
            range = mediumLimitCache->getMaxCommunicationRange(radio).get();
        else if (rangeFilter == RANGE_FILTER_INTERFERENCE_RANGE)
            range = mediumLimitCache->getMaxInterferenceRange(radio).get();
        else
            throw cRuntimeError("Unknown range filter %d", rangeFilter);
        if (std::isnan(range))
        {
            EV_WARN << "We can't use the NeighborCache for radio " << radio->getId() << ": range is NaN" << endl;
            sendToAllRadios(radio, frame);
        }
        else
            neighborCache->sendToNeighbors(radio, frame, range);
    }
    else
        sendToAllRadios(radio, frame);

}

void inet::physicallayer::RadioMedium::sendToAllRadios ( IRadio *  transmitter, const IRadioFrame *  frame  )

protectedvirtual

Sends a copy of the provided radio frame to all receivers on the radio medium.

Referenced by sendToAffectedRadios().

{
    for (const auto radio : radios)
        if (radio != nullptr)
            sendToRadio(transmitter, radio, frame);
}

void inet::physicallayer::RadioMedium::sendToRadio ( IRadio *  trasmitter, const IRadio *  receiver, const IRadioFrame *  frame  )

virtual

Referenced by sendToAllRadios(), inet::physicallayer::NeighborListNeighborCache::sendToNeighbors(), inet::physicallayer::QuadTreeNeighborCache::QuadTreeNeighborCacheVisitor::visit(), and inet::physicallayer::GridNeighborCache::GridNeighborCacheVisitor::visit().

{
    const Radio *transmitterRadio = check_and_cast<const Radio *>(transmitter);
    const Radio *receiverRadio = check_and_cast<const Radio *>(receiver);
    const ITransmission *transmission = frame->getTransmission();
    if (receiverRadio != transmitterRadio && isPotentialReceiver(receiverRadio, transmission)) {
        const IArrival *arrival = getArrival(receiverRadio, transmission);
        simtime_t propagationTime = arrival->getStartPropagationTime();
        EV_DEBUG << "Sending " << frame
                 << " from " << (IRadio *)transmitterRadio << " at " << transmission->getStartPosition()
                 << " to " << (IRadio *)receiverRadio << " at " << arrival->getStartPosition()
                 << " in " << propagationTime * 1E+6 << " us propagation time." << endl;
        auto radioFrame = static_cast<RadioFrame *>(createReceiverRadioFrame(transmission));
        cGate *gate = receiverRadio->getRadioGate()->getPathStartGate();
        ASSERT(dynamic_cast<IRadio *>(getSimulation()->getContextModule()) != nullptr);
        const_cast<Radio *>(transmitterRadio)->sendDirect(radioFrame, propagationTime, transmission->getDuration(), gate);
        communicationCache->setCachedFrame(receiverRadio, transmission, radioFrame);
        radioFrameSendCount++;
    }
}

IRadioFrame * inet::physicallayer::RadioMedium::transmitPacket ( const IRadio *  transmitter, cPacket *  macFrame  )

overridevirtual

Returns a new radio frame containing the radio signal transmission that represents the provided MAC frame.

A copy of this radio frame is sent to all affected radios. The MAC frame control info must be an instance of the TransmissionRequest class.

Implements inet::physicallayer::IRadioMedium.

{
    auto radioFrame = createTransmitterRadioFrame(radio, macFrame);
    auto transmission = radioFrame->getTransmission();
    addTransmission(radio, transmission);
    if (recordCommunicationLog)
        communicationLog.writeTransmission(radio, radioFrame);
    sendToAffectedRadios(const_cast<IRadio *>(radio), radioFrame);
    communicationCache->setCachedFrame(transmission, radioFrame);
    return radioFrame;
}

Member Data Documentation

const IAnalogModel* inet::physicallayer::RadioMedium::analogModel

protected

The analog model is never nullptr.

Referenced by computeReception(), getNoise(), getSNIR(), initialize(), and printToStream().

const IBackgroundNoise* inet::physicallayer::RadioMedium::backgroundNoise

protected

The background noise model or nullptr if unused.

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

long inet::physicallayer::RadioMedium::cacheDecisionGetCount

mutableprotected

Total number of reception decision cache queries.

Referenced by finish(), and getReceptionDecision().

long inet::physicallayer::RadioMedium::cacheDecisionHitCount

mutableprotected

Total number of reception decision cache hits.

Referenced by finish(), and getReceptionDecision().

long inet::physicallayer::RadioMedium::cacheInterferenceGetCount

mutableprotected

Total number of interference cache queries.

Referenced by finish(), and getInterference().

long inet::physicallayer::RadioMedium::cacheInterferenceHitCount

mutableprotected

Total number of interference cache hits.

Referenced by finish(), and getInterference().

long inet::physicallayer::RadioMedium::cacheNoiseGetCount

mutableprotected

Total number of noise cache queries.

Referenced by finish(), and getNoise().

long inet::physicallayer::RadioMedium::cacheNoiseHitCount

mutableprotected

Total number of noise cache hits.

Referenced by finish(), and getNoise().

long inet::physicallayer::RadioMedium::cacheReceptionGetCount

mutableprotected

Total number of reception cache queries.

Referenced by finish(), and getReception().

long inet::physicallayer::RadioMedium::cacheReceptionHitCount

mutableprotected

Total number of reception cache hits.

Referenced by finish(), and getReception().

long inet::physicallayer::RadioMedium::cacheResultGetCount

mutableprotected

Total number of reception result cache queries.

Referenced by finish(), and getReceptionResult().

long inet::physicallayer::RadioMedium::cacheResultHitCount

mutableprotected

Total number of reception result cache hits.

Referenced by finish(), and getReceptionResult().

long inet::physicallayer::RadioMedium::cacheSNIRGetCount

mutableprotected

Total number of SNIR cache queries.

Referenced by finish(), and getSNIR().

long inet::physicallayer::RadioMedium::cacheSNIRHitCount

mutableprotected

Total number of SNIR cache hits.

Referenced by finish(), and getSNIR().

ICommunicationCache* inet::physicallayer::RadioMedium::communicationCache

mutableprotected

Caches intermediate results of the ongoing communication for all radios.

Referenced by addRadio(), addTransmission(), computeInterferingReceptions(), getArrival(), getInterference(), getListening(), getNoise(), getReception(), getReceptionDecision(), getReceptionResult(), getSNIR(), initialize(), printToStream(), receivePacket(), receiveSignal(), removeNonInterferingTransmissions(), removeRadio(), sendToRadio(), transmitPacket(), and ~RadioMedium().

CommunicationLog inet::physicallayer::RadioMedium::communicationLog

protected

The communication log output recorder.

Referenced by initialize(), receivePacket(), transmitPacket(), and ~RadioMedium().

long inet::physicallayer::RadioMedium::interferenceComputationCount

mutableprotected

Total number of interference computations.

Referenced by computeInterference(), and finish().

long inet::physicallayer::RadioMedium::listeningDecisionComputationCount

mutableprotected

Total number of listening decision computations.

Referenced by computeListeningDecision(), and finish().

bool inet::physicallayer::RadioMedium::listeningFilter

protected

True means the radio medium doesn't send radio frames to a radio if it listens on the medium in incompatible mode (e.g.

different carrier frequency and/or bandwidth, different modulation, etc.)

Referenced by addRadio(), initialize(), isPotentialReceiver(), and removeRadio().

bool inet::physicallayer::RadioMedium::macAddressFilter

protected

True means the radio medium doesn't send radio frames to a radio if the mac address of the destination is different.

Referenced by addRadio(), initialize(), isPotentialReceiver(), and removeRadio().

const IMaterial* inet::physicallayer::RadioMedium::material

protected

The physical material of the medium is never nullptr.

Referenced by initialize().

IMediumLimitCache* inet::physicallayer::RadioMedium::mediumLimitCache

mutableprotected

Caches various medium limits among all radios.

Referenced by addRadio(), addTransmission(), initialize(), isInCommunicationRange(), isInInterferenceRange(), isInterferingTransmission(), printToStream(), removeRadio(), and sendToAffectedRadios().

INeighborCache* inet::physicallayer::RadioMedium::neighborCache

mutableprotected

Caches neighbors for all radios or nullptr if turned off.

Referenced by addRadio(), initialize(), printToStream(), removeRadio(), and sendToAffectedRadios().

const IObstacleLoss* inet::physicallayer::RadioMedium::obstacleLoss

protected

The obstacle loss model or nullptr if unused.

Referenced by initialize(), and printToStream().

const IPathLoss* inet::physicallayer::RadioMedium::pathLoss

protected

The path loss model is never nullptr.

Referenced by initialize(), and printToStream().

const IPhysicalEnvironment* inet::physicallayer::RadioMedium::physicalEnvironment

protected

The physical environment model or nullptr if unused.

Referenced by initialize().

const IPropagation* inet::physicallayer::RadioMedium::propagation

protected

The propagation model is never nullptr.

Referenced by addRadio(), addTransmission(), initialize(), and printToStream().

friend inet::physicallayer::RadioMedium::Radio

private

long inet::physicallayer::RadioMedium::radioFrameSendCount

mutableprotected

Total number of radio frame sends.

Referenced by finish(), receiveSignal(), and sendToRadio().

bool inet::physicallayer::RadioMedium::radioModeFilter

protected

True means the radio medium doesn't send radio frames to a radio if it's neither in receiver nor in transceiver mode.

Referenced by addRadio(), initialize(), isPotentialReceiver(), and removeRadio().

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

protected

The list of radios that can transmit and receive radio signals on the radio medium.

The radios follow each other in the order of their unique id. Radios are only removed from the beginning. This list may contain nullptr values.

Referenced by addRadio(), addTransmission(), removeRadio(), and sendToAllRadios().

RangeFilterKind inet::physicallayer::RadioMedium::rangeFilter

protected

The radio medium doesn't send radio frames to a radio if it's outside the range provided by the selected range filter.

Referenced by initialize(), isPotentialReceiver(), and sendToAffectedRadios().

long inet::physicallayer::RadioMedium::receptionComputationCount

mutableprotected

Total number of reception computations.

Referenced by computeReception(), and finish().

long inet::physicallayer::RadioMedium::receptionDecisionComputationCount

mutableprotected

Total number of data reception decision computations.

Referenced by computeReceptionDecision(), and finish().

long inet::physicallayer::RadioMedium::receptionResultComputationCount

mutableprotected

Total number of data reception result computations.

Referenced by computeReceptionResult().

bool inet::physicallayer::RadioMedium::recordCommunicationLog

protected

Records all transmissions and receptions into a separate trace file.

The communication log file can be found at: ${resultdir}/${configname}-${runnumber}.tlog

Referenced by initialize(), receivePacket(), transmitPacket(), and ~RadioMedium().

cMessage* inet::physicallayer::RadioMedium::removeNonInterferingTransmissionsTimer

protected

The message that is used to purge the internal state of the medium.

Referenced by addTransmission(), handleMessage(), initialize(), removeNonInterferingTransmissions(), and ~RadioMedium().

long inet::physicallayer::RadioMedium::transmissionCount

mutableprotected

Total number of transmissions.

Referenced by addTransmission(), and finish().

std::vector<const ITransmission *> inet::physicallayer::RadioMedium::transmissions

protected

The list of ongoing transmissions on the radio medium.

The transmissions follow each other in the order of their unique id. Transmissions are only removed from the beginning. This list doesn't contain nullptr values.

Referenced by addRadio(), addTransmission(), getInterference(), getReceptionDecision(), getReceptionResult(), isReceptionAttempted(), isReceptionPossible(), isReceptionSuccessful(), listenOnMedium(), receiveSignal(), removeNonInterferingTransmissions(), and ~RadioMedium().

---

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

• RadioMedium.h
• RadioMedium.cc