#include <ApskLayeredReceiver.h>

Inheritance diagram for inet::physicallayer::ApskLayeredReceiver:

Public Types
enum	LevelOfDetail { PACKET_DOMAIN, BIT_DOMAIN, SYMBOL_DOMAIN, SAMPLE_DOMAIN }

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

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 IDecoder *	getDecoder () const

virtual const IDemodulator *	getModulator () const

virtual const IPulseFilter *	getPulseFilter () const

virtual const IAnalogDigitalConverter *	getAnalogDigitalConverter () const

virtual bool	computeIsReceptionPossible (const IListening listening, const IReception reception, IRadioSignal::SignalPart part) const override
	Returns whether the reception of the provided part is possible or not. More...

virtual const IListening *	createListening (const IRadio *radio, const simtime_t startTime, const simtime_t endTime, const Coord &startPosition, const Coord &endPosition) const override
	Returns a description of how the receiver is listening on the medium. More...

virtual const IListeningDecision *	computeListeningDecision (const IListening listening, const IInterference interference) const override
	Returns the result of the listening process specifying the reception state of the receiver. More...

virtual const IReceptionResult *	computeReceptionResult (const IListening listening, const IReception reception, const IInterference interference, const ISnir snir, const std::vector< const IReceptionDecision * > *decisions) const override
	Returns the complete result of the reception process for the provided reception. More...

Public Member Functions inherited from inet::physicallayer::SnirReceiverBase
virtual double	getSNIRThreshold () const

virtual bool	computeIsReceptionSuccessful (const IListening listening, const IReception reception, IRadioSignal::SignalPart part, const IInterference interference, const ISnir snir) const override
	Returns whether the reception of the provided part is actually successful or failed by the receiver. More...

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

virtual W	getMinInterferencePower () const override
	Returns the minimum interference power below which receptions are to be ignored while computing the interference. More...

virtual W	getMinReceptionPower () const override
	Returns the minimum reception power below which successful reception is definitely not possible. More...

virtual bool	computeIsReceptionPossible (const IListening listening, const ITransmission transmission) const override
	Returns whether the reception of the provided transmission is possible or not independently of the reception conditions. More...

virtual bool	computeIsReceptionAttempted (const IListening listening, const IReception reception, IRadioSignal::SignalPart part, const IInterference *interference) const override
	Returns whether the reception of the provided part is actually attempted or ignored by the receiver. More...

virtual const IReceptionDecision *	computeReceptionDecision (const IListening listening, const IReception reception, IRadioSignal::SignalPart part, const IInterference interference, const ISnir snir) const override
	Returns the reception decision for the transmission part that specifies whether the reception is possible, attempted, and successful. More...

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

virtual std::string	printToString () const

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

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

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

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

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

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

Protected Member Functions
virtual void	initialize (int stage) override

virtual const IReceptionAnalogModel *	createAnalogModel (const LayeredTransmission transmission, const ISnir snir) const

virtual const IReceptionSampleModel *	createSampleModel (const LayeredTransmission transmission, const ISnir snir, const IReceptionAnalogModel *analogModel) const

virtual const IReceptionSymbolModel *	createSymbolModel (const LayeredTransmission transmission, const ISnir snir, const IReceptionSampleModel *sampleModel) const

virtual const IReceptionBitModel *	createBitModel (const LayeredTransmission transmission, const ISnir snir, const IReceptionSymbolModel *symbolModel) const

virtual const IReceptionPacketModel *	createPacketModel (const LayeredTransmission transmission, const ISnir snir, const IReceptionBitModel *bitModel) const

Protected Member Functions inherited from inet::physicallayer::ReceiverBase
virtual int	numInitStages () const override

virtual W	computeSignalPower (const IListening listening, const ISnir snir, const IInterference *interference) const

virtual Packet *	computeReceivedPacket (const ISnir *snir, bool isReceptionSuccessful) const

Protected Attributes
LevelOfDetail	levelOfDetail

const ILayeredErrorModel *	errorModel

const IDecoder *	decoder

const IDemodulator *	demodulator

const IPulseFilter *	pulseFilter

const IAnalogDigitalConverter *	analogDigitalConverter

W	energyDetection

W	sensitivity

Hz	centerFrequency

Hz	bandwidth

double	snirThreshold

Protected Attributes inherited from inet::physicallayer::SnirReceiverBase
double	snirThreshold = NaN

SnirThresholdMode	snirThresholdMode = SnirThresholdMode::STM_UNDEFINED

Additional Inherited Members
Protected Types inherited from inet::physicallayer::SnirReceiverBase
enum	SnirThresholdMode { SnirThresholdMode::STM_UNDEFINED = -1, SnirThresholdMode::STM_MIN, SnirThresholdMode::STM_MEAN }

Member Enumeration Documentation

◆ LevelOfDetail

enum inet::physicallayer::ApskLayeredReceiver::LevelOfDetail

Enumerator
PACKET_DOMAIN
BIT_DOMAIN
SYMBOL_DOMAIN
SAMPLE_DOMAIN

                        {
         PACKET_DOMAIN,
         BIT_DOMAIN,
         SYMBOL_DOMAIN,
         SAMPLE_DOMAIN,
     };

Constructor & Destructor Documentation

◆ ApskLayeredReceiver()

inet::physicallayer::ApskLayeredReceiver::ApskLayeredReceiver ( )

                                          :
     levelOfDetail(static_cast<LevelOfDetail>(-1)),
     errorModel(nullptr),
     decoder(nullptr),
     demodulator(nullptr),
     pulseFilter(nullptr),
     analogDigitalConverter(nullptr),
     energyDetection(W(NaN)),
     sensitivity(W(NaN)),
     centerFrequency(Hz(NaN)),
     bandwidth(Hz(NaN)),
     snirThreshold(NaN)
 {
 }

Member Function Documentation

◆ computeIsReceptionPossible()

bool inet::physicallayer::ApskLayeredReceiver::computeIsReceptionPossible	(	const IListening *	listening,
		const IReception *	reception,
		IRadioSignal::SignalPart	part
	)		const

overridevirtual

Returns whether the reception of the provided part is possible or not.

For example, it might check if the reception power is above sensitivity.

This function may be called before the reception actually starts at the receiver, thus it must be purely functional and support optimistic parallel computation.

Reimplemented from inet::physicallayer::ReceiverBase.

 {
     const BandListening *bandListening = check_and_cast<const BandListening *>(listening);
     const LayeredReception *scalarReception = check_and_cast<const LayeredReception *>(reception);
     // TODO scalar
     const ScalarReceptionSignalAnalogModel *analogModel = check_and_cast<const ScalarReceptionSignalAnalogModel *>(scalarReception->getAnalogModel());
     if (bandListening->getCenterFrequency() != analogModel->getCenterFrequency() || bandListening->getBandwidth() != analogModel->getBandwidth()) {
         EV_DEBUG << "Computing reception possible: listening and reception bands are different -> reception is impossible" << endl;
         return false;
     }
     else {
         const INarrowbandSignal *narrowbandSignalAnalogModel = check_and_cast<const INarrowbandSignal *>(scalarReception->getAnalogModel());
         W minReceptionPower = narrowbandSignalAnalogModel->computeMinPower(reception->getStartTime(), reception->getEndTime());
         bool isReceptionPossible = minReceptionPower >= sensitivity;
         EV_DEBUG << "Computing reception possible" << EV_FIELD(minReceptionPower) << EV_FIELD(sensitivity) << " -> reception is " << (isReceptionPossible ? "possible" : "impossible") << endl;
         return isReceptionPossible;
     }
 }

◆ computeListeningDecision()

const IListeningDecision * inet::physicallayer::ApskLayeredReceiver::computeListeningDecision	(	const IListening *	listening,
		const IInterference *	interference
	)		const

overridevirtual

Returns the result of the listening process specifying the reception state of the receiver.

This function must be purely functional and support optimistic parallel computation.

Implements inet::physicallayer::IReceiver.

 {
     const IRadio *receiver = listening->getReceiver();
     const IRadioMedium *radioMedium = receiver->getMedium();
     const IAnalogModel *analogModel = radioMedium->getAnalogModel();
     const INoise *noise = analogModel->computeNoise(listening, interference);
     const NarrowbandNoiseBase *flatNoise = check_and_cast<const NarrowbandNoiseBase *>(noise);
     W maxPower = flatNoise->computeMaxPower(listening->getStartTime(), listening->getEndTime());
     bool isListeningPossible = maxPower >= energyDetection;
     delete noise;
     EV_DEBUG << "Computing listening possible: maximum power = " << maxPower << ", energy detection = " << energyDetection << " -> listening is " << (isListeningPossible ? "possible" : "impossible") << endl;
     return new ListeningDecision(listening, isListeningPossible);
 }

◆ computeReceptionResult()

const IReceptionResult * inet::physicallayer::ApskLayeredReceiver::computeReceptionResult	(	const IListening *	listening,
		const IReception *	reception,
		const IInterference *	interference,
		const ISnir *	snir,
		const std::vector< const IReceptionDecision * > *	decisions
	)		const

overridevirtual

Returns the complete result of the reception process for the provided reception.

This function may be called before the reception actually starts at the receiver, thus it must be purely functional and support optimistic parallel computation.

Reimplemented from inet::physicallayer::ReceiverBase.

 {
     const LayeredTransmission *transmission = dynamic_cast<const LayeredTransmission *>(reception->getTransmission());
     const IReceptionAnalogModel *analogModel = createAnalogModel(transmission, snir);
     const IReceptionSampleModel *sampleModel = createSampleModel(transmission, snir, analogModel);
     const IReceptionSymbolModel *symbolModel = createSymbolModel(transmission, snir, sampleModel);
     const IReceptionBitModel *bitModel = createBitModel(transmission, snir, symbolModel);
     const IReceptionPacketModel *packetModel = createPacketModel(transmission, snir, bitModel);
     auto packet = const_cast<Packet *>(packetModel->getPacket());
     auto errorRateInd = packet->addTagIfAbsent<ErrorRateInd>();
     if (symbolModel != nullptr)
         errorRateInd->setSymbolErrorRate(symbolModel->getSymbolErrorRate());
     if (bitModel != nullptr)
         errorRateInd->setBitErrorRate(bitModel->getBitErrorRate());
     if (packetModel != nullptr)
         errorRateInd->setPacketErrorRate(packetModel->getPacketErrorRate());
     auto snirInd = packet->addTagIfAbsent<SnirInd>();
     snirInd->setMinimumSnir(snir->getMin());
     snirInd->setMaximumSnir(snir->getMax());
     snirInd->setAverageSnir(snir->getMean());
     return new LayeredReceptionResult(reception, decisions, packetModel, bitModel, symbolModel, sampleModel, analogModel);
 }

◆ createAnalogModel()

const IReceptionAnalogModel * inet::physicallayer::ApskLayeredReceiver::createAnalogModel	(	const LayeredTransmission *	transmission,
		const ISnir *	snir
	)		const

protectedvirtual

 {
     // TODO interference + receptionAnalogModel;
     return nullptr;
 }

Referenced by computeReceptionResult().

◆ createBitModel()

const IReceptionBitModel * inet::physicallayer::ApskLayeredReceiver::createBitModel	(	const LayeredTransmission *	transmission,
		const ISnir *	snir,
		const IReceptionSymbolModel *	symbolModel
	)		const

protectedvirtual

 {
     if (levelOfDetail == BIT_DOMAIN)
         return errorModel->computeBitModel(transmission, snir);
     else if (levelOfDetail >= SYMBOL_DOMAIN)
         return demodulator->demodulate(symbolModel);
     else
         return nullptr;
 }

Referenced by computeReceptionResult().

◆ createListening()

const IListening * inet::physicallayer::ApskLayeredReceiver::createListening	(	const IRadio *	radio,
		const simtime_t	startTime,
		const simtime_t	endTime,
		const Coord &	startPosition,
		const Coord &	endPosition
	)		const

overridevirtual

Returns a description of how the receiver is listening on the medium.

Implements inet::physicallayer::IReceiver.

 {
     return new BandListening(radio, startTime, endTime, startPosition, endPosition, centerFrequency, bandwidth);
 }

◆ createPacketModel()

const IReceptionPacketModel * inet::physicallayer::ApskLayeredReceiver::createPacketModel	(	const LayeredTransmission *	transmission,
		const ISnir *	snir,
		const IReceptionBitModel *	bitModel
	)		const

protectedvirtual

 {
     if (levelOfDetail == PACKET_DOMAIN)
         return errorModel->computePacketModel(transmission, snir);
     else if (levelOfDetail >= BIT_DOMAIN)
         return decoder->decode(bitModel);
     else
         return nullptr;
 }

Referenced by computeReceptionResult().

◆ createSampleModel()

const IReceptionSampleModel * inet::physicallayer::ApskLayeredReceiver::createSampleModel	(	const LayeredTransmission *	transmission,
		const ISnir *	snir,
		const IReceptionAnalogModel *	analogModel
	)		const

protectedvirtual

 {
     if (levelOfDetail == SAMPLE_DOMAIN)
         return errorModel->computeSampleModel(transmission, snir);
     else if (analogDigitalConverter)
         return analogDigitalConverter->convertAnalogToDigital(analogModel);
     else
         return nullptr;
 }

Referenced by computeReceptionResult().

◆ createSymbolModel()

const IReceptionSymbolModel * inet::physicallayer::ApskLayeredReceiver::createSymbolModel	(	const LayeredTransmission *	transmission,
		const ISnir *	snir,
		const IReceptionSampleModel *	sampleModel
	)		const

protectedvirtual

 {
     if (levelOfDetail == SYMBOL_DOMAIN)
         return errorModel->computeSymbolModel(transmission, snir);
     else if (levelOfDetail >= SAMPLE_DOMAIN)
         return pulseFilter->filter(sampleModel);
     else
         return nullptr;
 }

Referenced by computeReceptionResult().

◆ getAnalogDigitalConverter()

virtual const IAnalogDigitalConverter* inet::physicallayer::ApskLayeredReceiver::getAnalogDigitalConverter ( ) const

inlinevirtual

67 { return analogDigitalConverter; }

◆ getDecoder()

virtual const IDecoder* inet::physicallayer::ApskLayeredReceiver::getDecoder ( ) const

inlinevirtual

64 { return decoder; }

◆ getModulator()

virtual const IDemodulator* inet::physicallayer::ApskLayeredReceiver::getModulator ( ) const

inlinevirtual

65 { return demodulator; }

◆ getPulseFilter()

virtual const IPulseFilter* inet::physicallayer::ApskLayeredReceiver::getPulseFilter ( ) const

inlinevirtual

66 { return pulseFilter; }

◆ initialize()

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

overrideprotectedvirtual

Reimplemented from inet::physicallayer::SnirReceiverBase.

 {
     SnirReceiverBase::initialize(stage);
     if (stage == INITSTAGE_LOCAL) {
         errorModel = dynamic_cast<ILayeredErrorModel *>(getSubmodule("errorModel"));
         decoder = dynamic_cast<IDecoder *>(getSubmodule("decoder"));
         demodulator = dynamic_cast<IDemodulator *>(getSubmodule("demodulator"));
         pulseFilter = dynamic_cast<IPulseFilter *>(getSubmodule("pulseFilter"));
         analogDigitalConverter = dynamic_cast<IAnalogDigitalConverter *>(getSubmodule("analogDigitalConverter"));
         energyDetection = mW(math::dBmW2mW(par("energyDetection")));
         // TODO temporary parameters
         sensitivity = mW(math::dBmW2mW(par("sensitivity")));
         centerFrequency = Hz(par("centerFrequency"));
         bandwidth = Hz(par("bandwidth"));
         const char *levelOfDetailStr = par("levelOfDetail");
         if (strcmp("packet", levelOfDetailStr) == 0)
             levelOfDetail = PACKET_DOMAIN;
         else if (strcmp("bit", levelOfDetailStr) == 0)
             levelOfDetail = BIT_DOMAIN;
         else if (strcmp("symbol", levelOfDetailStr) == 0)
             levelOfDetail = SYMBOL_DOMAIN;
         else if (strcmp("sample", levelOfDetailStr) == 0)
             levelOfDetail = SAMPLE_DOMAIN;
         else
             throw cRuntimeError("Unknown level of detail='%s'", levelOfDetailStr);
         if (levelOfDetail >= BIT_DOMAIN && !decoder)
             throw cRuntimeError("Decoder not configured");
         if (levelOfDetail >= SYMBOL_DOMAIN && !demodulator)
             throw cRuntimeError("Demodulator not configured");
         if (levelOfDetail >= SAMPLE_DOMAIN && !pulseFilter)
             throw cRuntimeError("Pulse filter not configured");
     }
 }

◆ printToStream()

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

overridevirtual

Prints this object to the provided output stream.

Reimplemented from inet::physicallayer::SnirReceiverBase.

 {
     stream << "ApskLayeredReceiver";
     if (level <= PRINT_LEVEL_DETAIL)
         stream << EV_FIELD(levelOfDetail)
                << EV_FIELD(centerFrequency);
     if (level <= PRINT_LEVEL_TRACE)
         stream << EV_FIELD(errorModel, printFieldToString(errorModel, level + 1, evFlags))
                << EV_FIELD(decoder, printFieldToString(decoder, level + 1, evFlags))
                << EV_FIELD(demodulator, printFieldToString(demodulator, level + 1, evFlags))
                << EV_FIELD(pulseFilter, printFieldToString(pulseFilter, level + 1, evFlags))
                << EV_FIELD(analogDigitalConverter, printFieldToString(analogDigitalConverter, level + 1, evFlags))
                << EV_FIELD(energyDetection)
                << EV_FIELD(sensitivity)
                << EV_FIELD(bandwidth)
                << EV_FIELD(snirThreshold);
     return stream;
 }

Member Data Documentation

◆ analogDigitalConverter

const IAnalogDigitalConverter* inet::physicallayer::ApskLayeredReceiver::analogDigitalConverter

protected

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

◆ bandwidth

Hz inet::physicallayer::ApskLayeredReceiver::bandwidth

protected

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

◆ centerFrequency

Hz inet::physicallayer::ApskLayeredReceiver::centerFrequency

protected

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

◆ decoder

const IDecoder* inet::physicallayer::ApskLayeredReceiver::decoder

protected

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

◆ demodulator

const IDemodulator* inet::physicallayer::ApskLayeredReceiver::demodulator

protected

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

◆ energyDetection

W inet::physicallayer::ApskLayeredReceiver::energyDetection

protected

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

◆ errorModel

const ILayeredErrorModel* inet::physicallayer::ApskLayeredReceiver::errorModel

protected

Referenced by createBitModel(), createPacketModel(), createSampleModel(), createSymbolModel(), initialize(), and printToStream().

◆ levelOfDetail

LevelOfDetail inet::physicallayer::ApskLayeredReceiver::levelOfDetail

protected

Referenced by createBitModel(), createPacketModel(), createSampleModel(), createSymbolModel(), initialize(), and printToStream().

◆ pulseFilter

const IPulseFilter* inet::physicallayer::ApskLayeredReceiver::pulseFilter

protected

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

◆ sensitivity

W inet::physicallayer::ApskLayeredReceiver::sensitivity

protected

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

◆ snirThreshold

double inet::physicallayer::ApskLayeredReceiver::snirThreshold

protected

Referenced by printToStream().

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

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Member Enumeration Documentation

◆ LevelOfDetail

Constructor & Destructor Documentation

◆ ApskLayeredReceiver()

Member Function Documentation

◆ computeIsReceptionPossible()

◆ computeListeningDecision()

◆ computeReceptionResult()

◆ createAnalogModel()

◆ createBitModel()

◆ createListening()

◆ createPacketModel()

◆ createSampleModel()

◆ createSymbolModel()

◆ getAnalogDigitalConverter()

◆ getDecoder()

◆ getModulator()

◆ getPulseFilter()

◆ initialize()

◆ printToStream()

Member Data Documentation

◆ analogDigitalConverter

◆ bandwidth

◆ centerFrequency

◆ decoder

◆ demodulator

◆ energyDetection

◆ errorModel

◆ levelOfDetail

◆ pulseFilter

◆ sensitivity

◆ snirThreshold