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

#include <RadioMedium.h>

Inheritance diagram for inet::physicallayer::RadioMedium:

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 void	removeTransmission (const ITransmission *transmission)
	Removes a transmission from the radio medium. More...

virtual IWirelessSignal *	createTransmitterSignal (const IRadio radio, Packet packet)
	Creates a new signal for the transmitter. More...

virtual IWirelessSignal *	createReceiverSignal (const ITransmission *transmission)
	Creates a new signal for a receiver. More...

virtual void	sendToAffectedRadios (IRadio transmitter, const IWirelessSignal signal)
	Sends a copy of the provided signal to all affected receivers on the radio medium. More...

virtual void	sendToAllRadios (IRadio transmitter, const IWirelessSignal signal)
	Sends a copy of the provided signal to all receivers on the radio medium. More...

virtual void	pickUpSignals (IRadio *receiver)
	Sends a copy of all ongoing signals to the receiver on the radio medium. More...

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 physicalenvironment::IPhysicalEnvironment *	physicalEnvironment
	The physical environment model or nullptr if unused. More...

const physicalenvironment::IMaterial *	material
	The physical material of the medium is never nullptr. More...

RangeFilterKind	rangeFilter
	The radio medium doesn't send signals 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 signals to a radio if it's neither in receiver nor in transceiver mode. More...

bool	listeningFilter
	True means the radio medium doesn't send signals 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 signals to a radio if the mac address of the destination is different. More...

bool	recordTransmissionLog
	Records all transmissions (if recordTransmissionLog is enabled) and receptions (if recordReceptionLog is enabled) into a separate trace file. More...

bool	recordReceptionLog

Timer
cMessage *	removeNonInterferingTransmissionsTimer
	The message that is used to purge the internal state of the 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 list of radios and transmissions along with intermediate results. More...

Logging
CommunicationLog	communicationLog
	The communication log output recorder. More...

Statistics
long	transmissionCount
	Total number of transmissions. More...

long	signalSendCount
	Total number of signal 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

Reception
virtual bool	matchesMacAddressFilter (const IRadio radio, const Packet packet) 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

virtual const std::vector< const IReception * > *	computeInterferingReceptions (const IReception *reception) const

virtual const IReception *	computeReception (const IRadio receiver, const ITransmission transmission) const

virtual const IInterference *	computeInterference (const IRadio receiver, const IListening listening) const

virtual const IInterference *	computeInterference (const IRadio receiver, const IListening listening, const ITransmission *transmission) const

virtual const IReceptionDecision *	computeReceptionDecision (const IRadio receiver, const IListening listening, const ITransmission *transmission, IRadioSignal::SignalPart part) const

virtual const IReceptionResult *	computeReceptionResult (const IRadio receiver, const IListening listening, const ITransmission *transmission) const

virtual const IListeningDecision *	computeListeningDecision (const IRadio receiver, const IListening listening) const

	RadioMedium ()

virtual	~RadioMedium ()

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

virtual const physicalenvironment::IMaterial *	getMaterial () const override
	Returns the material of this medium. More...

virtual const IPropagation *	getPropagation () const override
	Returns the signal propagation model of this medium. More...

virtual const IPathLoss *	getPathLoss () const override
	Returns the signal path loss model of this medium. More...

virtual const IObstacleLoss *	getObstacleLoss () const override
	Returns the signal obstacle loss model of this medium. More...

virtual const IAnalogModel *	getAnalogModel () const override
	Returns the signal analog model of this medium. More...

virtual const IBackgroundNoise *	getBackgroundNoise () const override
	Returns the background noise model of this medium. More...

virtual const physicalenvironment::IPhysicalEnvironment *	getPhysicalEnvironment () const override
	Returns the physical environment model of this 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 medium. More...

virtual void	removeRadio (const IRadio *radio) override
	Removes a radio from the medium. More...

virtual const IRadio *	getRadio (int id) const override
	Returns radio instance from medium by id. More...

virtual void	sendToRadio (IRadio trasmitter, const IRadio receiver, const IWirelessSignal *signal)

virtual IWirelessSignal *	transmitPacket (const IRadio transmitter, Packet packet) override
	Returns a new signal containing the signal transmission that represents the provided packet. More...

virtual Packet *	receivePacket (const IRadio receiver, IWirelessSignal signal) override
	Returns the packet that was transmitted in the provided signal. More...

virtual const ITransmission *	getTransmission (int id) const override
	Returns transmission instance from medium by id. 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 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, intval_t value, cObject details) override

virtual void	receiveSignal (cComponent source, simsignal_t signal, cObject value, cObject *details) override

Additional Inherited Members
Public Types inherited from inet::IPrintableObject
enum	PrintLevel { PRINT_LEVEL_TRACE, PRINT_LEVEL_DEBUG, PRINT_LEVEL_DETAIL, PRINT_LEVEL_INFO, PRINT_LEVEL_COMPLETE = INT_MIN }

enum	PrintFlag { PRINT_FLAG_FORMATTED = (1 << 0), PRINT_FLAG_MULTILINE = (1 << 1) }

Public Member Functions inherited from inet::IPrintableObject
virtual	~IPrintableObject ()

virtual std::string	printToString () const

virtual std::string	printToString (int level, int evFlags=0) const

virtual std::string	getInfoStringRepresentation (int evFlags=0) const

virtual std::string	getDetailStringRepresentation (int evFlags=0) const

virtual std::string	getDebugStringRepresentation (int evFlags=0) const

virtual std::string	getTraceStringRepresentation (int evFlags=0) const

virtual std::string	getCompleteStringRepresentation (int evFlags=0) const

Static Public Attributes inherited from inet::physicallayer::IRadioMedium
static simsignal_t	radioAddedSignal = cComponent::registerSignal("radioAdded")
	This simsignal is emitted when a radio is added to the medium. More...

static simsignal_t	radioRemovedSignal = cComponent::registerSignal("radioRemoved")
	This simsignal is emitted when a radio is removed from the medium. More...

static simsignal_t	signalAddedSignal = cComponent::registerSignal("signalAdded")
	This simsignal is emitted when a signal is added to the medium. More...

static simsignal_t	signalRemovedSignal = cComponent::registerSignal("signalRemoved")
	This simsignal is emitted when a signal is removed from the medium. More...

static simsignal_t	signalDepartureStartedSignal = cComponent::registerSignal("signalDepartureStarted")
	This simsignal is emitted when a signal departure is started on the medium. More...

static simsignal_t	signalDepartureEndedSignal = cComponent::registerSignal("signalDepartureEnded")
	This simsignal is emitted when a signal departure is ended on the medium. More...

static simsignal_t	signalArrivalStartedSignal = cComponent::registerSignal("signalArrivalStarted")
	This simsignal is emitted when a signal arrival is started on the medium. More...

static simsignal_t	signalArrivalEndedSignal = cComponent::registerSignal("signalArrivalEnded")
	This simsignal is emitted when a signal arrival is ended on the medium. More...

Detailed Description

The default implementation of the radio medium interface.

Member Enumeration Documentation

◆ RangeFilterKind

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

◆ RadioMedium()

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),
     recordTransmissionLog(false),
     recordReceptionLog(false),
     removeNonInterferingTransmissionsTimer(nullptr),
     mediumLimitCache(nullptr),
     neighborCache(nullptr),
     communicationCache(nullptr),
     transmissionCount(0),
     signalSendCount(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)
 {
 }

◆ ~RadioMedium()

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

virtual

 {
     cancelAndDelete(removeNonInterferingTransmissionsTimer);
     if (recordTransmissionLog || recordReceptionLog)
         communicationLog.close();
 }

Member Function Documentation

◆ addRadio()

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

overridevirtual

Adds a new radio to the 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.

 {
     Enter_Method("addRadio");
     communicationCache->addRadio(radio);
     if (neighborCache)
         neighborCache->addRadio(radio);
     mediumLimitCache->addRadio(radio);
     communicationCache->mapTransmissions([&] (const ITransmission *transmission) {
         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(interfaceConfigChangedSignal, this);
     emit(radioAddedSignal, radioModule);
 }

◆ addTransmission()

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

protectedvirtual

Adds a new transmission to the radio medium.

 {
     Enter_Method("addTransmission");
     transmissionCount++;
     communicationCache->addTransmission(transmission);
     simtime_t maxArrivalEndTime = transmission->getEndTime();
     communicationCache->mapRadios([&] (const IRadio *receiverRadio) {
         if (receiverRadio != nullptr && receiverRadio != transmitterRadio && receiverRadio->getReceiver() != nullptr) {
             const IArrival *arrival = propagation->computeArrival(transmission, receiverRadio->getAntenna()->getMobility());
             const IntervalTree::Interval *interval = new IntervalTree::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())
         scheduleAt(communicationCache->getCachedInterferenceEndTime(transmission), removeNonInterferingTransmissionsTimer);
     emit(signalAddedSignal, check_and_cast<const cObject *>(transmission));
 }

Referenced by transmitPacket().

◆ computeInterference() [1/2]

const IInterference * inet::physicallayer::RadioMedium::computeInterference	(	const IRadio *	receiver,
		const IListening *	listening
	)		const

protectedvirtual

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

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

◆ computeInterference() [2/2]

const IInterference * inet::physicallayer::RadioMedium::computeInterference	(	const IRadio *	receiver,
		const IListening *	listening,
		const ITransmission *	transmission
	)		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);
     return new Interference(noise, interferingReceptions);
 }

◆ computeInterferingReceptions() [1/2]

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

protectedvirtual

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

Referenced by computeInterference().

◆ computeInterferingReceptions() [2/2]

const std::vector< const IReception * > * inet::physicallayer::RadioMedium::computeInterferingReceptions ( const IReception * reception ) 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;
 }

◆ computeListeningDecision()

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

protectedvirtual

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

Referenced by listenOnMedium().

◆ computeReception()

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

protectedvirtual

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

Referenced by getReception().

◆ computeReceptionDecision()

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

protectedvirtual

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

Referenced by getReceptionDecision().

◆ computeReceptionResult()

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

protectedvirtual

 {
     receptionResultComputationCount++;
     const IReception *reception = getReception(radio, transmission);
     const IInterference *interference = getInterference(radio, listening, transmission);
     const ISnir *snir = getSNIR(radio, transmission);
     const IReceptionDecision *receptionDecision = getReceptionDecision(radio, listening, transmission, IRadioSignal::SIGNAL_PART_WHOLE);
     const std::vector<const IReceptionDecision *> *receptionDecisions = new std::vector<const IReceptionDecision *> { receptionDecision };
     return radio->getReceiver()->computeReceptionResult(listening, reception, interference, snir, receptionDecisions);
 }

Referenced by getReceptionResult().

◆ createReceiverSignal()

IWirelessSignal * inet::physicallayer::RadioMedium::createReceiverSignal ( const ITransmission * transmission )

protectedvirtual

Creates a new signal for a receiver.

 {
     auto signal = new WirelessSignal(transmission);
     signal->setDuration(transmission->getDuration());
     auto transmitterPacket = transmission->getPacket();
     if (transmitterPacket != nullptr) {
         auto receiverPacket = transmitterPacket->dup();
         receiverPacket->clearTags();
         receiverPacket->addTag<PacketProtocolTag>()->setProtocol(transmitterPacket->getTag<PacketProtocolTag>()->getProtocol());
         signal->setName(receiverPacket->getName());
         signal->encapsulate(receiverPacket);
     }
     return signal;
 }

Referenced by pickUpSignals(), and sendToRadio().

◆ createTransmitterSignal()

IWirelessSignal * inet::physicallayer::RadioMedium::createTransmitterSignal	(	const IRadio *	radio,
		Packet *	packet
	)

protectedvirtual

Creates a new signal for the transmitter.

 {
     if (packet != nullptr)
         take(packet);
     auto transmission = radio->getTransmitter()->createTransmission(radio, packet, simTime());
     auto signal = new WirelessSignal(transmission);
     auto duration = transmission->getDuration();
     if (duration > mediumLimitCache->getMaxTransmissionDuration())
         throw cRuntimeError("Maximum transmission duration is exceeded");
     signal->setDuration(duration);
     if (packet != nullptr) {
         signal->setName(packet->getName());
         signal->encapsulate(packet);
     }
     return signal;
 }

Referenced by transmitPacket().

◆ finish()

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 << "Signal send count = " << signalSendCount << 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("signal send count", signalSendCount);
     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, "%");
 }

◆ getAnalogModel()

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

inlineoverridevirtual

Returns the signal analog model of this medium.

This function never returns nullptr.

Implements inet::physicallayer::IRadioMedium.

309 { return analogModel; }

◆ getArrival()

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

Implements inet::physicallayer::IRadioMedium.

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

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

◆ getBackgroundNoise()

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

inlineoverridevirtual

Returns the background noise model of this medium.

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

Implements inet::physicallayer::IRadioMedium.

310 { return backgroundNoise; }

◆ getCommunicationCache()

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

inlineoverridevirtual

Implements inet::physicallayer::IRadioMedium.

314 { return communicationCache; }

◆ getInterference() [1/2]

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);
         communicationCache->setCachedInterference(receiver, transmission, interference);
     }
     return interference;
 }

◆ getInterference() [2/2]

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

Implements inet::physicallayer::IRadioMedium.

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

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

◆ getListening()

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

Implements inet::physicallayer::IRadioMedium.

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

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

◆ getMaterial()

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

inlineoverridevirtual

Returns the material of this medium.

This function never returns nullptr.

Implements inet::physicallayer::IRadioMedium.

305 { return material; }

◆ getMediumLimitCache()

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

inlineoverridevirtual

Implements inet::physicallayer::IRadioMedium.

312 { return mediumLimitCache; }

◆ getNeighborCache()

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

inlineoverridevirtual

Implements inet::physicallayer::IRadioMedium.

313 { return neighborCache; }

◆ getNoise()

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

Implements inet::physicallayer::IRadioMedium.

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

Referenced by getSNIR().

◆ getObstacleLoss()

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

inlineoverridevirtual

Returns the signal obstacle loss model of this medium.

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

Implements inet::physicallayer::IRadioMedium.

308 { return obstacleLoss; }

◆ getPathLoss()

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

inlineoverridevirtual

Returns the signal path loss model of this medium.

This function never returns nullptr.

Implements inet::physicallayer::IRadioMedium.

307 { return pathLoss; }

◆ getPhysicalEnvironment()

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

inlineoverridevirtual

Returns the physical environment model of this medium.

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

Implements inet::physicallayer::IRadioMedium.

311 { return physicalEnvironment; }

◆ getPropagation()

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

inlineoverridevirtual

Returns the signal propagation model of this medium.

This function never returns nullptr.

Implements inet::physicallayer::IRadioMedium.

306 { return propagation; }

◆ getRadio()

const IRadio * inet::physicallayer::RadioMedium::getRadio ( int id ) const

overridevirtual

Returns radio instance from medium by id.

May return a nullptr if no matching radio is registered.

Implements inet::physicallayer::IRadioMedium.

 {
     return communicationCache->getRadio(radioId);
 }

Referenced by pickUpSignals().

◆ getReception()

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

Implements inet::physicallayer::IRadioMedium.

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

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

◆ getReceptionDecision()

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

Referenced by computeReceptionResult().

◆ getReceptionResult()

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.

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

Referenced by receivePacket().

◆ getSNIR()

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

Implements inet::physicallayer::IRadioMedium.

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

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

◆ getTransmission()

const ITransmission * inet::physicallayer::RadioMedium::getTransmission ( int id ) const

overridevirtual

Returns transmission instance from medium by id.

May return a nullptr if no matching transmission is registered.

Implements inet::physicallayer::IRadioMedium.

 {
     return communicationCache->getTransmission(id);
 }

◆ handleMessage()

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

overrideprotectedvirtual

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

◆ initialize()

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<physicalenvironment::IPhysicalEnvironment *>(findModuleByPath(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: '%d'", rangeFilter);
         radioModeFilter = par("radioModeFilter");
         listeningFilter = par("listeningFilter");
         macAddressFilter = par("macAddressFilter");
         // initialize timers
         removeNonInterferingTransmissionsTimer = new cMessage("removeNonInterferingTransmissions");
         // initialize logging
         recordTransmissionLog = par("recordTransmissionLog");
         recordReceptionLog = par("recordReceptionLog");
         if (recordTransmissionLog || recordReceptionLog)
             communicationLog.open();
     }
     else if (stage == INITSTAGE_LAST)
         EV_INFO << "Initialized " << getCompleteStringRepresentation() << endl;
 }

◆ isInCommunicationRange()

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

protectedvirtual

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

Referenced by isPotentialReceiver().

◆ isInInterferenceRange()

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

protectedvirtual

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

Referenced by isInterferingTransmission(), and isPotentialReceiver().

◆ isInterferingTransmission() [1/2]

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

protectedvirtual

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

Referenced by computeInterferingReceptions().

◆ isInterferingTransmission() [2/2]

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

protectedvirtual

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

◆ isPotentialReceiver()

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 signal to this receiver.

 {
     const Radio *receiverRadio = dynamic_cast<const Radio *>(radio);
     if (radioModeFilter && receiverRadio != nullptr && receiverRadio->getRadioMode() != IRadio::RADIO_MODE_RECEIVER && receiverRadio->getRadioMode() != IRadio::RADIO_MODE_TRANSCEIVER)
         return false;
     else if (listeningFilter && radio->getReceiver() != nullptr && !radio->getReceiver()->computeIsReceptionPossible(getListening(radio, transmission), transmission))
         return false;
     // TODO where is the tag?
     else if (macAddressFilter && !matchesMacAddressFilter(radio, transmission->getPacket()))
         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;
 }

Referenced by pickUpSignals(), and sendToRadio().

◆ isReceptionAttempted()

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);
     bool isReceptionAttempted = receiver->getReceiver()->computeIsReceptionAttempted(listening, reception, part, interference);
     delete interference;
     return isReceptionAttempted;
 }

◆ isReceptionPossible()

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);
     bool isReceptionPossible = receiver->getReceiver()->computeIsReceptionAttempted(listening, reception, part, interference);
     delete interference;
     return isReceptionPossible;
 }

◆ isReceptionSuccessful()

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 ISnir *snir = getSNIR(receiver, transmission);
     bool isReceptionSuccessful = receiver->getReceiver()->computeIsReceptionSuccessful(listening, reception, part, interference, snir);
     delete interference;
     return isReceptionSuccessful;
 }

◆ listenOnMedium()

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

Implements inet::physicallayer::IRadioMedium.

 {
     Enter_Method("listenOnMedium");
     const IListeningDecision *decision = computeListeningDecision(radio, listening);
     EV_DEBUG << "Listening results in: " << decision << " with " << listening << " on medium by " << radio << endl;
     return decision;
 }

◆ matchesMacAddressFilter()

bool inet::physicallayer::RadioMedium::matchesMacAddressFilter	(	const IRadio *	radio,
		const Packet *	packet
	)		const

protectedvirtual

 {
     const auto& macAddressReq = const_cast<Packet *>(packet)->findTag<MacAddressInd>();
     if (macAddressReq == nullptr)
         return true;
     const MacAddress address = macAddressReq->getDestAddress();
     if (address.isBroadcast() || address.isMulticast())
         return true;
     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 NetworkInterface *interface = interfaceTable->getInterface(i);
         if (interface && interface->getMacAddress() == address)
             return true;
     }
     return false;
 }

Referenced by isPotentialReceiver().

◆ numInitStages()

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

inlineoverrideprotectedvirtual

218 { return NUM_INIT_STAGES; }

◆ pickUpSignals()

void inet::physicallayer::RadioMedium::pickUpSignals ( IRadio * receiver )

protectedvirtual

Sends a copy of all ongoing signals to the receiver on the radio medium.

 {
     communicationCache->mapTransmissions([&] (const ITransmission *transmission) {
         auto transmitterRadio = dynamic_cast<const Radio *>(getRadio(transmission->getTransmitterId()));
         if (!transmitterRadio)
             return;
         if (communicationCache->getCachedSignal(receiverRadio, transmission) == nullptr &&
             receiverRadio != transmitterRadio && isPotentialReceiver(receiverRadio, transmission))
         {
             const IArrival *arrival = getArrival(receiverRadio, transmission);
             if (arrival->getEndTime() >= simTime()) {
                 cMethodCallContextSwitcher contextSwitcher(transmitterRadio);
                 contextSwitcher.methodCall("sendToRadio");
                 const Packet *packet = transmission->getPacket();
                 EV_DEBUG << "Picking up " << packet << " originally sent "
                          << " from " << (IRadio *)transmitterRadio << " at " << transmission->getStartPosition()
                          << " to " << (IRadio *)receiverRadio << " at " << arrival->getStartPosition()
                          << " in " << arrival->getStartPropagationTime() * 1E+6 << " us propagation time." << endl;
                 auto signal = static_cast<WirelessSignal *>(createReceiverSignal(transmission));
                 simtime_t delay = arrival->getStartTime() - simTime();
                 simtime_t duration = delay > 0 ? signal->getDuration() : signal->getDuration() + delay;
                 cGate *gate = receiverRadio->getRadioGate()->getPathStartGate();
                 const_cast<Radio *>(transmitterRadio)->sendDirect(signal, delay > 0 ? delay : 0, duration, gate);
                 communicationCache->setCachedSignal(receiverRadio, transmission, signal);
                 signalSendCount++;
             }
         }
     });
 }

Referenced by receiveSignal().

◆ printToStream()

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

overridevirtual

Prints this object to the provided output stream.

Reimplemented from inet::IPrintableObject.

 {
     stream << static_cast<const cSimpleModule *>(this);
     if (level <= PRINT_LEVEL_TRACE) {
         stream << EV_FIELD(propagation, printFieldToString(propagation, level + 1, evFlags))
                << EV_FIELD(pathLoss, printFieldToString(pathLoss, level + 1, evFlags))
                << EV_FIELD(analogModel, printFieldToString(analogModel, level + 1, evFlags))
                << EV_FIELD(obstacleLoss, printFieldToString(obstacleLoss, level + 1, evFlags))
                << EV_FIELD(backgroundNoise, printFieldToString(backgroundNoise, level + 1, evFlags))
                << EV_FIELD(mediumLimitCache, printFieldToString(mediumLimitCache, level + 1, evFlags))
                << EV_FIELD(neighborCache, printFieldToString(neighborCache, level + 1, evFlags))
                << EV_FIELD(communicationCache, printFieldToString(communicationCache, level + 1, evFlags));
     }
     return stream;
 }

◆ receivePacket()

Packet * inet::physicallayer::RadioMedium::receivePacket	(	const IRadio *	receiver,
		IWirelessSignal *	signal
	)

overridevirtual

Returns the packet that was transmitted in the provided signal.

Implements inet::physicallayer::IRadioMedium.

 {
     Enter_Method("receivePacket");
     const ITransmission *transmission = signal->getTransmission();
     const IListening *listening = communicationCache->getCachedListening(radio, transmission);
     if (recordReceptionLog)
         communicationLog.writeReception(radio, signal);
     const IReceptionResult *result = getReceptionResult(radio, listening, transmission);
     communicationCache->removeCachedReceptionResult(radio, transmission);
     Packet *packet = result->getPacket()->dup();
     delete result;
     return packet;
 }

◆ receiveSignal() [1/2]

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

overridevirtual

 {
     Enter_Method("%s", cComponent::getSignalName(signal));
  
     if (signal == interfaceConfigChangedSignal) {
         Enter_Method("interfaceConfigChanged");
         auto interfaceChange = check_and_cast<NetworkInterfaceChangeDetails *>(value);
         if (interfaceChange->getFieldId() == NetworkInterface::F_MACADDRESS) {
             auto radio = check_and_cast<Radio *>(interfaceChange->getNetworkInterface()->getSubmodule("radio"));
             pickUpSignals(radio);
         }
     }
     else
         throw cRuntimeError("Unknown signal");
 }

◆ receiveSignal() [2/2]

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

overridevirtual

 {
     Enter_Method("%s", cComponent::getSignalName(signal));
  
     if (signal == IRadio::radioModeChangedSignal) {
         Enter_Method("radioModeChanged");
         auto radio = check_and_cast<Radio *>(source);
         pickUpSignals(radio);
     }
     else if (signal == IRadio::listeningChangedSignal) {
         Enter_Method("listeningChanged");
         auto radio = check_and_cast<Radio *>(source);
         communicationCache->mapTransmissions([&] (const ITransmission *transmission) {
             const IArrival *arrival = getArrival(radio, transmission);
             const IListening *listening = radio->getReceiver()->createListening(radio, arrival->getStartTime(), arrival->getEndTime(), arrival->getStartPosition(), arrival->getEndPosition());
             delete communicationCache->getCachedListening(radio, transmission);
             communicationCache->setCachedListening(radio, transmission, listening);
         });
         pickUpSignals(radio);
     }
     else
         throw cRuntimeError("Unknown signal");
 }

◆ removeNonInterferingTransmissions()

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.

 {
     communicationCache->removeNonInterferingTransmissions([&] (const ITransmission *transmission) {
         emit(signalRemovedSignal, check_and_cast<const cObject *>(transmission));
     });
     communicationCache->mapTransmissions([&] (const ITransmission *transmission) {
         auto interferenceEndTime = communicationCache->getCachedInterferenceEndTime(transmission);
         if (!removeNonInterferingTransmissionsTimer->isScheduled() && interferenceEndTime > simTime())
             scheduleAt(interferenceEndTime, removeNonInterferingTransmissionsTimer);
     });
 }

Referenced by handleMessage().

◆ removeRadio()

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

overridevirtual

Removes a radio from the 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.

 {
     Enter_Method("removeRadio");
     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(interfaceConfigChangedSignal, this);
     emit(radioRemovedSignal, radioModule);
 }

◆ removeTransmission()

void inet::physicallayer::RadioMedium::removeTransmission ( const ITransmission * transmission )

protectedvirtual

Removes a transmission from the radio medium.

 {
     Enter_Method("removeTranmsission");
     emit(signalRemovedSignal, check_and_cast<const cObject *>(transmission));
     communicationCache->removeTransmission(transmission);
 }

◆ sendToAffectedRadios()

void inet::physicallayer::RadioMedium::sendToAffectedRadios	(	IRadio *	transmitter,
		const IWirelessSignal *	signal
	)

protectedvirtual

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

 {
     const WirelessSignal *signal = check_and_cast<const WirelessSignal *>(transmittedSignal);
     EV_DEBUG << "Sending " << transmittedSignal << " with " << signal->getBitLength() << " bits in " << signal->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, transmittedSignal);
         }
         else
             neighborCache->sendToNeighbors(radio, transmittedSignal, range);
     }
     else
         sendToAllRadios(radio, transmittedSignal);
  
 }

Referenced by transmitPacket().

◆ sendToAllRadios()

void inet::physicallayer::RadioMedium::sendToAllRadios	(	IRadio *	transmitter,
		const IWirelessSignal *	signal
	)

protectedvirtual

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

 {
     communicationCache->mapRadios([&] (const IRadio *radio) {
         sendToRadio(transmitter, radio, signal);
     });
 }

Referenced by sendToAffectedRadios().

◆ sendToRadio()

void inet::physicallayer::RadioMedium::sendToRadio	(	IRadio *	trasmitter,
		const IRadio *	receiver,
		const IWirelessSignal *	signal
	)

virtual

 {
     const ITransmission *transmission = transmittedSignal->getTransmission();
     if (receiver != transmitter && receiver->getReceiver() != nullptr && isPotentialReceiver(receiver, transmission)) {
         auto transmitterRadio = const_cast<cSimpleModule *>(check_and_cast<const cSimpleModule *>(transmitter));
         cMethodCallContextSwitcher contextSwitcher(transmitterRadio);
         contextSwitcher.methodCall("sendToRadio");
         const IArrival *arrival = getArrival(receiver, transmission);
         simtime_t propagationTime = arrival->getStartPropagationTime();
         EV_DEBUG << "Sending " << transmittedSignal
                  << " from " << transmitter << " at " << transmission->getStartPosition()
                  << " to " << receiver << " at " << arrival->getStartPosition()
                  << " in " << propagationTime * 1E+6 << " us propagation time." << endl;
         auto receivedSignal = static_cast<WirelessSignal *>(createReceiverSignal(transmission));
         cGate *gate = receiver->getRadioGate()->getPathStartGate();
         transmitterRadio->sendDirect(receivedSignal, propagationTime, transmission->getDuration(), gate);
         communicationCache->setCachedSignal(receiver, transmission, receivedSignal);
         signalSendCount++;
     }
 }

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

◆ transmitPacket()

IWirelessSignal * inet::physicallayer::RadioMedium::transmitPacket	(	const IRadio *	transmitter,
		Packet *	packet
	)

overridevirtual

Returns a new signal containing the signal transmission that represents the provided packet.

A copy of this signal is sent to all affected radios.

Implements inet::physicallayer::IRadioMedium.

 {
     Enter_Method("transmitPacket");
     auto signal = createTransmitterSignal(radio, packet);
     auto transmission = signal->getTransmission();
     addTransmission(radio, transmission);
     if (recordTransmissionLog)
         communicationLog.writeTransmission(radio, signal);
     sendToAffectedRadios(const_cast<IRadio *>(radio), signal);
     communicationCache->setCachedSignal(transmission, signal);
     return signal;
 }

Member Data Documentation

◆ analogModel

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

protected

The analog model is never nullptr.

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

◆ backgroundNoise

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

protected

The background noise model or nullptr if unused.

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

◆ cacheDecisionGetCount

long inet::physicallayer::RadioMedium::cacheDecisionGetCount

mutableprotected

Total number of reception decision cache queries.

Referenced by finish(), and getReceptionDecision().

◆ cacheDecisionHitCount

long inet::physicallayer::RadioMedium::cacheDecisionHitCount

mutableprotected

Total number of reception decision cache hits.

Referenced by finish(), and getReceptionDecision().

◆ cacheInterferenceGetCount

long inet::physicallayer::RadioMedium::cacheInterferenceGetCount

mutableprotected

Total number of interference cache queries.

Referenced by finish(), and getInterference().

◆ cacheInterferenceHitCount

long inet::physicallayer::RadioMedium::cacheInterferenceHitCount

mutableprotected

Total number of interference cache hits.

Referenced by finish(), and getInterference().

◆ cacheNoiseGetCount

long inet::physicallayer::RadioMedium::cacheNoiseGetCount

mutableprotected

Total number of noise cache queries.

Referenced by finish(), and getNoise().

◆ cacheNoiseHitCount

long inet::physicallayer::RadioMedium::cacheNoiseHitCount

mutableprotected

Total number of noise cache hits.

Referenced by finish(), and getNoise().

◆ cacheReceptionGetCount

long inet::physicallayer::RadioMedium::cacheReceptionGetCount

mutableprotected

Total number of reception cache queries.

Referenced by finish(), and getReception().

◆ cacheReceptionHitCount

long inet::physicallayer::RadioMedium::cacheReceptionHitCount

mutableprotected

Total number of reception cache hits.

Referenced by finish(), and getReception().

◆ cacheResultGetCount

long inet::physicallayer::RadioMedium::cacheResultGetCount

mutableprotected

Total number of reception result cache queries.

Referenced by finish(), and getReceptionResult().

◆ cacheResultHitCount

long inet::physicallayer::RadioMedium::cacheResultHitCount

mutableprotected

Total number of reception result cache hits.

Referenced by finish(), and getReceptionResult().

◆ cacheSNIRGetCount

long inet::physicallayer::RadioMedium::cacheSNIRGetCount

mutableprotected

Total number of SNIR cache queries.

Referenced by finish(), and getSNIR().

◆ cacheSNIRHitCount

long inet::physicallayer::RadioMedium::cacheSNIRHitCount

mutableprotected

Total number of SNIR cache hits.

Referenced by finish(), and getSNIR().

◆ communicationCache

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

mutableprotected

Caches list of radios and transmissions along with intermediate results.

Referenced by addRadio(), addTransmission(), computeInterferingReceptions(), getArrival(), getInterference(), getListening(), getNoise(), getRadio(), getReception(), getReceptionDecision(), getReceptionResult(), getSNIR(), getTransmission(), initialize(), pickUpSignals(), printToStream(), receivePacket(), receiveSignal(), removeNonInterferingTransmissions(), removeRadio(), removeTransmission(), sendToAllRadios(), sendToRadio(), and transmitPacket().

◆ communicationLog

CommunicationLog inet::physicallayer::RadioMedium::communicationLog

protected

The communication log output recorder.

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

◆ interferenceComputationCount

long inet::physicallayer::RadioMedium::interferenceComputationCount

mutableprotected

Total number of interference computations.

Referenced by computeInterference(), and finish().

◆ listeningDecisionComputationCount

long inet::physicallayer::RadioMedium::listeningDecisionComputationCount

mutableprotected

Total number of listening decision computations.

Referenced by computeListeningDecision(), and finish().

◆ listeningFilter

bool inet::physicallayer::RadioMedium::listeningFilter

protected

True means the radio medium doesn't send signals 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().

◆ macAddressFilter

bool inet::physicallayer::RadioMedium::macAddressFilter

protected

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

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

◆ material

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

protected

The physical material of the medium is never nullptr.

Referenced by initialize().

◆ mediumLimitCache

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

mutableprotected

Caches various medium limits among all radios.

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

◆ neighborCache

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

mutableprotected

Caches neighbors for all radios or nullptr if turned off.

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

◆ obstacleLoss

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

protected

The obstacle loss model or nullptr if unused.

Referenced by initialize(), and printToStream().

◆ pathLoss

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

protected

The path loss model is never nullptr.

Referenced by initialize(), and printToStream().

◆ physicalEnvironment

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

protected

The physical environment model or nullptr if unused.

Referenced by initialize().

◆ propagation

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

protected

The propagation model is never nullptr.

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

◆ Radio

friend inet::physicallayer::RadioMedium::Radio

private

◆ radioModeFilter

bool inet::physicallayer::RadioMedium::radioModeFilter

protected

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

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

◆ rangeFilter

RangeFilterKind inet::physicallayer::RadioMedium::rangeFilter

protected

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

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

◆ receptionComputationCount

long inet::physicallayer::RadioMedium::receptionComputationCount

mutableprotected

Total number of reception computations.

Referenced by computeReception(), and finish().

◆ receptionDecisionComputationCount

long inet::physicallayer::RadioMedium::receptionDecisionComputationCount

mutableprotected

Total number of data reception decision computations.

Referenced by computeReceptionDecision(), and finish().

◆ receptionResultComputationCount

long inet::physicallayer::RadioMedium::receptionResultComputationCount

mutableprotected

Total number of data reception result computations.

Referenced by computeReceptionResult().

◆ recordReceptionLog

bool inet::physicallayer::RadioMedium::recordReceptionLog

protected

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

◆ recordTransmissionLog

bool inet::physicallayer::RadioMedium::recordTransmissionLog

protected

Records all transmissions (if recordTransmissionLog is enabled) and receptions (if recordReceptionLog is enabled) into a separate trace file.

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

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

◆ removeNonInterferingTransmissionsTimer

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

◆ signalSendCount

long inet::physicallayer::RadioMedium::signalSendCount

mutableprotected

Total number of signal sends.

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

◆ transmissionCount

long inet::physicallayer::RadioMedium::transmissionCount

mutableprotected

Total number of transmissions.

Referenced by addTransmission(), and finish().

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

Protected Types

Protected Member Functions

Protected Attributes

Private Attributes

Reception

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ RangeFilterKind

Constructor & Destructor Documentation

◆ RadioMedium()

◆ ~RadioMedium()

Member Function Documentation

◆ addRadio()

◆ addTransmission()

◆ computeInterference() [1/2]

◆ computeInterference() [2/2]

◆ computeInterferingReceptions() [1/2]

◆ computeInterferingReceptions() [2/2]

◆ computeListeningDecision()

◆ computeReception()

◆ computeReceptionDecision()

◆ computeReceptionResult()

◆ createReceiverSignal()

◆ createTransmitterSignal()

◆ finish()

◆ getAnalogModel()

◆ getArrival()

◆ getBackgroundNoise()

◆ getCommunicationCache()

◆ getInterference() [1/2]

◆ getInterference() [2/2]

◆ getListening()

◆ getMaterial()

◆ getMediumLimitCache()

◆ getNeighborCache()

◆ getNoise()

◆ getObstacleLoss()

◆ getPathLoss()

◆ getPhysicalEnvironment()

◆ getPropagation()

◆ getRadio()

◆ getReception()

◆ getReceptionDecision()

◆ getReceptionResult()

◆ getSNIR()

◆ getTransmission()

◆ handleMessage()

◆ initialize()

◆ isInCommunicationRange()

◆ isInInterferenceRange()

◆ isInterferingTransmission() [1/2]

◆ isInterferingTransmission() [2/2]

◆ isPotentialReceiver()

◆ isReceptionAttempted()

◆ isReceptionPossible()

◆ isReceptionSuccessful()

◆ listenOnMedium()

◆ matchesMacAddressFilter()

◆ numInitStages()

◆ pickUpSignals()

◆ printToStream()

◆ receivePacket()

◆ receiveSignal() [1/2]

◆ receiveSignal() [2/2]

◆ removeNonInterferingTransmissions()

◆ removeRadio()

◆ removeTransmission()

◆ sendToAffectedRadios()

◆ sendToAllRadios()

◆ sendToRadio()

◆ transmitPacket()

Member Data Documentation

◆ analogModel

◆ backgroundNoise

◆ cacheDecisionGetCount

◆ cacheDecisionHitCount

◆ cacheInterferenceGetCount

◆ cacheInterferenceHitCount

◆ cacheNoiseGetCount