#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::physicallayer::IPrintableObject
enum	PrintLevel { PRINT_LEVEL_TRACE, PRINT_LEVEL_DEBUG, PRINT_LEVEL_DETAIL, PRINT_LEVEL_INFO, PRINT_LEVEL_COMPLETE = INT_MIN }

Public Member Functions
	GridNeighborCache ()

virtual	~GridNeighborCache ()

virtual std::ostream &	printToStream (std::ostream &stream, int level) 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 IRadioFrame frame, 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::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 int	numInitStages () const override

virtual void	initialize (int stage) override

virtual void	handleMessage (cMessage *msg) override

void	fillCubeVector ()

Protected Attributes
SpatialGrid *	grid

Radios	radios

RadioMedium *	radioMedium

Coord	constraintAreaMin

Coord	constraintAreaMax

cMessage *	refillCellsTimer

double	refillPeriod

double	maxSpeed

Coord	cellSize

Member Typedef Documentation

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

Constructor & Destructor Documentation

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

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

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

virtual

 {
     cancelAndDelete(refillCellsTimer);
     delete grid;
 }

Member Function Documentation

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())
         scheduleAt(simTime() + 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);
 }

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

protected

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

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

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();
     scheduleAt(simTime() + refillPeriod, msg);
 }

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

overrideprotectedvirtual

 {
     if (stage == INITSTAGE_LOCAL) {
         radioMedium = getModuleFromPar<RadioMedium>(par("radioMediumModule"), this);
         cellSize.x = par("cellSizeX");
         cellSize.y = par("cellSizeY");
         cellSize.z = par("cellSizeZ");
         refillPeriod = par("refillPeriod");
         refillCellsTimer = new cMessage("refillCellsTimer");
     }
     else if (stage == INITSTAGE_LINK_LAYER_2) {
         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();
         scheduleAt(simTime() + refillPeriod, refillCellsTimer);
     }
 }

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

inlineoverrideprotectedvirtual

57 { return NUM_INIT_STAGES; }

inet::NUM_INIT_STAGES

The number of initialization stages.

Definition: InitStages.h:116

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

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

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

overridevirtual

Implements inet::physicallayer::INeighborCache.

 {
     auto it = find(radios.begin(), radios.end(), 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());
     }
 }

void inet::physicallayer::GridNeighborCache::sendToNeighbors	(	IRadio *	transmitter,
		const IRadioFrame *	frame,
		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, frame);
     grid->rangeQuery(transmitterPos, radius, &visitor);
 }