inet::physicallayer::DimensionalAnalogModelBase Class Reference

#include <DimensionalAnalogModelBase.h>

Inheritance diagram for inet::physicallayer::DimensionalAnalogModelBase:

Public Member Functions
virtual std::ostream &	printToStream (std::ostream &stream, int level) const override
	Prints this object to the provided output stream. More...
virtual const ConstMapping *	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::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
Protected Member Functions inherited from inet::physicallayer::AnalogModelBase
virtual EulerAngles	computeTransmissionDirection (const ITransmission *transmission, const IArrival *arrival) const

Protected Attributes
bool	attenuateWithCarrierFrequency
Mapping::InterpolationMethod	interpolationMode

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

const INoise * inet::physicallayer::DimensionalAnalogModelBase::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 carrierFrequency = bandListening->getCarrierFrequency();
    Hz bandwidth = bandListening->getBandwidth();
    std::vector<ConstMapping *> receptionPowers;
    const DimensionalNoise *dimensionalBackgroundNoise = dynamic_cast<const DimensionalNoise *>(interference->getBackgroundNoise());
    if (dimensionalBackgroundNoise) {
        const ConstMapping *backgroundNoisePower = dimensionalBackgroundNoise->getPower();
        if (backgroundNoisePower->getDimensionSet().hasDimension(Dimension::frequency) || (carrierFrequency == dimensionalBackgroundNoise->getCarrierFrequency() && bandwidth == dimensionalBackgroundNoise->getBandwidth()))
            receptionPowers.push_back(const_cast<ConstMapping *>(backgroundNoisePower));
    }
    const std::vector<const IReception *> *interferingReceptions = interference->getInterferingReceptions();
    for (const auto & interferingReception : *interferingReceptions) {
        const DimensionalReception *dimensionalReception = check_and_cast<const DimensionalReception *>(interferingReception);
        const ConstMapping *receptionPower = dimensionalReception->getPower();
        if (receptionPower->getDimensionSet().hasDimension(Dimension::frequency) || (carrierFrequency == dimensionalReception->getCarrierFrequency() && bandwidth == dimensionalReception->getBandwidth())) {
            receptionPowers.push_back(const_cast<ConstMapping *>(receptionPower));
            EV_DEBUG << "Interference power begin " << endl;
            dimensionalReception->getPower()->print(EVSTREAM);
            EV_DEBUG << "Interference power end" << endl;
        }
    }
    DimensionSet dimensions = receptionPowers[0]->getDimensionSet();
    if (!dimensions.hasDimension(Dimension::time))
        dimensions.addDimension(Dimension::time);
    ConstMapping *listeningMapping = MappingUtils::createMapping(Argument::MappedZero, dimensions, Mapping::STEPS);
    ConcatConstMapping<std::plus<double> > *noisePower = new ConcatConstMapping<std::plus<double> >(listeningMapping, receptionPowers.begin(), receptionPowers.end(), false, Argument::MappedZero);
    EV_TRACE << "Noise power begin " << endl;
    noisePower->print(EVSTREAM);
    EV_TRACE << "Noise power end" << endl;
    return new DimensionalNoise(listening->getStartTime(), listening->getEndTime(), carrierFrequency, bandwidth, noisePower);
}

const ConstMapping * inet::physicallayer::DimensionalAnalogModelBase::computeReceptionPower ( const IRadio *  radio, const ITransmission *  transmission, const IArrival *  arrival  ) const

virtual

Referenced by inet::physicallayer::DimensionalAnalogModel::computeReception(), and inet::physicallayer::LayeredDimensionalAnalogModel::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 IDimensionalSignal *dimensionalSignalAnalogModel = check_and_cast<const IDimensionalSignal *>(transmission->getAnalogModel());
    const simtime_t transmissionStartTime = transmission->getStartTime();
    const simtime_t transmissionEndTime = transmission->getEndTime();
    const simtime_t receptionStartTime = arrival->getStartTime();
    const simtime_t receptionEndTime = arrival->getEndTime();
    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);
    m distance = m(receptionStartPosition.distance(transmission->getStartPosition()));
    mps propagationSpeed = radioMedium->getPropagation()->getPropagationSpeed();
    const ConstMapping *transmissionPower = dimensionalSignalAnalogModel->getPower();
    EV_DEBUG << "Transmission power begin " << endl;
    transmissionPower->print(EVSTREAM);
    EV_DEBUG << "Transmission power end" << endl;
    const DimensionSet& dimensions = transmissionPower->getDimensionSet();
    bool hasTimeDimension = dimensions.hasDimension(Dimension::time);
    bool hasFrequencyDimension = dimensions.hasDimension(Dimension::frequency);
    ConstMappingIterator *it = transmissionPower->createConstIterator();
    Mapping *receptionPower = MappingUtils::createMapping(Argument::MappedZero, dimensions, interpolationMode);
    while (true) {
        const Argument& elementTransmissionPosition = it->getPosition();
        Hz carrierFrequency = attenuateWithCarrierFrequency || !hasFrequencyDimension ? narrowbandSignalAnalogModel->getCarrierFrequency() : Hz(elementTransmissionPosition.getArgValue(Dimension::frequency));
        double pathLoss = radioMedium->getPathLoss()->computePathLoss(propagationSpeed, carrierFrequency, distance);
        double obstacleLoss = radioMedium->getObstacleLoss() ? radioMedium->getObstacleLoss()->computeObstacleLoss(carrierFrequency, transmission->getStartPosition(), receptionStartPosition) : 1;
        W elementTransmissionPower = W(it->getValue());
        W elementReceptionPower = elementTransmissionPower * std::min(1.0, transmitterAntennaGain * receiverAntennaGain * pathLoss * obstacleLoss);
        Argument elementReceptionPosition = elementTransmissionPosition;
        if (hasTimeDimension) {
            if (elementTransmissionPosition.getTime() == transmissionStartTime)
                elementReceptionPosition.setTime(receptionStartTime);
            else if (elementTransmissionPosition.getTime() == transmissionEndTime)
                elementReceptionPosition.setTime(receptionEndTime);
            else {
                double alpha = (elementTransmissionPosition.getTime() - transmissionStartTime).dbl() / (transmissionEndTime - transmissionStartTime).dbl();
                simtime_t elementReceptionTime = (1 - alpha) * receptionStartTime.dbl() + alpha * receptionEndTime.dbl();
                elementReceptionPosition.setTime(elementReceptionTime);
            }
        }
        receptionPower->setValue(elementReceptionPosition, elementReceptionPower.get());
        if (it->hasNext())
            it->next();
        else
            break;
    }
    delete it;
    EV_DEBUG << "Reception power begin " << endl;
    receptionPower->print(EVSTREAM);
    EV_DEBUG << "Reception power end" << endl;
    return receptionPower;
}

const ISNIR * inet::physicallayer::DimensionalAnalogModelBase::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.

{
    const DimensionalReception *dimensionalReception = check_and_cast<const DimensionalReception *>(reception);
    const DimensionalNoise *dimensionalNoise = check_and_cast<const DimensionalNoise *>(noise);
    return new DimensionalSNIR(dimensionalReception, dimensionalNoise);
}

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

overrideprotectedvirtual

{
    AnalogModelBase::initialize(stage);
    if (stage == INITSTAGE_LOCAL) {
        attenuateWithCarrierFrequency = par("attenuateWithCarrierFrequency");
        const char *interpolationModeString = par("interpolationMode");
        if (!strcmp("linear", interpolationModeString))
            interpolationMode = Mapping::LINEAR;
        else if (!strcmp("sample-hold", interpolationModeString))
            interpolationMode = Mapping::STEPS;
        else
            throw cRuntimeError("Unknown interpolation mode: '%s'", interpolationModeString);
    }
}

std::ostream & inet::physicallayer::DimensionalAnalogModelBase::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::IPrintableObject.

Reimplemented in inet::physicallayer::LayeredDimensionalAnalogModel, and inet::physicallayer::DimensionalAnalogModel.

Referenced by inet::physicallayer::DimensionalAnalogModel::printToStream(), and inet::physicallayer::LayeredDimensionalAnalogModel::printToStream().

{
    if (level <= PRINT_LEVEL_TRACE)
        stream << ", attenuateWithCarrierFrequency = " << attenuateWithCarrierFrequency
               << ", interpolationMode = " << interpolationMode;
    return stream;
}

Member Data Documentation

bool inet::physicallayer::DimensionalAnalogModelBase::attenuateWithCarrierFrequency

protected

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

Mapping::InterpolationMethod inet::physicallayer::DimensionalAnalogModelBase::interpolationMode

protected

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

---

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

• DimensionalAnalogModelBase.h
• DimensionalAnalogModelBase.cc