inet::physicallayer::GridNeighborCache Class Reference

#include <GridNeighborCache.h>

Inheritance diagram for inet::physicallayer::GridNeighborCache:

Classes
class	GridNeighborCacheVisitor

Public Types
typedef std::vector< const IRadio * >	Radios
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) }

Public Member Functions
	GridNeighborCache ()
virtual	~GridNeighborCache ()
virtual std::ostream &	printToStream (std::ostream &stream, int level, int evFlags=0) const override
	Prints this object to the provided output stream. More...
virtual void	addRadio (const IRadio *radio) override
virtual void	removeRadio (const IRadio *radio) override
virtual void	sendToNeighbors (IRadio *transmitter, const IWirelessSignal *signal, double range) const override
	Sends the provided frame (using the radio medium) to all neighbors within the given range. More...
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 int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessage (cMessage *msg) override
void	fillCubeVector ()

Protected Attributes
SpatialGrid *	grid
Radios	radios
ModuleRefByPar< RadioMedium >	radioMedium
Coord	constraintAreaMin
Coord	constraintAreaMax
cMessage *	refillCellsTimer
double	refillPeriod
double	maxSpeed
Coord	cellSize

Member Typedef Documentation

Radios

typedef std::vector<const IRadio *> inet::physicallayer::GridNeighborCache::Radios

Constructor & Destructor Documentation

GridNeighborCache()

inet::physicallayer::GridNeighborCache::GridNeighborCache

(

)

                                     :
    grid(nullptr),
    constraintAreaMin(Coord::NIL),
    constraintAreaMax(Coord::NIL),
    refillCellsTimer(nullptr),
    refillPeriod(NaN),
    maxSpeed(NaN),
    cellSize(Coord::NIL)
{
}

~GridNeighborCache()

inet::physicallayer::GridNeighborCache::~GridNeighborCache ( )

virtual

{
    cancelAndDelete(refillCellsTimer);
    delete grid;
}

Member Function Documentation

addRadio()

void inet::physicallayer::GridNeighborCache::addRadio ( const IRadio *  radio )

overridevirtual

Implements inet::physicallayer::INeighborCache.

{
    radios.push_back(radio);
    Coord radioPos = radio->getAntenna()->getMobility()->getCurrentPosition();
    maxSpeed = radioMedium->getMediumLimitCache()->getMaxSpeed().get();
    if (maxSpeed != 0 && !refillCellsTimer->isScheduled() && initialized())
        scheduleAfter(refillPeriod, refillCellsTimer);
    Coord newConstraintAreaMin = radioMedium->getMediumLimitCache()->getMinConstraintArea();
    Coord newConstraintAreaMax = radioMedium->getMediumLimitCache()->getMaxConstraintArea();
    // If the constraintArea changed we must rebuild the grid
    if (newConstraintAreaMin != constraintAreaMin || newConstraintAreaMax != constraintAreaMax) {
        constraintAreaMin = newConstraintAreaMin;
        constraintAreaMax = newConstraintAreaMax;
        if (initialized())
            fillCubeVector();
    }
    else if (initialized())
        grid->insertPoint(check_and_cast<const cObject *>(radio), radioPos);
}

fillCubeVector()

void inet::physicallayer::GridNeighborCache::fillCubeVector ( )

protected

{
    delete grid;
    grid = new SpatialGrid(cellSize, constraintAreaMin, constraintAreaMax);
    for (auto& elem : radios) {
        const IRadio *radio = elem;
        Coord radioPos = radio->getAntenna()->getMobility()->getCurrentPosition();
        grid->insertPoint(check_and_cast<const cObject *>(radio), radioPos);
    }
}

Referenced by addRadio(), handleMessage(), initialize(), and removeRadio().

handleMessage()

void inet::physicallayer::GridNeighborCache::handleMessage ( cMessage *  msg )

overrideprotectedvirtual

{
    if (!msg->isSelfMessage())
        throw cRuntimeError("This module only handles self messages");
    EV_DETAIL << "Updating the grid cells" << endl;
    fillCubeVector();
    scheduleAfter(refillPeriod, msg);
}

initialize()

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

overrideprotectedvirtual

{
    if (stage == INITSTAGE_LOCAL) {
        radioMedium.reference(this, "radioMediumModule", true);
        cellSize.x = par("cellSizeX");
        cellSize.y = par("cellSizeY");
        cellSize.z = par("cellSizeZ");
        refillPeriod = par("refillPeriod");
        refillCellsTimer = new cMessage("refillCellsTimer");
    }
    else if (stage == INITSTAGE_PHYSICAL_LAYER_NEIGHBOR_CACHE) {
        constraintAreaMin = radioMedium->getMediumLimitCache()->getMinConstraintArea();
        constraintAreaMax = radioMedium->getMediumLimitCache()->getMaxConstraintArea();
        maxSpeed = radioMedium->getMediumLimitCache()->getMaxSpeed().get();
        const Coord constraintAreaSize = constraintAreaMax - constraintAreaMin;
        if (std::isnan(cellSize.x))
            cellSize.x = constraintAreaSize.x / par("cellCountX").doubleValue();
        if (std::isnan(cellSize.y))
            cellSize.y = constraintAreaSize.y / par("cellCountY").doubleValue();
        if (std::isnan(cellSize.z))
            cellSize.z = constraintAreaSize.z / par("cellCountZ").doubleValue();
        fillCubeVector();
        scheduleAfter(refillPeriod, refillCellsTimer);
    }
}

numInitStages()

virtual int inet::physicallayer::GridNeighborCache::numInitStages ( ) const

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

printToStream()

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

overridevirtual

Prints this object to the provided output stream.

Reimplemented from inet::IPrintableObject.

{
    stream << "GridNeighborCache";
    if (level <= PRINT_LEVEL_TRACE)
        stream << EV_FIELD(cellSize)
               << EV_FIELD(refillPeriod)
               << EV_FIELD(maxSpeed);
    return stream;
}

removeRadio()

void inet::physicallayer::GridNeighborCache::removeRadio ( const IRadio *  radio )

overridevirtual

Implements inet::physicallayer::INeighborCache.

{
    auto it = find(radios, radio);
    if (it != radios.end()) {
        radios.erase(it);
        Coord newConstraintAreaMin = radioMedium->getMediumLimitCache()->getMinConstraintArea();
        Coord newConstraintAreaMax = radioMedium->getMediumLimitCache()->getMaxConstraintArea();
        if (newConstraintAreaMin != constraintAreaMin || newConstraintAreaMax != constraintAreaMax) {
            constraintAreaMin = newConstraintAreaMin;
            constraintAreaMax = newConstraintAreaMax;
        }
        maxSpeed = radioMedium->getMediumLimitCache()->getMaxSpeed().get();
        fillCubeVector();
        if (maxSpeed == 0 && initialized())
            cancelEvent(refillCellsTimer);
    }
    else {
        throw cRuntimeError("You can't remove radio: %d because it is not in our radio vector", radio->getId());
    }
}

sendToNeighbors()

void inet::physicallayer::GridNeighborCache::sendToNeighbors ( IRadio *  transmitter, const IWirelessSignal *  signal, double  range  ) const

overridevirtual

Sends the provided frame (using the radio medium) to all neighbors within the given range.

Implements inet::physicallayer::INeighborCache.

{
    double radius = range + (maxSpeed * refillPeriod);
    Coord transmitterPos = transmitter->getAntenna()->getMobility()->getCurrentPosition();
    GridNeighborCacheVisitor visitor(radioMedium, transmitter, signal);
    grid->rangeQuery(transmitterPos, radius, &visitor);
}

Member Data Documentation

cellSize

Coord inet::physicallayer::GridNeighborCache::cellSize

protected

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

constraintAreaMax

Coord inet::physicallayer::GridNeighborCache::constraintAreaMax

protected

Referenced by addRadio(), fillCubeVector(), initialize(), and removeRadio().

constraintAreaMin

Coord inet::physicallayer::GridNeighborCache::constraintAreaMin

protected

Referenced by addRadio(), fillCubeVector(), initialize(), and removeRadio().

grid

SpatialGrid* inet::physicallayer::GridNeighborCache::grid

protected

Referenced by addRadio(), fillCubeVector(), sendToNeighbors(), and ~GridNeighborCache().

maxSpeed

double inet::physicallayer::GridNeighborCache::maxSpeed

protected

Referenced by addRadio(), initialize(), printToStream(), removeRadio(), and sendToNeighbors().

radioMedium

ModuleRefByPar<RadioMedium> inet::physicallayer::GridNeighborCache::radioMedium

protected

Referenced by addRadio(), initialize(), removeRadio(), and sendToNeighbors().

radios

Radios inet::physicallayer::GridNeighborCache::radios

protected

Referenced by addRadio(), fillCubeVector(), and removeRadio().

refillCellsTimer

cMessage* inet::physicallayer::GridNeighborCache::refillCellsTimer

protected

Referenced by addRadio(), initialize(), removeRadio(), and ~GridNeighborCache().

refillPeriod

double inet::physicallayer::GridNeighborCache::refillPeriod

protected

Referenced by addRadio(), handleMessage(), initialize(), printToStream(), and sendToNeighbors().

---

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

• GridNeighborCache.h
• GridNeighborCache.cc