CommunityMov Class Reference

#include <CommunityMov.h>

List of all members.

Protected Member Functions
virtual void	initialize (int)
	Initializes mobility model parameters.
virtual void	normalize_coordinate (Coord *position)
	translating position to an only positive system
virtual simtime_t	extract_stoptime ()
	extracts the stop time of the simulation from the tracefile
virtual void	setTargetPosition ()
	sets the next target of the node
virtual void	extractDataFrom (cXMLElement *node)
	extract data from given <position_update> element
virtual void	fixIfHostGetsOutside ()
	overridden from LineSegmentsMobilityBase
virtual void	setInitialPosition (cXMLElement *elem)
	set the initial position of the node
Protected Attributes
int	nodeId
	we'll have to compare this to the <node_id> elements
simtime_t	sim_stop
	The mobility simulation duration.
cXMLElement *	nextPosChange
	points to the next <position_change> element
cXMLElement *	rootElem
	point to the root element of the file

---

Member Function Documentation

simtime_t CommunityMov::extract_stoptime

(

)

[protected, virtual]

extracts the stop time of the simulation from the tracefile

{
        // get script: param should point to <simulation> element
        cXMLElement *xmlElem = par("MobilityTrace");

        if (strcmp(xmlElem->getTagName(),"simulation")!=0)
                error("MobilityTrace: <simulation> is expected as root element not <%s> at %s", xmlElem->getTagName(), xmlElem->getSourceLocation());

        usleep(10000);

        //Looking for stoptime tag
        xmlElem = xmlElem->getElementByPath("statistics");
        if (!xmlElem)
                error("element doesn't have <statistics> child at %s", xmlElem->getSourceLocation());

        //Read stoptime value
        const char *stoptime = firstChildWithTag(xmlElem, "stoptime")->getNodeValue();

        //Return stoptime as double
        return(atof(stoptime));
}

void CommunityMov::extractDataFrom

(

cXMLElement *

node

)

[protected, virtual]

extract data from given <position_update> element

{
        double end_time;
        double duration;
        double imag_duration;
        double distance;

    // extract data from <position_update> element
    const char *startTimeStr = firstChildWithTag(node, "start_time")->getNodeValue();
    cXMLElement *destElem = firstChildWithTag(node, "destination");
    const char *xStr = firstChildWithTag(destElem, "xpos")->getNodeValue();
    const char *yStr = firstChildWithTag(destElem, "ypos")->getNodeValue();
    const char *velocity = firstChildWithTag(node, "velocity")->getNodeValue();

    //If XML file not in correct format give error
    if (!velocity || !xStr || !yStr)
        error("no content in <velocity>, <destination>/<xpos> or <ypos> element at %s", node->getSourceLocation());

    //Normalize and set goal coordinates and
    targetPos.x=atof(xStr);
    targetPos.y=atof(yStr);
    normalize_coordinate(&targetPos);

    //Calculate the ideal movement distance and duration
    distance = sqrt(pow(targetPos.x - pos.x,2)+pow(targetPos.y - pos.y,2));

    //Check if node is paused
    if(atof(velocity)!=0)
        imag_duration = distance/atof(velocity);
    else
        imag_duration = sim_stop.dbl();

    //Look for next <position_update> to extract targetTime
    cXMLElement *nextElem = node->getNextSibling();
    while (nextElem)
    {
        const char *nodeIdStr = firstChildWithTag(nextElem, "node_id")->getNodeValue();
        if (nodeIdStr && atoi(nodeIdStr)==nodeId)
            break;
        nextElem = nextElem->getNextSibling();
    }

    //If this is the last move calculate targetTime only according to given velocity
    if (!nextElem)
    {
        targetTime = imag_duration + atof(startTimeStr);
        //Set maximum target at targetTime
        if(targetTime>sim_stop) {
                targetTime=sim_stop;
        }
    }
    //else set targetTime the start time of the next movement
    else
    {
        end_time = atof(firstChildWithTag(nextElem, "start_time")->getNodeValue());
        targetTime = end_time;
        //Calculate the real duration of this movement
        duration = end_time - atof(startTimeStr);

        //In case next element wasn't written properly to have start_time
        if (!firstChildWithTag(nextElem, "start_time")->getNodeValue())
               error("no content in <start_time> at %s", nextElem->getSourceLocation());
    }
}

void CommunityMov::fixIfHostGetsOutside

(

)

[protected, virtual]

overridden from LineSegmentsMobilityBase

{
    raiseErrorIfOutside();
}

void CommunityMov::initialize

(

int

stage

)

[protected, virtual]

Initializes mobility model parameters.

{
    BasicMobility::initialize(stage);

    EV << "initializing CommunityMov stage " << stage << endl;

    if (stage == 1)
    {
        //Read ned parameters
        updateInterval = par("updateInterval");
        stationary = par("stationary");

        //Find simulation duration
        sim_stop=extract_stoptime();

        nodeId = par("nodeId");
        if (nodeId == -1)
            nodeId = getParentModule()->getIndex();

        // get script: param should point to <simulation> element
        rootElem = par("MobilityTrace");
        //std::cout << rootElem->getTagName() << endl;
        if (strcmp(rootElem->getTagName(),"simulation")!=0)
            error("MobilityTrace: <simulation> is expected as root element not <%s> at %s", rootElem->getTagName(), rootElem->getSourceLocation());

        //Set initial position
        setInitialPosition(rootElem);

        //Looking for first position_change tag
        nextPosChange = rootElem->getElementByPath("mobility/position_change");
        if (!nextPosChange)
            error("element doesn't have <mobility> child or <position_change> grandchild at %s", rootElem->getSourceLocation());

        // host moves for the first time now
        beginNextMove(new cMessage("move"));

        WATCH(pos);
        WATCH(targetPos);
        WATCH(step);
    }
}

void CommunityMov::normalize_coordinate

(

Coord *

position

)

[protected, virtual]

translating position to an only positive system

{
        int playgroundlength = getParentModule()->getParentModule()->par("playgroundSizeX");
        int playgroundwidth = getParentModule()->getParentModule()->par("playgroundSizeY");

        position->x+=(playgroundlength/2);
        position->y+=(playgroundwidth/2);
}

void CommunityMov::setInitialPosition

(

cXMLElement *

elem

)

[protected, virtual]

set the initial position of the node

{
        //Go to <node_settings>/<node> in xml file
        nextPosChange = elem->getElementByPath("node_settings/node");
        if (!nextPosChange)
            error("element doesn't have <node_settings> child or <node> grandchild at %s", elem->getSourceLocation());

        //Find the first child with the specific node_id
        while (nextPosChange)
        {
                const char *nodeIdStr = firstChildWithTag(nextPosChange, "node_id")->getNodeValue();
                if (nodeIdStr && atoi(nodeIdStr)==nodeId)
                        break;
                nextPosChange = nextPosChange->getNextSibling();
        }
        cXMLElement *posElem = firstChildWithTag(nextPosChange, "position");
        pos.x =atof( firstChildWithTag(posElem, "xpos")->getNodeValue() );
        pos.y =atof( firstChildWithTag(posElem, "ypos")->getNodeValue() );

        //Translating coordinates to only positive system and saving them to pos variable
        normalize_coordinate(&pos);
        updatePosition();

        //There is no target - initial position
        targetPos.x=pos.x;
        targetPos.y=pos.y;
}

void CommunityMov::setTargetPosition

(

)

[protected, virtual]

sets the next target of the node

{
    // find next <position_update> element with matching <node_id> tag (current one also OK)

    while (nextPosChange)
    {
        const char *nodeIdStr = firstChildWithTag(nextPosChange, "node_id")->getNodeValue();
        if (nodeIdStr && atoi(nodeIdStr)==nodeId)
            break;
        nextPosChange = nextPosChange->getNextSibling();
    }

    if (!nextPosChange)
    {
        stationary = true;
        //par("stationary")=true;
        return;
    }

    // extract data from it
    extractDataFrom(nextPosChange);

    // skip this one
    nextPosChange = nextPosChange->getNextSibling();
}

---

Member Data Documentation

cXMLElement* CommunityMov::nextPosChange [protected]

points to the next <position_change> element

int CommunityMov::nodeId [protected]

we'll have to compare this to the <node_id> elements

cXMLElement* CommunityMov::rootElem [protected]

point to the root element of the file

simtime_t CommunityMov::sim_stop [protected]

The mobility simulation duration.

---

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

• CommunityMov.h
• CommunityMov.cc