inet::physicallayer::APSKLayeredReceiver Class Reference

#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::physicallayer::IPrintableObject
enum	PrintLevel {   PRINT_LEVEL_TRACE, PRINT_LEVEL_DEBUG, PRINT_LEVEL_DETAIL, PRINT_LEVEL_INFO,   PRINT_LEVEL_COMPLETE = INT_MIN }

Public Member Functions
	APSKLayeredReceiver ()
virtual std::ostream &	printToStream (std::ostream &stream, int level) 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 override
	Returns the complete result of the reception process for the provided reception. More...
Public Member Functions inherited from inet::physicallayer::SNIRReceiverBase
	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...
virtual ReceptionIndication *	createReceptionIndication () const
	Returns an empty reception indication (control info). More...
Public Member Functions inherited from inet::physicallayer::IPrintableObject
virtual	~IPrintableObject ()
virtual std::string	getInfoStringRepresentation () const
virtual std::string	getDetailStringRepresentation () const
virtual std::string	getDebugStringRepresentation () const
virtual std::string	getTraceStringRepresentation () const
virtual std::string	getCompleteStringRepresentation () const

Protected Member Functions
virtual 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
virtual const APSKPhyFrame *	createPhyFrame (const IReceptionPacketModel *packetModel) const
Protected Member Functions inherited from inet::physicallayer::SNIRReceiverBase
virtual const ReceptionIndication *	computeReceptionIndication (const ISNIR *snir) const override
	Returns the physical properties of the reception including noise and signal related measures, error probabilities, actual error counts, etc. More...
Protected Member Functions inherited from inet::physicallayer::ReceiverBase
virtual int	numInitStages () const override

Protected Attributes
LevelOfDetail	levelOfDetail
const ILayeredErrorModel *	errorModel
const IDecoder *	decoder
const IDemodulator *	demodulator
const IPulseFilter *	pulseFilter
const IAnalogDigitalConverter *	analogDigitalConverter
W	energyDetection
W	sensitivity
Hz	carrierFrequency
Hz	bandwidth
double	snirThreshold
Protected Attributes inherited from inet::physicallayer::SNIRReceiverBase
double	snirThreshold

Member Enumeration Documentation

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

inet::physicallayer::APSKLayeredReceiver::APSKLayeredReceiver

(

)

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

Member Function Documentation

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->getCarrierFrequency() != analogModel->getCarrierFrequency() || 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: minimum reception power = " << minReceptionPower << ", sensitivity = " << sensitivity << " -> reception is " << (isReceptionPossible ? "possible" : "impossible") << endl;
        return isReceptionPossible;
    }
}

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

const IReceptionResult * inet::physicallayer::APSKLayeredReceiver::computeReceptionResult ( const IListening *  listening, const IReception *  reception, const IInterference *  interference, const ISNIR *  snir  ) 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);
    const APSKPhyFrame *phyFrame = createPhyFrame(packetModel);
    ReceptionIndication *receptionIndication = new ReceptionIndication();
    receptionIndication->setMinSNIR(snir->getMin());
//    receptionIndication->setMinRSSI(analogModel->getMinRSSI());
//    receptionIndication->setSymbolErrorRate(bitModel->getBitErrorRate());
//    receptionIndication->setBitErrorRate(symbolModel->getSymbolErrorRate());
//    receptionIndication->setPacketErrorRate(packetModel->getPacketErrorRate());
    const ReceptionPacketModel *receptionPacketModel = new ReceptionPacketModel(phyFrame, new BitVector(*packetModel->getSerializedPacket()), bps(NaN), -1, packetModel->isPacketErrorless());
    delete packetModel;
// TODO: true, true, receptionPacketModel->isPacketErrorless()
    return new LayeredReceptionResult(reception, new std::vector<const IReceptionDecision *>(), receptionIndication, receptionPacketModel, bitModel, symbolModel, sampleModel, analogModel);
}

const IReceptionAnalogModel * inet::physicallayer::APSKLayeredReceiver::createAnalogModel ( const LayeredTransmission *  transmission, const ISNIR *  snir  ) const

protectedvirtual

Referenced by computeReceptionResult().

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

const IReceptionBitModel * inet::physicallayer::APSKLayeredReceiver::createBitModel ( const LayeredTransmission *  transmission, const ISNIR *  snir, const IReceptionSymbolModel *  symbolModel  ) const

protectedvirtual

Referenced by computeReceptionResult().

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

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, carrierFrequency, bandwidth);
}

const IReceptionPacketModel * inet::physicallayer::APSKLayeredReceiver::createPacketModel ( const LayeredTransmission *  transmission, const ISNIR *  snir, const IReceptionBitModel *  bitModel  ) const

protectedvirtual

Referenced by computeReceptionResult().

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

const APSKPhyFrame * inet::physicallayer::APSKLayeredReceiver::createPhyFrame ( const IReceptionPacketModel *  packetModel ) const

protectedvirtual

Referenced by computeReceptionResult().

{
    const BitVector *bits = packetModel->getSerializedPacket();
    if (bits != nullptr)
        return APSKPhyFrameSerializer().deserialize(bits);
    else
        return check_and_cast<const APSKPhyFrame *>(packetModel->getPacket()->dup());
}

const IReceptionSampleModel * inet::physicallayer::APSKLayeredReceiver::createSampleModel ( const LayeredTransmission *  transmission, const ISNIR *  snir, const IReceptionAnalogModel *  analogModel  ) const

protectedvirtual

Referenced by computeReceptionResult().

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

const IReceptionSymbolModel * inet::physicallayer::APSKLayeredReceiver::createSymbolModel ( const LayeredTransmission *  transmission, const ISNIR *  snir, const IReceptionSampleModel *  sampleModel  ) const

protectedvirtual

Referenced by computeReceptionResult().

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

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

inlinevirtual

{ return analogDigitalConverter; }

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

inlinevirtual

{ return decoder; }

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

inlinevirtual

{ return demodulator; }

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

inlinevirtual

{ return pulseFilter; }

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

overrideprotectedvirtual

Reimplemented from inet::physicallayer::SNIRReceiverBase.

{
    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::dBm2mW(par("energyDetection")));
        // TODO: temporary parameters
        sensitivity = mW(math::dBm2mW(par("sensitivity")));
        carrierFrequency = Hz(par("carrierFrequency"));
        bandwidth = Hz(par("bandwidth"));
        snirThreshold = math::dB2fraction(par("snirThreshold"));
        const char *levelOfDetailStr = par("levelOfDetail").stringValue();
        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");
    }
}

std::ostream & inet::physicallayer::APSKLayeredReceiver::printToStream ( std::ostream &  stream, int  level  ) const

overridevirtual

Prints this object to the provided output stream.

Function calls to operator<< with pointers or references either const or not are all forwarded to this function.

Reimplemented from inet::physicallayer::SNIRReceiverBase.

{
    stream << "APSKLayeredReceiver";
    if (level <= PRINT_LEVEL_DETAIL)
        stream << ", levelOfDetail = " << levelOfDetail
               << ", carrierFrequency = " << carrierFrequency;
    if (level <= PRINT_LEVEL_TRACE)
        stream << ", errorModel = " << printObjectToString(errorModel, level + 1)
               << ", decoder = " << printObjectToString(decoder, level + 1)
               << ", demodulator = " << printObjectToString(demodulator, level + 1)
               << ", pulseFilter = " << printObjectToString(pulseFilter, level + 1)
               << ", analogDigitalConverter = " << printObjectToString(analogDigitalConverter, level + 1)
               << ", energyDetection = " << energyDetection
               << ", sensitivity = " << sensitivity
               << ", bandwidth = " << bandwidth
               << ", snirThreshold = " << snirThreshold;
    return stream;
}

Member Data Documentation

const IAnalogDigitalConverter* inet::physicallayer::APSKLayeredReceiver::analogDigitalConverter

protected

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

Hz inet::physicallayer::APSKLayeredReceiver::bandwidth

protected

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

Hz inet::physicallayer::APSKLayeredReceiver::carrierFrequency

protected

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

const IDecoder* inet::physicallayer::APSKLayeredReceiver::decoder

protected

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

const IDemodulator* inet::physicallayer::APSKLayeredReceiver::demodulator

protected

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

W inet::physicallayer::APSKLayeredReceiver::energyDetection

protected

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

const ILayeredErrorModel* inet::physicallayer::APSKLayeredReceiver::errorModel

protected

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

LevelOfDetail inet::physicallayer::APSKLayeredReceiver::levelOfDetail

protected

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

const IPulseFilter* inet::physicallayer::APSKLayeredReceiver::pulseFilter

protected

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

W inet::physicallayer::APSKLayeredReceiver::sensitivity

protected

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

double inet::physicallayer::APSKLayeredReceiver::snirThreshold

protected

Referenced by initialize(), and printToStream().

---

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

• APSKLayeredReceiver.h
• APSKLayeredReceiver.cc