inet::physicallayer::DimensionalAnalogModelBase Class Reference

#include <DimensionalAnalogModelBase.h>

Inheritance diagram for inet::physicallayer::DimensionalAnalogModelBase:

Public Member Functions
virtual const Ptr< const IFunction< WpHz, Domain< simsec, Hz > > >	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 INoise *	computeNoise (const IReception *reception, const INoise *noise) const override
	Returns the total noise summing up all the reception and the noise. 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::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

Protected Member Functions
virtual void	initialize (int stage) override
Protected Member Functions inherited from inet::physicallayer::AnalogModelBase
virtual double	computeAntennaGain (const IAntennaGain *antenna, const Coord &startPosition, const Coord &endPosition, const Quaternion &startOrientation) const

Protected Attributes
bool	attenuateWithCenterFrequency

Additional Inherited Members
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) }

Member Function Documentation

computeNoise() [1/2]

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 centerFrequency = bandListening->getCenterFrequency();
    Hz bandwidth = bandListening->getBandwidth();
    std::vector<Ptr<const IFunction<WpHz, Domain<simsec, Hz>>>> receptionPowers;
    const DimensionalNoise *dimensionalBackgroundNoise = check_and_cast_nullable<const DimensionalNoise *>(interference->getBackgroundNoise());
    if (dimensionalBackgroundNoise) {
        const auto& backgroundNoisePower = dimensionalBackgroundNoise->getPower();
        receptionPowers.push_back(backgroundNoisePower);
    }
    const std::vector<const IReception *> *interferingReceptions = interference->getInterferingReceptions();
    for (const auto& interferingReception : *interferingReceptions) {
        const DimensionalReception *dimensionalReception = check_and_cast<const DimensionalReception *>(interferingReception);
        auto receptionPower = dimensionalReception->getPower();
        receptionPowers.push_back(receptionPower);
        EV_TRACE << "Interference power begin " << endl;
        EV_TRACE << *receptionPower << endl;
        EV_TRACE << "Interference power end" << endl;
    }
    const Ptr<const IFunction<WpHz, Domain<simsec, Hz>>>& noisePower = makeShared<SummedFunction<WpHz, Domain<simsec, Hz>>>(receptionPowers);
    EV_TRACE << "Noise power begin " << endl;
    EV_TRACE << *noisePower << endl;
    EV_TRACE << "Noise power end" << endl;
    const auto& bandpassFilter = makeShared<Boxcar2DFunction<double, simsec, Hz>>(simsec(listening->getStartTime()), simsec(listening->getEndTime()), centerFrequency - bandwidth / 2, centerFrequency + bandwidth / 2, 1);
    return new DimensionalNoise(listening->getStartTime(), listening->getEndTime(), centerFrequency, bandwidth, noisePower->multiply(bandpassFilter));
}

computeNoise() [2/2]

const INoise * inet::physicallayer::DimensionalAnalogModelBase::computeNoise ( const IReception *  reception, const INoise *  noise  ) const

overridevirtual

Returns the total noise summing up all the reception and the noise.

This function never returns nullptr.

Implements inet::physicallayer::IAnalogModel.

{
    auto dimensionalReception = check_and_cast<const DimensionalReception *>(reception);
    auto dimensionalNoise = check_and_cast<const DimensionalNoise *>(noise);
    const Ptr<const IFunction<WpHz, Domain<simsec, Hz>>>& noisePower = makeShared<AddedFunction<WpHz, Domain<simsec, Hz>>>(dimensionalReception->getPower(), dimensionalNoise->getPower());
    return new DimensionalNoise(reception->getStartTime(), reception->getEndTime(), dimensionalReception->getCenterFrequency(), dimensionalReception->getBandwidth(), noisePower);
}

computeReceptionPower()

const Ptr< const IFunction< WpHz, Domain< simsec, Hz > > > inet::physicallayer::DimensionalAnalogModelBase::computeReceptionPower ( const IRadio *  radio, const ITransmission *  transmission, const IArrival *  arrival  ) const

virtual

{
    const IRadioMedium *radioMedium = receiverRadio->getMedium();
    const DimensionalTransmission *dimensionalTransmission = check_and_cast<const DimensionalTransmission *>(transmission);
    const IDimensionalSignal *dimensionalSignalAnalogModel = check_and_cast<const IDimensionalSignal *>(transmission->getAnalogModel());
    const Coord& transmissionStartPosition = transmission->getStartPosition();
    const Coord& receptionStartPosition = arrival->getStartPosition();
    double transmitterAntennaGain = computeAntennaGain(transmission->getTransmitterAntennaGain(), transmissionStartPosition, arrival->getStartPosition(), transmission->getStartOrientation());
    double receiverAntennaGain = computeAntennaGain(receiverRadio->getAntenna()->getGain().get(), arrival->getStartPosition(), transmissionStartPosition, arrival->getStartOrientation());
    const auto& transmissionPowerFunction = dimensionalSignalAnalogModel->getPower();
    EV_TRACE << "Transmission power begin " << endl;
    EV_TRACE << *transmissionPowerFunction << endl;
    EV_TRACE << "Transmission power end" << endl;
    Point<simsec, Hz> propagationShift(simsec(arrival->getStartTime() - transmission->getStartTime()), Hz(0));
    const auto& propagatedTransmissionPowerFunction = makeShared<DomainShiftedFunction<WpHz, Domain<simsec, Hz>>>(transmissionPowerFunction, propagationShift);
    Ptr<const IFunction<double, Domain<simsec, Hz>>> attenuationFunction = makeShared<FrequencyDependentAttenuationFunction>(radioMedium, transmitterAntennaGain, receiverAntennaGain, transmissionStartPosition, receptionStartPosition);
    Ptr<const IFunction<WpHz, Domain<simsec, Hz>>> receptionPower;
    if (attenuateWithCenterFrequency) {
        const auto& constantAttenuationFunction = makeShared<ConstantFunction<double, Domain<simsec, Hz>>>(attenuationFunction->getValue(Point<simsec, Hz>(simsec(0), dimensionalTransmission->getCenterFrequency())));
        receptionPower = propagatedTransmissionPowerFunction->multiply(constantAttenuationFunction);
    }
    else {
        Hz lower = dimensionalTransmission->getCenterFrequency() - dimensionalTransmission->getBandwidth() / 2;
        Hz upper = dimensionalTransmission->getCenterFrequency() + dimensionalTransmission->getBandwidth() / 2;
        Hz step = dimensionalTransmission->getBandwidth() / 10; // TODO parameter for 10
        const auto& approximatedAttenuationFunction = makeShared<ApproximatedFunction<double, Domain<simsec, Hz>, 1, Hz>>(lower, upper, step, &AverageInterpolator<Hz, double>::singleton, attenuationFunction);
        receptionPower = propagatedTransmissionPowerFunction->multiply(approximatedAttenuationFunction);
    }
    EV_TRACE << "Reception power begin " << endl;
    EV_TRACE << *receptionPower << endl;
    EV_TRACE << "Reception power end" << endl;
    return receptionPower;
}

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

computeSNIR()

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

initialize()

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

overrideprotectedvirtual

{
    AnalogModelBase::initialize(stage);
    if (stage == INITSTAGE_LOCAL)
        attenuateWithCenterFrequency = par("attenuateWithCenterFrequency"); // TODO rename center
}

Member Data Documentation

attenuateWithCenterFrequency

bool inet::physicallayer::DimensionalAnalogModelBase::attenuateWithCenterFrequency

protected

Referenced by computeReceptionPower(), and initialize().

---

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

• DimensionalAnalogModelBase.h
• DimensionalAnalogModelBase.cc