inet::physicallayer::ErrorModelBase Class Reference

#include <ErrorModelBase.h>

Inheritance diagram for inet::physicallayer::ErrorModelBase:

Public Types
enum	CorruptionMode {   CorruptionMode::CM_UNDEFINED = -1, CorruptionMode::CM_PACKET, CorruptionMode::CM_CHUNK, CorruptionMode::CM_BYTE,   CorruptionMode::CM_BIT }
enum	SnirMode { SnirMode::SM_UNDEFINED = -1, SnirMode::SM_MIN, SnirMode::SM_MEAN }
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) }

Protected Member Functions
virtual void	initialize (int stage) override
virtual double	getScalarSnir (const ISnir *snir) const
virtual bool	hasProbabilisticError (b length, double ber) const
virtual Packet *	corruptBits (const Packet *packet, double ber, bool &isCorrupted) const
virtual Packet *	corruptBytes (const Packet *packet, double ber, bool &isCorrupted) const
virtual Packet *	corruptChunks (const Packet *packet, double ber, bool &isCorrupted) const
virtual Packet *	corruptPacket (const Packet *packet, bool &isCorrupted) const
virtual Packet *	computeCorruptedPacket (const Packet *packet, double ber) const
virtual Packet *	computeCorruptedPacket (const ISnir *snir) const override

Protected Attributes
CorruptionMode	corruptionMode = CorruptionMode::CM_UNDEFINED
SnirMode	snirMode = SnirMode::SM_UNDEFINED
double	snirOffset = NaN

Additional Inherited Members
Public Member Functions inherited from inet::physicallayer::IErrorModel
virtual double	computePacketErrorRate (const ISnir *snir, IRadioSignal::SignalPart part) const =0
	Returns the packet error rate based on SNIR, modulation, FEC encoding and any other physical layer characteristics. More...
virtual double	computeBitErrorRate (const ISnir *snir, IRadioSignal::SignalPart part) const =0
	Returns the bit error rate based on SNIR, modulation, FEC encoding and any other physical layer characteristics. More...
virtual double	computeSymbolErrorRate (const ISnir *snir, IRadioSignal::SignalPart part) const =0
	Returns the symbol error rate based on SNIR, modulation, and any other physical layer characteristics. More...
Public Member Functions inherited from inet::IPrintableObject
virtual	~IPrintableObject ()
virtual std::ostream &	printToStream (std::ostream &stream, int level, int evFlags=0) const
	Prints this object to the provided output stream. More...
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

Member Enumeration Documentation

CorruptionMode

enum inet::physicallayer::ErrorModelBase::CorruptionMode

strong

Enumerator
CM_UNDEFINED
CM_PACKET
CM_CHUNK
CM_BYTE
CM_BIT

                              {
        CM_UNDEFINED = -1,
        CM_PACKET,
        CM_CHUNK,
        CM_BYTE,
        CM_BIT
    };

SnirMode

enum inet::physicallayer::ErrorModelBase::SnirMode

strong

Enumerator
SM_UNDEFINED
SM_MIN
SM_MEAN

                        {
        SM_UNDEFINED = -1,
        SM_MIN,
        SM_MEAN
    };

Member Function Documentation

computeCorruptedPacket() [1/2]

Packet * inet::physicallayer::ErrorModelBase::computeCorruptedPacket ( const ISnir *  snir ) const

overrideprotectedvirtual

Implements inet::physicallayer::IErrorModel.

{
    auto transmittedPacket = snir->getReception()->getTransmission()->getPacket();
    auto ber = computeBitErrorRate(snir, IRadioSignal::SIGNAL_PART_WHOLE);
    auto receivedPacket = computeCorruptedPacket(transmittedPacket, ber);
    receivedPacket->clearTags();
    receivedPacket->addTag<PacketProtocolTag>()->setProtocol(transmittedPacket->getTag<PacketProtocolTag>()->getProtocol());
    return receivedPacket;
}

computeCorruptedPacket() [2/2]

Packet * inet::physicallayer::ErrorModelBase::computeCorruptedPacket ( const Packet *  packet, double  ber  ) const

protectedvirtual

Reimplemented in inet::physicallayer::Ieee80211ErrorModelBase.

{
    bool isCorrupted = false;
    Packet *corruptedPacket = nullptr;
    // TODO this while loop looks bad, but we don't have any other chance now, because the decision whether the reception is successful or not has been already made
    while (!isCorrupted) {
        switch (corruptionMode) {
            case CorruptionMode::CM_PACKET:
                corruptedPacket = corruptPacket(packet, isCorrupted);
                break;
            case CorruptionMode::CM_CHUNK:
                corruptedPacket = corruptChunks(packet, ber, isCorrupted);
                break;
            case CorruptionMode::CM_BYTE:
                corruptedPacket = corruptBytes(packet, ber, isCorrupted);
                break;
            case CorruptionMode::CM_BIT:
                corruptedPacket = corruptBits(packet, ber, isCorrupted);
                break;
            default:
                throw cRuntimeError("Unknown corruption mode");
        }
        if (!isCorrupted)
            delete corruptedPacket;
    }
    return corruptedPacket;
}

Referenced by inet::physicallayer::Ieee80211ErrorModelBase::computeCorruptedPacket(), and computeCorruptedPacket().

corruptBits()

Packet * inet::physicallayer::ErrorModelBase::corruptBits ( const Packet *  packet, double  ber, bool &  isCorrupted  ) const

protectedvirtual

{
    std::vector<bool> corruptedBits;
    const auto& all = packet->peekAllAsBits();
    for (bool bit : all->getBits()) {
        if (hasProbabilisticError(b(1), ber)) {
            isCorrupted = true;
            bit = !bit;
        }
        corruptedBits.push_back(bit);
    }
    return new Packet(packet->getName(), makeShared<BitsChunk>(corruptedBits));
}

Referenced by computeCorruptedPacket().

corruptBytes()

Packet * inet::physicallayer::ErrorModelBase::corruptBytes ( const Packet *  packet, double  ber, bool &  isCorrupted  ) const

protectedvirtual

{
    std::vector<uint8_t> corruptedBytes;
    const auto& all = packet->peekAllAsBytes();
    for (uint8_t byte : all->getBytes()) {
        if (hasProbabilisticError(B(1), ber)) {
            isCorrupted = true;
            byte = ~byte;
        }
        corruptedBytes.push_back(byte);
    }
    return new Packet(packet->getName(), makeShared<BytesChunk>(corruptedBytes));
}

Referenced by computeCorruptedPacket().

corruptChunks()

Packet * inet::physicallayer::ErrorModelBase::corruptChunks ( const Packet *  packet, double  ber, bool &  isCorrupted  ) const

protectedvirtual

{
    b offset = b(0);
    auto corruptedPacket = new Packet(packet->getName());
    while (auto chunk = packet->peekAt(offset, b(-1), Chunk::PF_ALLOW_NULLPTR)) {
        if (hasProbabilisticError(chunk->getChunkLength(), ber)) {
            isCorrupted = true;
            auto corruptedChunk = chunk->dupShared();
            corruptedChunk->markIncorrect();
            corruptedPacket->insertAtBack(corruptedChunk);
        }
        else
            corruptedPacket->insertAtBack(chunk);
        offset += chunk->getChunkLength();
    }
    return corruptedPacket;
}

Referenced by computeCorruptedPacket().

corruptPacket()

Packet * inet::physicallayer::ErrorModelBase::corruptPacket ( const Packet *  packet, bool &  isCorrupted  ) const

protectedvirtual

{
    isCorrupted = true;
    auto corruptedPacket = packet->dup();
    corruptedPacket->setBitError(true);
    return corruptedPacket;
}

Referenced by computeCorruptedPacket().

getScalarSnir()

double inet::physicallayer::ErrorModelBase::getScalarSnir ( const ISnir *  snir ) const

protectedvirtual

{
    double scalarSnir;
    if (snirMode == SnirMode::SM_MIN)
        scalarSnir = snir->getMin();
    else if (snirMode == SnirMode::SM_MEAN)
        scalarSnir = snir->getMean();
    else
        throw cRuntimeError("Unknown SNIR mode");
    return scalarSnir * snirOffset;
}

Referenced by inet::physicallayer::ApskErrorModel::computeBitErrorRate(), inet::physicallayer::Ieee80211OfdmErrorModel::computeBitModel(), inet::physicallayer::Ieee80211BerTableErrorModel::computePacketErrorRate(), inet::physicallayer::Ieee80211ErrorModelBase::computePacketErrorRate(), inet::physicallayer::ApskErrorModel::computeSymbolErrorRate(), and inet::physicallayer::Ieee80211OfdmErrorModel::computeSymbolModel().

hasProbabilisticError()

bool inet::physicallayer::ErrorModelBase::hasProbabilisticError ( b  length, double  ber  ) const

protectedvirtual

{
    ASSERT(0.0 < ber && ber <= 1.0);
    return dblrand() < 1 - std::pow((1 - ber), length.get());
}

Referenced by corruptBits(), corruptBytes(), and corruptChunks().

initialize()

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

overrideprotectedvirtual

Reimplemented in inet::physicallayer::Ieee80211OfdmErrorModel, inet::physicallayer::StochasticErrorModel, and inet::physicallayer::Ieee80211BerTableErrorModel.

{
    if (stage == INITSTAGE_LOCAL) {
        const char *corruptionModeString = par("corruptionMode");
        if (!strcmp("packet", corruptionModeString))
            corruptionMode = CorruptionMode::CM_PACKET;
        else if (!strcmp("chunk", corruptionModeString))
            corruptionMode = CorruptionMode::CM_CHUNK;
        else if (!strcmp("byte", corruptionModeString))
            corruptionMode = CorruptionMode::CM_BYTE;
        else if (!strcmp("bit", corruptionModeString))
            corruptionMode = CorruptionMode::CM_BIT;
        else
            throw cRuntimeError("Unknown corruption mode");
        const char *snirModeString = par("snirMode");
        if (!strcmp("min", snirModeString))
            snirMode = SnirMode::SM_MIN;
        else if (!strcmp("mean", snirModeString))
            snirMode = SnirMode::SM_MEAN;
        else
            throw cRuntimeError("Unknown SNIR mode: '%s'", snirModeString);
        snirOffset = inet::math::dB2fraction(par("snirOffset"));
    }
}

Referenced by inet::physicallayer::Ieee80211OfdmErrorModel::initialize().

Member Data Documentation

corruptionMode

CorruptionMode inet::physicallayer::ErrorModelBase::corruptionMode = CorruptionMode::CM_UNDEFINED

protected

Referenced by inet::physicallayer::Ieee80211ErrorModelBase::computeCorruptedPacket(), computeCorruptedPacket(), and initialize().

snirMode

SnirMode inet::physicallayer::ErrorModelBase::snirMode = SnirMode::SM_UNDEFINED

protected

Referenced by getScalarSnir(), and initialize().

snirOffset

double inet::physicallayer::ErrorModelBase::snirOffset = NaN

protected

Referenced by getScalarSnir(), and initialize().

---

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

• ErrorModelBase.h
• ErrorModelBase.cc