#include <Vivaldi.h>

Inheritance diagram for Vivaldi:

Public Member Functions
virtual	~Vivaldi ()
virtual void	init (NeighborCache *neighborCache)
void	processCoordinates (const simtime_t &rtt, const AbstractNcsNodeInfo &nodeInfo)
Prox	getCoordinateBasedProx (const AbstractNcsNodeInfo &info) const
virtual AbstractNcsNodeInfo *	getUnvalidNcsInfo () const
virtual AbstractNcsNodeInfo *	createNcsInfo (const std::vector< double > &coords) const
const VivaldiCoordsInfo &	getOwnNcsInfo () const
const std::vector< double > &	getOwnCoordinates () const
double	getOwnError () const
double	getOwnHeightVector () const
Protected Member Functions
virtual void	finishVivaldi ()
virtual void	updateDisplay ()
virtual double	calcError (const simtime_t &rtt, double dist, double weight)
virtual double	calcDelta (const simtime_t &rtt, double dist, double weight)
Protected Attributes
VivaldiCoordsInfo *	ownCoords
double	errorC
double	coordC
bool	showPosition
GlobalStatistics *	globalStatistics
NeighborCache *	neighborCache
Private Attributes
bool	enableHeightVector
uint32_t	dimension

Detailed Description

Definition at line 39 of file Vivaldi.h.

Constructor & Destructor Documentation

virtual Vivaldi::~Vivaldi ( ) [inline, virtual]

Definition at line 66 of file Vivaldi.h.

{ delete ownCoords; };

Member Function Documentation

double Vivaldi::calcDelta	(	const simtime_t &	rtt,
		double	dist,
		double	weight
	)			`[protected, virtual]`

Reimplemented in SVivaldi.

Definition at line 115 of file Vivaldi.cc.

Referenced by processCoordinates().

{
    // estimates the delta factor
    return coordC * weight;
}

double Vivaldi::calcError	(	const simtime_t &	rtt,
		double	dist,
		double	weight
	)			`[protected, virtual]`

Reimplemented in SVivaldi.

Definition at line 102 of file Vivaldi.cc.

Referenced by processCoordinates().

{
    double relErr = 0;
    if (rtt != 0) {
        //eSample computes the relative error for this sample
        relErr = fabs(dist - rtt) / rtt;
    }
    // update weighted moving average of local error
    return (relErr * errorC * weight) +
           ownCoords->getError() * (1 - errorC * weight);
}

AbstractNcsNodeInfo * Vivaldi::createNcsInfo ( const std::vector< double > & coords ) const [virtual]

Implements AbstractNcs.

Definition at line 128 of file Vivaldi.cc.

{
    assert(coords.size() > 1);
    VivaldiCoordsInfo* info = new VivaldiCoordsInfo();

    uint8_t i;
    for (i = 0; i < coords.size() - (enableHeightVector ? 2 : 1); ++i) {
        info->setCoords(i, coords[i]);
    }
    info->setError(coords[i++]);

    if (enableHeightVector) {
        info->setHeightVector(coords[i]);
    }

    return info;
}

void Vivaldi::finishVivaldi ( ) [protected, virtual]

Definition at line 163 of file Vivaldi.cc.

{
    globalStatistics->addStdDev("Vivaldi: Errori(ei)", ownCoords->getError());
}

Prox Vivaldi::getCoordinateBasedProx ( const AbstractNcsNodeInfo & info ) const [virtual]

Implements AbstractNcs.

Definition at line 122 of file Vivaldi.cc.

{
    return ownCoords->getDistance(abstractInfo);
}

const std::vector<double>& Vivaldi::getOwnCoordinates ( ) const [inline]

Definition at line 78 of file Vivaldi.h.

{ return ownCoords->getCoords(); };

double Vivaldi::getOwnError ( ) const [inline]

Definition at line 79 of file Vivaldi.h.

{ return ownCoords->getError(); };

double Vivaldi::getOwnHeightVector ( ) const [inline]

Definition at line 80 of file Vivaldi.h.

{ return ownCoords->getHeightVector(); };

const VivaldiCoordsInfo& Vivaldi::getOwnNcsInfo ( ) const [inline, virtual]

Implements AbstractNcs.

Definition at line 77 of file Vivaldi.h.

{ return *ownCoords; };

virtual AbstractNcsNodeInfo* Vivaldi::getUnvalidNcsInfo ( ) const [inline, virtual]

Implements AbstractNcs.

Definition at line 74 of file Vivaldi.h.

{ return new VivaldiCoordsInfo(enableHeightVector); };

void Vivaldi::init ( NeighborCache * neighborCache ) [virtual]

Implements AbstractNcs.

Reimplemented in SVivaldi.

Definition at line 32 of file Vivaldi.cc.

{
    this->neighborCache = neighborCache;

    errorC = neighborCache->par("vivaldiErrorConst");
    coordC = neighborCache->par("vivaldiCoordConst");
    dimension = neighborCache->par("vivaldiDimConst");
    enableHeightVector = neighborCache->par("vivaldiEnableHeightVector");
    showPosition = neighborCache->par("vivaldiShowPosition");

    // init variables
    VivaldiCoordsInfo::setDimension(dimension);
    ownCoords = new VivaldiCoordsInfo();

    for (uint32_t i = 0; i < dimension; i++) {
        ownCoords->setCoords(i, uniform(-.2, .2));
    }
    if (enableHeightVector) ownCoords->setHeightVector(0.0);

    WATCH(*ownCoords);

    globalStatistics = GlobalStatisticsAccess().get();
};

void Vivaldi::processCoordinates	(	const simtime_t &	rtt,
		const AbstractNcsNodeInfo &	nodeInfo
	)			`[virtual]`

Reimplemented from AbstractNcs.

Definition at line 56 of file Vivaldi.cc.

{
    if (rtt <= 0.0) {
        std::cout << "Vivaldi::processCoordinates() called with rtt = "
                  << rtt << std::endl;
        return;
    }

    if (!dynamic_cast<const VivaldiCoordsInfo*>(&nodeInfo)) {
        throw cRuntimeError("Vivaldi coords needed!");
    }
    const VivaldiCoordsInfo& info =
        *(static_cast<const VivaldiCoordsInfo*>(&nodeInfo));

    // calculate weight
    double weight = (((ownCoords->getError() + info.getError()) == 0) ? 0 :
        (ownCoords->getError() / (ownCoords->getError() + info.getError())));

    // calculate distance
    double dist = ownCoords->getDistance(info).proximity;

    // ... own error
    ownCoords->setError(calcError(rtt, dist, weight));

    // delta
    double delta = calcDelta(rtt, dist, weight);

    // update local coordinates
    if (dist > 0) {
        for (uint8_t i = 0; i < dimension; i++) {
            ownCoords->setCoords(i, ownCoords->getCoords(i) +
                                    (delta * (SIMTIME_DBL(rtt) - dist)) *
                                    ((ownCoords->getCoords(i) - info.getCoords(i)) /
                                     dist));
        }
        if(enableHeightVector) {
            ownCoords->setHeightVector(ownCoords->getHeightVector() +
                                      (delta * (SIMTIME_DBL(rtt) - dist)));
        }
    }

    updateDisplay();
}

void Vivaldi::updateDisplay ( ) [protected, virtual]

Definition at line 147 of file Vivaldi.cc.

Referenced by processCoordinates().

{
    char buf[60];
    sprintf(buf, "xi[0]: %f xi[1]: %f ", ownCoords->getCoords(0),
            ownCoords->getCoords(1));
    neighborCache->getDisplayString().setTagArg("t", 0, buf);

    // show nodes at estimated position TODO
    if (showPosition) {
        for (uint32_t i = 0; i < dimension; i++)
            neighborCache->getParentModule()
                ->getDisplayString().setTagArg("p", i,
                                               ownCoords->getCoords(i) * 1000);
    }
}