inet::SuperpositioningMobility Class Reference

#include <SuperpositioningMobility.h>

Inheritance diagram for inet::SuperpositioningMobility:

Public Member Functions
virtual const Coord &	getCurrentPosition () override
	Returns the position at the current simulation time. More...
virtual const Coord &	getCurrentVelocity () override
	Returns the velocity at the current simulation time. More...
virtual const Coord &	getCurrentAcceleration () override
	Returns the acceleration at the current simulation time. More...
virtual const Quaternion &	getCurrentAngularPosition () override
	Returns the angular position at the current simulation time. More...
virtual const Quaternion &	getCurrentAngularVelocity () override
	Returns the angular velocity at the current simulation time. More...
virtual const Quaternion &	getCurrentAngularAcceleration () override
	Returns the angular acceleration at the current simulation time. More...
virtual void	receiveSignal (cComponent *source, simsignal_t signal, cObject *object, cObject *details) override
Public Member Functions inherited from inet::MobilityBase
virtual double	getMaxSpeed () const override
	Returns the maximum possible speed at any future time. More...
virtual const Coord &	getConstraintAreaMax () const override
	Returns the maximum position along each axes for. More...
virtual const Coord &	getConstraintAreaMin () const override
	Returns the minimum position along each axes for. More...
Public Member Functions inherited from inet::IMobility
virtual	~IMobility ()

Protected Types
enum	PositionComposition {   PositionComposition::PC_UNDEFINED = -1, PositionComposition::PC_ZERO, PositionComposition::PC_SUM, PositionComposition::PC_AVERAGE,   PositionComposition::PC_ELEMENT }
enum	OrientationComposition {   OrientationComposition::OC_UNDEFINED = -1, OrientationComposition::OC_ZERO, OrientationComposition::OC_SUM, OrientationComposition::OC_AVERAGE,   OrientationComposition::OC_FACE_FORWARD, OrientationComposition::OC_ELEMENT }

Protected Member Functions
virtual int	numInitStages () const override
	Returns the required number of initialize stages. More...
virtual void	initialize (int stage) override
	Initializes mobility model parameters. More...
virtual void	handleSelfMessage (cMessage *msg) override
	Called upon arrival of a self messages, subclasses must override. More...
virtual void	setInitialPosition () override
	Initializes the position from the display string or from module parameters. More...
Protected Member Functions inherited from inet::MobilityBase
	MobilityBase ()
virtual int	getId () const override
virtual void	initializePosition ()
	Initializes mobility position. More...
virtual void	checkPosition ()
	Checks whether the position is valid or not. More...
virtual void	initializeOrientation ()
	Initializes the orientation from module parameters. More...
virtual void	refreshDisplay () const override
	Moves the visual representation module's icon to the new position on the screen. More...
virtual void	updateDisplayStringFromMobilityState () const
virtual void	handleParameterChange (const char *name) override
	Allows changing parameters from the GUI. More...
virtual void	handleMessage (cMessage *msg) override
	This modules should only receive self-messages. More...
virtual void	emitMobilityStateChangedSignal ()
	Emits a signal with the updated mobility state. More...
virtual Coord	getRandomPosition ()
	Returns a new random position satisfying the constraint area. More...
virtual cModule *	findSubjectModule ()
	Returns the module that represents the object moved by this mobility module. More...
virtual bool	isOutside ()
	Returns true if the mobility is outside of the constraint area. More...
virtual void	reflectIfOutside (Coord &targetPosition, Coord &velocity, rad &angle, rad &elevation, Quaternion &quaternion)
	Utility function to reflect the node if it goes outside the constraint area. More...
virtual void	wrapIfOutside (Coord &targetPosition)
	Utility function to wrap the node to the opposite edge (torus) if it goes outside the constraint area. More...
virtual void	placeRandomlyIfOutside (Coord &targetPosition)
	Utility function to place the node randomly if it goes outside the constraint area. More...
virtual void	raiseErrorIfOutside ()
	Utility function to raise an error if the node gets outside the constraint area. More...
virtual void	handleIfOutside (BorderPolicy policy, Coord &targetPosition, Coord &velocity)
	Invokes one of reflectIfOutside(), wrapIfOutside() and placeRandomlyIfOutside(), depending on the given border policy. More...
virtual void	handleIfOutside (BorderPolicy policy, Coord &targetPosition, Coord &velocity, rad &heading)
virtual void	handleIfOutside (BorderPolicy policy, Coord &targetPosition, Coord &velocity, rad &heading, rad &elevation)
virtual void	handleIfOutside (BorderPolicy policy, Coord &targetPosition, Coord &velocity, rad &heading, rad &elevation, Quaternion &quaternion)

Protected Attributes
Coord	lastVelocity
Coord	lastAcceleration
Quaternion	lastAngularVelocity
Quaternion	lastAngularAcceleration
PositionComposition	positionComposition = PositionComposition::PC_UNDEFINED
OrientationComposition	orientationComposition = OrientationComposition::OC_UNDEFINED
int	positionElementIndex = -1
int	orientationElementIndex = -1
std::vector< IMobility * >	elements
Protected Attributes inherited from inet::MobilityBase
cModule *	subjectModule
	Pointer to visual representation module, to speed up repeated access. More...
const CanvasProjection *	canvasProjection
	The 2D projection used on the canvas. More...
Coord	constraintAreaMin
	3 dimensional position and size of the constraint area (in meters). More...
Coord	constraintAreaMax
Coord	lastPosition
	The last position that was reported. More...
Quaternion	lastOrientation
	The last orientation that was reported. More...
StringFormat	format

Additional Inherited Members
Public Types inherited from inet::MobilityBase
enum	BorderPolicy { REFLECT, WRAP, PLACERANDOMLY, RAISEERROR }
	Selects how a mobility module should behave if it reaches the edge of the constraint area. More...
Static Public Attributes inherited from inet::IMobility
static simsignal_t	mobilityStateChangedSignal = cComponent::registerSignal("mobilityStateChanged")
	A signal used to publish mobility state changes. More...

Member Enumeration Documentation

OrientationComposition

enum inet::SuperpositioningMobility::OrientationComposition

strongprotected

Enumerator
OC_UNDEFINED
OC_ZERO
OC_SUM
OC_AVERAGE
OC_FACE_FORWARD
OC_ELEMENT

                                      {
        OC_UNDEFINED = -1,
        OC_ZERO,
        OC_SUM,
        OC_AVERAGE,
        OC_FACE_FORWARD,
        OC_ELEMENT,
    };

PositionComposition

enum inet::SuperpositioningMobility::PositionComposition

strongprotected

Enumerator
PC_UNDEFINED
PC_ZERO
PC_SUM
PC_AVERAGE
PC_ELEMENT

                                   {
        PC_UNDEFINED = -1,
        PC_ZERO,
        PC_SUM,
        PC_AVERAGE,
        PC_ELEMENT,
    };

Member Function Documentation

getCurrentAcceleration()

const Coord & inet::SuperpositioningMobility::getCurrentAcceleration ( )

overridevirtual

Returns the acceleration at the current simulation time.

Implements inet::IMobility.

{
    switch (positionComposition) {
        case PositionComposition::PC_ZERO:
            lastAcceleration = Coord::ZERO;
            break;
        case PositionComposition::PC_AVERAGE:
        case PositionComposition::PC_SUM:
            lastAcceleration = Coord::ZERO;
            for (auto element : elements)
                lastAcceleration += element->getCurrentAcceleration();
            if (positionComposition == PositionComposition::PC_AVERAGE)
                lastAcceleration /= elements.size();
            break;
        case PositionComposition::PC_ELEMENT:
            lastAcceleration = elements[positionElementIndex]->getCurrentAcceleration();
            break;
        default:
            throw cRuntimeError("Unknown orientation composition");
    }
    return lastAcceleration;
}

getCurrentAngularAcceleration()

const Quaternion & inet::SuperpositioningMobility::getCurrentAngularAcceleration ( )

overridevirtual

Returns the angular acceleration at the current simulation time.

Implements inet::IMobility.

{
    switch (orientationComposition) {
        case OrientationComposition::OC_ZERO:
            lastAngularAcceleration = Quaternion::IDENTITY;
            break;
        case OrientationComposition::OC_SUM:
            lastAngularAcceleration = Quaternion::IDENTITY;
            for (auto element : elements)
                lastAngularAcceleration *= Quaternion(element->getCurrentAngularAcceleration());
            break;
        case OrientationComposition::OC_AVERAGE:
            lastAngularAcceleration = Quaternion::NIL;
            break;
        case OrientationComposition::OC_FACE_FORWARD:
            lastAngularAcceleration = Quaternion::NIL;
            break;
        case OrientationComposition::OC_ELEMENT:
            lastAngularAcceleration = Quaternion::NIL;
            break;
        default:
            throw cRuntimeError("Unknown orientation composition");
    }
    return lastAngularAcceleration;
}

getCurrentAngularPosition()

const Quaternion & inet::SuperpositioningMobility::getCurrentAngularPosition ( )

overridevirtual

Returns the angular position at the current simulation time.

Implements inet::IMobility.

{
    switch (orientationComposition) {
        case OrientationComposition::OC_ZERO:
            lastOrientation = Quaternion::IDENTITY;
            break;
        case OrientationComposition::OC_SUM:
            lastOrientation = Quaternion::IDENTITY;
            for (auto element : elements)
                lastOrientation *= Quaternion(element->getCurrentAngularPosition());
            break;
        case OrientationComposition::OC_AVERAGE: {
            Coord rotatedX;
            Coord rotatedY;
            Coord rotatedZ;
            for (auto element : elements) {
                Quaternion quaternion(element->getCurrentAngularPosition());
                rotatedX += quaternion.rotate(Coord::X_AXIS);
                rotatedY += quaternion.rotate(Coord::Y_AXIS);
                rotatedZ += quaternion.rotate(Coord::Z_AXIS);
            }
            rotatedX.normalize();
            rotatedY.normalize();
            rotatedZ.normalize();
            double matrix[3][3];
            matrix[0][0] = rotatedX.x;
            matrix[1][0] = rotatedX.y;
            matrix[2][0] = rotatedX.z;
            matrix[0][1] = rotatedY.x;
            matrix[1][1] = rotatedY.y;
            matrix[2][1] = rotatedY.z;
            matrix[0][2] = rotatedZ.x;
            matrix[1][2] = rotatedZ.y;
            matrix[2][2] = rotatedZ.z;
            if (!rotatedX.isUnspecified() && !rotatedY.isUnspecified() && !rotatedZ.isUnspecified())
                lastOrientation = RotationMatrix(matrix).toQuaternion();
            break;
        }
        case OrientationComposition::OC_FACE_FORWARD: {
            // determine orientation based on direction
            Coord lastVelocity = getCurrentVelocity();
            if (lastVelocity != Coord::ZERO) {
                Coord direction = lastVelocity;
                direction.normalize();
                auto alpha = rad(atan2(direction.y, direction.x));
                auto beta = rad(-asin(direction.z));
                auto gamma = rad(0.0);
                lastOrientation = Quaternion(EulerAngles(alpha, beta, gamma));
            }
            break;
        }
        case OrientationComposition::OC_ELEMENT: {
            lastOrientation = elements[orientationElementIndex]->getCurrentAngularPosition();
            break;
        }
        default:
            throw cRuntimeError("Unknown orientation composition");
    }
    return lastOrientation;
}

getCurrentAngularVelocity()

const Quaternion & inet::SuperpositioningMobility::getCurrentAngularVelocity ( )

overridevirtual

Returns the angular velocity at the current simulation time.

Implements inet::IMobility.

{
    switch (orientationComposition) {
        case OrientationComposition::OC_ZERO:
            lastAngularVelocity = Quaternion::IDENTITY;
            break;
        case OrientationComposition::OC_SUM:
            lastAngularVelocity = Quaternion::IDENTITY;
            for (auto element : elements)
                lastAngularVelocity *= Quaternion(element->getCurrentAngularVelocity());
            break;
        case OrientationComposition::OC_AVERAGE:
            lastAngularVelocity = Quaternion::NIL;
            break;
        case OrientationComposition::OC_FACE_FORWARD:
            lastAngularVelocity = Quaternion::NIL;
            break;
        case OrientationComposition::OC_ELEMENT:
            lastAngularVelocity = Quaternion::NIL;
            break;
        default:
            throw cRuntimeError("Unknown orientation composition");
    }
    return lastAngularVelocity;
}

getCurrentPosition()

const Coord & inet::SuperpositioningMobility::getCurrentPosition ( )

overridevirtual

Returns the position at the current simulation time.

Implements inet::IMobility.

{
    switch (positionComposition) {
        case PositionComposition::PC_ZERO:
            lastPosition = Coord::ZERO;
            break;
        case PositionComposition::PC_AVERAGE:
        case PositionComposition::PC_SUM:
            lastPosition = Coord::ZERO;
            for (auto element : elements)
                lastPosition += element->getCurrentPosition();
            if (positionComposition == PositionComposition::PC_AVERAGE)
                lastPosition /= elements.size();
            break;
        case PositionComposition::PC_ELEMENT:
            lastPosition = elements[positionElementIndex]->getCurrentPosition();
            break;
        default:
            throw cRuntimeError("Unknown orientation composition");
    }
    return lastPosition;
}

Referenced by setInitialPosition().

getCurrentVelocity()

const Coord & inet::SuperpositioningMobility::getCurrentVelocity ( )

overridevirtual

Returns the velocity at the current simulation time.

Implements inet::IMobility.

{
    switch (positionComposition) {
        case PositionComposition::PC_ZERO:
            lastVelocity = Coord::ZERO;
            break;
        case PositionComposition::PC_AVERAGE:
        case PositionComposition::PC_SUM:
            lastVelocity = Coord::ZERO;
            for (auto element : elements)
                lastVelocity += element->getCurrentVelocity();
            if (positionComposition == PositionComposition::PC_AVERAGE)
                lastVelocity /= elements.size();
            break;
        case PositionComposition::PC_ELEMENT:
            lastVelocity = elements[positionElementIndex]->getCurrentVelocity();
            break;
        default:
            throw cRuntimeError("Unknown orientation composition");
    }
    return lastVelocity;
}

Referenced by getCurrentAngularPosition().

handleSelfMessage()

virtual void inet::SuperpositioningMobility::handleSelfMessage ( cMessage *  msg )

inlineoverrideprotectedvirtual

Called upon arrival of a self messages, subclasses must override.

Implements inet::MobilityBase.

{ throw cRuntimeError("Unknown self message"); }

initialize()

void inet::SuperpositioningMobility::initialize ( int  stage )

overrideprotectedvirtual

Initializes mobility model parameters.

Reimplemented from inet::MobilityBase.

{
    MobilityBase::initialize(stage);
    EV_TRACE << "initializing SuperpositioningMobility stage " << stage << endl;
    if (stage == INITSTAGE_LOCAL) {
        const char *positionCompositionAsString = par("positionComposition");
        if (!strcmp(positionCompositionAsString, "zero"))
            positionComposition = PositionComposition::PC_ZERO;
        else if (!strcmp(positionCompositionAsString, "sum"))
            positionComposition = PositionComposition::PC_SUM;
        else if (!strcmp(positionCompositionAsString, "average"))
            positionComposition = PositionComposition::PC_AVERAGE;
        else {
            positionComposition = PositionComposition::PC_ELEMENT;
            positionElementIndex = std::stoi(positionCompositionAsString);
        }
        const char *orientationCompositionAsString = par("orientationComposition");
        if (!strcmp(orientationCompositionAsString, "zero"))
            orientationComposition = OrientationComposition::OC_ZERO;
        else if (!strcmp(orientationCompositionAsString, "sum"))
            orientationComposition = OrientationComposition::OC_SUM;
        else if (!strcmp(orientationCompositionAsString, "average"))
            orientationComposition = OrientationComposition::OC_AVERAGE;
        else if (!strcmp(orientationCompositionAsString, "faceForward"))
            orientationComposition = OrientationComposition::OC_FACE_FORWARD;
        else {
            orientationComposition = OrientationComposition::OC_ELEMENT;
            orientationElementIndex = std::stoi(orientationCompositionAsString);
        }
        int numElements = par("numElements");
        for (int i = 0; i < numElements; i++) {
            auto element = getSubmodule("element", i);
            element->subscribe(IMobility::mobilityStateChangedSignal, this);
            elements.push_back(check_and_cast<IMobility *>(element));
        }
        WATCH(lastVelocity);
        WATCH(lastAcceleration);
    }
    else if (stage == INITSTAGE_LAST)
        initializePosition();
}

numInitStages()

virtual int inet::SuperpositioningMobility::numInitStages ( ) const

inlineoverrideprotectedvirtual

Returns the required number of initialize stages.

Reimplemented from inet::MobilityBase.

{ return NUM_INIT_STAGES; }

receiveSignal()

void inet::SuperpositioningMobility::receiveSignal ( cComponent *  source, simsignal_t  signal, cObject *  object, cObject *  details  )

overridevirtual

{
    Enter_Method("%s", cComponent::getSignalName(signal));
 
    if (IMobility::mobilityStateChangedSignal == signal)
        emitMobilityStateChangedSignal();
}

setInitialPosition()

void inet::SuperpositioningMobility::setInitialPosition ( )

overrideprotectedvirtual

Initializes the position from the display string or from module parameters.

Reimplemented from inet::MobilityBase.

{
    lastPosition = getCurrentPosition();
}

Member Data Documentation

elements

std::vector<IMobility *> inet::SuperpositioningMobility::elements

protected

Referenced by getCurrentAcceleration(), getCurrentAngularAcceleration(), getCurrentAngularPosition(), getCurrentAngularVelocity(), getCurrentPosition(), getCurrentVelocity(), and initialize().

lastAcceleration

Coord inet::SuperpositioningMobility::lastAcceleration

protected

Referenced by getCurrentAcceleration(), and initialize().

lastAngularAcceleration

Quaternion inet::SuperpositioningMobility::lastAngularAcceleration

protected

Referenced by getCurrentAngularAcceleration().

lastAngularVelocity

Quaternion inet::SuperpositioningMobility::lastAngularVelocity

protected

Referenced by getCurrentAngularVelocity().

lastVelocity

Coord inet::SuperpositioningMobility::lastVelocity

protected

Referenced by getCurrentAngularPosition(), getCurrentVelocity(), and initialize().

orientationComposition

OrientationComposition inet::SuperpositioningMobility::orientationComposition = OrientationComposition::OC_UNDEFINED

protected

Referenced by getCurrentAngularAcceleration(), getCurrentAngularPosition(), getCurrentAngularVelocity(), and initialize().

orientationElementIndex

int inet::SuperpositioningMobility::orientationElementIndex = -1

protected

Referenced by getCurrentAngularPosition(), and initialize().

positionComposition

PositionComposition inet::SuperpositioningMobility::positionComposition = PositionComposition::PC_UNDEFINED

protected

Referenced by getCurrentAcceleration(), getCurrentPosition(), getCurrentVelocity(), and initialize().

positionElementIndex

int inet::SuperpositioningMobility::positionElementIndex = -1

protected

Referenced by getCurrentAcceleration(), getCurrentPosition(), getCurrentVelocity(), and initialize().

---

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

• SuperpositioningMobility.h
• SuperpositioningMobility.cc