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) const override
	Prints this object to the provided output stream. More...
virtual double	getMin () 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::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 double	computeMin () const

Protected Attributes
double	minSNIR
Protected Attributes inherited from inet::physicallayer::SNIRBase
const IReception *	reception
const INoise *	noise

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 }

Constructor & Destructor Documentation

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

                                                                                                     :
    SNIRBase(reception, noise),
    minSNIR(NaN)
{
}

Member Function Documentation

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

protectedvirtual

Referenced by getMin().

{
    const DimensionalNoise *dimensionalNoise = check_and_cast<const DimensionalNoise *>(noise);
    const DimensionalReception *dimensionalReception = check_and_cast<const DimensionalReception *>(reception);
    EV_DEBUG << "Reception power begin " << endl;
    dimensionalReception->getPower()->print(EVSTREAM);
    EV_DEBUG << "Reception power end" << endl;
    const ConstMapping *noisePower = dimensionalNoise->getPower();
    const ConstMapping *receptionPower = dimensionalReception->getPower();
    const ConstMapping *snirMapping = MappingUtils::divide(*receptionPower, *noisePower);
    const simtime_t startTime = reception->getStartTime();
    const simtime_t endTime = reception->getEndTime();
    Hz carrierFrequency = dimensionalReception->getCarrierFrequency();
    Hz bandwidth = dimensionalReception->getBandwidth();
    const DimensionSet& dimensions = receptionPower->getDimensionSet();
    Argument startArgument(dimensions);
    Argument endArgument(dimensions);
    if (dimensions.hasDimension(Dimension::time)) {
        startArgument.setTime(startTime);
        // NOTE: to exclude the moment where the reception power starts to be 0 again
        endArgument.setTime(MappingUtils::pre(endTime));
    }
    if (dimensions.hasDimension(Dimension::frequency)) {
        startArgument.setArgValue(Dimension::frequency, (carrierFrequency - bandwidth / 2).get());
        endArgument.setArgValue(Dimension::frequency, nexttoward((carrierFrequency + bandwidth / 2).get(), 0));
    }
    EV_DEBUG << "SNIR begin " << endl;
    snirMapping->print(EVSTREAM);
    EV_DEBUG << "SNIR end" << endl;
    double minSNIR = MappingUtils::findMin(*snirMapping, startArgument, endArgument);
    EV_DEBUG << "Computing minimum SNIR: start = " << startArgument << ", end = " << endArgument << " -> minimum SNIR = " << minSNIR << endl;
    delete snirMapping;
    return minSNIR;
}

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

overridevirtual

Implements inet::physicallayer::ISNIR.

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

std::ostream & inet::physicallayer::DimensionalSNIR::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::SNIRBase.

{
    stream << "DimensionalSNIR";
    if (level <= PRINT_LEVEL_DETAIL)
        stream << ", minSNIR = " << minSNIR;
    return SNIRBase::printToStream(stream, level);
}

Member Data Documentation

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