inet::physicallayer::DimensionalSnir Class Reference

#include <DimensionalSnir.h>

Inheritance diagram for inet::physicallayer::DimensionalSnir:

Public Member Functions
	DimensionalSnir (const DimensionalReception *reception, const DimensionalNoise *noise)
virtual std::ostream &	printToStream (std::ostream &stream, int level, int evFlags=0) const override
	Prints this object to the provided output stream. More...
virtual double	getMin () const override
virtual double	getMax () const override
virtual double	getMean () const override
Public Member Functions inherited from inet::physicallayer::SnirBase
	SnirBase (const IReception *reception, const INoise *noise)
virtual const IReception *	getReception () const override
virtual const INoise *	getNoise () const override
Public Member Functions inherited from inet::IPrintableObject
virtual	~IPrintableObject ()
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 double	computeMin () const
virtual double	computeMax () const
virtual double	computeMean () const

Protected Attributes
double	minSNIR
double	maxSNIR
double	meanSNIR
Protected Attributes inherited from inet::physicallayer::SnirBase
const IReception *	reception
const INoise *	noise

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

Constructor & Destructor Documentation

DimensionalSnir()

inet::physicallayer::DimensionalSnir::DimensionalSnir	(	const DimensionalReception *	reception,
		const DimensionalNoise *	noise
	)

                                                                                                     :
    SnirBase(reception, noise),
    minSNIR(NaN),
    maxSNIR(NaN),
    meanSNIR(NaN)
{
}

Member Function Documentation

computeMax()

double inet::physicallayer::DimensionalSnir::computeMax ( ) const

protectedvirtual

{
    // TODO factor out common part
    const DimensionalNoise *dimensionalNoise = check_and_cast<const DimensionalNoise *>(noise);
    const DimensionalReception *dimensionalReception = check_and_cast<const DimensionalReception *>(reception);
    EV_DEBUG << "Reception power begin " << endl;
    EV_DEBUG << *dimensionalReception->getPower() << endl;
    EV_DEBUG << "Reception power end" << endl;
    auto noisePower = dimensionalNoise->getPower();
    auto receptionPower = dimensionalReception->getPower();
    auto snir = receptionPower->divide(noisePower);
    auto startTime = simsec(reception->getStartTime());
    auto endTime = simsec(reception->getEndTime());
    Hz centerFrequency = dimensionalReception->getCenterFrequency();
    Hz bandwidth = dimensionalReception->getBandwidth();
    Point<simsec, Hz> startPoint(startTime, centerFrequency - bandwidth / 2);
    Point<simsec, Hz> endPoint(endTime, centerFrequency + bandwidth / 2);
    EV_TRACE << "SNIR begin " << endl;
    EV_TRACE << *snir << endl;
    EV_TRACE << "SNIR end" << endl;
    double maxSNIR = snir->getMax(Interval<simsec, Hz>(startPoint, endPoint, 0b1, 0b0, 0b0));
    EV_DEBUG << "Computing maximum SNIR" << EV_FIELD(startPoint) << EV_FIELD(endPoint) << EV_FIELD(maxSNIR) << endl;
    return maxSNIR;
}

Referenced by getMax().

computeMean()

double inet::physicallayer::DimensionalSnir::computeMean ( ) const

protectedvirtual

{
    // TODO factor out common part
    const DimensionalNoise *dimensionalNoise = check_and_cast<const DimensionalNoise *>(noise);
    const DimensionalReception *dimensionalReception = check_and_cast<const DimensionalReception *>(reception);
    EV_TRACE << "Reception power begin " << endl;
    EV_TRACE << *dimensionalReception->getPower() << endl;
    EV_TRACE << "Reception power end" << endl;
    auto noisePower = dimensionalNoise->getPower();
    auto receptionPower = dimensionalReception->getPower();
    auto snir = receptionPower->divide(noisePower);
    auto startTime = simsec(reception->getStartTime());
    auto endTime = simsec(reception->getEndTime());
    Hz centerFrequency = dimensionalReception->getCenterFrequency();
    Hz bandwidth = dimensionalReception->getBandwidth();
    Point<simsec, Hz> startPoint(startTime, centerFrequency - bandwidth / 2);
    Point<simsec, Hz> endPoint(endTime, centerFrequency + bandwidth / 2);
    EV_TRACE << "SNIR begin " << endl;
    EV_TRACE << *snir << endl;
    EV_TRACE << "SNIR end" << endl;
    double meanSNIR = snir->getMean(Interval<simsec, Hz>(startPoint, endPoint, 0b1, 0b0, 0b0));
    EV_DEBUG << "Computing mean SNIR" << EV_FIELD(startPoint) << EV_FIELD(endPoint) << EV_FIELD(meanSNIR) << endl;
    return meanSNIR;
}

Referenced by getMean().

computeMin()

double inet::physicallayer::DimensionalSnir::computeMin ( ) const

protectedvirtual

{
    // TODO factor out common part
    const DimensionalNoise *dimensionalNoise = check_and_cast<const DimensionalNoise *>(noise);
    const DimensionalReception *dimensionalReception = check_and_cast<const DimensionalReception *>(reception);
    EV_TRACE << "Reception power begin " << endl;
    EV_TRACE << *dimensionalReception->getPower() << endl;
    EV_TRACE << "Reception power end" << endl;
    auto noisePower = dimensionalNoise->getPower();
    auto receptionPower = dimensionalReception->getPower();
    auto snir = receptionPower->divide(noisePower);
    simsec startTime = simsec(reception->getStartTime());
    simsec endTime = simsec(reception->getEndTime());
    Hz centerFrequency = dimensionalReception->getCenterFrequency();
    Hz bandwidth = dimensionalReception->getBandwidth();
    Point<simsec, Hz> startPoint(startTime, centerFrequency - bandwidth / 2);
    Point<simsec, Hz> endPoint(endTime, centerFrequency + bandwidth / 2);
    EV_TRACE << "SNIR begin " << endl;
    EV_TRACE << *snir << endl;
    EV_TRACE << "SNIR end" << endl;
    double minSNIR = snir->getMin(Interval<simsec, Hz>(startPoint, endPoint, 0b1, 0b0, 0b0));
    EV_DEBUG << "Computing minimum SNIR" << EV_FIELD(startPoint) << EV_FIELD(endPoint) << EV_FIELD(minSNIR) << endl;
    return minSNIR;
}

Referenced by getMin().

getMax()

double inet::physicallayer::DimensionalSnir::getMax ( ) const

overridevirtual

Implements inet::physicallayer::ISnir.

{
    if (std::isnan(maxSNIR))
        maxSNIR = computeMax();
    return maxSNIR;
}

getMean()

double inet::physicallayer::DimensionalSnir::getMean ( ) const

overridevirtual

Implements inet::physicallayer::ISnir.

{
    if (std::isnan(meanSNIR))
        meanSNIR = computeMean();
    return meanSNIR;
}

getMin()

double inet::physicallayer::DimensionalSnir::getMin ( ) const

overridevirtual

Implements inet::physicallayer::ISnir.

{
    if (std::isnan(minSNIR))
        minSNIR = computeMin();
    return minSNIR;
}

printToStream()

std::ostream & inet::physicallayer::DimensionalSnir::printToStream ( std::ostream &  stream, int  level, int  evFlags = 0  ) const

overridevirtual

Prints this object to the provided output stream.

Reimplemented from inet::physicallayer::SnirBase.

{
    stream << "DimensionalSnir";
    if (level <= PRINT_LEVEL_DETAIL)
        stream << EV_FIELD(minSNIR);
    return SnirBase::printToStream(stream, level);
}

Member Data Documentation

maxSNIR

double inet::physicallayer::DimensionalSnir::maxSNIR

mutableprotected

Referenced by computeMax(), and getMax().

meanSNIR

double inet::physicallayer::DimensionalSnir::meanSNIR

mutableprotected

Referenced by computeMean(), and getMean().

minSNIR

double inet::physicallayer::DimensionalSnir::minSNIR

mutableprotected

Referenced by computeMin(), getMin(), and printToStream().

---

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

• DimensionalSnir.h
• DimensionalSnir.cc