inet::physicallayer::ScalarAnalogModelBase Class Reference

#include <ScalarAnalogModelBase.h>

Inheritance diagram for inet::physicallayer::ScalarAnalogModelBase:

Public Member Functions
virtual W	computeReceptionPower (const IRadio *radio, const ITransmission *transmission, const IArrival *arrival) const
virtual const INoise *	computeNoise (const IListening *listening, const IInterference *interference) const override
	Returns the total noise summing up all the interfering receptions and noises. More...
virtual const ISNIR *	computeSNIR (const IReception *reception, const INoise *noise) const override
	Returns the signal to noise and interference ratio. More...
Public Member Functions inherited from inet::physicallayer::IAnalogModel
virtual const IReception *	computeReception (const IRadio *receiver, const ITransmission *transmission, const IArrival *arrival) const =0
	Returns the reception for the provided transmission at the receiver. More...
Public Member Functions inherited from inet::physicallayer::IPrintableObject
virtual	~IPrintableObject ()
virtual std::ostream &	printToStream (std::ostream &stream, int level) const
	Prints this object to the provided output stream. More...
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 bool	areOverlappingBands (Hz carrierFrequency1, Hz bandwidth1, Hz carrierFrequency2, Hz bandwidth2) const
Protected Member Functions inherited from inet::physicallayer::AnalogModelBase
virtual EulerAngles	computeTransmissionDirection (const ITransmission *transmission, const IArrival *arrival) const

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

Member Function Documentation

bool inet::physicallayer::ScalarAnalogModelBase::areOverlappingBands ( Hz  carrierFrequency1, Hz  bandwidth1, Hz  carrierFrequency2, Hz  bandwidth2  ) const

protectedvirtual

Referenced by computeNoise().

{
    return carrierFrequency1 + bandwidth1 / 2 >= carrierFrequency2 - bandwidth2 / 2 &&
           carrierFrequency1 - bandwidth1 / 2 <= carrierFrequency2 + bandwidth2 / 2;
}

const INoise * inet::physicallayer::ScalarAnalogModelBase::computeNoise ( const IListening *  listening, const IInterference *  interference  ) const

overridevirtual

Returns the total noise summing up all the interfering receptions and noises.

This function never returns nullptr.

Implements inet::physicallayer::IAnalogModel.

{
    const BandListening *bandListening = check_and_cast<const BandListening *>(listening);
    Hz commonCarrierFrequency = bandListening->getCarrierFrequency();
    Hz commonBandwidth = bandListening->getBandwidth();
    simtime_t noiseStartTime = SimTime::getMaxTime();
    simtime_t noiseEndTime = 0;
    std::map<simtime_t, W> *powerChanges = new std::map<simtime_t, W>();
    const std::vector<const IReception *> *interferingReceptions = interference->getInterferingReceptions();
    for (auto reception : *interferingReceptions) {
        const ISignalAnalogModel *signalAnalogModel = reception->getAnalogModel();
        const INarrowbandSignal *narrowbandSignalAnalogModel = check_and_cast<const INarrowbandSignal *>(signalAnalogModel);
        Hz signalCarrierFrequency = narrowbandSignalAnalogModel->getCarrierFrequency();
        Hz signalBandwidth = narrowbandSignalAnalogModel->getBandwidth();
        if (commonCarrierFrequency == signalCarrierFrequency && commonBandwidth == signalBandwidth)
        {
            const IScalarSignal *scalarSignalAnalogModel = check_and_cast<const IScalarSignal *>(signalAnalogModel);
            W power = scalarSignalAnalogModel->getPower();
            simtime_t startTime = reception->getStartTime();
            simtime_t endTime = reception->getEndTime();
            if (startTime < noiseStartTime)
                noiseStartTime = startTime;
            if (endTime > noiseEndTime)
                noiseEndTime = endTime;
            std::map<simtime_t, W>::iterator itStartTime = powerChanges->find(startTime);
            if (itStartTime != powerChanges->end())
                itStartTime->second += power;
            else
                powerChanges->insert(std::pair<simtime_t, W>(startTime, power));
            std::map<simtime_t, W>::iterator itEndTime = powerChanges->find(endTime);
            if (itEndTime != powerChanges->end())
                itEndTime->second -= power;
            else
                powerChanges->insert(std::pair<simtime_t, W>(endTime, -power));
        }
        else if (areOverlappingBands(commonCarrierFrequency, commonBandwidth, narrowbandSignalAnalogModel->getCarrierFrequency(), narrowbandSignalAnalogModel->getBandwidth()))
            throw cRuntimeError("Overlapping bands are not supported");
    }
    const ScalarNoise *scalarBackgroundNoise = dynamic_cast<const ScalarNoise *>(interference->getBackgroundNoise());
    if (scalarBackgroundNoise) {
        if (commonCarrierFrequency == scalarBackgroundNoise->getCarrierFrequency() && commonBandwidth == scalarBackgroundNoise->getBandwidth()) {
            const std::map<simtime_t, W> *backgroundNoisePowerChanges = scalarBackgroundNoise->getPowerChanges();
            for (const auto & backgroundNoisePowerChange : *backgroundNoisePowerChanges) {
                std::map<simtime_t, W>::iterator jt = powerChanges->find(backgroundNoisePowerChange.first);
                if (jt != powerChanges->end())
                    jt->second += backgroundNoisePowerChange.second;
                else
                    powerChanges->insert(std::pair<simtime_t, W>(backgroundNoisePowerChange.first, backgroundNoisePowerChange.second));
            }
        }
        else if (areOverlappingBands(commonCarrierFrequency, commonBandwidth, scalarBackgroundNoise->getCarrierFrequency(), scalarBackgroundNoise->getBandwidth()))
            throw cRuntimeError("Overlapping bands are not supported");
    }
    EV_TRACE << "Noise power begin " << endl;
    W noise = W(0);
    for (std::map<simtime_t, W>::const_iterator it = powerChanges->begin(); it != powerChanges->end(); it++) {
        noise += it->second;
        EV_TRACE << "Noise at " << it->first << " = " << noise << endl;
    }
    EV_TRACE << "Noise power end" << endl;
    return new ScalarNoise(noiseStartTime, noiseEndTime, commonCarrierFrequency, commonBandwidth, powerChanges);
}

W inet::physicallayer::ScalarAnalogModelBase::computeReceptionPower ( const IRadio *  radio, const ITransmission *  transmission, const IArrival *  arrival  ) const

virtual

Referenced by inet::physicallayer::ScalarAnalogModel::computeReception(), and inet::physicallayer::LayeredScalarAnalogModel::computeReception().

{
    const IRadioMedium *radioMedium = receiverRadio->getMedium();
    const IRadio *transmitterRadio = transmission->getTransmitter();
    const IAntenna *receiverAntenna = receiverRadio->getAntenna();
    const IAntenna *transmitterAntenna = transmitterRadio->getAntenna();
    const INarrowbandSignal *narrowbandSignalAnalogModel = check_and_cast<const INarrowbandSignal *>(transmission->getAnalogModel());
    const IScalarSignal *scalarSignalAnalogModel = check_and_cast<const IScalarSignal *>(transmission->getAnalogModel());
    const Coord receptionStartPosition = arrival->getStartPosition();
    const Coord receptionEndPosition = arrival->getEndPosition();
    const EulerAngles transmissionDirection = computeTransmissionDirection(transmission, arrival);
    const EulerAngles transmissionAntennaDirection = transmission->getStartOrientation() - transmissionDirection;
    const EulerAngles receptionAntennaDirection = transmissionDirection - arrival->getStartOrientation();
    double transmitterAntennaGain = transmitterAntenna->computeGain(transmissionAntennaDirection);
    double receiverAntennaGain = receiverAntenna->computeGain(receptionAntennaDirection);
    double pathLoss = radioMedium->getPathLoss()->computePathLoss(transmission, arrival);
    double obstacleLoss = radioMedium->getObstacleLoss() ? radioMedium->getObstacleLoss()->computeObstacleLoss(narrowbandSignalAnalogModel->getCarrierFrequency(), transmission->getStartPosition(), receptionStartPosition) : 1;
    W transmissionPower = scalarSignalAnalogModel->getPower();
    return transmissionPower * std::min(1.0, transmitterAntennaGain * receiverAntennaGain * pathLoss * obstacleLoss);
}

const ISNIR * inet::physicallayer::ScalarAnalogModelBase::computeSNIR ( const IReception *  reception, const INoise *  noise  ) const

overridevirtual

Returns the signal to noise and interference ratio.

This function never returns nullptr.

Implements inet::physicallayer::IAnalogModel.

{
    return new ScalarSNIR(reception, noise);
}

---

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

• ScalarAnalogModelBase.h
• ScalarAnalogModelBase.cc