Class to provide spatial and temporal correlation in the posture selection process of the MoBAN mobility model. More...

#include <PostureTransition.h>

Classes
struct	AreaBound
	Data type for one instance of the area (space) boundary. More...

struct	AreaType
	Data type for one instance of area type. More...

struct	CombinationType
	Data type for one instance of space-time combination. More...

struct	TimeBound
	Data type for one instance of the time boundary. More...

struct	TimeDomainType
	Data type for one instance of time domain. More...

struct	TransMatrix
	Data type for one instance of Markov transition matrix. More...

Public Member Functions
	PostureTransition (int)
	Construct a posture transition object. More...

	~PostureTransition ()

int	addMatrix (std::string, double **, bool)
	Receives a transition matrix and add to the list. More...

int	addSteadyState (std::string, double *)
	Receives a steady state vector, extracts the corresponding transition matrix considering the default matrix, and add to the list of given matrices. More...

int	addAreaType (std::string)
	Adds a area type to the list with the given name and returns the index of this area type in the list. More...

bool	setAreaBoundry (int, Coord, Coord)
	Adds the given boundary to the existing area type specified by the given ID . More...

int	addTimeDomain (std::string)
	Adds a time domain to the list with the given name and returns the index of the this time domain in the list. More...

bool	setTimeBoundry (int, simtime_t, simtime_t)
	Adds the given boundary to the existing time domain specified by the given ID . More...

bool	addCombination (std::string, std::string, std::string)
	Adds a space-time combination to the list. More...

double **	getMatrix (simtime_t, Coord)
	Gets a time and location, and returns the corresponding Markov transition matrix. More...

Protected Types
typedef std::vector< TransMatrix * >	TransMatrixList
	Data type for a list of Markov transition matrices. More...

typedef std::vector< AreaType * >	AreaTypeList
	Data type for the list of area types. More...

typedef std::vector< TimeDomainType * >	TimeDomainList
	Data type for the list of time domains. More...

typedef std::vector< CombinationType * >	CombinationList
	Data type for the list of space-time combinations. More...

Protected Member Functions
double **	extractMatrixFromSteadyState (double *)
	Gets a steady state vector and return a matrix which is as close as posible to the default matrix and satisfies the given steady state. More...

int	findTimeDomain (simtime_t)
	Gets a time and finds the ID of the containing time domain if there is. More...

int	findAreaType (Coord)
	Gets a location and finds the ID of the containing area type if there is. More...

bool	isMarkovian (double **)
	Checks if a matrix can be a Markov transition matrix. More...

bool	isMarkovian (double *)
	Checks if a vector can be the steady state of a Markov chain. More...

void	multMatrix (double , double , double **)
	Multiplies two matrices with dimension numPos*numPose . More...

void	addMatrix (double , double , double **)
	Adds two matrices with dimension numPos*numPose . More...

void	subtractMatrix (double , double , double **)
	Subtracts two matrices with dimension numPos*numPose . More...

void	multVector (double , double *)
	Multiply a vector of size numPos with its transpose. More...

Protected Attributes
int	numPos
	Number of postures. More...

int	defaultMatrixID
	The index of the default (base) transition matrix. More...

TransMatrixList	matrixList
	The list of all given transition matrices. More...

AreaTypeList	areaTypeList
	The list of all defined area types. More...

TimeDomainList	timeDomainList
	The list of all defined time domains. More...

CombinationList	combinationList
	The list of all given space-time combinations. More...

Detailed Description

Class to provide spatial and temporal correlation in the posture selection process of the MoBAN mobility model.

This class obtains and stores Markovian transition matrices. There is also the possibility to get a steady state vector. In this case, the closest transition matrix to the default Makov matrix is extracted which satisfies the given steady state vector. The class also receives the defined area types and time domains as well as given space-time domains during the initialization phase. During the simulation run, the class provide a functions to return the corresponding markov matrix for a given time and location. It will be used whenever a new posture is going to be selected.

Author: Majid Nabi

Member Typedef Documentation

typedef std::vector<AreaType *> inet::PostureTransition::AreaTypeList

protected

Data type for the list of area types.

typedef std::vector<CombinationType *> inet::PostureTransition::CombinationList

protected

Data type for the list of space-time combinations.

typedef std::vector<TimeDomainType *> inet::PostureTransition::TimeDomainList

protected

Data type for the list of time domains.

typedef std::vector<TransMatrix *> inet::PostureTransition::TransMatrixList

protected

Data type for a list of Markov transition matrices.

Constructor & Destructor Documentation

inet::PostureTransition::PostureTransition ( int numPosture )

Construct a posture transition object.

Constructor function of the class.

The parameter is the number of postures which is the dimension of all matrices

It sets the value for t he number of posture. It also suppose the first given transition matrix as default. However, during parsing the xml configuration file, if a matrix has attribute type with value "default", it will be considered as the default (base) transition matrix.

 {
     numPos = numPosture;
     defaultMatrixID = 0;    // if no default matrix found, the first one will be supposed as the default matrix.
 }

inet::PostureTransition::~PostureTransition ( )

 {
     for (auto comb: combinationList) {
         delete comb;
     }
     for (auto mat: matrixList) {
         for (int i = 0; i < numPos; ++i)
             delete [] mat->matrix[i];
         delete [] mat->matrix;
         delete mat;
     }
     for (auto areaType: areaTypeList) {
         for (auto bound: areaType->boundries)
             delete bound;
         delete areaType;
     }
     for (auto timeDomain: timeDomainList) {
         for (auto bound: timeDomain->boundries)
             delete bound;
         delete timeDomain;
     }
 }

Member Function Documentation

int inet::PostureTransition::addAreaType ( std::string name )

Adds a area type to the list with the given name and returns the index of this area type in the list.

Creates a new area type instance and adds it to the list.

The boundaries of the area type is empty now. It will be filled later. The function returns the index of the new area type in the list as its output.

Referenced by inet::MoBANCoordinator::readConfigurationFile().

 {
     //Check if the name is repetitive
     AreaTypeList::const_iterator areaIt;
     for (areaIt = areaTypeList.begin(); areaIt != areaTypeList.end(); areaIt++) {
         if ((*areaIt)->name == name) {
             std::string str = "There are multiple area types with the same name: " + name + " in the configuration file!";
             throw cRuntimeError(str.c_str());
         }
     }
 
     AreaType *area = new AreaType;
     area->name = name;
     areaTypeList.push_back(area);
     return areaTypeList.size() - 1;
 }

bool inet::PostureTransition::addCombination	(	std::string	areaName,
		std::string	timeName,
		std::string	matrixName
	)

Adds a space-time combination to the list.

This function creates a new space-time combination instance and adds it to the combinations list.

It checks if the given names for area type, time domain, and matrix are previously defined and exist in the corresponding lists. Note that at least area type or time domain should have been specified for a combination. Otherwise the combination is not meaningful. if for example a combination has no area type and just has specified time domain, it means that for the whole simulation area, it will be the same and the proper matrix is selected based on the time.

Referenced by inet::MoBANCoordinator::readConfigurationFile().

 {
     int thisID;
     CombinationType *comb = new CombinationType;
     comb->areaID = -1;
     comb->timeID = -1;
     comb->matrixID = -1;
 
     // look for matching area type name.
     thisID = 0;
     AreaTypeList::const_iterator areaIt;
     for (areaIt = areaTypeList.begin(); areaIt != areaTypeList.end(); areaIt++) {
         if (areaName == (*areaIt)->name) {
             comb->areaID = thisID;
             break;
         }
         ++thisID;
     }
 
     // in the input name is empty, it means that no area type is specified for this combination.
     if (comb->areaID == -1 && !areaName.empty()) {
         std::string str = "Undefined area type name is given in a combinations: " + areaName + ", " + timeName + ", " + matrixName;
         throw cRuntimeError(str.c_str());
     }
 
     // look for matching time domain name.
     thisID = 0;
     TimeDomainList::const_iterator timeIt;
     for (timeIt = timeDomainList.begin(); timeIt != timeDomainList.end(); timeIt++) {
         if (timeName == (*timeIt)->name) {
             comb->timeID = thisID;
             break;
         }
         ++thisID;
     }
     if (comb->timeID == -1 && !timeName.empty()) {
         std::string str = "Undefined time domain name is given in a combinations: " + areaName + ", " + timeName + ", " + matrixName;
         throw cRuntimeError(str.c_str());
     }
 
     if (comb->areaID == -1 && comb->timeID == -1)
         throw cRuntimeError("Both area type and time domain is unspecified in a combination.");
 
     // look for matching transition matrix name.
     thisID = 0;
     TransMatrixList::const_iterator matrixIt;
     for (matrixIt = matrixList.begin(); matrixIt != matrixList.end(); matrixIt++) {
         if (matrixName == (*matrixIt)->name) {
             comb->matrixID = thisID;
             break;
         }
         ++thisID;
     }
     if (comb->matrixID == -1)
         throw cRuntimeError("Undefined matrix name is given in the combinations");
 
     combinationList.push_back(comb);
 
     return true;
 }

void inet::PostureTransition::addMatrix	(	double **	mat1,
		double **	mat2,
		double **	res
	)

protected

Adds two matrices with dimension numPos*numPose .

Function to add two matrix with the known dimensions as number of postures.

Referenced by extractMatrixFromSteadyState(), and inet::MoBANCoordinator::readConfigurationFile().

 {
     int i, j;
     for (i = 0; i < numPos; i++) {
         for (j = 0; j < numPos; j++)
             res[i][j] = mat1[i][j] + mat2[i][j];
     }
 }

int inet::PostureTransition::addMatrix	(	std::string	name,
		double **	matrix,
		bool	thisDefault
	)

Receives a transition matrix and add to the list.

This function initiates a new instance of markov matrix with the given matrix.

Note that it copies the matrix into the created matrix. The function first verifies if the given matrix can be a Markov transition matrix.

 {
     //check if the name is repetitive
     TransMatrixList::const_iterator matrixIt;
     for (matrixIt = matrixList.begin(); matrixIt != matrixList.end(); matrixIt++) {
         if ((*matrixIt)->name == name) {
             std::string str = "There are multiple matrices with the same name: " + name + " in the configuration file!";
             throw cRuntimeError(str.c_str());
         }
     }
 
     // verify if the given matrix is Markovian
     if (!isMarkovian(matrix)) {
         std::string str = "Given transition matrix " + name + " is not Markovian!";
         throw cRuntimeError(str.c_str());
     }
 
     TransMatrix *mat = new TransMatrix;
 
     mat->name = name;
     mat->matrix = new double *[numPos];
     for (int i = 0; i < numPos; ++i) {
         mat->matrix[i] = new double[numPos];
         for (int j = 0; j < numPos; ++j)
             mat->matrix[i][j] = matrix[i][j];
     }
 
     matrixList.push_back(mat);
 
     if (thisDefault)
         defaultMatrixID = matrixList.size() - 1;
 
     return 0;
 }

int inet::PostureTransition::addSteadyState	(	std::string	name,
		double *	iVector
	)

Receives a steady state vector, extracts the corresponding transition matrix considering the default matrix, and add to the list of given matrices.

This function creates a new instance of markov matrix to be filled with a derived matrix from the given steady state vector.

The function first verifies if the given vector can be a steady state vector. Then extracts a markov matrix based on that and adds it to the list of given matrices.

Referenced by inet::MoBANCoordinator::readConfigurationFile().

 {
     //check if the name is repetitive
     TransMatrixList::const_iterator matrixIt;
     for (matrixIt = matrixList.begin(); matrixIt != matrixList.end(); matrixIt++) {
         if ((*matrixIt)->name == name) {
             std::string str = "There are multiple matrices with the same name: " + name + " in the configuration file!";
             throw cRuntimeError(str.c_str());
         }
     }
 
     // check if the given matrix is Markovian
     if (!isMarkovian(iVector)) {
         std::string str = "Given steady state vector " + name + " cannot be true!";
         throw cRuntimeError(str.c_str());
     }
 
     // make a local copy of the input steady state vector
     double *steady = new double[numPos];
     for (int i = 0; i < numPos; ++i)
         steady[i] = iVector[i];
 
     TransMatrix *mat = new TransMatrix;
     mat->name = name;
     mat->matrix = extractMatrixFromSteadyState(steady);
     delete [] steady;
 
     matrixList.push_back(mat);
 
     return 0;
 }

int inet::PostureTransition::addTimeDomain ( std::string name )

Adds a time domain to the list with the given name and returns the index of the this time domain in the list.

Creates a new time domain instance and adds it to the list.

The boundaries of the time domain is empty now. It will be filled later. The function returns the index of the time domain in the list as its output.

Referenced by inet::MoBANCoordinator::readConfigurationFile().

 {
     //Check if the name is repetitive
     TimeDomainList::const_iterator timeIt;
     for (timeIt = timeDomainList.begin(); timeIt != timeDomainList.end(); timeIt++) {
         if ((*timeIt)->name == name) {
             std::string str = "There are multiple time domains with the same name: " + name + " in the configuration file!";
             throw cRuntimeError(str.c_str());
         }
     }
 
     TimeDomainType *time = new TimeDomainType;
     time->name = name;
     timeDomainList.push_back(time);
     return timeDomainList.size() - 1;
 }

double ** inet::PostureTransition::extractMatrixFromSteadyState ( double * vec )

protected

Gets a steady state vector and return a matrix which is as close as posible to the default matrix and satisfies the given steady state.

This function receives a steady state vector and extracts a Markovian matrix which is as close as possible to the default markov matrix and satisfies the given steady state vector.

Referenced by addSteadyState().

 {
     int i, j;
     double **dafaultMat;
 
     //make output matrix and an identity matrix and a temp
     double **mat = new double *[numPos];
     double **temp1 = new double *[numPos];
     double **temp2 = new double *[numPos];
     double **temp3 = new double *[numPos];
     double **identity = new double *[numPos];
     int **change = new int *[numPos];
     for (int i = 0; i < numPos; ++i) {
         mat[i] = new double[numPos];
         temp1[i] = new double[numPos];
         temp2[i] = new double[numPos];
         temp3[i] = new double[numPos];
         identity[i] = new double[numPos];
         change[i] = new int[numPos];
     }
 
     for (i = 0; i < numPos; i++)
         for (j = 0; j < numPos; j++)
             if (i == j)
                 identity[i][j] = 1;
             else
                 identity[i][j] = 0;
 
     double *sum = new double[numPos];
     int *changeSum = new int[numPos];
 
     dafaultMat = matrixList.at(defaultMatrixID)->matrix;
 
     for (int numTry = 0; numTry < 400; ++numTry) {
         subtractMatrix(identity, dafaultMat, temp1);
         multVector(vec, temp2);
         multMatrix(temp1, temp2, temp3);
         addMatrix(dafaultMat, temp3, mat);
 
         //remember if it has not changed
         for (i = 0; i < numPos; i++)
             for (j = 0; j < numPos; j++)
                 change[i][j] = 1;
 
 
         for (j = 0; j < numPos; j++)
             for (i = 0; i < numPos; i++) {
                 if (mat[i][j] < 0) {
                     mat[i][j] = 0;
                     change[i][j] = 0;
                 }
                 if (mat[i][j] > 1) {
                     mat[i][j] = 1;
                     change[i][j] = 0;
                 }
             }
 
         for (j = 0; j < numPos; j++) {
             sum[j] = 0;
             changeSum[j] = 0;
             for (i = 0; i < numPos; i++) {
                 sum[j] += mat[i][j];
                 changeSum[j] += change[i][j];
             }
         }
 
         for (j = 0; j < numPos; j++)
             for (i = 0; i < numPos; i++) {
                 if (change[i][j] == 1)
                     mat[i][j] = mat[i][j] + (1 - sum[j]) / changeSum[j];
             }
 
         dafaultMat = mat;
     }
 
     for (j = 0; j < numPos; j++)
         for (i = 0; i < numPos; i++) {
             if (mat[i][j] < 0)
                 mat[i][j] = 0;
             if (mat[i][j] > 1)
                 mat[i][j] = 1;
         }
 
     EV_DEBUG << "Generated Markov matrix from the steady state: " << endl;
     for (int k = 0; k < numPos; ++k) {
         for (int f = 0; f < numPos; ++f)
             EV_DEBUG << mat[k][f] << "       ";
         EV_DEBUG << endl;
     }
 
     for (int i = 0; i < numPos; ++i) {
         delete [] temp1[i];
         delete [] temp2[i];
         delete [] temp3[i];
         delete [] identity[i];
         delete [] change[i];
     }
     delete [] temp1;
     delete [] temp2;
     delete [] temp3;
     delete [] identity;
     delete [] change;
     delete [] sum;
     delete [] changeSum;
 
     return mat;
 }

int inet::PostureTransition::findAreaType ( Coord iLocation )

protected

Gets a location and finds the ID of the containing area type if there is.

Looks for the first containing area type for the given location.

If not, return -1.

It return the Id of the found area type. If no area type is found which contains the given location, it returns -1.

Referenced by getMatrix().

 {
     int locationID = 0;
     AreaTypeList::const_iterator areaIt;
     for (areaIt = areaTypeList.begin(); areaIt != areaTypeList.end(); areaIt++) {
         std::vector<AreaBound *> boundList = (*areaIt)->boundries;
 
         std::vector<AreaBound *>::const_iterator bound;
         for (bound = boundList.begin(); bound != boundList.end(); bound++) {
             if (iLocation.isInBoundary((*bound)->low, (*bound)->high))
                 return locationID;
         }
         ++locationID;
     }
     EV_DEBUG << "Area Type not found" << endl;
     return -1;
 }

int inet::PostureTransition::findTimeDomain ( simtime_t iTime )

protected

Gets a time and finds the ID of the containing time domain if there is.

Looks for the first containing time domain for the given time instance.

If not, return -1.

It return the Id of the found time domain. If no time domain is found which contains the given time instance, it returns -1.

Referenced by getMatrix().

 {
     int timeID = 0;
     TimeDomainList::const_iterator timeIt;
     for (timeIt = timeDomainList.begin(); timeIt != timeDomainList.end(); timeIt++) {
         std::vector<TimeBound *> boundList = (*timeIt)->boundries;
 
         std::vector<TimeBound *>::const_iterator bound;
         for (bound = boundList.begin(); bound != boundList.end(); bound++) {
             if (iTime >= (*bound)->low && iTime < (*bound)->high)
                 return timeID;
         }
         ++timeID;
     }
     EV_DEBUG << "Time domain not found" << endl;
     return -1;
 }

double ** inet::PostureTransition::getMatrix	(	simtime_t	iTime,
		Coord	iLocation
	)

Gets a time and location, and returns the corresponding Markov transition matrix.

This function is actually the main usage of this class.

It gets a time instance and a location within the simulation area, and then looks for the first fitting combination. If found, it returns the specified Markov transition matrix for that combination as its output. If no combination is found, it returns the default matrix.

Referenced by inet::MoBANCoordinator::selectPosture().

 {
     int timeID, locationID, matrixID;
 
     timeID = findTimeDomain(iTime);
     locationID = findAreaType(iLocation);
 
     matrixID = defaultMatrixID;
 
     CombinationList::const_iterator combIt;
     for (combIt = combinationList.begin(); combIt != combinationList.end(); combIt++) {
         if ((*combIt)->timeID == timeID && (*combIt)->areaID == locationID) {
             matrixID = (*combIt)->matrixID;
             break;
         }
     }
 
     EV_DEBUG << "The corresponding Markov matrix for time" << iTime.dbl() << " and location " << iLocation.info() << " is: " << matrixList.at(matrixID)->name << endl;
 
     return matrixList.at(matrixID)->matrix;
 }

bool inet::PostureTransition::isMarkovian ( double ** matrix )

protected

Checks if a matrix can be a Markov transition matrix.

Verifies if a matrix can be a Markovian transition matrix.

All elements should be in the range [0,1] and elements of each column of the matrix should add up to 1.

Each element of the matrix should be in the range [0 1]. Further, all elements of each column should adds up to one.

Referenced by addMatrix(), and addSteadyState().

 {
     double sumCol;
     for (int j = 0; j < numPos; ++j) {
         sumCol = 0;
         for (int i = 0; i < numPos; ++i) {
             if (matrix[i][j] < 0 || matrix[i][j] > 1)
                 return false;
             sumCol += matrix[i][j];
         }
 
         if (!math::close(sumCol, 1.0))
             return false;
     }
 
     return true;
 }

bool inet::PostureTransition::isMarkovian ( double * vec )

protected

Checks if a vector can be the steady state of a Markov chain.

Verifies if a vector can be the steady state of a Markov model.

All elements should be in the range [0,1] and the sum of elements should be 1.

Each element of the matrix should be in the range [0 1]. Further, the sum of all elements should be one.

 {
     double sumCol = 0;
     for (int i = 0; i < numPos; ++i) {
         if (vec[i] < 0 || vec[i] > 1)
             return false;
         sumCol += vec[i];
     }
 
     if (!math::close(sumCol, 1.0))
         return false;
     else
         return true;
 }

void inet::PostureTransition::multMatrix	(	double **	mat1,
		double **	mat2,
		double **	res
	)

protected

Multiplies two matrices with dimension numPos*numPose .

Function to multiply two matrix with the known dimensions as number of postures.

Referenced by extractMatrixFromSteadyState().

 {
     int i, j, l;
     for (i = 0; i < numPos; i++) {
         for (j = 0; j < numPos; j++) {
             res[i][j] = 0;
             for (l = 0; l < numPos; l++)
                 res[i][j] += mat1[i][l] * mat2[l][j];
         }
     }
 }

void inet::PostureTransition::multVector	(	double *	vec,
		double **	res
	)

protected

Multiply a vector of size numPos with its transpose.

Function to multiply a vector by its transpose (pi .

pi^T). The size in equal to the number of postures.

Referenced by extractMatrixFromSteadyState().

 {
     int i, j;
     for (i = 0; i < numPos; i++) {
         for (j = 0; j < numPos; j++)
             res[i][j] = vec[i] * vec[j];
     }
 }

bool inet::PostureTransition::setAreaBoundry	(	int	id,
		Coord	lowBound,
		Coord	highBound
	)

Adds the given boundary to the existing area type specified by the given ID .

This function gets an index of an existing area type and adds the given boundary to the boundary list of that area type.

Referenced by inet::MoBANCoordinator::readConfigurationFile().

 {
     AreaBound *bound = new AreaBound;
     bound->low = lowBound;
     bound->high = highBound;
 
     areaTypeList.at(id)->boundries.push_back(bound);
 
     return true;
 }

bool inet::PostureTransition::setTimeBoundry	(	int	id,
		simtime_t	lowBound,
		simtime_t	highBound
	)

Adds the given boundary to the existing time domain specified by the given ID .

This function gets an index of an existing time domain and adds the given boundary to the boundary list of that time domain.

Referenced by inet::MoBANCoordinator::readConfigurationFile().

 {
     TimeBound *bound = new TimeBound;
     bound->low = lowBound;
     bound->high = highBound;
 
     timeDomainList.at(id)->boundries.push_back(bound);
 
     return true;
 }

void inet::PostureTransition::subtractMatrix	(	double **	mat1,
		double **	mat2,
		double **	res
	)

protected

Subtracts two matrices with dimension numPos*numPose .

Function to subtract two matrix with the known dimensions as number of postures.

Referenced by extractMatrixFromSteadyState().

 {
     int i, j;
     for (i = 0; i < numPos; i++) {
         for (j = 0; j < numPos; j++)
             res[i][j] = mat1[i][j] - mat2[i][j];
     }
 }

Member Data Documentation

AreaTypeList inet::PostureTransition::areaTypeList

protected

The list of all defined area types.

Referenced by addAreaType(), addCombination(), findAreaType(), setAreaBoundry(), and ~PostureTransition().

CombinationList inet::PostureTransition::combinationList

protected

The list of all given space-time combinations.

Referenced by addCombination(), getMatrix(), and ~PostureTransition().

int inet::PostureTransition::defaultMatrixID

protected

The index of the default (base) transition matrix.

If no default is set, the first matrix is supposed as the default. Default matrix is used for the cases that a time or space domain does not lie in any given area types or time domains. It is also used for generating the transition matrix in the case that a steady state vector is given for a space-time domain.

Referenced by addMatrix(), extractMatrixFromSteadyState(), getMatrix(), and PostureTransition().